Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

10.1 KB
Raw Blame
package httpapi

import (
	"agentflow/internal/domain"
	"fmt"
	"strings"
	"sync"
	"time"
)

// Coalesce token deltas while retaining the order of thinking, tools and status.
// Bound transcript metadata independently of the live generation event window.
type assistantActivityLog struct {
	mu        sync.Mutex
	events    []domain.AssistantActivityEvent
	bytes     int
	truncated bool
}

func (l *assistantActivityLog) add(event assistantStreamEvent) {
	switch event.Kind {
	case "answerReset":
		l.mu.Lock()
		defer l.mu.Unlock()
		l.dropTextLocked()
		return
	case "answer", "text":
		l.mu.Lock()
		defer l.mu.Unlock()
		l.appendTextLocked(event)
		return
	case "thinkingStart", "thinking", "tool", "toolDone", "status", "agentText", "agentModel":
	default:
		return
	}
	l.mu.Lock()
	defer l.mu.Unlock()
	starting := event.Kind == "thinkingStart"
	if starting {
		event.Kind = "thinking"
		event.ID = fmt.Sprintf("thinking-%d", len(l.events))
		event.Text = ""
	}
	// Subagents run beside Main Bot, so only thoughts of the same agent join.
	if !starting && event.Kind == "thinking" && len(l.events) > 0 && l.events[len(l.events)-1].Kind == "thinking" && l.events[len(l.events)-1].Parent == event.Parent {
		last := &l.events[len(l.events)-1]
		if event.Full && strings.Contains(last.Text, strings.TrimSpace(event.Text)) {
			return
		}
		if len(last.Text)+len(event.Text) > 32000 || l.bytes+len(event.Text) > 512<<10 {
			l.truncated = true
			return
		}
		last.Text += event.Text
		l.bytes += len(event.Text)
		return
	}
	if event.Kind == "agentText" {
		for _, existing := range l.events {
			if existing.Kind == "agentText" && existing.Parent == event.Parent && existing.Text == event.Text {
				return
			}
		}
	}
	event.Input = truncateRunes(event.Input, 8000)
	event.Output = truncateRunes(event.Output, 8000)
	size := len(event.Text) + len(event.Detail) + len(event.Input) + len(event.Output)
	if len(l.events) >= 512 || l.bytes+size > 512<<10 {
		l.truncated = true
		return
	}
	event.Text = truncateRunes(event.Text, 32000)
	event.Detail = truncateRunes(event.Detail, 4000)
	event.Full = false
	l.events = append(l.events, event)
	l.bytes += len(event.Text) + len(event.Detail) + len(event.Input) + len(event.Output)
}

// Text written between tool calls stays in the transcript, in order. A later
// tool opens the next paragraph instead of appending onto the previous one.
func (l *assistantActivityLog) appendTextLocked(event assistantStreamEvent) {
	text := event.Text
	if text == "" {
		return
	}
	// A token that is only a space or a newline is still Markdown. Dropping it
	// turns "## 标题" into "##标题" and glues a table to the heading.
	if strings.TrimSpace(text) == "" {
		if len(l.events) == 0 || l.events[len(l.events)-1].Kind != "text" {
			return
		}
		last := &l.events[len(l.events)-1]
		if len(last.Text)+len(text) > 32000 || l.bytes+len(text) > 512<<10 {
			l.truncated = true
			return
		}
		last.Text += text
		l.bytes += len(text)
		return
	}
	// The CLI sends the finished block again after the tool that followed it.
	// That copy is already on screen; appending it would place the paragraph
	// twice, once on each side of the tool.
	if event.Full {
		trimmed := strings.TrimSpace(text)
		for _, existing := range l.events {
			if existing.Kind == "text" && strings.Contains(existing.Text, trimmed) {
				return
			}
		}
	}
	if len(l.events) > 0 && l.events[len(l.events)-1].Kind == "text" {
		last := &l.events[len(l.events)-1]
		trimmed := strings.TrimSpace(text)
		if event.Full && strings.Contains(last.Text, trimmed) {
			return
		}
		if event.Full && strings.TrimSpace(last.Text) != "" && (strings.HasPrefix(trimmed, strings.TrimSpace(last.Text)) || strings.HasPrefix(replyCompact(trimmed), replyCompact(last.Text))) {
			if len(text) > 32000 || l.bytes-len(last.Text)+len(text) > 512<<10 {
				l.truncated = true
				return
			}
			l.bytes += len(text) - len(last.Text)
			last.Text = text
			return
		}
		if len(last.Text)+len(text) > 32000 || l.bytes+len(text) > 512<<10 {
			l.truncated = true
			return
		}
		last.Text += text
		l.bytes += len(text)
		return
	}
	if len(l.events) >= 512 || l.bytes+len(text) > 512<<10 {
		l.truncated = true
		return
	}
	event.Kind = "text"
	event.Full = false
	event.Tool = ""
	event.Detail = ""
	event.Text = truncateRunes(text, 32000)
	if event.ID == "" {
		event.ID = fmt.Sprintf("text-%d", len(l.events))
	}
	l.events = append(l.events, event)
	l.bytes += len(event.Text)
}

func (l *assistantActivityLog) dropTextLocked() {
	kept := make([]domain.AssistantActivityEvent, 0, len(l.events))
	used := 0
	for _, event := range l.events {
		if event.Kind == "text" {
			continue
		}
		kept = append(kept, event)
		used += len(event.Text) + len(event.Detail)
	}
	l.events = kept
	l.bytes = used
}

func replyCompact(text string) string {
	return strings.Join(strings.Fields(text), "")
}

// replyRicher keeps the copy that still has its spaces and line breaks when
// two strings are the same once whitespace is ignored.
func replyRicher(primary, alternate string) string {
	if len(alternate) > len(primary) {
		return alternate
	}
	return primary
}

func replyParagraphs(text string) []string {
	text = strings.TrimSpace(text)
	if text == "" {
		return nil
	}
	raw := strings.Split(text, "\n\n")
	out := make([]string, 0, len(raw))
	for _, part := range raw {
		part = strings.TrimSpace(part)
		if part != "" {
			out = append(out, part)
		}
	}
	return out
}

// dropRepeatedReply keeps distinct paragraphs. A trailing copy of the previous
// paragraph, or a second copy of the whole reply, is removed.
func dropRepeatedReply(text string) string {
	parts := replyParagraphs(text)
	for len(parts) >= 2 && replyCompact(parts[len(parts)-1]) == replyCompact(parts[len(parts)-2]) {
		parts = parts[:len(parts)-1]
	}
	if len(parts) >= 2 && len(parts)%2 == 0 {
		mid := len(parts) / 2
		if replyCompact(strings.Join(parts[:mid], "\n\n")) == replyCompact(strings.Join(parts[mid:], "\n\n")) {
			parts = parts[:mid]
		}
	}
	return strings.Join(parts, "\n\n")
}

// assistantVisibleReply keeps every paragraph the model wrote, including the
// ones that arrived before later tool calls. The CLI result is often only the
// last paragraph, and sometimes repeats that paragraph. A repeated copy is
// stored once.
func assistantVisibleReply(final string, events []domain.AssistantActivityEvent) string {
	final = stripAssistantCLINotices(final)
	parts := make([]string, 0, 4)
	for _, event := range events {
		if event.Kind != "text" {
			continue
		}
		if text := strings.TrimSpace(event.Text); text != "" && !assistantCLINoticeText(text) {
			parts = append(parts, text)
		}
	}
	joined := strings.Join(parts, "\n\n")
	final = strings.TrimSpace(final)
	if joined == "" {
		return dropRepeatedReply(final)
	}
	compactJoined := replyCompact(joined)
	compactFinal := replyCompact(final)
	if final == "" || compactFinal == "" || compactFinal == compactJoined+compactJoined || strings.Contains(joined, final) {
		return joined
	}
	if compactFinal == compactJoined {
		return replyRicher(joined, final)
	}
	if strings.Contains(final, joined) || strings.HasPrefix(compactFinal, compactJoined) {
		repeated := dropRepeatedReply(final)
		if replyCompact(repeated) == compactJoined {
			return replyRicher(joined, repeated)
		}
		return repeated
	}
	// The CLI result is usually only the last paragraph, sometimes with a
	// summary that never streamed as its own segment. Keep every earlier
	// paragraph and append just the new tail.
	last := parts[len(parts)-1]
	if replyCompact(final) == replyCompact(last) {
		if len(final) > len(last) && strings.HasSuffix(joined, last) {
			return strings.TrimSuffix(joined, last) + final
		}
		return joined
	}
	if strings.HasPrefix(final, last) {
		suffix := strings.TrimSpace(strings.TrimPrefix(final, last))
		if suffix == "" || replyCompact(suffix) == replyCompact(last) {
			return joined
		}
		return dropRepeatedReply(joined + "\n\n" + suffix)
	}
	return dropRepeatedReply(joined + "\n\n" + final)
}

// stripAssistantCLINotices drops the CLI's "Tool ... does not exist" lines
// from a reply. A reply made only of such lines is kept so the turn is not
// stored empty.
func stripAssistantCLINotices(text string) string {
	if !strings.Contains(text, "does not exist in the current tool set") {
		return text
	}
	lines := strings.Split(text, "\n")
	kept := lines[:0:0]
	for _, line := range lines {
		if !assistantCLINoticeText(line) {
			kept = append(kept, line)
		}
	}
	stripped := strings.TrimSpace(strings.Join(kept, "\n"))
	if stripped == "" {
		return text
	}
	return stripped
}

func transcriptWorthKeeping(text string, events []domain.AssistantActivityEvent) bool {
	if strings.TrimSpace(text) != "" {
		return true
	}
	for _, event := range events {
		switch event.Kind {
		case "text", "thinking":
			if strings.TrimSpace(event.Text) != "" {
				return true
			}
		case "tool", "toolDone":
			return true
		}
	}
	return false
}
func (l *assistantActivityLog) snapshot() []domain.AssistantActivityEvent {
	l.mu.Lock()
	defer l.mu.Unlock()
	out := append([]domain.AssistantActivityEvent(nil), l.events...)
	if l.truncated {
		out = append(out, domain.AssistantActivityEvent{Kind: "status", Text: "部分执行记录超过保存上限,已省略。"})
	}
	return out
}
func publicAssistantEvent(event assistantStreamEvent, user domain.User) assistantStreamEvent {
	if event.At == nil {
		now := time.Now().UTC()
		event.At = &now
	}
	event.Text = redactAssistantSecrets(event.Text, user)
	event.Detail = redactAssistantSecrets(event.Detail, user)
	event.Input = redactAssistantSecrets(event.Input, user)
	event.Output = redactAssistantSecrets(event.Output, user)
	return event
}

// Execution metadata belongs to the UI, never the model's conversation prompt.
func assistantPromptMessages(messages []assistantMessage) []assistantMessage {
	out := append([]assistantMessage(nil), messages...)
	for i := range out {
		out[i].Activity = nil
		out[i].RunIDs = nil
		out[i].Assets = nil
		out[i].Model = ""
		out[i].Usage = nil
		if out[i].Unfinished != "" {
			out[i].Content = assistantUnfinishedPromptContent(messages[i])
			out[i].Unfinished = ""
		}
	}
	return out
}

func (l *assistantActivityLog) forUser(user domain.User) []domain.AssistantActivityEvent {
	out := l.snapshot()
	for i := range out {
		out[i] = publicAssistantEvent(out[i], user)
	}
	return out
}