Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

21.4 KB
Raw Blame
package runtime

import (
	"encoding/json"
	"fmt"
	"strings"
)

// ClaudeStream renders the Claude-style stream-json lines that both the SOP
// protocol adapter (handleClaudeStream) and AI 对话 parse: deltas become
// stream_event content blocks, finished text / thinking / tool calls become
// assistant blocks, tool outputs become user tool_result blocks and the turn
// ends with a result line. Every line carries the CLI's session ID once it is
// known, so a node can resume the session.
type ClaudeStream struct {
	SessionID string
	// LastText is the latest finished assistant text, the turn's answer when
	// the CLI reports none of its own.
	LastText string
	block    string
	started  map[string]bool
	usage    map[string]int64
	done     bool
}

func (s *ClaudeStream) line(v map[string]any) string {
	if s.SessionID != "" {
		v["session_id"] = s.SessionID
	}
	data, _ := json.Marshal(v)
	return string(data)
}

// Init announces the session; model may be empty.
func (s *ClaudeStream) Init(sessionID, model string) []string {
	if sessionID = strings.TrimSpace(sessionID); sessionID != "" {
		s.SessionID = sessionID
	}
	event := map[string]any{"type": "system", "subtype": "init"}
	if model != "" {
		event["model"] = model
	}
	return []string{s.line(event)}
}

// Delta streams text into the content block key (kind "text" or
// "thinking"), opening it first.
func (s *ClaudeStream) Delta(key, kind, text string) []string {
	if text == "" {
		return nil
	}
	var out []string
	if s.block != key {
		out = append(s.CloseBlock(), s.line(map[string]any{"type": "stream_event", "event": map[string]any{"type": "content_block_start", "content_block": map[string]any{"type": kind}}}))
		s.block = key
	}
	delta := map[string]any{"type": "text_delta", "text": text}
	if kind == "thinking" {
		delta = map[string]any{"type": "thinking_delta", "thinking": text}
	}
	return append(out, s.line(map[string]any{"type": "stream_event", "event": map[string]any{"type": "content_block_delta", "delta": delta}}))
}

func (s *ClaudeStream) CloseBlock() []string {
	if s.block == "" {
		return nil
	}
	s.block = ""
	return []string{s.line(map[string]any{"type": "stream_event", "event": map[string]any{"type": "content_block_stop"}})}
}

func (s *ClaudeStream) assistant(block map[string]any) []string {
	return append(s.CloseBlock(), s.line(map[string]any{"type": "assistant", "message": map[string]any{"role": "assistant", "content": []map[string]any{block}}}))
}

// Text records a finished assistant text block.
func (s *ClaudeStream) Text(text string) []string {
	if strings.TrimSpace(text) == "" {
		return s.CloseBlock()
	}
	s.LastText = text
	return s.assistant(map[string]any{"type": "text", "text": text})
}

// Thinking records a finished reasoning block.
func (s *ClaudeStream) Thinking(text string) []string {
	if strings.TrimSpace(text) == "" {
		return s.CloseBlock()
	}
	return s.assistant(map[string]any{"type": "thinking", "thinking": text})
}

// ToolUse records a tool call once per id.
func (s *ClaudeStream) ToolUse(id, name string, input any) []string {
	if id == "" || name == "" {
		return nil
	}
	if s.started == nil {
		s.started = map[string]bool{}
	}
	if s.started[id] {
		return nil
	}
	s.started[id] = true
	if input == nil {
		input = map[string]any{}
	}
	return s.assistant(map[string]any{"type": "tool_use", "id": id, "name": name, "input": input})
}

// ToolResult records a finished tool call.
func (s *ClaudeStream) ToolResult(id string, failed bool, content string) []string {
	if id == "" {
		return nil
	}
	return append(s.CloseBlock(), s.line(map[string]any{"type": "user", "message": map[string]any{"role": "user", "content": []map[string]any{{"type": "tool_result", "tool_use_id": id, "is_error": failed, "content": content}}}}))
}

// AddUsage accumulates token counts reported per step.
func (s *ClaudeStream) AddUsage(input, output, cacheRead, cacheWrite, reasoning int64) {
	if s.usage == nil {
		s.usage = map[string]int64{}
	}
	s.usage["input_tokens"] += input
	s.usage["output_tokens"] += output
	s.usage["cache_read_input_tokens"] += cacheRead
	s.usage["cache_creation_input_tokens"] += cacheWrite
	s.usage["reasoning_tokens"] += reasoning
}

// SetUsage replaces the accumulated usage with a turn total.
func (s *ClaudeStream) SetUsage(input, output, cacheRead, cacheWrite, reasoning int64) {
	s.usage = nil
	s.AddUsage(input, output, cacheRead, cacheWrite, reasoning)
}

// Result ends the turn once; an empty text falls back to LastText.
func (s *ClaudeStream) Result(text string, failed bool) []string {
	if s.done {
		return nil
	}
	s.done = true
	if strings.TrimSpace(text) == "" && !failed {
		text = s.LastText
	}
	subtype := "success"
	if failed {
		subtype = "error"
	}
	event := map[string]any{"type": "result", "subtype": subtype, "is_error": failed, "result": text}
	if s.usage != nil {
		event["usage"] = s.usage
	}
	return append(s.CloseBlock(), s.line(event))
}

// Finished reports whether Result was emitted.
func (s *ClaudeStream) Finished() bool { return s.done }

// NewAgentCLITranslator returns the translator from an agent CLI's native
// headless output (one JSON object per line) to ClaudeStream lines.
func NewAgentCLITranslator(kind string) func(string) []string {
	var translate func(*ClaudeStream, map[string]any) []string
	switch kind {
	case AgentCLIOpenCode:
		translate = (&openCodeStream{}).translate
	case AgentCLICursor:
		translate = (&cursorStream{}).translate
	case AgentCLIAntigravity:
		translate = (&antigravityStream{}).translate
	case AgentCLIKimi:
		translate = (&kimiStream{}).translate
	case AgentCLIPi:
		translate = (&piStream{}).translate
	case AgentCLIDeepSeek:
		translate = (&dshStream{}).translate
	case AgentCLIZCode:
		translate = (&zcodeStream{}).translate
	default:
		return nil
	}
	stream := &ClaudeStream{}
	return func(line string) []string {
		line = strings.TrimSpace(line)
		if line == "" || line[0] != '{' {
			return nil
		}
		var raw map[string]any
		if json.Unmarshal([]byte(line), &raw) != nil {
			return nil
		}
		return translate(stream, raw)
	}
}

func jsonText(value any) string {
	switch v := value.(type) {
	case nil:
		return ""
	case string:
		return v
	}
	data, _ := json.Marshal(value)
	return string(data)
}

// contentText joins the text parts of an MCP / chat content value.
func contentText(value any) string {
	if text, ok := value.(string); ok {
		return text
	}
	var parts []string
	for _, item := range sliceValue(value) {
		part, _ := item.(map[string]any)
		if text := stringValue(part["text"]); text != "" {
			parts = append(parts, text)
		}
	}
	if len(parts) == 0 && value != nil {
		return jsonText(value)
	}
	return strings.Join(parts, "\n")
}

func errorText(value any) string {
	switch v := value.(type) {
	case string:
		return v
	case map[string]any:
		for _, key := range []string{"message", "error"} {
			if text := errorText(v[key]); text != "" {
				return text
			}
		}
		if data, ok := v["data"].(map[string]any); ok {
			if text := errorText(data); text != "" {
				return text
			}
		}
		if name := stringValue(v["name"]); name != "" {
			return name
		}
	}
	return ""
}

// openCodeStream: `opencode run --format json` reports finished parts.
type openCodeStream struct {
	started bool
	failure string
}

func (o *openCodeStream) translate(s *ClaudeStream, raw map[string]any) []string {
	var out []string
	if !o.started {
		if session := stringValue(raw["sessionID"]); session != "" {
			o.started = true
			out = s.Init(session, "")
		}
	}
	part, _ := raw["part"].(map[string]any)
	switch stringValue(raw["type"]) {
	case "reasoning":
		out = append(out, s.Thinking(stringValue(part["text"]))...)
	case "text":
		out = append(out, s.Text(stringValue(part["text"]))...)
	case "tool_use":
		state, _ := part["state"].(map[string]any)
		id := stringValue(part["callID"])
		out = append(out, s.ToolUse(id, stringValue(part["tool"]), state["input"])...)
		switch stringValue(state["status"]) {
		case "completed":
			out = append(out, s.ToolResult(id, false, jsonText(state["output"]))...)
		case "error":
			out = append(out, s.ToolResult(id, true, jsonText(state["error"]))...)
		}
	case "step_finish":
		tokens, _ := part["tokens"].(map[string]any)
		cache, _ := tokens["cache"].(map[string]any)
		s.AddUsage(int64Value(tokens["input"]), int64Value(tokens["output"]), int64Value(cache["read"]), int64Value(cache["write"]), int64Value(tokens["reasoning"]))
		if reason := stringValue(part["reason"]); reason != "tool-calls" && reason != "" {
			out = append(out, s.Result("", o.failure != "" && s.LastText == "")...)
		}
	case "error":
		o.failure = errorText(raw["error"])
		if o.failure == "" {
			o.failure = "OpenCode 运行失败"
		}
		out = append(out, s.Result(o.failure, true)...)
	}
	return out
}

// cursorStream: `cursor-agent -p --output-format stream-json
// --stream-partial-output`. Partial assistant events carry timestamp_ms and
// one text chunk each; the final assistant event repeats the whole text.
type cursorStream struct {
	segment  int
	partial  strings.Builder
	thinking strings.Builder
}

func (c *cursorStream) flushText(s *ClaudeStream) []string {
	text := c.partial.String()
	c.partial.Reset()
	c.segment++
	return s.Text(text)
}

func (c *cursorStream) flushThinking(s *ClaudeStream) []string {
	text := c.thinking.String()
	c.thinking.Reset()
	if text == "" {
		return nil
	}
	c.segment++
	return s.Thinking(text)
}

func cursorToolCall(raw map[string]any) (name string, input any, result map[string]any) {
	call, _ := raw["tool_call"].(map[string]any)
	for key, value := range call {
		if !strings.HasSuffix(key, "ToolCall") {
			continue
		}
		body, _ := value.(map[string]any)
		args, _ := body["args"].(map[string]any)
		result, _ = body["result"].(map[string]any)
		switch key {
		case "mcpToolCall":
			server := stringValue(args["providerIdentifier"])
			if server == "" {
				server = stringValue(args["serverIdentifier"])
			}
			return "mcp__" + server + "__" + stringValue(args["toolName"]), args["args"], result
		case "shellToolCall":
			return "Bash", map[string]any{"command": args["command"]}, result
		}
		name = strings.TrimSuffix(key, "ToolCall")
		if name != "" {
			name = strings.ToUpper(name[:1]) + name[1:]
		}
		delete(args, "toolCallId")
		return name, args, result
	}
	return "", nil, nil
}

func (c *cursorStream) translate(s *ClaudeStream, raw map[string]any) []string {
	switch stringValue(raw["type"]) {
	case "system":
		if stringValue(raw["subtype"]) == "init" {
			return s.Init(stringValue(raw["session_id"]), stringValue(raw["model"]))
		}
	case "thinking":
		if stringValue(raw["subtype"]) == "delta" {
			text := stringValue(raw["text"])
			c.thinking.WriteString(text)
			return s.Delta(fmt.Sprintf("thinking#%d", c.segment), "thinking", text)
		}
		return c.flushThinking(s)
	case "assistant":
		message, _ := raw["message"].(map[string]any)
		text := contentText(message["content"])
		out := c.flushThinking(s)
		if _, partial := raw["timestamp_ms"]; partial {
			c.partial.WriteString(text)
			return append(out, s.Delta(fmt.Sprintf("text#%d", c.segment), "text", text)...)
		}
		c.partial.Reset()
		c.segment++
		return append(out, s.Text(text)...)
	case "tool_call":
		out := append(c.flushThinking(s), c.flushText(s)...)
		id := stringValue(raw["call_id"])
		name, input, result := cursorToolCall(raw)
		out = append(out, s.ToolUse(id, name, input)...)
		if stringValue(raw["subtype"]) == "completed" {
			success, ok := result["success"]
			failure := result["error"]
			if !ok && failure == nil {
				failure = result["rejected"]
			}
			if failure != nil {
				out = append(out, s.ToolResult(id, true, jsonText(failure))...)
			} else {
				body, _ := success.(map[string]any)
				content := body["content"]
				if content == nil {
					content = success
				}
				out = append(out, s.ToolResult(id, false, contentText(content))...)
			}
		}
		return out
	case "result":
		out := append(c.flushThinking(s), c.flushText(s)...)
		usage, _ := raw["usage"].(map[string]any)
		s.SetUsage(int64Value(usage["inputTokens"]), int64Value(usage["outputTokens"]), int64Value(usage["cacheReadTokens"]), int64Value(usage["cacheWriteTokens"]), 0)
		failed, _ := raw["is_error"].(bool)
		text := stringValue(raw["result"])
		if failed && text == "" {
			text = errorText(raw["error"])
		}
		return append(out, s.Result(text, failed)...)
	}
	return nil
}

// antigravityStream: `agy -p --output-format stream-json`.
type antigravityStream struct {
	text    strings.Builder
	failure string
}

func (a *antigravityStream) translate(s *ClaudeStream, raw map[string]any) []string {
	switch stringValue(raw["event"]) {
	case "init":
		init, _ := raw["init"].(map[string]any)
		return s.Init(stringValue(raw["conversation_id"]), stringValue(init["model"]))
	case "step_update":
		step, _ := raw["step_update"].(map[string]any)
		return a.translateStep(s, step)
	case "result":
		result, _ := raw["result"].(map[string]any)
		failed := stringValue(result["status"]) != "SUCCESS"
		text := stringValue(result["response"])
		if failed {
			if text = errorText(result["error"]); text == "" {
				text = a.failure
			}
			if text == "" {
				text = "Antigravity 运行失败"
			}
		}
		if usage, ok := result["usage"].(map[string]any); ok {
			s.SetUsage(int64Value(usage["input_tokens"]), int64Value(usage["output_tokens"]), int64Value(usage["cache_read_tokens"]), 0, int64Value(usage["thinking_tokens"]))
		}
		return s.Result(text, failed)
	}
	return nil
}

// translateStep dispatches one `step_update` payload by its step_type.
// error_message steps only remember the failure for the final result.
func (a *antigravityStream) translateStep(s *ClaudeStream, step map[string]any) []string {
	index := int64Value(step["step_index"])
	done := stringValue(step["state"]) == "DONE"
	switch stringValue(step["step_type"]) {
	case "agent_response":
		return a.responseStep(s, step, index, done)
	case "tool":
		return antigravityToolStep(s, step, index, done)
	case "error_message":
		if text := errorText(step["error"]); text != "" {
			a.failure = text
		}
	}
	return nil
}

// responseStep streams the text delta and, once the step is DONE, records its
// usage and emits the accumulated text as one block.
func (a *antigravityStream) responseStep(s *ClaudeStream, step map[string]any, index int64, done bool) []string {
	delta := stringValue(step["text_delta"])
	a.text.WriteString(delta)
	out := s.Delta(fmt.Sprintf("text#%d", index), "text", delta)
	if done {
		if usage, ok := step["usage"].(map[string]any); ok {
			s.AddUsage(int64Value(usage["input_tokens"]), int64Value(usage["output_tokens"]), int64Value(usage["cache_read_tokens"]), 0, int64Value(usage["thinking_tokens"]))
		}
		out = append(out, s.Text(a.text.String())...)
		a.text.Reset()
	}
	return out
}

// antigravityToolStep reports the tool call (unwrapping call_mcp_tool into the
// mcp__<server>__<tool> name) and, once the step is DONE, its result.
func antigravityToolStep(s *ClaudeStream, step map[string]any, index int64, done bool) []string {
	info, _ := step["tool_info"].(map[string]any)
	id := fmt.Sprintf("%s#%d", stringValue(step["conversation_id"]), index)
	name := stringValue(info["name"])
	input := info["parameters"]
	if params, ok := input.(map[string]any); ok && name == "call_mcp_tool" {
		name, input = "mcp__"+stringValue(params["ServerName"])+"__"+stringValue(params["ToolName"]), params["Arguments"]
	}
	out := s.ToolUse(id, name, input)
	if done {
		failure := errorText(info["error"])
		if failure != "" {
			out = append(out, s.ToolResult(id, true, failure)...)
		} else {
			out = append(out, s.ToolResult(id, false, jsonText(info["output"]))...)
		}
	}
	return out
}

// kimiStream: `kimi -p --output-format stream-json` prints whole messages;
// the session ID only arrives with the closing resume hint.
type kimiStream struct{ started bool }

func (k *kimiStream) translate(s *ClaudeStream, raw map[string]any) []string {
	var out []string
	if !k.started {
		k.started = true
		out = s.Init("", "")
	}
	switch stringValue(raw["role"]) {
	case "assistant":
		if text, ok := raw["content"].(string); ok {
			out = append(out, s.Text(text)...)
		}
		for _, item := range sliceValue(raw["content"]) {
			part, _ := item.(map[string]any)
			switch stringValue(part["type"]) {
			case "text":
				out = append(out, s.Text(stringValue(part["text"]))...)
			case "think", "thinking":
				text := stringValue(part["think"])
				if text == "" {
					text = stringValue(part["thinking"])
				}
				out = append(out, s.Thinking(text)...)
			}
		}
		for _, item := range sliceValue(raw["tool_calls"]) {
			call, _ := item.(map[string]any)
			function, _ := call["function"].(map[string]any)
			var input any = map[string]any{}
			if arguments := stringValue(function["arguments"]); arguments != "" {
				_ = json.Unmarshal([]byte(arguments), &input)
			}
			out = append(out, s.ToolUse(stringValue(call["id"]), stringValue(function["name"]), input)...)
		}
	case "tool":
		out = append(out, s.ToolResult(stringValue(raw["tool_call_id"]), false, contentText(raw["content"]))...)
	case "meta":
		if stringValue(raw["type"]) == "session.resume_hint" {
			s.SessionID = stringValue(raw["session_id"])
			out = append(out, s.Init(s.SessionID, "")...)
			out = append(out, s.Result("", false)...)
		}
	}
	return out
}

// piStream: `pi --mode json` streams deltas per content index and reports
// finished messages and tool executions.
type piStream struct {
	turn    int
	failure string
}

func (p *piStream) translate(s *ClaudeStream, raw map[string]any) []string {
	switch stringValue(raw["type"]) {
	case "session":
		return s.Init(stringValue(raw["id"]), "")
	case "turn_start":
		p.turn++
	case "message_update":
		event, _ := raw["assistantMessageEvent"].(map[string]any)
		key := fmt.Sprintf("%d#%d", p.turn, int64Value(event["contentIndex"]))
		switch stringValue(event["type"]) {
		case "text_delta":
			return s.Delta(key, "text", stringValue(event["delta"]))
		case "thinking_delta":
			return s.Delta(key, "thinking", stringValue(event["delta"]))
		}
	case "message_end":
		message, _ := raw["message"].(map[string]any)
		if stringValue(message["role"]) != "assistant" {
			return nil
		}
		usage, _ := message["usage"].(map[string]any)
		s.AddUsage(int64Value(usage["input"]), int64Value(usage["output"]), int64Value(usage["cacheRead"]), int64Value(usage["cacheWrite"]), int64Value(usage["reasoning"]))
		if stringValue(message["stopReason"]) == "error" {
			p.failure = stringValue(message["errorMessage"])
		}
		var out []string
		for _, item := range sliceValue(message["content"]) {
			part, _ := item.(map[string]any)
			switch stringValue(part["type"]) {
			case "text":
				out = append(out, s.Text(stringValue(part["text"]))...)
			case "thinking":
				out = append(out, s.Thinking(stringValue(part["thinking"]))...)
			case "toolCall":
				out = append(out, s.ToolUse(stringValue(part["id"]), stringValue(part["name"]), part["arguments"])...)
			}
		}
		return append(out, s.CloseBlock()...)
	case "tool_execution_start":
		// Top-level calls are reported from the assistant message; nested ones
		// (MCP tools called from codemode) only appear here.
		if stringValue(raw["parentToolCallId"]) == "" {
			return nil
		}
		return s.ToolUse(stringValue(raw["toolCallId"]), stringValue(raw["toolName"]), raw["args"])
	case "tool_execution_end":
		result, _ := raw["result"].(map[string]any)
		failed, _ := raw["isError"].(bool)
		return s.ToolResult(stringValue(raw["toolCallId"]), failed, contentText(result["content"]))
	case "agent_end":
		if p.failure != "" && s.LastText == "" {
			return s.Result(p.failure, true)
		}
		return s.Result("", false)
	}
	return nil
}

// dshStream: `dsh --profile headless --json` run events.
// dshStream: `dsh --json` caps every event string at 8 KiB and flags the event
// `truncated`; only the terminal `final` carries the whole answer. A truncated
// text is held back so `final` can replace it instead of being appended to it.
type dshStream struct{ failure, truncatedText string }

func (d *dshStream) translate(s *ClaudeStream, raw map[string]any) []string {
	kind := stringValue(raw["type"])
	var out []string
	if d.truncatedText != "" && (kind == "thinking" || kind == "text" || kind == "tool_call" || kind == "tool_result") {
		out = s.Text(d.truncatedText)
		d.truncatedText = ""
	}
	switch kind {
	case "session":
		return append(out, s.Init(stringValue(raw["sessionId"]), "")...)
	case "thinking":
		return append(out, s.Thinking(stringValue(raw["text"]))...)
	case "text":
		if raw["truncated"] == true {
			d.truncatedText = stringValue(raw["text"])
			return out
		}
		return append(out, s.Text(stringValue(raw["text"]))...)
	case "tool_call":
		return append(out, s.ToolUse(stringValue(raw["callId"]), stringValue(raw["tool"]), raw["input"])...)
	case "tool_result":
		return append(out, s.ToolResult(stringValue(raw["callId"]), stringValue(raw["status"]) != "completed", jsonText(raw["result"]))...)
	case "status":
		if stringValue(raw["phase"]) == "step_end" {
			usage, _ := raw["usage"].(map[string]any)
			s.AddUsage(int64Value(usage["inputTokens"]), int64Value(usage["outputTokens"]), int64Value(usage["cacheReadTokens"]), int64Value(usage["cacheWriteTokens"]), int64Value(usage["reasoningTokens"]))
		}
	case "error":
		d.failure = errorText(raw)
	case "final":
		if session := stringValue(raw["sessionId"]); session != "" {
			s.SessionID = session
		}
		reason, _ := raw["reason"].(map[string]any)
		failed := stringValue(reason["kind"]) != "completed"
		text := stringValue(raw["text"])
		if held := d.truncatedText; held != "" {
			d.truncatedText = ""
			if strings.HasPrefix(text, held) {
				held = text
			}
			out = append(out, s.Text(held)...)
		}
		if failed && text == "" {
			if text = d.failure; text == "" {
				text = "DeepSeek Harness 运行结束:" + stringValue(reason["kind"])
			}
		}
		return append(out, s.Result(text, failed)...)
	}
	return out
}