Files
sam 69a46249cc
Quality / check (pull_request) Successful in 3m38s
feat(webui): draw each transcript entry with its Trace pattern (#1718)
Record the model's reasoning parts. The step run view shows reasoning as a
Thought row, shell calls as a terminal, the gate as a test run, web_fetch as a
source, finish as the verdict, and each fan-out branch as a subagent.
2026-11-01 22:09:53 +11:00

188 lines
5.4 KiB
Go

package modelloop
import (
"context"
"encoding/json"
"strings"
"sync"
"time"
"unicode/utf8"
"github.com/samcharles93/ai-sdk/chat"
"github.com/samcharles93/ai-sdk/core"
"github.com/samcharles93/archie-core/internal/domain/agentrun"
"github.com/samcharles93/archie-core/internal/webhookguard"
)
// transcriptFieldLimit caps each recorded text field, in bytes.
const transcriptFieldLimit = 32 << 10
// compactionPrefix starts the instruction agentloop sends to summarise the
// history, which marks a model call as a compaction rather than a step.
const compactionPrefix = "Compact the conversation history above"
// transcript records one agent run's conversation through agentloop's model
// and tool hooks. Tool hooks run concurrently, so entries are numbered and
// reported under one lock to keep their order.
type transcript struct {
report func(agentrun.TranscriptEntry)
mu sync.Mutex
seq int
prompted bool
lastUser string
started map[string]time.Time
}
func newTranscript(report func(agentrun.TranscriptEntry)) *transcript {
return &transcript{report: report, started: map[string]time.Time{}}
}
func (t *transcript) add(entry agentrun.TranscriptEntry) {
t.seq++
entry.Seq = t.seq
t.report(entry)
}
func (t *transcript) ModelCallStarted(context.Context, chat.Request) {}
func (t *transcript) ModelCallFinished(_ context.Context, req chat.Request, resp *chat.Response, err error, latency time.Duration, usage *chat.Usage) {
t.mu.Lock()
defer t.mu.Unlock()
entry := agentrun.TranscriptEntry{Kind: agentrun.TranscriptModel, LatencyMS: latency.Milliseconds(), Usage: transcriptUsage(usage)}
if isCompaction(req) {
entry.Kind = agentrun.TranscriptCompaction
} else {
t.recordInput(req.Messages)
}
if err != nil {
entry.Error = clip(err.Error(), nil)
}
if resp != nil {
entry.Text = clip(resp.Content, &entry.TextBytes)
entry.Reasoning = clip(reasoning(resp.Parts), &entry.ReasoningBytes)
entry.FinishReason = resp.FinishReason
for _, call := range resp.ToolCalls {
recorded := agentrun.TranscriptToolCall{ID: call.ID, Name: call.Name}
recorded.Args = clipArgs(call.Arguments, &recorded.ArgsBytes)
entry.ToolCalls = append(entry.ToolCalls, recorded)
}
}
t.add(entry)
}
// recordInput records the prompt on the first call, and after that each user
// message the loop appended since the model last answered: gate feedback,
// recovery nudges. Assistant and tool messages are recorded from the response
// and the tool hooks instead.
func (t *transcript) recordInput(messages []chat.Message) {
if !t.prompted {
t.prompted = true
for _, message := range messages {
t.recordMessage(message)
}
return
}
start := len(messages)
for start > 0 && messages[start-1].Role == chat.RoleUser {
start--
}
for _, message := range messages[start:] {
if message.Content != t.lastUser {
t.recordMessage(message)
}
}
}
func (t *transcript) recordMessage(message chat.Message) {
kind := agentrun.TranscriptUser
switch message.Role {
case chat.RoleSystem:
kind = agentrun.TranscriptSystem
case chat.RoleUser:
t.lastUser = message.Content
default:
return
}
entry := agentrun.TranscriptEntry{Kind: kind}
entry.Text = clip(message.Content, &entry.TextBytes)
t.add(entry)
}
func (t *transcript) BeforeToolExecute(_ context.Context, call *core.ToolCall) (*core.Skip, error) {
t.mu.Lock()
t.started[call.ToolCallID] = time.Now()
t.mu.Unlock()
return nil, nil
}
func (t *transcript) AfterToolExecute(_ context.Context, call core.ToolCall, result *core.ToolResult) {
t.mu.Lock()
defer t.mu.Unlock()
entry := agentrun.TranscriptEntry{Kind: agentrun.TranscriptTool, CallID: call.ToolCallID, Tool: call.ToolName}
if started, ok := t.started[call.ToolCallID]; ok {
entry.LatencyMS = time.Since(started).Milliseconds()
delete(t.started, call.ToolCallID)
}
entry.Args = clipArgs(call.Input, &entry.ArgsBytes)
entry.Output = clip(result.Output, &entry.OutputBytes)
entry.Error = clip(result.Error, nil)
t.add(entry)
}
func reasoning(parts chat.Parts) string {
var texts []string
for _, part := range parts {
if thought, ok := part.(chat.ReasoningPart); ok && thought.Text != "" {
texts = append(texts, thought.Text)
}
}
return strings.Join(texts, "\n\n")
}
func isCompaction(req chat.Request) bool {
n := len(req.Messages)
return n > 0 && req.Messages[n-1].Role == chat.RoleUser && strings.HasPrefix(req.Messages[n-1].Content, compactionPrefix)
}
func transcriptUsage(usage *chat.Usage) *agentrun.Usage {
if usage == nil {
return nil
}
return &agentrun.Usage{
PromptTokens: usage.PromptTokens,
CompletionTokens: usage.CompletionTokens,
TotalTokens: usage.TotalTokens,
CachedTokens: usage.CachedTokens,
CacheCreationTokens: usage.CacheCreationTokens,
}
}
// clipArgs redacts tool arguments by key when they are JSON, then clips them.
func clipArgs(args string, full *int) string {
if json.Valid([]byte(args)) {
if redacted, err := webhookguard.RedactPayload([]byte(args)); err == nil {
args = string(redacted)
}
}
return clip(args, full)
}
// clip redacts secret-shaped spans and cuts text to transcriptFieldLimit on a
// rune boundary, storing the original size in full when it cuts.
func clip(text string, full *int) string {
text = webhookguard.RedactText(text)
if len(text) <= transcriptFieldLimit {
return text
}
if full != nil {
*full = len(text)
}
cut := transcriptFieldLimit
for cut > 0 && !utf8.RuneStart(text[cut]) {
cut--
}
return text[:cut]
}