Files
archie/internal/agentexec/harness_output_claude.go
T
sam 0f6448c048
deploy / plan (push) Failing after 1s
deploy / gate (push) Skipped
deploy / archied-image (push) Skipped
deploy / agent-image (push) Skipped
deploy / dist-zip (push) Skipped
refactor(agentexec): delete unused runner injection seams, ServeCaptureMCP, an unreachable approval branch and orphan fixtures
2026-11-09 01:43:53 +11:00

172 lines
4.7 KiB
Go

package agentexec
import (
"bytes"
"encoding/json"
"strings"
"github.com/samcharles93/archie-core/internal/domain/agentrun"
)
// claudeCodeHarnessOutput reads Claude Code's newline-delimited stream-json
// output. It keeps tool-use IDs until the corresponding user tool_result
// arrives and retains assistant usage as a fallback for interrupted runs.
type claudeCodeHarnessOutput struct {
sessionID string
pending map[string]string
messageUsage agentrun.Usage
seenMessages map[string]struct{}
hasResult bool
resultUsage agentrun.Usage
}
func newClaudeCodeHarnessOutput() *claudeCodeHarnessOutput {
return &claudeCodeHarnessOutput{
pending: make(map[string]string),
seenMessages: make(map[string]struct{}),
}
}
func (o *claudeCodeHarnessOutput) Line(line []byte, report agentrun.Reporter) {
var event struct {
Type string `json:"type"`
SessionID string `json:"session_id"`
Message json.RawMessage `json:"message"`
Usage json.RawMessage `json:"usage"`
}
if json.Unmarshal(line, &event) != nil {
return
}
if event.SessionID != "" {
o.sessionID = event.SessionID
}
switch event.Type {
case "assistant":
o.assistant(event.Message)
case "user":
o.user(event.Message, report)
case "result":
if usage, ok := decodeClaudeUsage(event.Usage); ok {
o.resultUsage = usage
o.hasResult = true
}
}
}
func (o *claudeCodeHarnessOutput) assistant(raw json.RawMessage) {
var message struct {
ID string `json:"id"`
Usage json.RawMessage `json:"usage"`
Content []struct {
Type string `json:"type"`
ID string `json:"id"`
Name string `json:"name"`
Input any `json:"input"`
} `json:"content"`
}
if json.Unmarshal(raw, &message) != nil {
return
}
if usage, ok := decodeClaudeUsage(message.Usage); ok && (message.ID == "" || o.markMessage(message.ID)) {
o.messageUsage = addUsage(o.messageUsage, usage)
}
for _, block := range message.Content {
if block.Type == "tool_use" && block.ID != "" && block.Name != "" {
o.pending[block.ID] = block.Name
}
}
}
func (o *claudeCodeHarnessOutput) user(raw json.RawMessage, report agentrun.Reporter) {
var message struct {
Content []struct {
Type string `json:"type"`
ToolUseID string `json:"tool_use_id"`
Content json.RawMessage `json:"content"`
IsError bool `json:"is_error"`
} `json:"content"`
}
if json.Unmarshal(raw, &message) != nil {
return
}
for _, block := range message.Content {
if block.Type != "tool_result" || block.ToolUseID == "" {
continue
}
tool, ok := o.pending[block.ToolUseID]
if !ok {
continue
}
delete(o.pending, block.ToolUseID)
report.ReportToolCall(agentrun.ToolCallReport{
Tool: tool, Detail: ClipToolCallDetail(claudeResultContent(block.Content)),
Failed: block.IsError,
})
}
}
func (o *claudeCodeHarnessOutput) markMessage(id string) bool {
if _, seen := o.seenMessages[id]; seen {
return false
}
o.seenMessages[id] = struct{}{}
return true
}
func (o *claudeCodeHarnessOutput) SessionID() string { return o.sessionID }
func (o *claudeCodeHarnessOutput) Usage() agentrun.Usage {
if o.hasResult {
return o.resultUsage
}
return o.messageUsage
}
func decodeClaudeUsage(raw json.RawMessage) (agentrun.Usage, bool) {
var fields struct {
InputTokens int `json:"input_tokens"`
OutputTokens int `json:"output_tokens"`
CacheReadInputTokens int `json:"cache_read_input_tokens"`
CacheCreationInputTokens int `json:"cache_creation_input_tokens"`
}
if len(raw) == 0 || bytes.Equal(bytes.TrimSpace(raw), []byte("null")) || json.Unmarshal(raw, &fields) != nil {
return agentrun.Usage{}, false
}
return usageFromFields(fields.InputTokens, fields.OutputTokens, fields.CacheReadInputTokens, fields.CacheCreationInputTokens), true
}
// usageFromFields folds cache reads and writes into PromptTokens, as the
// built-in loop's Anthropic provider does: Claude's input_tokens excludes
// them, and budgets must count a harness run the way they count a built-in
// one.
func usageFromFields(input, output, cacheRead, cacheCreation int) agentrun.Usage {
prompt := input + cacheRead + cacheCreation
return agentrun.Usage{
PromptTokens: prompt, CompletionTokens: output, TotalTokens: prompt + output,
CachedTokens: cacheRead, CacheCreationTokens: cacheCreation,
}
}
func claudeResultContent(raw json.RawMessage) string {
var content string
if json.Unmarshal(raw, &content) == nil {
return content
}
var blocks []struct {
Type string `json:"type"`
Text string `json:"text"`
}
if json.Unmarshal(raw, &blocks) != nil {
return ""
}
texts := make([]string, 0, len(blocks))
for _, block := range blocks {
if block.Type == "text" {
texts = append(texts, block.Text)
}
}
return strings.Join(texts, "\n")
}