Files
coder/coderd/x/chatd/acp_transcript.go
T
Hugo Dutka e75885a37e feat: add ACP subagent waiting and transcript streaming (#30560)
Add `acp_wait_agent` to stream ACP transcripts, including reasoning and
nested tool activity, to users while returning the subagent's text
response to the parent model. Reconnect dropped streams from their
transcript cursor, preserve running sessions on wait timeout or
cancellation, and persist separate user-visible and model-visible
results.

Depends on #31022.

Generated with Codex, carefully reviewed by Hugo.
2026-10-26 17:55:52 +01:00

253 lines
9.2 KiB
Go

package chatd
import (
"bytes"
"encoding/json"
"strings"
"golang.org/x/xerrors"
acp "github.com/coder/acp-go-sdk"
"github.com/coder/coder/v2/coderd/httpapi"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/workspacesdk"
)
type acpTranscriptTool struct {
call acp.SessionUpdateToolCall
message, part, resultMessage int
}
// acpTranscriptPart identifies a part within the final transcript's messages.
// Text and reasoning append; tool calls and results update by tool_call_id.
type acpTranscriptPart struct {
MessageIndex int `json:"message_index"`
Role codersdk.ChatMessageRole `json:"role"`
Part codersdk.ChatMessagePart `json:"part"`
}
// acpTranscript reduces replacement-style ACP tool updates within one generation.
type acpTranscript struct {
messages []codersdk.ChatACPTranscriptMessage
tools map[string]*acpTranscriptTool
response strings.Builder
partText strings.Builder
messageID string
}
func newACPTranscript() *acpTranscript {
return &acpTranscript{
messages: []codersdk.ChatACPTranscriptMessage{},
tools: make(map[string]*acpTranscriptTool),
}
}
func (t *acpTranscript) appendPart(role codersdk.ChatMessageRole, part codersdk.ChatMessagePart, messageID *string) acpTranscriptPart {
id := ""
if messageID != nil {
id = *messageID
}
newMessage := len(t.messages) == 0 || t.messages[len(t.messages)-1].Role != role || (id != "" && id != t.messageID)
if newMessage {
t.messages = append(t.messages, codersdk.ChatACPTranscriptMessage{Role: role, Content: []codersdk.ChatMessagePart{}})
}
message := &t.messages[len(t.messages)-1]
if len(message.Content) > 0 && (part.Type == codersdk.ChatMessagePartTypeText || part.Type == codersdk.ChatMessagePartTypeReasoning) && message.Content[len(message.Content)-1].Type == part.Type {
last := &message.Content[len(message.Content)-1]
if t.partText.Len() == 0 {
_, _ = t.partText.WriteString(last.Text)
}
_, _ = t.partText.WriteString(part.Text)
// String shares the buffer without copying the accumulated prefix.
last.Text = t.partText.String()
} else {
t.partText.Reset()
message.Content = append(message.Content, part)
}
t.messageID = id
return acpTranscriptPart{MessageIndex: len(t.messages) - 1, Role: role, Part: part}
}
func acpContentText(update json.RawMessage) (string, bool, error) {
var raw struct {
Content *json.RawMessage `json:"content" validate:"required"`
}
if err := json.Unmarshal(update, &raw); err != nil {
return "", false, err
}
if err := httpapi.Validate.Struct(raw); err != nil {
return "", false, err
}
var content struct {
Type string `json:"type" validate:"required"`
// Decode text only for text blocks; other variants remain opaque.
Text *json.RawMessage `json:"text" validate:"required_if=Type text"`
}
if err := json.Unmarshal(*raw.Content, &content); err != nil {
return "", false, err
}
if err := httpapi.Validate.Struct(content); err != nil {
return "", false, err
}
if content.Type != "text" {
return string(*raw.Content), false, nil
}
var text string
if err := json.Unmarshal(*content.Text, &text); err != nil {
return "", false, err
}
return text, true, nil
}
// validateACPToolUpdate checks fields that the SDK decodes without validation.
// Unknown fields remain allowed for protocol extensions.
func validateACPToolUpdate(update json.RawMessage) error {
var fields struct {
SessionUpdate string `json:"sessionUpdate" validate:"required,oneof=tool_call tool_call_update"`
ToolCallID string `json:"toolCallId" validate:"required"`
Title *string `json:"title" validate:"required_if=SessionUpdate tool_call"`
Status *acp.ToolCallStatus `json:"status" validate:"omitempty,oneof=pending in_progress completed failed"`
Kind *acp.ToolKind `json:"kind" validate:"omitempty,oneof=read edit delete move search execute think fetch switch_mode other"`
}
if err := json.Unmarshal(update, &fields); err != nil {
return err
}
return httpapi.Validate.Struct(fields)
}
// consume includes agent messages, agent reasoning, and tool activity in
// the wait transcript and live preview. It omits protocol metadata such as command
// lists, usage, plans, capability changes, and tool metadata, plus unknown updates.
// Session errors are returned separately by acpWaitResponse.
func (t *acpTranscript) consume(event workspacesdk.ACPEvent) ([]acpTranscriptPart, error) {
switch event.Kind {
case workspacesdk.ACPEventKindError:
// Session errors are returned separately by acpWaitResponse.
return nil, nil
case workspacesdk.ACPEventKindUpdate:
var header struct {
Kind string `json:"sessionUpdate" validate:"required"`
}
if err := json.Unmarshal(event.Update, &header); err != nil {
return nil, xerrors.Errorf("decode ACP update: %w", err)
}
if err := httpapi.Validate.Struct(header); err != nil {
return nil, xerrors.Errorf("invalid ACP update: %w", err)
}
switch header.Kind {
case "agent_message_chunk", "agent_thought_chunk", "tool_call", "tool_call_update":
default:
return nil, nil
}
var (
text string
isText bool
err error
)
switch header.Kind {
case "agent_message_chunk", "agent_thought_chunk":
text, isText, err = acpContentText(event.Update)
case "tool_call", "tool_call_update":
err = validateACPToolUpdate(event.Update)
}
if err != nil {
return nil, xerrors.Errorf("invalid ACP %s: %w", header.Kind, err)
}
var update acp.SessionUpdate
if err := json.Unmarshal(event.Update, &update); err != nil {
return nil, xerrors.Errorf("decode ACP update: %w", err)
}
switch {
case update.AgentMessageChunk != nil:
chunk := update.AgentMessageChunk
if isText {
_, _ = t.response.WriteString(text)
}
return []acpTranscriptPart{t.appendPart(codersdk.ChatMessageRoleAssistant, codersdk.ChatMessageText(text), chunk.MessageId)}, nil
case update.AgentThoughtChunk != nil:
chunk := update.AgentThoughtChunk
return []acpTranscriptPart{t.appendPart(codersdk.ChatMessageRoleAssistant, codersdk.ChatMessageReasoning(text), chunk.MessageId)}, nil
case update.ToolCall != nil:
return t.updateTool(*update.ToolCall)
case update.ToolCallUpdate != nil:
u := update.ToolCallUpdate
call := acp.SessionUpdateToolCall{ToolCallId: u.ToolCallId, Title: string(u.ToolCallId)}
if existing := t.tools[string(u.ToolCallId)]; existing != nil {
call = existing.call
}
if u.Title != nil {
call.Title = *u.Title
}
if u.Status != nil {
call.Status = *u.Status
}
if u.Kind != nil {
call.Kind = *u.Kind
}
if u.Content != nil {
call.Content = u.Content
}
if u.Locations != nil {
call.Locations = u.Locations
}
if u.RawInput != nil {
call.RawInput = u.RawInput
}
if u.RawOutput != nil {
call.RawOutput = u.RawOutput
}
return t.updateTool(call)
default:
return nil, nil
}
}
return nil, nil
}
func (t *acpTranscript) updateTool(call acp.SessionUpdateToolCall) ([]acpTranscriptPart, error) {
args := json.RawMessage(`{}`)
if call.RawInput != nil {
var err error
args, err = json.Marshal(call.RawInput)
if err != nil {
return nil, xerrors.Errorf("encode ACP tool input: %w", err)
}
}
result, err := json.Marshal(map[string]any{"status": call.Status, "output": call.RawOutput, "content": call.Content, "locations": call.Locations, "kind": call.Kind})
if err != nil {
return nil, xerrors.Errorf("encode ACP tool result: %w", err)
}
id := string(call.ToolCallId)
tool := t.tools[id]
if tool == nil {
t.appendPart(codersdk.ChatMessageRoleAssistant, codersdk.ChatMessagePart{Type: codersdk.ChatMessagePartTypeToolCall, ToolCallID: id}, nil)
tool = &acpTranscriptTool{message: len(t.messages) - 1, part: len(t.messages[len(t.messages)-1].Content) - 1}
t.messages = append(t.messages, codersdk.ChatACPTranscriptMessage{Role: codersdk.ChatMessageRoleTool, Content: []codersdk.ChatMessagePart{{Type: codersdk.ChatMessagePartTypeToolResult, ToolCallID: id}}})
tool.resultMessage = len(t.messages) - 1
t.tools[id] = tool
}
tool.call = call
name := call.Title
if name == "" {
name = id
}
callPart := codersdk.ChatMessageToolCall(id, name, args)
previousCall := t.messages[tool.message].Content[tool.part]
t.messages[tool.message].Content[tool.part] = callPart
resultPart := codersdk.ChatMessageToolResult(id, name, result, call.Status == acp.ToolCallStatusFailed, false)
previousResult := t.messages[tool.resultMessage].Content[0]
t.messages[tool.resultMessage].Content[0] = resultPart
t.messageID = ""
var parts []acpTranscriptPart
if previousCall.ToolName != name || !bytes.Equal(previousCall.Args, args) {
parts = append(parts, acpTranscriptPart{MessageIndex: tool.message, Role: codersdk.ChatMessageRoleAssistant, Part: callPart})
}
// A populated result completes a tool in the chat renderer. Keep running
// tools as calls until ACP reports a terminal status.
if (call.Status == acp.ToolCallStatusCompleted || call.Status == acp.ToolCallStatusFailed) &&
(previousResult.ToolName != name || !bytes.Equal(previousResult.Result, result)) {
parts = append(parts, acpTranscriptPart{MessageIndex: tool.resultMessage, Role: codersdk.ChatMessageRoleTool, Part: resultPart})
}
return parts, nil
}