172 lines
4.7 KiB
Go
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")
|
|
}
|