Files

977 lines
29 KiB
Go

package claude
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"regexp"
"sort"
"strconv"
"strings"
"time"
"git.a-wan.net/alan/pipelines/internal/claudehost"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// ---- CLI line envelope -----------------------------------------------------
type lineEnvelope struct {
Timestamp string `json:"timestamp"`
Type string `json:"type"`
Subtype string `json:"subtype"`
UUID string `json:"uuid"`
SessionID string `json:"session_id"`
ParentToolUseID string `json:"parent_tool_use_id"`
Message json.RawMessage `json:"message"`
Event json.RawMessage `json:"event"`
RequestID string `json:"request_id"`
Request json.RawMessage `json:"request"`
Response json.RawMessage `json:"response"`
Status string `json:"status"`
CompactMetadata json.RawMessage `json:"compactMetadata"`
Result string `json:"result"`
IsError bool `json:"is_error"`
TotalCostUSD float64 `json:"total_cost_usd"`
Usage json.RawMessage `json:"usage"`
// Origin and IsMeta mark a user line the harness injected (an agent report,
// a task notification, a reminder); see classifyInjected.
Origin json.RawMessage `json:"origin"`
IsMeta bool `json:"isMeta"`
// RateLimitInfo is the payload of a rate_limit_event line (see quota.go).
RateLimitInfo json.RawMessage `json:"rate_limit_info"`
}
type contentBlock struct {
Type string `json:"type"`
Text string `json:"text"`
Thinking string `json:"thinking"`
ID string `json:"id"`
Name string `json:"name"`
Input json.RawMessage `json:"input"`
ToolUseID string `json:"tool_use_id"`
Content json.RawMessage `json:"content"`
IsError bool `json:"is_error"`
Source *struct {
Type string `json:"type"`
MediaType string `json:"media_type"`
Data string `json:"data"`
} `json:"source"`
}
type messageBody struct {
ID string `json:"id"`
Role string `json:"role"`
Model string `json:"model"`
Content json.RawMessage `json:"content"`
}
type toolRequest struct {
Subtype string `json:"subtype"`
CallbackID string `json:"callback_id"`
ToolName string `json:"tool_name"`
DisplayName string `json:"display_name"`
Description string `json:"description"`
Input json.RawMessage `json:"input"`
PermissionSuggestions json.RawMessage `json:"permission_suggestions"`
ToolUseID string `json:"tool_use_id"`
DecisionReason string `json:"decision_reason"`
}
type streamEvent struct {
Type string `json:"type"`
Index int `json:"index"`
Message *messageBody `json:"message"`
ContentBlock *contentBlock `json:"content_block"`
Delta *struct {
Type string `json:"type"`
Text string `json:"text"`
Thinking string `json:"thinking"`
PartialJSON string `json:"partial_json"`
} `json:"delta"`
}
// ---- Dispatch --------------------------------------------------------------
func (s *session) handleLine(p *process, line []byte) {
var envelope lineEnvelope
if err := json.Unmarshal(line, &envelope); err != nil {
return
}
// Subagent traffic is a sidechain: its text and tools are not the operator's
// main turn, and history excludes the same entries (isSidechain).
if envelope.ParentToolUseID != "" {
return
}
switch envelope.Type {
case "control_request":
s.handleControlRequest(p, envelope)
case "control_response":
s.handleControlResponse(p, envelope)
case "stream_event":
s.adoptFollowUpTurn()
s.handleStreamEvent(envelope)
case "assistant":
s.adoptFollowUpTurn()
s.handleAssistant(envelope)
case "user":
s.handleUser(envelope)
case "result":
s.handleResult(envelope)
case "rate_limit_event":
s.handleRateLimit(envelope.RateLimitInfo)
case "system":
if envelope.Subtype == "task_started" || envelope.Subtype == "task_progress" {
s.handleTaskMetadata(line)
return
}
if envelope.Subtype == "task_notification" {
s.finishNotifiedTask(line)
return
}
s.handleSystem(envelope)
}
}
func (s *session) handleControlResponse(p *process, envelope lineEnvelope) {
var reply struct {
Subtype string `json:"subtype"`
RequestID string `json:"request_id"`
Response json.RawMessage `json:"response"`
Error string `json:"error"`
}
if json.Unmarshal(envelope.Response, &reply) != nil || reply.RequestID == "" {
return
}
if p == nil {
return
}
p.mu.Lock()
ch := p.pending[reply.RequestID]
delete(p.pending, reply.RequestID)
p.mu.Unlock()
if ch == nil {
return
}
if reply.Subtype == "error" {
select {
case ch <- controlReply{err: reply.Error}:
default:
}
return
}
select {
case ch <- controlReply{response: reply.Response}:
default:
}
}
func (s *session) handleControlRequest(p *process, envelope lineEnvelope) {
var request toolRequest
if json.Unmarshal(envelope.Request, &request) != nil {
return
}
switch request.Subtype {
case "can_use_tool":
s.receivePermission(p, envelope.RequestID, request)
case "hook_callback":
if !claudehost.IsAutomationHook(request.CallbackID) {
s.respondUnsupported(p, envelope.RequestID)
return
}
snapshot, _ := claudehost.ParseAutomationHook(request.CallbackID, s.id, request.Input, time.Now().UnixMilli())
s.mu.Lock()
s.automations = snapshot
s.automationProcess = p
s.mu.Unlock()
// A detachable host observes and acknowledges its own callback before
// the server is involved. Direct processes need the adapter response.
if p.link == nil {
_ = p.respond(envelope.RequestID, map[string]any{})
}
case "mcp_message":
s.respondUnsupported(p, envelope.RequestID)
default:
s.respondUnsupported(p, envelope.RequestID)
}
}
func (s *session) respondUnsupported(p *process, requestID string) {
if p == nil || requestID == "" {
return
}
_ = p.write(map[string]any{
"type": "control_response",
"response": map[string]any{
"subtype": "error",
"request_id": requestID,
"error": "This Pipelines server does not support that Claude Code interaction",
},
})
}
// ---- Streaming text --------------------------------------------------------
func (s *session) handleStreamEvent(envelope lineEnvelope) {
var event streamEvent
if json.Unmarshal(envelope.Event, &event) != nil {
return
}
s.mu.Lock()
defer s.mu.Unlock()
switch event.Type {
case "message_start":
s.streamID = ""
if event.Message != nil {
s.streamID = event.Message.ID
}
if s.streamID == "" {
s.streamID = envelope.UUID
}
s.resetStreamLocked()
case "content_block_start":
if event.ContentBlock == nil {
return
}
kind := streamKind(event.ContentBlock.Type)
if kind == "" {
return
}
ordinal := s.streamOrdinals[kind]
s.streamOrdinals[kind] = ordinal + 1
s.streamBlocks[event.Index] = blockState{kind: kind, ordinal: ordinal}
case "content_block_delta":
if event.Delta == nil {
return
}
block, ok := s.streamBlocks[event.Index]
kind := block.kind
if !ok {
kind = streamKind(deltaKind(event.Delta.Type))
if kind == "" {
return
}
block = blockState{kind: kind, ordinal: s.streamOrdinals[kind]}
s.streamOrdinals[kind]++
s.streamBlocks[event.Index] = block
}
var delta string
switch event.Delta.Type {
case "text_delta":
if block.kind != protocol.ChatPartText {
return
}
delta = event.Delta.Text
case "thinking_delta":
if block.kind != protocol.ChatPartReasoning {
return
}
delta = event.Delta.Thinking
default:
return
}
if delta == "" {
return
}
s.streamText[event.Index] += delta
messageID := s.streamID
if messageID == "" {
return
}
partID := protocol.ChatDeltaPartID(messageID, block.kind, block.ordinal)
s.broadcastLocked(protocol.ChatEventFrame{
SessionID: s.id,
NativeTurnID: s.turnID,
MessageID: messageID,
Kind: block.kind,
Delta: delta,
Part: &protocol.ChatPart{ID: partID, Type: block.kind},
})
case "message_stop":
// Keep the assembled blocks: the CLI sends the completed assistant
// message after message_stop, and that message must not repeat text
// already delivered as deltas. message_start resets them for the next one.
}
}
func streamKind(blockType string) string {
switch blockType {
case "text":
return protocol.ChatPartText
case "thinking", "reasoning":
return protocol.ChatPartReasoning
default:
return ""
}
}
func deltaKind(deltaType string) string {
switch deltaType {
case "text_delta":
return "text"
case "thinking_delta":
return "thinking"
default:
return ""
}
}
// resetStreamLocked forgets the assembled stream blocks of the previous message.
func (s *session) resetStreamLocked() {
s.streamBlocks = map[int]blockState{}
s.streamText = map[int]string{}
s.streamOrdinals = map[string]int{}
s.streamClaimed = map[int]bool{}
}
// claimStreamedLocked finds the streamed block a completed text or thinking block
// repeats. The CLI sends one assistant event per content block, so a block's
// index within the event (usually 0) is not its stream index: a text block that
// follows a thinking block streams at index 1 but arrives alone in its event.
// The match is the first unclaimed streamed block of the same kind whose text
// is a prefix of the completed text, preferring the event-local index. An
// unclaimed streamed block of that kind that disagrees is returned too, so the
// caller suppresses the repeat instead of emitting the whole answer again.
func (s *session) claimStreamedLocked(kind, full string, local int) (blockState, string, bool) {
indices := make([]int, 0, len(s.streamBlocks)+1)
indices = append(indices, local)
others := make([]int, 0, len(s.streamBlocks))
for index := range s.streamBlocks {
if index != local {
others = append(others, index)
}
}
sort.Ints(others)
indices = append(indices, others...)
disagree := -1
for _, index := range indices {
block := s.streamBlocks[index]
streamed := s.streamText[index]
if block.kind != kind || s.streamClaimed[index] || streamed == "" {
continue
}
if strings.HasPrefix(full, streamed) {
s.streamClaimed[index] = true
return block, streamed, true
}
if disagree < 0 {
disagree = index
}
}
if disagree >= 0 {
s.streamClaimed[disagree] = true
return s.streamBlocks[disagree], s.streamText[disagree], true
}
return blockState{}, "", false
}
// broadcastLocked emits while the session lock is already held: the caller is a
// stream-delta path that owns state it just updated.
func (s *session) broadcastLocked(frame protocol.ChatEventFrame) {
if s.silent {
return
}
targets := make([]chan protocol.ChatEventFrame, 0, len(s.subs))
for ch := range s.subs {
targets = append(targets, ch)
}
for _, ch := range targets {
select {
case ch <- frame:
default:
}
}
}
// ---- Completed messages ----------------------------------------------------
func (s *session) handleAssistant(envelope lineEnvelope) {
var body messageBody
if json.Unmarshal(envelope.Message, &body) != nil {
return
}
messageID := strings.TrimSpace(body.ID)
if messageID == "" {
messageID = envelope.UUID
}
if messageID == "" {
return
}
blocks := decodeBlocks(body.Content)
s.mu.Lock()
if messageID != s.streamID {
// A message that was not streamed (or a new one): nothing streamed can
// be aligned with it. Later events of the same message keep this state.
s.resetStreamLocked()
s.streamID = messageID
}
if body.Model != "" {
s.modelActual = body.Model
}
// Align the completed message with what was streamed, then emit only the
// remainder: the CLI sends deltas first and the full block afterwards.
var frames []protocol.ChatEventFrame
for index, block := range blocks {
switch block.Type {
case "text", "thinking":
kind := protocol.ChatPartText
full := block.Text
if block.Type == "thinking" {
kind = protocol.ChatPartReasoning
full = block.Thinking
}
if strings.TrimSpace(full) == "" {
continue
}
state, streamed, matched := s.claimStreamedLocked(kind, full, index)
if !matched {
state = blockState{kind: kind, ordinal: s.streamOrdinals[kind]}
s.streamOrdinals[kind]++
}
delta := full
if strings.HasPrefix(full, streamed) {
delta = full[len(streamed):]
} else if streamed != "" {
// The stream and the final block disagree; never duplicate the
// whole answer. The authoritative transcript carries the full text.
delta = ""
}
if delta == "" {
continue
}
frames = append(frames, protocol.ChatEventFrame{
SessionID: s.id,
NativeTurnID: s.turnID,
MessageID: messageID,
Kind: kind,
Delta: delta,
Part: &protocol.ChatPart{ID: protocol.ChatDeltaPartID(messageID, kind, state.ordinal), Type: kind},
})
case "tool_use":
if block.ID == "" {
continue
}
s.toolMessages[block.ID] = messageID
input := truncateJSON(block.Input, 64<<10)
frames = append(frames, protocol.ChatEventFrame{
SessionID: s.id,
NativeTurnID: s.turnID,
MessageID: messageID,
Kind: protocol.ChatEventTool,
Part: &protocol.ChatPart{
Type: protocol.ChatPartTool,
ID: block.ID,
Name: block.Name,
State: &protocol.ChatToolState{
Status: protocol.ChatToolRunning,
Input: input,
},
},
})
var shell *protocol.ChatShell
switch block.Name {
case "Bash":
shell = s.recordShellLocked(block.ID, bashCommand(input))
if shell != nil && backgroundRequested(input) {
s.shells[block.ID].background = true
}
case "Agent", "Task":
// A subagent usually runs in the background; its immediate
// result says so, and a foreground one simply finishes.
shell = s.recordShellLocked(block.ID, agentLabel(input))
if shell != nil {
s.shells[block.ID].background = true
}
}
if shell != nil {
snapshot := s.shells[block.ID]
applyToolMetadata(&snapshot.shell, block.Name, input, envelope.Timestamp)
copy := snapshot.shell
shell = &copy
frames = append(frames, protocol.ChatEventFrame{SessionID: s.id, Kind: protocol.ChatEventShell, Shell: shell})
}
}
}
framesCopy := frames
s.mu.Unlock()
for _, frame := range framesCopy {
s.emit(frame)
}
}
func (s *session) handleUser(envelope lineEnvelope) {
var body messageBody
if json.Unmarshal(envelope.Message, &body) != nil {
return
}
blocks := decodeBlocks(body.Content)
origin := decodeOrigin(envelope.Origin)
for _, block := range blocks {
if block.Type != "text" {
continue
}
if strings.Contains(block.Text, "<task-notification>") {
s.finishBackgroundTasks(block.Text)
}
// The operator's own prompts are published when they are sent, so the
// stream echo is never drawn again. Harness input that the operator did
// not send is drawn as a report card or a notice, never as a prompt.
s.emitInjected(classifyInjected(block.Text, origin, envelope.IsMeta))
}
for _, block := range blocks {
if block.Type != "tool_result" || block.ToolUseID == "" {
continue
}
text, images := toolResultContent(block.Content)
status := protocol.ChatToolCompleted
var toolErr *protocol.ChatError
exit := exitCode(text)
if block.IsError || (exit != nil && *exit != 0) {
status = protocol.ChatToolError
message := "the tool returned an error"
if exit != nil && *exit != 0 {
message = fmt.Sprintf("Exit code %d", *exit)
}
if strings.TrimSpace(text) != "" {
message = boundedText(strings.TrimSpace(text), 2<<10)
}
toolErr = &protocol.ChatError{Type: "tool", Message: message}
}
content := []protocol.ChatToolContent{}
if text != "" {
content = append(content, protocol.ChatToolContent{Type: "text", Text: boundedText(text, 128<<10)})
}
content = append(content, images...)
s.mu.Lock()
messageID := s.toolMessages[block.ToolUseID]
shell := s.shells[block.ToolUseID]
s.mu.Unlock()
part := protocol.ChatPart{
Type: protocol.ChatPartTool,
ID: block.ToolUseID,
State: &protocol.ChatToolState{
Status: status,
Content: content,
Error: toolErr,
},
}
s.emit(protocol.ChatEventFrame{
SessionID: s.id,
NativeTurnID: s.turnID,
MessageID: messageID,
Kind: protocol.ChatEventTool,
Part: &part,
})
if shell != nil {
var frame *protocol.ChatShell
s.mu.Lock()
if snapshot, ok := s.shells[block.ToolUseID]; ok && snapshot.background && launchedInBackground(text) {
// Started, not finished: it stays running until Claude Code
// reports the task's completion.
snapshot.output = text
snapshot.size = int64(len(text))
} else if ok {
snapshot.shell.Status = protocol.ChatShellExited
snapshot.shell.Exit = exit
if text != "" && len(text) >= len(snapshot.output) {
snapshot.output = text
snapshot.size = int64(len(text))
if len(snapshot.output) > commandOutputCap {
snapshot.output = snapshot.output[:commandOutputCap]
}
}
copy := snapshot.shell
frame = &copy
}
s.mu.Unlock()
if frame != nil {
s.emit(protocol.ChatEventFrame{SessionID: s.id, Kind: protocol.ChatEventShell, Shell: frame})
}
}
}
}
func (s *session) handleResult(envelope lineEnvelope) {
s.mu.Lock()
turn := s.turnID
running := s.running
proc := s.proc
if s.silent {
proc = nil // replayed: the live usage query is made once caught up
}
s.running = false
s.turnID = ""
// Messages written mid-turn that the CLI did not fold into this turn run
// next as their own turn; its output adopts a new turn id.
s.awaitFollowUp = s.steered > 0
s.steered = 0
s.approvals = map[string]*pendingApproval{}
s.forms = map[string]*pendingForm{}
s.resetStreamLocked()
s.mu.Unlock()
if envelope.Subtype != "success" && envelope.Subtype != "error_during_execution" && envelope.Subtype != "" {
message := strings.TrimSpace(envelope.Result)
if message == "" {
message = "Claude Code ended the turn: " + envelope.Subtype
}
s.emit(protocol.ChatEventFrame{
SessionID: s.id,
NativeTurnID: turn,
MessageID: "claude-result-" + turn,
Kind: protocol.ChatEventTool,
Part: &protocol.ChatPart{
Type: protocol.ChatPartTool,
ID: "claude-result-" + turn,
Name: "Claude Code",
State: &protocol.ChatToolState{Status: protocol.ChatToolError, Error: &protocol.ChatError{Type: envelope.Subtype, Message: boundedText(message, 2<<10)}},
},
})
}
if running {
s.emit(protocol.ChatEventFrame{SessionID: s.id, NativeTurnID: turn, Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded, TurnID: turn}})
}
if proc != nil {
go s.refreshUsage(proc)
}
}
func (s *session) handleSystem(envelope lineEnvelope) {
switch envelope.Subtype {
case "status":
if envelope.Status == "compacting" {
s.emit(protocol.ChatEventFrame{SessionID: s.id, NativeTurnID: s.currentTurn(), Kind: protocol.ChatEventCompaction, Compaction: &protocol.ChatCompaction{Status: "running"}})
}
case "compact_boundary":
s.emit(protocol.ChatEventFrame{SessionID: s.id, NativeTurnID: s.currentTurn(), Kind: protocol.ChatEventCompaction, Compaction: &protocol.ChatCompaction{Status: "completed"}})
case "init":
// The CLI re-emits init at each turn; keep only the authoritative identity.
s.adoptFollowUpTurn()
if envelope.SessionID != "" && envelope.SessionID != s.id {
s.mu.Lock()
s.lastErr = "Claude Code opened unexpected session " + envelope.SessionID
s.mu.Unlock()
}
}
}
func (s *session) currentTurn() string {
s.mu.Lock()
defer s.mu.Unlock()
return s.turnID
}
// ---- Tool helpers ----------------------------------------------------------
func decodeBlocks(raw json.RawMessage) []contentBlock {
if len(raw) == 0 {
return nil
}
var blocks []contentBlock
if json.Unmarshal(raw, &blocks) == nil {
return blocks
}
var text string
if json.Unmarshal(raw, &text) == nil && text != "" {
return []contentBlock{{Type: "text", Text: text}}
}
return nil
}
func toolResultContent(raw json.RawMessage) (string, []protocol.ChatToolContent) {
var text string
if json.Unmarshal(raw, &text) == nil {
return text, nil
}
blocks := decodeBlocks(raw)
var builder strings.Builder
images := []protocol.ChatToolContent{}
for _, block := range blocks {
switch block.Type {
case "text":
if builder.Len() > 0 {
builder.WriteString("\n")
}
builder.WriteString(block.Text)
case "image":
if block.Source != nil && block.Source.Data != "" && len(block.Source.Data) <= 512<<10 {
images = append(images, protocol.ChatToolContent{
Type: "file",
Mime: block.Source.MediaType,
Name: "image",
URI: "data:" + block.Source.MediaType + ";base64," + block.Source.Data,
})
}
}
}
return builder.String(), images
}
var exitLine = regexp.MustCompile(`(?m)^Exit code (\d+)\s*$`)
// exitCode reads the CLI's own "Exit code N" prefix. A successful command with
// no prefix is 0; an error without a numeric code stays unknown.
func exitCode(text string) *int {
if match := exitLine.FindStringSubmatch(text); len(match) == 2 {
if value, err := strconv.Atoi(match[1]); err == nil {
return &value
}
}
if strings.TrimSpace(text) != "" && !strings.HasPrefix(strings.TrimSpace(text), "Exit code") {
zero := 0
return &zero
}
return nil
}
func bashCommand(input json.RawMessage) string {
var parsed struct {
Command string `json:"command"`
}
if json.Unmarshal(input, &parsed) == nil {
return parsed.Command
}
return ""
}
func truncateJSON(raw json.RawMessage, limit int) json.RawMessage {
if len(raw) == 0 {
return json.RawMessage(`{}`)
}
if len(raw) > limit {
wrapped, _ := json.Marshal(map[string]any{"truncated": true, "preview": string(raw[:limit])})
return wrapped
}
return raw
}
func boundedText(text string, limit int) string {
if len(text) <= limit {
return text
}
return text[:limit] + "\n… (truncated)"
}
// ---- Shells ----------------------------------------------------------------
const commandOutputCap = 128 << 10
type shellSnapshot struct {
shell protocol.ChatShell
output string
size int64
order uint64
// background marks a command or subagent that may outlive its tool call:
// its immediate result only says it started.
background bool
taskID string
}
// backgroundRequested reports a Bash call asked to run in the background.
func backgroundRequested(input json.RawMessage) bool {
var parsed struct {
Background bool `json:"run_in_background"`
}
return json.Unmarshal(input, &parsed) == nil && parsed.Background
}
// agentLabel names a subagent the way the operator recognises it.
func agentLabel(input json.RawMessage) string {
var parsed struct {
Description string `json:"description"`
Type string `json:"subagent_type"`
}
_ = json.Unmarshal(input, &parsed)
label := strings.TrimSpace(parsed.Description)
if label == "" {
label = strings.TrimSpace(parsed.Type)
}
if label == "" {
return "Agent"
}
return "Agent: " + label
}
// launchedInBackground recognises Claude Code's immediate result for a task
// that keeps running after its tool call returns.
func launchedInBackground(text string) bool {
return strings.Contains(text, "running in background with ID") ||
strings.HasPrefix(strings.TrimSpace(text), "Async agent launched")
}
var (
taskNotificationPattern = regexp.MustCompile(`(?s)<task-notification>(.*?)</task-notification>`)
taskToolUsePattern = regexp.MustCompile(`<tool-use-id>\s*([^<\s]+)\s*</tool-use-id>`)
taskSummaryPattern = regexp.MustCompile(`(?s)<summary>(.*?)</summary>`)
taskExitPattern = regexp.MustCompile(`exit code (-?\d+)`)
)
// finishNotifiedTask handles the SDK's structured completion message for a
// background task, the counterpart of the <task-notification> text.
func (s *session) finishNotifiedTask(line []byte) {
s.handleTaskMetadata(line)
var notice struct {
ToolUseID string `json:"tool_use_id"`
Status string `json:"status"`
Summary string `json:"summary"`
}
if json.Unmarshal(line, &notice) != nil || notice.ToolUseID == "" {
return
}
s.emitInjected(taskNoticeLine(notice.ToolUseID, notice.Status, strings.Join(strings.Fields(notice.Summary), " ")))
s.finishBackgroundTasks(fmt.Sprintf(
"<task-notification><tool-use-id>%s</tool-use-id><status>%s</status><summary>%s</summary></task-notification>",
notice.ToolUseID, notice.Status, notice.Summary,
))
}
// endShellsLocked marks every command still running as exited (with no exit
// code: none was reported) and returns their final states, sorted by id, for
// the caller to publish once s.mu is released. Callers hold s.mu.
func (s *session) endShellsLocked() []*protocol.ChatShell {
var ended []*protocol.ChatShell
for _, snapshot := range s.shells {
if snapshot.shell.Status != protocol.ChatShellRunning {
continue
}
snapshot.shell.Status = protocol.ChatShellExited
copy := snapshot.shell
ended = append(ended, &copy)
}
sort.Slice(ended, func(i, j int) bool { return ended[i].ID < ended[j].ID })
return ended
}
// finishBackgroundTasks marks the tasks a Claude Code task notification
// reports as finished, and publishes each one's final state.
func (s *session) finishBackgroundTasks(text string) {
var frames []*protocol.ChatShell
s.mu.Lock()
for _, match := range taskNotificationPattern.FindAllStringSubmatch(text, -1) {
toolID := taskToolUsePattern.FindStringSubmatch(match[1])
if toolID == nil {
continue
}
snapshot, ok := s.shells[toolID[1]]
if !ok || snapshot.shell.Status != protocol.ChatShellRunning {
continue
}
snapshot.shell.Status = protocol.ChatShellExited
if summary := taskSummaryPattern.FindStringSubmatch(match[1]); summary != nil {
line := strings.TrimSpace(summary[1])
if code := taskExitPattern.FindStringSubmatch(line); code != nil {
if exit, err := strconv.Atoi(code[1]); err == nil {
snapshot.shell.Exit = &exit
}
}
if line != "" {
snapshot.output = strings.TrimRight(snapshot.output, "\n") + "\n" + line
snapshot.size = int64(len(snapshot.output))
}
}
copy := snapshot.shell
frames = append(frames, &copy)
}
s.mu.Unlock()
for _, frame := range frames {
s.emit(protocol.ChatEventFrame{SessionID: s.id, Kind: protocol.ChatEventShell, Shell: frame})
}
}
func shellID(toolID string) string {
sum := sha256.Sum256([]byte("claude\x00" + toolID))
return "sh_claude_" + hex.EncodeToString(sum[:16])
}
// recordShellLocked retains a running Bash command. Called with s.mu held; the
// caller emits the returned frame after the tool part, in that order.
func (s *session) recordShellLocked(toolID, command string) *protocol.ChatShell {
if toolID == "" {
return nil
}
if prior := s.shells[toolID]; prior != nil {
if command != "" {
prior.shell.Command = command
}
copy := prior.shell
return &copy
}
id := shellID(toolID)
s.shellOrder = append(s.shellOrder, id)
shell := protocol.ChatShell{ID: id, Status: protocol.ChatShellRunning, Command: command}
s.shells[toolID] = &shellSnapshot{shell: shell, order: uint64(len(s.shellOrder))}
return &shell
}
// ---- Usage -----------------------------------------------------------------
type usageModel struct {
InputTokens int64 `json:"inputTokens"`
OutputTokens int64 `json:"outputTokens"`
CacheReadInputTokens int64 `json:"cacheReadInputTokens"`
CacheCreationInputTokens int64 `json:"cacheCreationInputTokens"`
CostUSD float64 `json:"costUSD"`
ContextWindow int64 `json:"contextWindow"`
}
type sessionUsage struct {
Session struct {
TotalCostUSD float64 `json:"total_cost_usd"`
ModelUsage map[string]usageModel `json:"model_usage"`
} `json:"session"`
}
type contextUsage struct {
TotalTokens int64 `json:"totalTokens"`
MaxTokens int64 `json:"maxTokens"`
}
// refreshUsage asks the CLI for its own cumulative session totals. It runs off
// the reader goroutine because a control request waits for a response that only
// the reader can deliver.
func (s *session) refreshUsage(p *process) {
ctx, cancel := contextWithTimeout(controlRequestTimeout)
defer cancel()
raw, err := p.request(ctx, "get_usage", map[string]any{"skip_behaviors": true})
if err != nil {
return
}
var totals sessionUsage
if json.Unmarshal(raw, &totals) != nil {
return
}
var input, output, cacheRead, cacheCreate int64
for _, model := range totals.Session.ModelUsage {
input += model.InputTokens
output += model.OutputTokens
cacheRead += model.CacheReadInputTokens
cacheCreate += model.CacheCreationInputTokens
}
total := input + output + cacheRead + cacheCreate
cost := totals.Session.TotalCostUSD
usage := &protocol.ChatUsage{
Scope: "session",
InputTokens: int(input),
OutputTokens: int(output),
TotalTokens: &total,
CostUSD: &cost,
}
ctx2, cancel2 := contextWithTimeout(controlRequestTimeout)
defer cancel2()
if rawContext, err := p.request(ctx2, "get_context_usage", map[string]any{}); err == nil {
var context contextUsage
if json.Unmarshal(rawContext, &context) == nil {
if context.MaxTokens > 0 {
usage.ContextWindow = &context.MaxTokens
usage.ContextTokens = &context.TotalTokens
}
}
}
s.emit(protocol.ChatEventFrame{SessionID: s.id, Kind: protocol.ChatEventUsage, Usage: usage})
}
func contextWithTimeout(timeout time.Duration) (context.Context, context.CancelFunc) {
return context.WithTimeout(context.Background(), timeout)
}