magic-agent 1.0.3 → 1.0.49

package/internal/agent/codebuddy.go

@@ -271,47 +271,10 @@ func (c codebuddyCore) complete(ctx context.Context, req Request) (Response, err
 	// 自定义模型才补端点（用户可能刚在 App 里配好就直接 -m 调用，没打开过选择器）。
 	c.ensureCustomModelEndpoint(req.Model)
 
-	// 附件（截图）：与 claude 同族，--print 文本模式收不了图，走
-	// --input-format stream-json（图片 content block 经 stdin）。
-	if hasImageAttachment(req.Attachments) {
-		return c.completeWithAttachments(ctx, req, start)
-	}
-
-	args := c.buildArgs(req)
-
-	// workspace：codebuddy 与 claude 同族（无工作目录 flag，--add-dir 只加额外目录）
-	stdout, stderr, err := runCLIEnvIn(ctx, req.Workspace, c.extraEnv, bin, args...)
-	if err != nil {
-		return Response{}, wrapCliError(c.name, stdout, stderr, err)
-	}
-
-	raw := strings.TrimSpace(stdout)
-	if raw == "" {
-		return Response{}, fmt.Errorf("%s CLI returned empty output", c.name)
-	}
-
-	text := extractCodeBuddyResult(raw)
-
-	// 兜底：个别版本会把 user 请求回显（<user_query>…</user_query>）当正文。
-	if cleaned := stripUserQueryEcho(text); cleaned != text {
-		text = cleaned
-	}
-	if strings.TrimSpace(text) == "" {
-		return Response{}, fmt.Errorf("%s CLI 返回内容仅为请求回显（无模型正文）", c.name)
-	}
-
-	return Response{
-		Text:      text,
-		Model:     req.Model,
-		SessionID: extractCodeBuddySession(raw),
-		Latency:   time.Since(start),
-	}, nil
-}
-
-// completeWithAttachments 走 stream-json 输入通道跑一次带附件的调用
-// （codebuddy 与 claude 同族协议），把事件归约成单次 Response。
-func (c codebuddyCore) completeWithAttachments(ctx context.Context, req Request, start time.Time) (Response, error) {
-	bin := c.bin()
+	// 提示词走 stdin 的 stream-json 通道（**所有**调用，含无附件的纯文本）。
+	// 与 claude 完全同构、同理由：位置参数在 Windows 上会被 .cmd 批处理拆坏
+	// （含换行时整段丢失），详见 claude.go Complete 的注释与 launch.go。
+	// 2026-10-01 起这不再是「附件专用」路径。
 	prompt := FlattenPrompt(req.SystemPrompt, req.Messages, false)
 	if prompt == "" {
 		return Response{}, fmt.Errorf("%s: empty prompt", c.name)
@@ -321,19 +284,26 @@ func (c codebuddyCore) completeWithAttachments(ctx context.Context, req Request,
 	if err != nil {
 		return Response{}, err
 	}
-	acc := &streamAccumulator{Engine: c.name, OnSessionID: req.OnSessionID}
+	acc := &streamAccumulator{
+		Engine:           c.name,
+		OnSessionID:      req.OnSessionID,
+		SanitizeTurnText: stripThinkBlock,
+	}
 	var fin streamJSONResult
-	seen, err := runStreamJSONIn(ctx, req.Workspace, c.extraEnv, bin, args, strings.NewReader(stdin), acc, &fin)
+	// CLI 的 stderr 尾巴留一份：非零退出与「没有 result 行」都要拿它拼可读原因
+	//（见 streamNoResultErr；不带的话只剩一句「stream ended without result line」）。
+	var cliStderr streamStderrBuf
+	seen, err := runStreamJSONIn(ctx, req.Workspace, c.extraEnv, bin, args, strings.NewReader(stdin), acc, &fin, &cliStderr)
 	if err != nil {
-		return Response{}, wrapCliError(c.name, "", "", err)
+		return Response{}, wrapCliError(c.name, "", cliStderr.String(), err)
 	}
 	if !seen {
-		return Response{}, fmt.Errorf("%s CLI stream ended without result line", c.name)
+		return Response{}, streamNoResultErr(c.name, cliStderr.String())
 	}
 	if fin.IsError {
 		return Response{}, fmt.Errorf("%s CLI error (subtype=%s): %s", c.name, fin.Subtype, truncateStr(fin.Result, 500))
 	}
-	text := stripUserQueryEcho(finalizeStreamText(fin, acc))
+	text := stripThinkBlock(stripUserQueryEcho(finalizeStreamText(fin, acc)))
 	if strings.TrimSpace(text) == "" {
 		return Response{}, fmt.Errorf("%s CLI 返回内容仅为请求回显（无模型正文）", c.name)
 	}
@@ -345,13 +315,15 @@ func (c codebuddyCore) completeWithAttachments(ctx context.Context, req Request,
 	}, nil
 }
 
-// buildArgs 构造 codebuddy CLI 参数（Complete 与 Stream 共用）。
+// buildArgs 构造 codebuddy CLI 参数（含末尾的位置参数 prompt）。
+//
+// ⚠️ 2026-10-01 起**生产路径已不再用它**（提示词全走 stdin），
+// 保留是因为 buildArgsBase 的语义仍被 streamJSONArgs 依赖。
 func (c codebuddyCore) buildArgs(req Request) []string {
 	return append(c.buildArgsBase(req), FlattenPrompt(req.SystemPrompt, req.Messages, false))
 }
 
-// buildArgsBase 构造参数（不含末尾的位置参数 prompt）——附件场景复用：
-// 那条路提示词走 stdin，不能再作为命令行参数传。
+// buildArgsBase 构造参数（不含末尾的位置参数 prompt）——提示词走 stdin 的路径复用它。
 func (c codebuddyCore) buildArgsBase(req Request) []string {
 	args := []string{"--print", "--output-format", "json"}
 	switch {
@@ -381,18 +353,25 @@ func (c codebuddyCore) buildArgsBase(req Request) []string {
 		// 四档权限档位：codebuddy 与 claude 同族，--permission-mode 取值完全一致
 		//（default / acceptEdits / auto / bypassPermissions），故复用同一映射。
 		// 改造前这里恒传 -y（= --dangerously-skip-permissions，第 4 档）。
-		args = append(args, "--permission-mode", claudePermissionMode(req.Permission))
+		// ⚠️ 2026-10-01：与 claude 同坑 —— 只传 --permission-mode 不传 --tools 时，
+		// codebuddy CLI 在 stream-json 模式下也不发 result 行；必须显式 --tools default。
+		args = append(args, "--tools", "default",
+			"--permission-mode", claudePermissionMode(req.Permission))
 	default:
 		args = append(args, "--tools", strings.Join(tools.Allowlist(), ","),
 			"--permission-mode", claudePermissionMode(req.Permission))
 	}
-	if m := stripModelPrefix(req.Model); m != "" {
+	if m := c.modelArg(req.Model); m != "" {
 		args = append(args, "--model", m)
 	} else if c.model != "" {
 		// 默认模型（codebuddy=hy3；codebuddy-ai 故意留空 = CLI 自身默认，
 		// 见文件头的模型注册表漂移说明）；空串 = 不传 --model。
 		args = append(args, "--model", c.model)
 	}
+	// 推理档位：codebuddy 的 --effort 认 minimal/low/medium/high/xhigh/max。
+	if lv := ReasoningLevel(req.Reasoning); lv != "" {
+		args = append(args, "--effort", lv)
+	}
 	// 统一参数矩阵：`--settings` 只接受一份载荷，故 MaxTokens 的 env 注入与
 	// 四档模型的 sandbox / autoMode / permissions 合并进同一个 JSON。
 	// 注意 codebuddy 的沙箱键集与 claude 略有差异（文档未列 failIfUnavailable），
@@ -414,97 +393,52 @@ func (c codebuddyCore) stream(ctx context.Context, req Request, onEvent func(Str
 	// 自定义模型才补端点（同 complete，见 custom_models.go）。
 	c.ensureCustomModelEndpoint(req.Model)
 
-	args := c.buildArgs(req)
-	if req.Append != nil || hasImageAttachment(req.Attachments) {
-		// 附件 / 常驻会话 → stream-json 输入通道：提示词改走 stdin（见 streamjson.go）。
-		prompt := FlattenPrompt(req.SystemPrompt, req.Messages, false)
-		var stdin io.Reader
-		if req.Append != nil {
-			pipe, perr := streamJSONInputPipe(prompt, req.Attachments, req.Append)
-			if perr != nil {
-				return StreamResult{}, perr
-			}
-			stdin = pipe
-		} else {
-			line, serr := streamJSONUserLine(prompt, req.Attachments)
-			if serr != nil {
-				return StreamResult{}, serr
-			}
-			stdin = strings.NewReader(line)
-		}
-		args = streamJSONArgs(c.buildArgsBase(req), prompt, true)
-		acc := &streamAccumulator{Engine: c.name, OnEvent: onEvent, OnSessionID: req.OnSessionID}
-		var fin streamJSONResult
-		seen, err := runStreamJSONIn(ctx, req.Workspace, c.extraEnv, bin, args, stdin, acc, &fin)
-		if err != nil {
-			return StreamResult{}, err
-		}
-		if !seen {
-			return StreamResult{}, fmt.Errorf("%s CLI stream ended without result line", c.name)
-		}
-		if fin.IsError {
-			return StreamResult{}, fmt.Errorf("%s CLI error (subtype=%s): %s", c.name, fin.Subtype, truncateStr(fin.Result, 500))
-		}
-		text := stripUserQueryEcho(finalizeStreamText(fin, acc))
-		if strings.TrimSpace(text) == "" {
-			return StreamResult{}, fmt.Errorf("%s CLI 返回内容仅为请求回显（无模型正文）", c.name)
-		}
-		return StreamResult{
-			Response: Response{
-				Engine:    c.name,
-				Text:      text,
-				Model:     fin.Model,
-				SessionID: fin.SessionID,
-				Latency:   time.Since(start),
-			},
-			Thinking: acc.Thinking.String(),
-			Tools:    acc.Tools,
-		}, nil
-	}
-	for i := range args {
-		if args[i] == "--output-format" {
-			args[i+1] = "stream-json"
-			break
-		}
-	}
-	args = append(args, "--include-partial-messages", "--verbose")
-
-	acc := &streamAccumulator{Engine: c.name, OnEvent: onEvent}
-	var fin struct {
-		Type      string `json:"type"`
-		Subtype   string `json:"subtype"`
-		IsError   bool   `json:"is_error"`
-		Result    string `json:"result"`
-		SessionID string `json:"session_id"`
-		Model     string `json:"model"`
+	// 提示词一律走 stdin 的 stream-json 输入通道（不再当位置参数）。
+	// 与 claude 完全同构、同理由（2026-10-01 改，Windows 实测）：
+	// 位置参数在 Windows 上会被 .cmd 批处理拆坏，含换行时整段丢失。
+	// 常驻会话（Request.Append 非 nil）的区别只在 stdin 是个**流**。
+	prompt := FlattenPrompt(req.SystemPrompt, req.Messages, false)
+	if prompt == "" {
+		return StreamResult{}, fmt.Errorf("%s: empty prompt", c.name)
 	}
-	seenResult := false
-
-	err := runStreamCLIEnvIn(ctx, req.Workspace, c.extraEnv, bin, args, func(line string) error {
-		isResult, perr := acc.handleNDJSONLine(line)
+	var stdin io.Reader
+	if req.Append != nil {
+		pipe, perr := streamJSONInputPipe(prompt, req.Attachments, req.Append)
 		if perr != nil {
-			return perr
+			return StreamResult{}, perr
 		}
-		if isResult {
-			_ = json.Unmarshal([]byte(line), &fin)
-			seenResult = true
+		stdin = pipe
+	} else {
+		line, serr := streamJSONUserLine(prompt, req.Attachments)
+		if serr != nil {
+			return StreamResult{}, serr
 		}
-		return nil
-	})
+		stdin = strings.NewReader(line)
+	}
+	args := streamJSONArgs(c.buildArgsBase(req), prompt, true)
+	acc := &streamAccumulator{
+		Engine:           c.name,
+		OnEvent:          onEvent,
+		OnSessionID:      req.OnSessionID,
+		AggregateOnly:    true,
+		SanitizeTurnText: stripThinkBlock,
+	}
+	var fin streamJSONResult
+	// 同上：stderr 尾巴是「为什么没走完协议」的唯一线索。
+	var cliStderr streamStderrBuf
+	seen, err := runStreamJSONIn(ctx, req.Workspace, c.extraEnv, bin, args, stdin, acc, &fin, &cliStderr)
 	if err != nil {
 		return StreamResult{}, err
 	}
-	if !seenResult {
-		return StreamResult{}, fmt.Errorf("%s CLI stream ended without result line", c.name)
+	if !seen {
+		err := streamNoResultErr(c.name, cliStderr.String())
+		acc.emitTurnFailed(acc.SessionID, err)
+		return StreamResult{}, err
 	}
 	if fin.IsError {
 		return StreamResult{}, fmt.Errorf("%s CLI error (subtype=%s): %s", c.name, fin.Subtype, truncateStr(fin.Result, 500))
 	}
-
-	text := stripUserQueryEcho(fin.Result)
-	if strings.TrimSpace(text) == "" {
-		text = strings.TrimSpace(acc.Text.String())
-	}
+	text := stripThinkBlock(stripUserQueryEcho(finalizeStreamText(fin, acc)))
 	if strings.TrimSpace(text) == "" {
 		return StreamResult{}, fmt.Errorf("%s CLI 返回内容仅为请求回显（无模型正文）", c.name)
 	}
@@ -533,8 +467,8 @@ type CodeBuddyEngine struct {
 // Name 实现 Engine。
 func (e *CodeBuddyEngine) Name() string { return "codebuddy" }
 
-// DefaultCodeBuddyTimeout 单次尝试默认超时（codebuddy / codebuddy-ai 共用）。
-const DefaultCodeBuddyTimeout = 5 * time.Minute
+// DefaultCodeBuddyTimeout 单次尝试默认超时（codebuddy / codebuddy-ai 共用；2026-10-10 由 5 分钟统一上调到 1 小时）。
+const DefaultCodeBuddyTimeout = time.Hour
 
 // DefaultCodeBuddyModel codebuddy 引擎的默认模型。
 // 未显式 -m 指定时使用 hy3（与 magic-video 的 DefaultCreativeModel 一致）。
@@ -873,6 +807,47 @@ func (e *CodeBuddyAIEngine) buildArgsBase(req Request) []string { return e.core(
 
 // ── 输出解析（两个后端共用）──────────────────────────────────
 
+// stripThinkBlock 剥离整段 <think>…</think> 思维链块。
+//
+// 为什么需要（2026-10-01 实测）：codebuddy 在 --tools off + 「直接输出纯文本
+// markdown」的约束下，仍会把推理写进 result 字段，形如
+//
+//	<think>The user is asking me to…</think>\n\n1
+//
+// 也就是**推理与正文同处一个字符串**。不剥掉的话：
+//   - `-o text` 的正文里混着英文推理，用户看到的是一段莫名其妙的话；
+//   - 更糟的是 --tools off 注入的约束里有「第一行必须是答案正文」，
+//     模型为遵守它而把答案挪到 think 块之后，客户端按行渲染会全乱。
+//
+// 与 stripUserQueryEcho 的关系：两者都是「剥掉不该当正文的前缀」，
+// 串联使用（先剥回显、再剥思维链）。llm 引擎的 thinkSplitter 是**流式**版本
+// （逐行喂、边喂边分流），这里是整段版本，用于 result 行一次性给全的场景。
+//
+// 找不到闭合标签时原样返回（宁可把标签露出来，也不要吞掉真内容）。
+//
+// ⚠️ 必须**循环**剥而不是只剥第一段：codebuddy 在多轮工具调用后会把每一轮的
+// 推理各写一个 think 块（<think>a</think>正文<think>b</think>正文…）。
+// 只剥第一段的话，第二段推理会原样漏进用户看到的正文 —— 症状是
+// 「回答中间突然冒出一段英文」，比整段漏出来更难定位。
+func stripThinkBlock(s string) string {
+	const (
+		open  = "<think>"
+		close = "</think>"
+	)
+	for {
+		i := strings.Index(s, open)
+		if i < 0 {
+			return s
+		}
+		j := strings.Index(s[i:], close)
+		if j < 0 {
+			// 未闭合 → 整段原样（不吞真内容）
+			return s
+		}
+		s = strings.TrimSpace(s[i+j+len(close):])
+	}
+}
+
 // stripUserQueryEcho 剥离 <user_query>…</user_query> 请求回显。
 func stripUserQueryEcho(s string) string {
 	t := strings.TrimSpace(s)

package/internal/agent/codebuddy_gateway.go

@@ -79,10 +79,10 @@ import (
 
 // DefaultCBGatewayTimeout 单次调用的默认超时。
 //
-// 10 分钟：网关侧的 runTimeoutMs 默认就是 1_800_000（30 分钟，实测值来自网关内核
-// DEFAULT_RUN_TIMEOUT_MS），而 CLI 的 -t 默认也是 600s —— 取 10 分钟与 CLI 层一致，
-// 避免「CLI 说 600s、引擎内部却更短」这种自相矛盾。要跑更久的任务显式给 -t。
-const DefaultCBGatewayTimeout = 10 * time.Minute
+// 网关侧的 runTimeoutMs 默认就是 1_800_000（30 分钟，实测值来自网关内核
+// DEFAULT_RUN_TIMEOUT_MS），本引擎默认取 1 小时与 CLI 的 -t 默认一致（2026-10-10 由 10 分钟
+// 上调），避免「CLI 说 1h、引擎内部却更短」这种自相矛盾。要跑更久的任务显式给 -t。
+const DefaultCBGatewayTimeout = time.Hour
 
 // cbGatewayMaxBody 单次响应体读取上限（webhook 受理响应很小，留足余量即可）。
 const cbGatewayMaxBody = 1 << 20 // 1 MiB
@@ -337,6 +337,10 @@ func (e *CodeBuddyGatewayEngine) run(ctx context.Context, req Request, onEvent f
 		sessionID: convID,
 	}
 	if err := e.consumeStream(httpCtx, client, r, runID, st, req.JSONSchema); err != nil {
+		// 流被截断 / 任务 failed / HTTP 拒绝都走这一条：已发出的正文 item
+		// 必须收成 failed，不能让它永远停在 running（消费方只能靠超时猜，
+		// 历史回放里那一条会永远显示「生成中」）。语义见 cbGatewayStreamState.fail。
+		st.fail(err)
 		return st.result(e, req, start), err
 	}
 	res := st.result(e, req, start)

package/internal/agent/codebuddy_gateway_stream.go

@@ -115,6 +115,21 @@ type cbGatewayStreamState struct {
 	status    string // 最近一次 status（错误信息用）
 	sessionID string // 会话锚点（网关回 sessionId 时以它为准）
 	tools     []ToolCall
+
+	// tracker 状态收敛的身份与版本（见 itemtracker.go）。
+	// 原生 id = 网关分配的 runId（一个 run 恒定，见 codebuddy_gateway.go 的 deliver）。
+	textTrack *itemTracker
+	// textTrack 是否已经发过事件（发过就不能再换 item id）。
+	textStarted bool
+}
+
+// trackers 惰性建立跟踪器。
+func (st *cbGatewayStreamState) trackers() *itemTracker {
+	if st.textTrack == nil {
+		st.textTrack = newItemTracker(cbGatewayEngineName, laneText)
+		st.textTrack.Begin(st.runID)
+	}
+	return st.textTrack
 }
 
 // Stream 实现 Streamer：走 webhook 投递 + SSE 收流（见文件头）。
@@ -241,6 +256,8 @@ func (st *cbGatewayStreamState) handleFrame(raw []byte, schema *JSONSchema) (boo
 		st.final = text
 		st.completed = true
 		st.emitText(text)
+		// completed = 轮次终点：发 turn_end 把 item 收成 final（见 finish 的注释）。
+		st.finish(firstNonEmpty(st.convID, st.sessionID))
 		return true, nil
 
 	case "streaming":
@@ -279,9 +296,72 @@ func (st *cbGatewayStreamState) emitText(full string) {
 		return
 	}
 	st.emitted.WriteString(full)
-	if st.onEvent != nil {
-		st.onEvent(StreamEvent{Kind: KindText, Text: full})
+	if st.onEvent == nil {
+		return
+	}
+	// ⚠️ snapshot 直接取 st.emitted（累积到此刻的全文），**不能**喂给
+	// tracker 的 Append —— Append 的语义是「把这段**增量**拼到已有 snapshot
+	// 后面」，而这里传进去的是「累积到此刻的全文」，两者混用会逐帧翻倍
+	// （第一帧"你好"、第二帧"你好世界"，累加后得到"你好你好世界"）。
+	//
+	// 正确分工见 itemtracker.go 文件头：tracker 管 id / revision / status，
+	// 内容累积由调用方独家负责。nextWith 就是为此准备的入口。
+	ev := StreamEvent{Kind: KindText, Text: full}
+	st.trackers().nextWith(StatusRunning, st.emitted.String()).apply(&ev)
+	st.textStarted = true
+	st.onEvent(ev)
+}
+
+// fail 异常收尾（status=failed）：流被截断 / 任务 failed / HTTP 拒绝 / 读出错。
+//
+// 与 finish 的分工：turn_end = 网关给了 completed 帧（成功收尾），
+// turn_failed = 没有（异常收尾），带 Error / Reason。
+// 挂到**已有**正文 item 上：partial 的内容仍然存在，只是这条 item 不再增长。
+// 从没建立过 item 时直接返回 —— 不该为「一句正文都没流出来」的轮次硬造 item。
+//
+// 只有一个调用点（run 里的 consumeStream 错误分支）：它已经覆盖了
+// handleFrame 报错、读流中断、无终帧、非 SSE 缺终帧等全部异常出口，
+// 在这里收口比在每个 return err 处各写一遍可靠。
+func (st *cbGatewayStreamState) fail(err error) {
+	if st.onEvent == nil || err == nil || !st.textStarted {
+		return
+	}
+	ev := StreamEvent{
+		Kind:      KindTurnFailed,
+		SessionID: firstNonEmpty(st.convID, st.sessionID),
+		Error:     err.Error(),
+		Reason:    ReasonOf(err),
+		Status:    StatusFailed,
+	}
+	if attrs, ok := st.trackers().Failed(st.emitted.String()); ok {
+		attrs.apply(&ev)
+	}
+	st.onEvent(ev)
+}
+
+// finish 收尾：把 item 标成 final（completed 帧已到，正文不会再变）。
+//
+// 发的是 **KindTurnEnd** 而不是又一条 KindText，原因有三个：
+//  1. 语义对：completed 帧是**轮次边界**，不是「又来了一段正文」。
+//     之前试过补一条空 Text 的 KindText 帧，能过测试但语义是错的 ——
+//     消费方按 Text 拼正文的实现会收到一个空增量。
+//  2. 不破坏既有收集器：现有测试与调用方都按「KindText 就是正文增量」收集，
+//     多一条空帧会让它们数错条数。
+//  3. 轮次边界有独立信号后，思考 lane（将来若有）也能靠它收尾 ——
+//     与 claude / dsh 引擎的处理方式一致。
+//
+// ⚠️ keep-alive 的空闲收工挂在 KindTurnEnd 上（见 keepAlive 的调用点），
+// 但 codebuddy-gateway 不在 AppendSupportOf 名单里，不会启用常驻会话，
+// 所以这里发 turn_end 是安全的。
+func (st *cbGatewayStreamState) finish(sessionID string) {
+	if st.onEvent == nil || !st.textStarted {
+		return
+	}
+	ev := StreamEvent{Kind: KindTurnEnd, Text: st.final, SessionID: sessionID}
+	if attrs, ok := st.trackers().Finalize(st.emitted.String()); ok {
+		attrs.apply(&ev)
 	}
+	st.onEvent(ev)
 }
 
 // result 把累积状态收成 StreamResult（终态与错误路径共用）。