magic-agent 2.4.2 → 2.6.0

package/internal/agent/streamjson.go

@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"sync"
 )
 
 // streamJSONResult 两家 CLI 收尾行（type=result）的公共形状。
@@ -81,9 +82,13 @@ func runStreamJSONIn(
 // streamJSONInputPipe 常驻会话的 stdin：先写首条 user 消息（提示词 + 附件），
 // 之后每从 appendCh 收到一条就再写一轮；appendCh 关闭 → 关掉写端 → 子进程收尾。
 //
+// replyCh 非 nil 时同时接收**原生控制应答行**（control_response，见 Request.Reply）：
+// 它和 appendCh 是两条独立的通道 —— 追加是「下一轮用户消息」，应答是「这一轮正等着的裁决」，
+// 混在一条通道里会让 CLI 把应答当 user 消息读（实测后果：整轮卡死）。
+//
 // 返回的 reader 交给子进程当 stdin（不 EOF 就一直活着）。写失败（子进程已退）时
 // 直接收摊，不让 goroutine 泄漏。
-func streamJSONInputPipe(prompt string, atts []Attachment, appendCh <-chan string) (io.Reader, error) {
+func streamJSONInputPipe(prompt string, atts []Attachment, appendCh <-chan string, replyCh <-chan string) (io.Reader, error) {
 	first, err := streamJSONUserLine(prompt, atts)
 	if err != nil {
 		return nil, err
@@ -94,19 +99,116 @@ func streamJSONInputPipe(prompt string, atts []Attachment, appendCh <-chan strin
 		if _, err := pw.Write([]byte(first)); err != nil {
 			return
 		}
-		for msg := range appendCh {
-			line, lerr := streamJSONUserLine(msg, nil)
-			if lerr != nil {
-				continue // 追加内容构造失败（不该发生）：跳过这一条，别把整个会话带崩
+		for {
+			select {
+			case msg, ok := <-appendCh:
+				if !ok {
+					return // 追加入口关闭 = 收工
+				}
+				line, lerr := streamJSONUserLine(msg, nil)
+				if lerr != nil {
+					continue // 追加内容构造失败（不该发生）：跳过这一条，别把整个会话带崩
+				}
+				if _, err := pw.Write([]byte(line)); err != nil {
+					return
+				}
+			case raw, ok := <-replyCh:
+				if !ok {
+					replyCh = nil // 应答通道关闭不等于收工：继续等 append
+					continue
+				}
+				if _, err := pw.Write(ensureTrailingNewline(raw)); err != nil {
+					return
+				}
 			}
-			if _, err := pw.Write([]byte(line)); err != nil {
+		}
+	}()
+	return pr, nil
+}
+
+// streamJSONLiveInput 一轮式调用的「活 stdin」：写完首条 user 消息后**保持写端打开**，
+// 只用来把原生控制应答行（control_response）喂回去；done 关闭即 EOF。
+//
+// 为什么不能继续用 strings.Reader（2026-10-25 实测）：那个 reader 一读完就 EOF，
+// CLI 随后发出 control_request（计划审批）时 stdin 已经关掉 —— 应答没有落点，
+// 整轮只能挂到超时。而只要把 stdin 留着，CLI 在被批准后就会继续跑完这一轮。
+// ⚠️ 代价：stdin 一直开着时 CLI 在吐完 result 后**不会自己退出**（实测），
+// 所以调用方必须在收到 turn_end / result / error 时立刻关掉 done —— 不能等 Stream 返回。
+func streamJSONLiveInput(prompt string, atts []Attachment, replyCh <-chan string, done <-chan struct{}) (io.Reader, error) {
+	first, err := streamJSONUserLine(prompt, atts)
+	if err != nil {
+		return nil, err
+	}
+	pr, pw := io.Pipe()
+	go func() {
+		defer pw.Close()
+		if _, err := pw.Write([]byte(first)); err != nil {
+			return
+		}
+		for {
+			select {
+			case <-done:
 				return
+			case raw, ok := <-replyCh:
+				if !ok {
+					replyCh = nil
+					continue
+				}
+				if _, err := pw.Write(ensureTrailingNewline(raw)); err != nil {
+					return
+				}
 			}
 		}
 	}()
 	return pr, nil
 }
 
+// streamJSONStdinFor 按 Request 的通道形态挑 stdin 实现（claude / codebuddy 共用）。
+//
+//	Append 非 nil  → 常驻会话（续轮）流；Reply 一并接上
+//	Reply  非 nil  → 一轮式「活 stdin」：只为准许回 control_response 而保持打开
+//	都没有          → 老行为：一行写完即 EOF
+//
+// 返回的 close 由调用方 defer —— 活 stdin 下它负责 EOF，让 CLI 退出。
+func streamJSONStdinFor(req Request, prompt string) (io.Reader, func(), error) {
+	if req.Append != nil {
+		pipe, err := streamJSONInputPipe(prompt, req.Attachments, req.Append, req.Reply)
+		return pipe, func() {}, err
+	}
+	if req.Reply != nil {
+		done := make(chan struct{})
+		var once sync.Once
+		closeFn := func() { once.Do(func() { close(done) }) }
+		pipe, err := streamJSONLiveInput(prompt, req.Attachments, req.Reply, done)
+		if err != nil {
+			return nil, func() {}, err
+		}
+		return pipe, closeFn, nil
+	}
+	line, err := streamJSONUserLine(prompt, req.Attachments)
+	if err != nil {
+		return nil, func() {}, err
+	}
+	return strings.NewReader(line), func() {}, nil
+}
+
+// streamTerminalKind 这一条事件是否代表「本轮结束」（活 stdin 据此立刻 EOF）。
+func streamTerminalKind(k StreamEventKind) bool {
+	switch k {
+	case KindTurnEnd, KindTurnFailed:
+		return true
+	}
+	return false
+}
+
+// ensureTrailingNewline 保证写进 stdin 的每一行都以换行结尾（NDJSON 一行一条）。
+func ensureTrailingNewline(s string) []byte {
+	if strings.HasSuffix(s, "\n") {
+		return []byte(s)
+	}
+	return []byte(s + "\n")
+}
+
 // streamJSONUserLine 把「提示词 + 附件」拼成一行 stream-json 输入（含结尾换行）。
 //
 // content 块顺序：图片附件（image block）在前、提示词文本在后 —— 与官方

package/internal/agent/tools_suffix_test.go

@@ -24,7 +24,10 @@ func argLogger(t *testing.T) (string, func() string) {
 	log := filepath.Join(dir, "args.log")
 	cli := filepath.Join(dir, "fake")
 	script := "#!/bin/sh\nprintf '%s\\n' \"$*\" > " + log +
-		"\necho '{\"type\":\"result\",\"result\":\"ok\"}'\n"
+		"\necho '{\"type\":\"result\",\"result\":\"ok\"}'\n" +
+		// trae 2.0 的 JSONL 事件（同一个假 CLI 要同时被 claude/codebuddy/trae 复用）
+		"\necho '{\"type\":\"item.completed\",\"item\":{\"id\":\"i\",\"type\":\"agent_message\",\"text\":\"ok\"}}'\n" +
+		"\necho '{\"type\":\"turn.completed\"}'\n"
 	if err := os.WriteFile(cli, []byte(script), 0o755); err != nil {
 		t.Fatal(err)
 	}
@@ -131,9 +134,9 @@ func TestTraeToolModeSuffix(t *testing.T) {
 	}
 }
 
-// TestTraeToolModeMapping 固化 trae 的工具模式契约（2026-09-16 真机验证）。
+// TestTraeToolModeMapping 固化 trae 的工具模式契约（2026-09-16 真机验证，2.0 同构）。
 //
-// trae-cli 的权限开关实测语义：
+// TRAE CLI 的权限开关语义：
 //   - --allowed-tool 只做「自动批准」，不裁剪工具集（--allowed-tool WebFetch
 //     仍下发全部 18 个工具）；
 //   - --disallowed-tool 才真正做减法；

package/internal/agent/trae.go

@@ -1,65 +1,58 @@
 package agent
 
-// trae.go - Trae CLI 引擎。
+// trae.go - TRAE CLI 引擎（2.0，命令名 traex）。
+//
+// 后端：TRAE CLI 2.0（0.2xx，Rust 版），非交互入口为
+// `traex exec --json`，输出 Codex 同源的 JSONL 事件流。
+// 参数构造与事件解析见 trae_exec.go。
 //
-// 后端：trae-cli（~/.local/bin/trae-cli）。非交互模式：-p，纯文本输出。
 // 与 claude/codebuddy 的关键差异：
 //
-//	- 没有 --model flag；模型默认取 trae 自身配置（~/.trae/trae_cli.yaml
-//	  的 model.name）。显式指定模型用 -c "model.name=<name>" 覆盖。
-//	- --output-format 有 json，但实测纯文本已足够稳定，这里用 text +
-//	  noToolSuffix（拼进 system 部分）压制 agent loop。
-//	- 自带 --query-timeout，把外层超时同时传给 CLI，保证语义一致。
-//	- 会话续接：--resume=<id>（pflag 可选值风格，必须等号传值）；
-//	  没有 --continue，续接最近一次会话用裸 --resume（AUTO 模式，
-//	  实测 -p 非交互模式下可用，能接住上一轮记忆）。
-//	- 工具：禁用靠 --disallowed-tool 逐个减法；启用靠全放行开关 -y。
-//	  trae 没有「只允许白名单这几个工具」的表达能力，白名单模式因此
-//	  降级为「默认开启所有工具」（详见 buildArgs 的工具模式映射）。
-//	- MaxTokens / Temperature 不支持：`-c <k>=<v>` 会整体覆盖模型配置块
-//	  （实测注入 model.max_tokens 后模型名漂移并触发配额错误），因此这两个
-//	  参数构造时静默忽略（见 engine_base.go 矩阵②）。
+//	- 没有独立 system prompt 通道；system / 多轮消息由 FlattenPrompt
+//	  拼进提示词（off 模式再追加 noToolSuffix）。
+//	- 模型用 -m/--model（不是 1.x 的 -c model.name=）；默认取
+//	  ~/.trae/traecli.toml 的 model。
+//	- 续接：`exec resume <id>` / `exec resume --last`（没有 --continue）。
+//	- 工具：off 靠 --disallowed-tool 逐个减法；on / 白名单用 -y 全放行
+//	  （trae 没有「只允许白名单」的表达能力）。
+//	- 没有 --query-timeout：超时完全由外层 runner 杀进程组。
+//	- MaxTokens / Temperature 不支持，静默忽略（见 engine_base.go 矩阵②）。
+//	- 附件没有原生图片通道（exec 的 -i 只收图片且与 1.x 行为不一致），
+//	  统一把绝对路径写进提示词，靠 CLI 的读文件工具。
 //
-// CLI 路径解析顺序：显式 BinPath → MAGIC_AGENT_TRAE_BIN → ~/.local/bin →
-// ~/bin → PATH（探测链统一收敛在 engine_base.go 的 cliBase）。
+// CLI 路径解析顺序：显式 BinPath → MAGIC_AGENT_TRAE_BIN → 安装器默认位 →
+// PATH（探测链统一收敛在 engine_base.go 的 cliBase）。
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 	"time"
 )
 
-// TraeEngine 通过 trae-cli 实现 Engine。
+// TraeEngine 通过 traex 实现 Engine。
 type TraeEngine struct {
 	// BinPath 显式指定 CLI 路径（空 = 自动探测）。测试注入用。
 	BinPath string
 
-	// Model 显式模型（非空时 -c model.name=<model> 覆盖 CLI 默认）。
+	// Model 显式模型（非空时 -m <model>）。
 	Model string
 }
 
 // Name 实现 Engine。
 func (e *TraeEngine) Name() string { return "trae" }
 
-// DefaultTraeTimeout 单次尝试默认超时（2026-10-10 由 10 分钟统一上调到 1 小时）。
+// DefaultTraeTimeout 单次尝试默认超时（1 小时，与其余 CLI 引擎对齐）。
 const DefaultTraeTimeout = time.Hour
 
 // traeOffDisableTools off 模式下逐个 --disallowed-tool 禁用的实体工具。
 //
-// 取自 trae-cli 实测的 18 个内置工具里「会读文件 / 会改机器」的那批：
-// Agent、ExitPlanMode、EnterPlanMode 是常驻元工具（实测 --disallowed-tool
-// 摘不掉，补集禁用后仍保留），Skill、TaskCreate/Get/List/Update、
-// BashOutput、KillShell 属会话内辅助、无外部副作用，故不在禁用之列。
-//
-// 注意工具名必须是真实存在的：编辑与写入在 trae 里叫 Edit / Write ——
-// 此前这里写的是并不存在的 `Replace`，等于 off 模式漏禁 Write。
+// 取「会读文件 / 会改机器」的那批；Skill / 任务管理等会话内辅助工具
+// 无外部副作用，不在禁用之列。
 var traeOffDisableTools = []string{"Bash", "Edit", "Write", "Glob", "Grep", "Read"}
 
-// bin 探测 trae-cli 路径（委托 cliBase 统一探测链）。
+// bin 探测 traex 路径（委托 cliBase 统一探测链）。
 func (e *TraeEngine) bin() string {
 	return traeBase.resolve(e.BinPath)
 }
@@ -73,42 +66,18 @@ func (e *TraeEngine) Detect() (bool, string) {
 	return true, p
 }
 
-// TraeDefaultModel 读取 ~/.trae/trae_cli.yaml 顶层 model.name，
-// 返回 trae CLI 当前配置的默认模型（如 "My-MiniMax-M3"）。
-// 轻量扫描解析（不引入 yaml 依赖）；文件缺失/格式变化返回空串。
+// TraeDefaultModel 返回 trae CLI 当前配置的默认模型（如 "MiniMax-M3.1-Flash"）。
+// 2.0 读 ~/.trae/traecli.toml 的顶层 `model = "..."`；文件缺失/格式变化返回空串。
 func TraeDefaultModel() string {
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return ""
 	}
-	data, err := os.ReadFile(filepath.Join(home, ".trae", "trae_cli.yaml"))
-	if err != nil {
-		return ""
-	}
-	inModelBlock := false
-	for _, ln := range strings.Split(string(data), "\n") {
-		trimmed := strings.TrimSpace(ln)
-		if !inModelBlock {
-			inModelBlock = ln == trimmed && strings.HasPrefix(trimmed, "model:")
-			continue
-		}
-		if strings.HasPrefix(trimmed, "name:") {
-			v := strings.TrimSpace(strings.TrimPrefix(trimmed, "name:"))
-			v = strings.Trim(v, `"'`)
-			if v != "" {
-				return v
-			}
-		}
-		if ln == trimmed && trimmed != "" {
-			inModelBlock = false
-		}
-	}
-	return ""
+	return traeDefaultModelFromTOML(filepath.Join(home, ".trae", "traecli.toml"))
 }
 
-// ListModels 实现 ModelLister：`trae-cli models --json` 是 trae 自己的
-// 权威清单（含用户自定义模型，如 ~/.trae/trae_cli.yaml 里的 My-MiniMax-M3）。
-// 取 name（= -c model.name=<name> 接受的那个标识），缺失时退回 real_name。
+// ListModels 实现 ModelLister：`traex models --json` 是 CLI 自己的权威清单。
+// 取 name（= -m 接受的标识），缺失时退回 real_name。
 func (e *TraeEngine) ListModels(ctx context.Context) ([]string, error) {
 	stdout, err := probeCLI(ctx, "trae", e.bin(), "models", "--json")
 	if err != nil {
@@ -120,48 +89,26 @@ func (e *TraeEngine) ListModels(ctx context.Context) ([]string, error) {
 	}
 	models := modelNamesFromObjects(objs, "name", "real_name")
 	if len(models) == 0 {
-		return nil, fmt.Errorf("%w: trae-cli models --json returned no entries", ErrNoModelSource)
+		return nil, fmt.Errorf("%w: traecli models --json returned no entries", ErrNoModelSource)
 	}
 	return models, nil
 }
 
-// Complete 实现 Engine：单次调用 trae-cli。
+// Complete 实现 Engine：单次 `exec --json`，把 JSONL 聚合成最终正文。
 func (e *TraeEngine) Complete(ctx context.Context, req Request) (Response, error) {
 	start := time.Now()
 	bin := e.bin()
 	if bin == "" {
 		return Response{}, fmt.Errorf("trae CLI not found; set MAGIC_AGENT_TRAE_BIN")
 	}
+	return e.completeExec(ctx, bin, req, start)
+}
 
-	prompt := FlattenPrompt(req.SystemPrompt, req.Messages, toolsIsOff(req))
-	if prompt == "" {
-		return Response{}, fmt.Errorf("trae: empty prompt")
-	}
-	// trae 没有独立 system 注入 flag；无 system prompt 时约束也要生效。
-	// 仅 off 模式追加：on/白名单下 noToolSuffix 会与「允许调用工具」冲突。
-	if req.SystemPrompt == "" && toolsIsOff(req) {
-		prompt += noToolSuffix
-	}
-	// 附件：trae-cli 没有图片/附件输入通道（--help 无 image/attach/input-format），
-	// 只能把绝对路径写进提示词，靠 trae 的读文件工具看 —— 因此需要工具可用。
-	prompt = appendAttachmentSection(prompt, req.Attachments)
-
-	args := e.buildArgs(req, prompt)
-
-	// workspace：trae 无工作目录 flag（有 --add-dir 但那是追加额外目录），子进程 cwd 即原生方式
-	stdout, stderr, err := runCLIIn(ctx, req.Workspace, bin, args...)
-	if err != nil {
-		return Response{}, wrapCliError("trae", stdout, stderr, err)
-	}
-
-	text := strings.TrimSpace(stdout)
-	if text == "" {
-		return Response{}, fmt.Errorf("trae CLI returned empty output")
-	}
-
+// modelLabel 本轮展示用模型名：请求显式 > 引擎注入 > CLI 配置默认。
+func (e *TraeEngine) modelLabel(req Request) string {
 	modelLabel := stripModelPrefix(req.Model)
 	if modelLabel == "" {
-		modelLabel = e.Model
+		modelLabel = stripModelPrefix(e.Model)
 	}
 	if modelLabel == "" {
 		if m := TraeDefaultModel(); m != "" {
@@ -170,175 +117,35 @@ func (e *TraeEngine) Complete(ctx context.Context, req Request) (Response, error
 			modelLabel = "cli-default"
 		}
 	}
-	return Response{
-		Text:  text,
-		Model: modelLabel,
-		// 纯文本模式下 CLI 不回 session_id；续接请求时把传入的 id 原样
-		// 回传，让调用方可以逐轮透传（新会话仍为空）。
-		SessionID: req.SessionID,
-		Latency:   time.Since(start),
-	}, nil
-}
-
-// buildArgs 构造 trae-cli 参数（Complete 与 Stream 共用）。
-func (e *TraeEngine) buildArgs(req Request, prompt string) []string {
-	args := []string{"-p"}
-	switch {
-	case req.SessionID != "":
-		// 续接指定会话：pflag 可选值风格（--resume string[="AUTO"]），
-		// 必须用等号形式 --resume=<id>；空格形式下裸 id 会被吞成 AUTO 默认值。
-		args = append(args, "--resume="+req.SessionID)
-	case req.Continue:
-		// 续接最近一次会话：裸 --resume 触发 AUTO 模式（实测 -p 可用）。
-		args = append(args, "--resume")
-	}
-	// 模型：显式值 > 引擎注入值；都为空则用 CLI 自身默认。
-	model := e.Model
-	if model == "" {
-		model = stripModelPrefix(req.Model)
-	}
-	if model != "" {
-		args = append(args, "-c", "model.name="+model)
-	}
-	// 统一参数矩阵：req.MaxTokens / req.Temperature 在 trae 上明确不支持、
-	// 静默忽略 —— `-c <k>=<v>` 会整体覆盖模型配置块，实测注入
-	// model.max_tokens 后模型名漂移并触发配额错误（见 engine_base.go 矩阵②）。
-	_ = req.MaxTokens
-	_ = req.Temperature
-	// 工具模式映射。trae-cli 的权限开关实测语义（2026-09-16 真机验证）：
-	//
-	//	--allowed-tool    只做「自动批准该工具」，**不裁剪**工具集
-	//	                  （实测 --allowed-tool WebFetch 仍下发全部 18 个工具）
-	//	--disallowed-tool 真正做减法，从工具集里移除该工具（实测 18 → 4）
-	//	-y / --yolo       跳过全部权限检查 ⇒ 全工具可用
-	//
-	// 由此得出映射：
-	//
-	//	off        逐个 --disallowed-tool 关掉内置工具（Bash/Edit/Write/Glob/Grep/Read）
-	//	on         -y（全放行；非 -p 交互场景下的权限旁路）
-	//	allowlist  默认开启所有工具 ⇒ 与 on 同一条全放行路径（-y）
-	//
-	// ⚠️ 白名单在 trae 上「降级为全放行」是刻意的默认语义，不是实现漏做：
-	// trae 无法表达「只允许这几个工具」——想收窄只能对补集逐个 --disallowed-tool，
-	// 而补集随 CLI 版本漂移（今天 18 个工具、明天可能加），漏一条就等于白名单失效，
-	// 维护成本高于收益。故认定「默认开启所有工具」为白名单模式在 trae 上的契约，
-	// 与 codex 的白名单降级（engine_base.go 矩阵④：白名单 → 全放行）保持一致。
-	//
-	// 返回值里不再出现 --allowed-tool：既然 -y 已全量放行，逐条声明只是
-	// 「看起来像收窄」的噪音（这正是此前 allowlist 被 -y 架空的观感来源）。
-	// 需要收窄时请用 off 模式（真减法），而不要指望白名单。
-	tools := toolsOrDefault(req.Tools)
-	switch {
-	case tools.IsOff():
-		// 真实工具名，逐个减法；`Replace` 不是 trae 的工具（编辑/写入是
-		// Edit / Write），此前写成 Replace 等于漏禁 Write。
-		for _, t := range traeOffDisableTools {
-			args = append(args, "--disallowed-tool", t)
-		}
-	case tools.IsOn():
-		args = append(args, "-y")
-	default:
-		// 默认开启所有工具：全放行开关是唯一有效机制。
-		args = append(args, "-y")
-	}
-	// 把外层超时透传给 CLI 的 query-timeout（取上限 600s，CLI 单查询上限）。
-	if req.Timeout > 0 {
-		qt := req.Timeout
-		if qt > 600*time.Second {
-			qt = 600 * time.Second
-		}
-		args = append(args, "--query-timeout", qt.String())
-	} else {
-		args = append(args, "--query-timeout", "600s")
-	}
-	args = append(args, prompt)
-	return args
+	return modelLabel
 }
 
-// Stream 实现 Streamer：流式调用 trae-cli。
-// trae 的 stream-json 用 delta.content 直出正文增量；
-// 模型侧不开 reasoning，无 thinking 通道（Thinking 恒为空）。
+// Stream 实现 Streamer：逐行消费 `exec --json`，正文 / 思考 / 工具实时转发。
 func (e *TraeEngine) Stream(ctx context.Context, req Request, onEvent func(StreamEvent)) (StreamResult, error) {
 	start := time.Now()
 	bin := e.bin()
 	if bin == "" {
 		return StreamResult{}, fmt.Errorf("trae CLI not found; set MAGIC_AGENT_TRAE_BIN")
 	}
+	return e.streamExec(ctx, bin, req, start, onEvent)
+}
 
+// traePrompt 组装 2.0 的单条提示词（system + 多轮 + off 约束 + 附件路径）。
+func traePrompt(req Request) (string, error) {
 	prompt := FlattenPrompt(req.SystemPrompt, req.Messages, toolsIsOff(req))
 	if prompt == "" {
-		return StreamResult{}, fmt.Errorf("trae: empty prompt")
+		return "", fmt.Errorf("trae: empty prompt")
 	}
 	if req.SystemPrompt == "" && toolsIsOff(req) {
 		prompt += noToolSuffix
 	}
-	prompt = appendAttachmentSection(prompt, req.Attachments)
-
-	args := e.buildArgs(req, prompt)
-	args = append(args, "--output-format", "stream-json", "--include-partial-messages")
-
-	acc := &streamAccumulator{Engine: e.Name(), OnEvent: onEvent, OnSessionID: req.OnSessionID}
-	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"`
-	}
-	seenResult := false
-
-	err := runStreamCLIIn(ctx, req.Workspace, bin, args, func(line string) error {
-		isResult, perr := acc.handleNDJSONLine(line)
-		if perr != nil {
-			return perr
-		}
-		if isResult {
-			_ = json.Unmarshal([]byte(line), &fin)
-			seenResult = true
-		}
-		return nil
-	})
-	if err != nil {
-		return StreamResult{}, err
-	}
-	if !seenResult {
-		err := fmt.Errorf("trae CLI stream ended without result line")
-		acc.emitTurnFailed(acc.SessionID, err)
-		return StreamResult{}, err
-	}
-	if fin.IsError {
-		return StreamResult{}, fmt.Errorf("trae CLI error (subtype=%s): %s", fin.Subtype, truncateStr(fin.Result, 500))
-	}
-
-	text := fin.Result
-	if text == "" {
-		text = strings.TrimSpace(acc.Text.String())
-	}
-	if text == "" {
-		return StreamResult{}, fmt.Errorf("trae CLI returned empty result")
-	}
+	return appendAttachmentSection(prompt, req.Attachments), nil
+}
 
-	modelLabel := stripModelPrefix(req.Model)
-	if modelLabel == "" {
-		modelLabel = e.Model
-	}
-	if modelLabel == "" {
-		if m := TraeDefaultModel(); m != "" {
-			modelLabel = m
-		} else {
-			modelLabel = "cli-default"
-		}
+// traeModelFor 模型取值：请求显式 > 引擎注入（都去掉 `trae/` 前缀）。
+func traeModelFor(req Request, e *TraeEngine) string {
+	if m := stripModelPrefix(req.Model); m != "" {
+		return m
 	}
-	return StreamResult{
-		Response: Response{
-			Engine:    e.Name(),
-			Text:      text,
-			Model:     modelLabel,
-			SessionID: fin.SessionID,
-			Latency:   time.Since(start),
-		},
-		Thinking: acc.Thinking.String(),
-		// trae 协议不暴露独立工具事件通道；Tools 恒为 nil。
-		// 见 stream.go 顶部协议说明。
-	}, nil
+	return stripModelPrefix(e.Model)
 }