magic-agent 1.0.0

package/internal/agent/codebuddy.go

@@ -0,0 +1,1044 @@
+package agent
+
+// codebuddy.go - CodeBuddy Code CLI 引擎（codebuddy / codebuddy-ai 两个账号）。
+//
+// 两个引擎共用本文件的实现核心（codebuddyCore），差异只有三处：引擎名 / 账号 / 默认模型。
+// 二者跑的是**同一个独立安装的 CLI**（npm i -g @tencent-ai/codebuddy-code），
+// 不再使用桌面 App（WorkBuddy / WorkBuddy AI）内置的那一份 —— 那份的凭据由 App
+// 通过 sidecar 通道用受管密钥静态加密，独立进程解不开（at-rest 登记表里
+// read/write 全是 missing-key），引擎只能拿到空输出；见 engine_base.go 的
+// codebuddyBase 注释。
+//
+// 账号怎么分开（一个 CLI 挂两个账号）：
+// CLI 的票据路径是 sharedDataPath/auth/<authentication.id>.info，而 authentication.id
+// 的取值链里 **ACC_PRODUCT_CONFIG_V3（环境变量）优先于 CLI 包内的 product.json**。
+// 给两个子进程注入不同的 id，就等于让它们各用各的账号、互不顶号（2026-09-28 实测）。
+//
+//	codebuddy     账号 id  codebuddy     →  auth/codebuddy.info
+//	codebuddy-ai  账号 id  codebuddy-ai  →  auth/codebuddy-ai.info
+//
+// 非交互协议与 claude 同源（CodeBuddy Code v2.x）、flag 面一致；模型清单与积分倍率
+// 走同一条扩展链（见 listModels）。
+//
+// 默认模型：codebuddy = hy3；codebuddy-ai 故意留空（交 CLI 自身默认，旧静态清单里的
+// kimi-k3-1 等实测被国际后端 400 拒绝）。
+//
+// 非交互模式输出 envelope 实测有两种形态，解析需兼容：
+//
+//	1. 单对象：{"type":"result","result":"<md>",...}
+//	2. 数组：[{...stream messages...}]，扫描 type=="result" 或
+//	   逐条拼 assistant text content
+//
+// 关键 flags：
+//
+//	--print --output-format json     单结果 envelope
+//	--model <m>                      裸模型名（hy3 / glm-5.3 / ...）
+//	--tools ""                       禁用全部工具
+//	-y                               启用工具（--dangerously-skip-permissions）
+//	-r, --resume <id>                续接指定会话（Request.SessionID 非空时传）。
+//	-c, --continue                   续接最近一次会话（Request.Continue）。
+//	                                 默认新会话不传 --no-session-persistence，
+//	                                 否则首轮会话不落盘、session_id 无法续接
+//	                                （与 claude 同款 "cannot be resumed" 语义）
+//	--append-system-prompt <s>       注入 system prompt（仅 off 模式附 noToolSuffix）
+//	--settings <json>                注入 {"env":{"CLAUDE_CODE_MAX_OUTPUT_TOKENS":"<n>"}}
+//	                                 实现 MaxTokens（codebuddy 无原生 max-tokens flag，
+//	                                 与 claude 同款 --settings 通道，见矩阵①）
+//
+// CLI 路径解析：显式 BinPath → MAGIC_AGENT_CODEBUDDY_BIN / MAGIC_AGENT_CODEBUDDY_AI_BIN
+// → PATH 上的 `codebuddy` → npm 全局 bin 目录（探测链统一收敛在 engine_base.go 的
+// cliBase）。**已不再探测桌面 App 包内的路径** —— 那是导致 missing-key 空输出的那份，
+// 原因见 codebuddyBase 注释。
+//
+// ⚠️ 在 WorkBuddy 会话内调用时，父进程注入的 SERVER__PORT 会让 CLI 抢
+// 父会话已监听的端口 → EADDRINUSE → 永久挂起。子进程环境由 env.go
+// 的 denylist 统一剔除该类变量。
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// codebuddyCore 两个 codebuddy 后端共享的实现核心。
+// CodeBuddyEngine / CodeBuddyAIEngine 都是它的薄壳（见文件头）。
+type codebuddyCore struct {
+	// name 引擎名：进错误消息、Response.Engine、agentSettingsPayload 的引擎键。
+	name string
+	// base 可执行文件探测链（engine_base.go 的 cliBase）。
+	base cliBase
+	// binPath 显式指定 CLI 路径（空 = 走 base 探测链）。测试注入用。
+	binPath string
+	// model 默认模型（空 = 不传 --model，交 CLI 自身默认）。
+	model string
+	// extraEnv 追加给子进程的环境变量（Go exec：重复 key 取最后 → 覆盖继承值）。
+	// 两个引擎都用它注入「配置目录 + 账号标识（ACC_PRODUCT_CONFIG_V3）」，
+	// 从而实现「同一个 CLI、两个账号」，见 codebuddyAccountEnv。
+	extraEnv []string
+	// extendedModelSources 启用扩展模型清单来源（两个 codebuddy 引擎均为 true）：
+	// ① 桌面客户端合并配置缓存 acc-product-config（客户端模型选择器同源，
+	// 见 codebuddyAIAccConfigPath / codebuddyAccConfigPath）→ ② 远程配置缓存
+	// ∪ App 包 product.json → ③ --help。
+	extendedModelSources bool
+	// modelCacheDirs 远程配置缓存的 local_storage 目录（按优先级），两个用途：
+	// extendedModelSources=true 时是扩展清单链 ②；一律用于 modelCredits 的兜底 ②
+	// （见 codebuddyAIModelCacheDirs / codebuddyModelCacheDirs）。
+	modelCacheDirs []string
+	// accConfigPath 该引擎对应桌面客户端的合并产品配置缓存路径（构造时算好：
+	// codebuddyAIAccConfigPath / codebuddyAccConfigPath）。三个用途：
+	// extendedModelSources=true 时是扩展清单链 ①；一律用于 modelCredits 的首选 ①；
+	// 以及**自定义模型端点同步**的来源（见 custom_models.go）。
+	accConfigPath string
+	// configDir 该引擎自己的配置目录（codebuddyDir / codebuddyAIDir），
+	// 即 CLI 读 models.json 的地方 —— 自定义模型端点同步的落点。
+	// 用户显式设了 CODEBUDDY_CONFIG_DIR 时以那个为准（见 effectiveConfigDir）。
+	configDir string
+}
+
+// bin 探测 CLI 路径（委托 cliBase 统一探测链）。
+func (c codebuddyCore) bin() string {
+	return c.base.resolve(c.binPath)
+}
+
+// detect 返回（是否可用，说明）。
+func (c codebuddyCore) detect() (bool, string) {
+	p := c.base.resolve(c.binPath)
+	if p == "" {
+		return false, c.base.notFound
+	}
+	if c.model == "" {
+		return true, p
+	}
+	return true, p + " (default model: " + c.model + ")"
+}
+
+// selectorModels 返回客户端模型选择器的显式清单（agents[].models），取自优先级最高的
+// 远程配置缓存目录；没有则返回 nil（**无权威清单** → acc 缓存不过滤，宁可多不可少）。
+func (c codebuddyCore) selectorModels() []string {
+	for _, dir := range c.modelCacheDirs {
+		if ids, ok := agentSelectorModels(dir); ok {
+			return ids
+		}
+	}
+	return nil
+}
+
+// extendedModelCatalog 扩展来源链（两个 codebuddy 引擎均启用）：返回（模型清单, 积分倍率表, 是否命中）。
+//
+// ① 客户端合并配置缓存 acc-product-config（注册表），按**客户端选择器清单**
+//
+//	agents[].models 过滤（见 agentSelectorModels / readAccCatalog）
+//
+// ② 远程配置缓存 ∪ App 包 product.json（超集近似，含国内后端条目）
+//
+// 命中 ① 时 ② 不再叠加 —— ① 就是客户端所见，别无二义。倍率表与清单同源同链。
+func (c codebuddyCore) extendedModelCatalog(bin string) ([]string, map[string]string, bool) {
+	if ids, credits := readAccCatalog(c.accConfigPath, c.selectorModels()); len(ids) > 0 {
+		return ids, credits, true
+	}
+	var ids []string
+	credits := map[string]string{}
+	for _, dir := range c.modelCacheDirs {
+		i, cr := remoteConfigCacheCatalog(dir)
+		ids = append(ids, i...)
+		for k, v := range cr {
+			if _, dup := credits[k]; !dup {
+				credits[k] = v
+			}
+		}
+	}
+	i, cr := readProductJSONCatalog(productJSONPath(bin))
+	ids = append(ids, i...)
+	for k, v := range cr {
+		if _, dup := credits[k]; !dup {
+			credits[k] = v
+		}
+	}
+	ids = dedupeModels(ids)
+	if len(ids) == 0 {
+		return nil, nil, false
+	}
+	return ids, credits, true
+}
+
+// modelCredits 返回各模型的**积分倍率表**（model → 规范化数字字符串，如 "0.34"，
+// 源自客户端 "x0.34 credits"）。来源链与 extendedModelCatalog 完全一致
+// （① acc 缓存 → ② 远程配置缓存 ∪ ③ App 包 product.json），但**只取倍率、
+// 不改变模型清单来源**：两个引擎的清单都走同一条扩展链（见 listModels），
+// 倍率表与清单同源同链、按 model id 对上。
+func (c codebuddyCore) modelCredits(bin string) map[string]string {
+	// ① 客户端合并配置缓存（与 extendedModelCatalog 同源同语义：**有模型即钉死**，
+	// 哪怕一条倍率都没有也不穿透 ②③ 去混别处的倍率 —— 客户端不给就是不显示）
+	if ids, credits := readAccCatalog(c.accConfigPath, c.selectorModels()); len(ids) > 0 {
+		if len(credits) == 0 {
+			return nil
+		}
+		return credits
+	}
+	// ② 远程配置缓存（按优先级，先到先得）∪ ③ App 包 product.json
+	credits := map[string]string{}
+	for _, dir := range c.modelCacheDirs {
+		_, cr := remoteConfigCacheCatalog(dir)
+		for k, v := range cr {
+			if _, dup := credits[k]; !dup {
+				credits[k] = v
+			}
+		}
+	}
+	_, cr := readProductJSONCatalog(productJSONPath(bin))
+	for k, v := range cr {
+		if _, dup := credits[k]; !dup {
+			credits[k] = v
+		}
+	}
+	if len(credits) == 0 {
+		return nil
+	}
+	return credits
+}
+
+// listModels 实现 ModelLister 的共享逻辑。
+//
+// 两个引擎**同一条三级来源链**：
+//
+//	① 客户端合并配置缓存 acc-product-config（客户端模型选择器同源）
+//	② 远程配置缓存 ∪ App 包 product.json（超集近似）
+//	③ --help 里 --model 描述自带的 "Currently supported: (...)" 清单
+//
+// 命中 ① 时 ② 不再叠加 —— ① 就是客户端所见，别无二义。
+//
+// 实测（2026-09-21 / 2026-09-28）：
+//
+//   - AI 端 acc 缓存 27 条（23 预制 + 4 custom-local，含 deepseek-v4.1-flash /
+//     gpt-5.6-*）；远程配置缓存（52 条）混着国内后端条目但没有 gpt；product.json
+//     （26 条）没有 deepseek-v4.1-flash；--help 只有 4 个分层别名。
+//   - WorkBuddy 端 acc 缓存 61 条（53 预制 + 8 custom-local）。**--help 只有 17 条**
+//     （9 预制 + 全部 8 个 custom-local）—— 官方预制只放行 9 个、且恰好不是客户端
+//     主力模型（hy3 / hy4-preview / deepseek-v4.1-flash / glm-5.3 全部不在内）。
+//     故 2026-09-28 起两端一致走扩展链：此前 codebuddy 只按 --help 出清单、倍率却按
+//     acc 缓存取，同一引擎两个字段读自两个文件，`model_credits` 里能查到倍率而
+//     `models` 里查不到该模型。
+//
+// ⚠️ --help 路径必须带 extraEnv：清单由登录后端下发，跟随配置目录。不带隔离
+// 环境时 codebuddy-ai 会读到共享 ~/.codebuddy 里 WorkBuddy 后端的清单。
+func (c codebuddyCore) listModels(ctx context.Context) ([]string, error) {
+	bin := c.bin()
+	if bin == "" {
+		return nil, fmt.Errorf("%s CLI not found", c.name)
+	}
+	// 顺带补自定义模型端点（幂等，见 syncCustomModelEndpoints）：
+	// 清单与端点同源，只列清单不同步就会「选得出来、调用报没有 url」。
+	c.syncCustomModelEndpoints()
+	if c.extendedModelSources {
+		// ① 客户端合并配置缓存（客户端模型选择器同源）→ ② 远程配置缓存 ∪
+		// App 包 product.json（超集近似）→ 都没有时落 ③ --help（见函数头）。
+		if ids, _, ok := c.extendedModelCatalog(bin); ok {
+			return ids, nil
+		}
+	}
+	stdout, stderr, err := runCLIEnvIn(ctx, "", c.extraEnv, bin, "--help")
+	if err != nil {
+		return nil, wrapCliError(c.name, stdout, stderr, err)
+	}
+	models := parseCodebuddyHelpModels(stdout)
+	if len(models) == 0 {
+		return nil, fmt.Errorf("%w: --help has no \"Currently supported\" list", ErrNoModelSource)
+	}
+	return models, nil
+}
+
+// syncCustomModelEndpoints 顺带把 App 里配好的自定义模型端点补进 CLI 的 models.json。
+//
+// 为什么放在 listModels：清单本身来自同一份 acc 缓存，**只列清单不同步端点**就会出现
+// 「模型选择器里列得出来、选了就报 has no endpoint url configured」。
+// best-effort（错误忽略）：同步失败不该让模型探测失败 —— 官方模型根本不读 models.json。
+func (c codebuddyCore) syncCustomModelEndpoints() {
+	_, _ = syncCustomModelsFromApp(c.accConfigPath, c.effectiveConfigDir())
+}
+
+// complete 单次调用的共享逻辑。
+func (c codebuddyCore) complete(ctx context.Context, req Request) (Response, error) {
+	start := time.Now()
+	bin := c.bin()
+	if bin == "" {
+		return Response{}, fmt.Errorf("%s CLI not found; set %s", c.name, c.base.envVar)
+	}
+	// 自定义模型才补端点（用户可能刚在 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()
+	prompt := FlattenPrompt(req.SystemPrompt, req.Messages, false)
+	if prompt == "" {
+		return Response{}, fmt.Errorf("%s: empty prompt", c.name)
+	}
+	args := streamJSONArgs(c.buildArgsBase(req), prompt, false)
+	stdin, err := streamJSONUserLine(prompt, req.Attachments)
+	if err != nil {
+		return Response{}, err
+	}
+	acc := &streamAccumulator{Engine: c.name, OnSessionID: req.OnSessionID}
+	var fin streamJSONResult
+	seen, err := runStreamJSONIn(ctx, req.Workspace, c.extraEnv, bin, args, strings.NewReader(stdin), acc, &fin)
+	if err != nil {
+		return Response{}, wrapCliError(c.name, "", "", err)
+	}
+	if !seen {
+		return Response{}, fmt.Errorf("%s CLI stream ended without result line", c.name)
+	}
+	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))
+	if strings.TrimSpace(text) == "" {
+		return Response{}, fmt.Errorf("%s CLI 返回内容仅为请求回显（无模型正文）", c.name)
+	}
+	return Response{
+		Text:      text,
+		Model:     fin.Model,
+		SessionID: fin.SessionID,
+		Latency:   time.Since(start),
+	}, nil
+}
+
+// buildArgs 构造 codebuddy CLI 参数（Complete 与 Stream 共用）。
+func (c codebuddyCore) buildArgs(req Request) []string {
+	return append(c.buildArgsBase(req), FlattenPrompt(req.SystemPrompt, req.Messages, false))
+}
+
+// buildArgsBase 构造参数（不含末尾的位置参数 prompt）——附件场景复用：
+// 那条路提示词走 stdin，不能再作为命令行参数传。
+func (c codebuddyCore) buildArgsBase(req Request) []string {
+	args := []string{"--print", "--output-format", "json"}
+	switch {
+	case req.SessionID != "":
+		// 续接指定会话（commander 风格空格传值）。默认新会话不传
+		// --no-session-persistence：不落盘的会话无法续接。
+		args = append(args, "--resume", req.SessionID)
+	case req.Continue:
+		// 续接最近一次会话（无需 id）。
+		args = append(args, "--continue")
+	}
+	// 工具模式决定两件事：CLI 侧的工具白名单，以及 system prompt 是否
+	// 追加 noToolSuffix。
+	//
+	// ⚠️ noToolSuffix 只在 off 模式注入。它明文写着「严禁使用任何工具」，
+	// 与 on / 白名单模式的目标直接冲突 —— 之前无条件注入，导致
+	// `--tools on` 表面开了工具、system prompt 却在压制模型调用，
+	// 表现为「工具启用无效」。enable 模式下必须让 system prompt 干净。
+	tools := toolsOrDefault(req.Tools)
+	switch {
+	case tools.IsOff():
+		// 关工具：不仅 CLI 侧禁掉，system prompt 也要堵住模型「伪工具调用」
+		// （实测 off 且不注入时，模型会输出 <tool_calls:xxxx> 这类假标签）。
+		args = append(args, "--tools", "")
+		args = append(args, "--append-system-prompt", noToolSuffix)
+	case tools.IsOn():
+		// 四档权限档位：codebuddy 与 claude 同族，--permission-mode 取值完全一致
+		//（default / acceptEdits / auto / bypassPermissions），故复用同一映射。
+		// 改造前这里恒传 -y（= --dangerously-skip-permissions，第 4 档）。
+		args = append(args, "--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 != "" {
+		args = append(args, "--model", m)
+	} else if c.model != "" {
+		// 默认模型（codebuddy=hy3；codebuddy-ai 故意留空 = CLI 自身默认，
+		// 见文件头的模型注册表漂移说明）；空串 = 不传 --model。
+		args = append(args, "--model", c.model)
+	}
+	// 统一参数矩阵：`--settings` 只接受一份载荷，故 MaxTokens 的 env 注入与
+	// 四档模型的 sandbox / autoMode / permissions 合并进同一个 JSON。
+	// 注意 codebuddy 的沙箱键集与 claude 略有差异（文档未列 failIfUnavailable），
+	// 由 sandboxSettings 按引擎区分（codebuddy / codebuddy-ai 同族同语义）。
+	if payload, ok := agentSettingsPayload(req, c.name); ok {
+		args = append(args, "--settings", payload)
+	}
+	return args
+}
+
+// stream 流式调用的共享逻辑。
+// 协议与 claude 同源（CodeBuddy Code 系 stream-json）。
+func (c codebuddyCore) stream(ctx context.Context, req Request, onEvent func(StreamEvent)) (StreamResult, error) {
+	start := time.Now()
+	bin := c.bin()
+	if bin == "" {
+		return StreamResult{}, fmt.Errorf("%s CLI not found; set %s", c.name, c.base.envVar)
+	}
+	// 自定义模型才补端点（同 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"`
+	}
+	seenResult := false
+
+	err := runStreamCLIEnvIn(ctx, req.Workspace, c.extraEnv, 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 {
+		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(fin.Result)
+	if strings.TrimSpace(text) == "" {
+		text = strings.TrimSpace(acc.Text.String())
+	}
+	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
+}
+
+// ── codebuddy：主账号 ────────────────────────────────────────
+
+// CodeBuddyEngine 通过**独立安装**的 CodeBuddy Code CLI 实现 Engine。
+// 账号标识 "codebuddy" → 票据 sharedDataPath/auth/codebuddy.info。
+type CodeBuddyEngine struct {
+	// BinPath 显式指定 CLI 路径（空 = 自动探测）。测试注入用。
+	BinPath string
+}
+
+// Name 实现 Engine。
+func (e *CodeBuddyEngine) Name() string { return "codebuddy" }
+
+// DefaultCodeBuddyTimeout 单次尝试默认超时（codebuddy / codebuddy-ai 共用）。
+const DefaultCodeBuddyTimeout = 5 * time.Minute
+
+// DefaultCodeBuddyModel codebuddy 引擎的默认模型。
+// 未显式 -m 指定时使用 hy3（与 magic-video 的 DefaultCreativeModel 一致）。
+const DefaultCodeBuddyModel = "hy3"
+
+// core 返回共享实现核心。
+// 扩展清单链（extendedModelSources）启用：与 codebuddy-ai 同源同链，清单按
+// acc 缓存（客户端模型选择器真实数据源）→ 远程配置缓存 ∪ product.json → --help；
+// 积分倍率走 modelCredits（同一条链，见 codebuddyAccConfigPath）。
+func (e *CodeBuddyEngine) core() codebuddyCore {
+	return codebuddyCore{
+		name:                 "codebuddy",
+		base:                 codebuddyBase,
+		binPath:              e.BinPath,
+		model:                DefaultCodeBuddyModel,
+		extraEnv:             codebuddyAccountEnv(codebuddyDir(), codebuddyAuthID, codebuddyAuthIDEnv),
+		extendedModelSources: true,
+		accConfigPath:        codebuddyAccConfigPath(),
+		modelCacheDirs:       codebuddyModelCacheDirs(),
+		configDir:            codebuddyDir(),
+	}
+}
+
+// bin 探测 codebuddy CLI 路径。
+func (e *CodeBuddyEngine) bin() string { return e.core().bin() }
+
+// Detect 实现 Engine。
+func (e *CodeBuddyEngine) Detect() (bool, string) { return e.core().detect() }
+
+// LoginCommand 实现 LoginRunner：拉起交互式会话（进去执行 /login）。
+// 带上本引擎的账号环境，确保登录结果落进本引擎用的票据 auth/codebuddy.info。
+func (e *CodeBuddyEngine) LoginCommand() (string, []string, []string, error) {
+	bin := e.bin()
+	if bin == "" {
+		return "", nil, nil, fmt.Errorf("%s CLI not found; set %s", e.Name(), codebuddyBase.envVar)
+	}
+	return bin, nil, codebuddyAccountEnv(codebuddyDir(), codebuddyAuthID, codebuddyAuthIDEnv), nil
+}
+
+// ListModels 实现 ModelLister。
+func (e *CodeBuddyEngine) ListModels(ctx context.Context) ([]string, error) {
+	return e.core().listModels(ctx)
+}
+
+// ModelCredits 实现 ModelCreditLister：各模型的积分倍率（规范化数字字符串，
+// 如 "0.34"，源自客户端 "x0.34 credits"）。**只取倍率表，清单不动** ——
+// codebuddy 的模型清单仍按 --help（见 listModels）；倍率来源链与 codebuddy-ai
+// 一致：acc 缓存（~/.workbuddy）→ 远程配置缓存 ∪ product.json。清单里某模型
+// 没有倍率数据时自然查不到（UI 不显示）；完全无数据返回 nil（CLI 端省略字段）。
+func (e *CodeBuddyEngine) ModelCredits(ctx context.Context) map[string]string {
+	bin := e.bin()
+	if bin == "" {
+		return nil
+	}
+	return e.core().modelCredits(bin)
+}
+
+// Complete 实现 Engine：单次调用 codebuddy CLI。
+func (e *CodeBuddyEngine) Complete(ctx context.Context, req Request) (Response, error) {
+	return e.core().complete(ctx, req)
+}
+
+// Stream 实现 Streamer。
+func (e *CodeBuddyEngine) Stream(ctx context.Context, req Request, onEvent func(StreamEvent)) (StreamResult, error) {
+	return e.core().stream(ctx, req, onEvent)
+}
+
+// buildArgs 构造 codebuddy CLI 参数。
+func (e *CodeBuddyEngine) buildArgs(req Request) []string { return e.core().buildArgs(req) }
+
+// buildArgsBase 构造参数（不含末尾的位置参数 prompt）。
+func (e *CodeBuddyEngine) buildArgsBase(req Request) []string { return e.core().buildArgsBase(req) }
+
+// ── codebuddy-ai：第二个账号 ─────────────────────────────────
+
+// DefaultCodeBuddyAIModel codebuddy-ai 引擎的默认模型。
+//
+// 故意留空：国际站账号的模型注册表与静态 --help 清单有漂移（--help 里的
+// kimi-k3-1 / deepseek-v4-pro 实测被后端 400 拒绝），强制指定 hy3 有同款风险，
+// 故默认不传 --model、交 CLI 自身默认；-m 仍可显式指定。
+const DefaultCodeBuddyAIModel = ""
+
+// CodeBuddyAIEngine 与 CodeBuddyEngine 用**同一个**（独立安装的）CodeBuddy Code CLI，
+// 只是账号不同：account id "codebuddy-ai" → 票据 sharedDataPath/auth/codebuddy-ai.info。
+// 协议 / flag 面完全一致。
+type CodeBuddyAIEngine struct {
+	// BinPath 显式指定 CLI 路径（空 = 自动探测）。测试注入用。
+	BinPath string
+}
+
+// Name 实现 Engine。
+func (e *CodeBuddyAIEngine) Name() string { return "codebuddy-ai" }
+
+// core 返回共享实现核心。
+func (e *CodeBuddyAIEngine) core() codebuddyCore {
+	return codebuddyCore{
+		name:                 "codebuddy-ai",
+		base:                 codebuddyAIBase,
+		binPath:              e.BinPath,
+		model:                DefaultCodeBuddyAIModel,
+		extraEnv:             codebuddyAIExtraEnv(),
+		extendedModelSources: true,
+		modelCacheDirs:       codebuddyAIModelCacheDirs(),
+		accConfigPath:        codebuddyAIAccConfigPath(),
+		configDir:            codebuddyAIDir(),
+	}
+}
+
+// workbuddyAccConfigPath 返回 WorkBuddy 系桌面客户端的合并产品配置缓存路径
+// （appHome = 客户端数据目录名：".workbuddy-ai" / ".workbuddy"）。
+//
+// 桌面客户端把「product.json ∪ 网关远程配置 ∪ 用户自定义模型」合并后的运行时
+// 配置缓存在 <数据目录>/cache/acc-product-config-v*.json，与 product.json 同构
+// （models[].id + models[].credits）—— 这是客户端模型选择器的真实数据源。
+// 文件名带版本号（当前 v3）：glob 全部版本取 mtime 最新；客户端从未运行过时
+// 文件不存在，返回 ""（调用方回退各自的下一条来源）。
+//
+// 两端同构不同目录：codebuddy-ai → ~/.workbuddy-ai（WorkBuddy AI App）；
+// codebuddy → ~/.workbuddy（WorkBuddy App，实测 2026-09-22 同样有 v3 缓存：
+// 58 个模型 33 条倍率，含 hy3 x0.00 —— codebuddy 倍率的首选来源）。
+func workbuddyAccConfigPath(appHome string) string {
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		home = os.Getenv("HOME")
+	}
+	hits, err := filepath.Glob(filepath.Join(home, appHome, "cache", "acc-product-config-v*.json"))
+	if err != nil || len(hits) == 0 {
+		return ""
+	}
+	best := ""
+	var bestMod time.Time
+	for _, p := range hits {
+		fi, statErr := os.Stat(p)
+		if statErr != nil {
+			continue
+		}
+		if best == "" || fi.ModTime().After(bestMod) {
+			best, bestMod = p, fi.ModTime()
+		}
+	}
+	return best
+}
+
+// codebuddyAIAccConfigPath 返回 AI 桌面客户端（~/.workbuddy-ai）的合并产品配置
+// 缓存路径。实测 2026-09-21：27 条 = 23 预制 + 4 custom-local，含
+// deepseek-v4.1-flash 与 gpt-5.6-sol/terra/luna、gpt-6-astra 等静态 product.json
+// 里还没有的新模型；endpoint=www.workbuddy.ai、daemon 持续刷新。
+func codebuddyAIAccConfigPath() string {
+	return workbuddyAccConfigPath(".workbuddy-ai")
+}
+
+// codebuddyAccConfigPath 返回 WorkBuddy 桌面客户端（非 AI，~/.workbuddy）的
+// 合并产品配置缓存路径 —— codebuddy 引擎积分倍率的首选来源。
+func codebuddyAccConfigPath() string {
+	return workbuddyAccConfigPath(".workbuddy")
+}
+
+// codebuddyAIModelCacheDirs 返回 codebuddy-ai 模型清单的远程配置缓存目录（按优先级）。
+//
+// 隔离目录优先；共享 ~/.codebuddy 兜底 —— 桌面 App daemon 仍在共享目录运行，
+// 会把网关下发的远程配置持续刷在那里（实测 2026-09-21：隔离 CLI 自身拉
+// /v3/config 全部 400，deepseek-v4.1-flash 所在的远程配置缓存只存在于共享目录）。
+// 只读缓存文件，不触碰凭据。用户显式设置 CODEBUDDY_CONFIG_DIR 时只信该目录。
+func codebuddyAIModelCacheDirs() []string {
+	dirs := []string{filepath.Join(codebuddyAIDir(), "local_storage")}
+	if os.Getenv("CODEBUDDY_CONFIG_DIR") != "" {
+		return dirs
+	}
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		home = os.Getenv("HOME")
+	}
+	shared := filepath.Join(home, ".codebuddy", "local_storage")
+	if shared != dirs[0] {
+		dirs = append(dirs, shared)
+	}
+	return dirs
+}
+
+// codebuddyModelCacheDirs 返回 codebuddy（非 ai）远程配置缓存目录，**按可信度排序**。
+// 引擎自身不注入 CODEBUDDY_CONFIG_DIR；用户显式设置时只信该目录（与 CLI 的实际
+// 读取一致）。只读缓存文件，不触碰凭据。
+//
+// ⚠️ 首选 `~/.workbuddy/local_storage`（**与 acc 缓存同源**，客户端当前账号正在
+// 持续刷它，实测 10:48 更新），共享 `~/.codebuddy/local_storage` 只作兜底：那里
+// 可能还留着**别的账号**的旧条目（实测同一份 d43e… 缓存里 userId=f231e9af 的
+// 清单是 hy4-preview-f、ed6c16d4 的是 hy4-preview，mtime 相同）。选择器清单按本
+// 目录优先级取「mtime 最新那一条」，所以目录顺序 = 账号可信度顺序，错了会把
+// 上一账号的型号混进 -m 清单。
+func codebuddyModelCacheDirs() []string {
+	if dir := os.Getenv("CODEBUDDY_CONFIG_DIR"); dir != "" {
+		return []string{filepath.Join(dir, "local_storage")}
+	}
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		home = os.Getenv("HOME")
+	}
+	own := filepath.Join(home, ".workbuddy", "local_storage")
+	shared := filepath.Join(home, ".codebuddy", "local_storage")
+	if shared != own {
+		return []string{own, shared}
+	}
+	return []string{own}
+}
+
+// codebuddyAIDir codebuddy-ai 引擎的专用配置目录（~/.codebuddy-ai）。
+//
+// 注意：**账号**的隔离靠 authentication.id（见 codebuddyAuthID / codebuddyAIAuthID），
+// 与配置目录无关 —— 票据文件是共享的 sharedDataPath/auth/<id>.info。
+// 这里分目录是为了让两个引擎的 settings / keyblob / 会话 / 插件缓存各归各的，
+// 避免互相覆盖（历史上共享目录时出现过登录态被顶）。
+func codebuddyAIDir() string {
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		home = os.Getenv("HOME")
+	}
+	return filepath.Join(home, ".codebuddy-ai")
+}
+
+// ── 账号隔离：一个 CLI，两个账号 ─────────────────────────────
+//
+// CLI 的票据路径由 authentication.id 决定：
+//
+//	sharedDataPath/auth/<authentication.id>.info   （sharedDataPath 与配置目录无关）
+//
+// 而 authentication.id 的取值链是：
+//
+//	① 合并后的产品配置 → ② ACC_PRODUCT_CONFIG_PATH 指向的文件
+//	→ ③ ACC_PRODUCT_CONFIG_V3 / _V2（环境变量里的 JSON）→ ④ CLI 包内 product.json
+//
+// 实测（2026-09-28）：独立运行时 ①② 为空，③ 生效 —— 给两个子进程注入不同的 id，
+// CLI 就各读各的票据、各用各的账号，互不顶号（改 id 后立刻改读另一份 .info 并能正常出正文）。
+//
+// ⚠️ ACC_PRODUCT_CONFIG_PATH 必须**清空**：父会话（WorkBuddy App / 内嵌会话）会把它
+// 指到自己的 acc-product-config，而它优先级**高于** ③，会把账号选回 App 的默认账号。
+const (
+	// codebuddyAuthID codebuddy 引擎的账号标识（票据 auth/codebuddy.info）。
+	codebuddyAuthID = "codebuddy"
+	// codebuddyAIAuthID codebuddy-ai 引擎的账号标识（票据 auth/codebuddy-ai.info）。
+	codebuddyAIAuthID = "codebuddy-ai"
+
+	// codebuddyAuthIDEnv / codebuddyAIAuthIDEnv：各引擎自己的账号覆盖变量
+	//（临时切到别的账号用；不读通用的 ACC_PRODUCT_CONFIG_V3，理由见 codebuddyAccountEnv）。
+	codebuddyAuthIDEnv   = "MAGIC_AGENT_CODEBUDDY_AUTH_ID"
+	codebuddyAIAuthIDEnv = "MAGIC_AGENT_CODEBUDDY_AI_AUTH_ID"
+)
+
+// codebuddyAccountEnv 构造「选定账号」的子进程环境变量。
+//
+//   - ACC_PRODUCT_CONFIG_PATH 恒清空（见上）
+//   - ACC_PRODUCT_CONFIG_V3   只声明 authentication.id
+//   - CODEBUDDY_CONFIG_DIR    该引擎自己的配置目录（settings / keyblob / 会话）；
+//     用户已显式设置时尊重之
+//
+// 想临时换账号：设**各引擎自己的** authIDEnv（见 codebuddyAuthIDEnv /
+// codebuddyAIAuthIDEnv）。刻意**不**读通用的 ACC_PRODUCT_CONFIG_V3 当覆盖 ——
+// 那个变量一旦在全局会话里存在，两个引擎就会静默合并成同一个账号，
+// 「一个 CLI 挂两个账号」的设计当场作废。
+func codebuddyAccountEnv(configDir, authID, authIDEnv string) []string {
+	if v := strings.TrimSpace(os.Getenv(authIDEnv)); v != "" {
+		authID = v
+	}
+	env := []string{
+		"ACC_PRODUCT_CONFIG_PATH=",
+		`ACC_PRODUCT_CONFIG_V3={"authentication":{"id":"` + authID + `"}}`,
+	}
+	if os.Getenv("CODEBUDDY_CONFIG_DIR") == "" {
+		env = append(env, "CODEBUDDY_CONFIG_DIR="+configDir)
+	}
+	return env
+}
+
+// codebuddyDir codebuddy 引擎的配置目录（= CLI 默认目录 ~/.codebuddy）。
+func codebuddyDir() string {
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		home = os.Getenv("HOME")
+	}
+	return filepath.Join(home, ".codebuddy")
+}
+
+// codebuddyAIExtraEnv 返回 codebuddy-ai 子进程的账号环境变量。
+// 与 codebuddy 的差异只在账号标识与配置目录，二进制是同一个。
+func codebuddyAIExtraEnv() []string {
+	return codebuddyAccountEnv(codebuddyAIDir(), codebuddyAIAuthID, codebuddyAIAuthIDEnv)
+}
+
+// bin 探测 codebuddy-ai CLI 路径。
+func (e *CodeBuddyAIEngine) bin() string { return e.core().bin() }
+
+// Detect 实现 Engine。
+func (e *CodeBuddyAIEngine) Detect() (bool, string) { return e.core().detect() }
+
+// LoginCommand 实现 LoginRunner：拉起交互式会话（进去执行 /login）。
+// 与 CodeBuddyEngine 用同一个二进制，账号环境不同（票据 auth/codebuddy-ai.info）。
+func (e *CodeBuddyAIEngine) LoginCommand() (string, []string, []string, error) {
+	bin := e.bin()
+	if bin == "" {
+		return "", nil, nil, fmt.Errorf("%s CLI not found; set %s", e.Name(), codebuddyAIBase.envVar)
+	}
+	return bin, nil, codebuddyAIExtraEnv(), nil
+}
+
+// ListModels 实现 ModelLister。
+func (e *CodeBuddyAIEngine) ListModels(ctx context.Context) ([]string, error) {
+	return e.core().listModels(ctx)
+}
+
+// ModelCredits 实现 ModelCreditLister：各模型的积分倍率（规范化数字字符串，
+// 如 "0.34"，源自客户端 "x0.34 credits"）。与 ListModels 同源同链
+// （core().modelCredits，即 extendedModelCatalog 的倍率半边）；客户端不给倍率
+// 的模型（custom-local）不在返回值里；引擎不可用 / 无倍率数据时返回 nil。
+func (e *CodeBuddyAIEngine) ModelCredits(ctx context.Context) map[string]string {
+	bin := e.bin()
+	if bin == "" {
+		return nil
+	}
+	return e.core().modelCredits(bin)
+}
+
+// Complete 实现 Engine：单次调用 codebuddy-ai CLI。
+func (e *CodeBuddyAIEngine) Complete(ctx context.Context, req Request) (Response, error) {
+	return e.core().complete(ctx, req)
+}
+
+// Stream 实现 Streamer。
+func (e *CodeBuddyAIEngine) Stream(ctx context.Context, req Request, onEvent func(StreamEvent)) (StreamResult, error) {
+	return e.core().stream(ctx, req, onEvent)
+}
+
+// buildArgs 构造 codebuddy-ai CLI 参数。
+func (e *CodeBuddyAIEngine) buildArgs(req Request) []string { return e.core().buildArgs(req) }
+
+// buildArgsBase 构造参数（不含末尾的位置参数 prompt）。
+func (e *CodeBuddyAIEngine) buildArgsBase(req Request) []string { return e.core().buildArgsBase(req) }
+
+// ── 输出解析（两个后端共用）──────────────────────────────────
+
+// stripUserQueryEcho 剥离 <user_query>…</user_query> 请求回显。
+func stripUserQueryEcho(s string) string {
+	t := strings.TrimSpace(s)
+	if !strings.HasPrefix(t, "<user_query>") {
+		return s
+	}
+	end := strings.Index(t, "</user_query>")
+	if end < 0 {
+		return ""
+	}
+	return strings.TrimSpace(t[end+len("</user_query>"):])
+}
+
+// extractCodeBuddyResult 解析 codebuddy 输出，兼容三种形态：
+//
+//  1. 单对象 envelope {"type":"result","result":"..."}
+//  2. 数组：优先 type=="result"，否则拼接全部 assistant text
+//  3. 解析失败原样返回
+func extractCodeBuddyResult(raw string) string {
+	trimmed := strings.TrimSpace(raw)
+	if trimmed == "" {
+		return raw
+	}
+
+	// Shape 1: 单对象。
+	var single struct {
+		Type    string `json:"type"`
+		IsError bool   `json:"is_error"`
+		Result  string `json:"result"`
+	}
+	if trimmed[0] == '{' {
+		if err := json.Unmarshal([]byte(trimmed), &single); err == nil {
+			if single.Result != "" {
+				return single.Result
+			}
+		}
+	}
+
+	// Shape 2: stream 消息数组。
+	if trimmed[0] == '[' {
+		var msgs []json.RawMessage
+		if err := json.Unmarshal([]byte(trimmed), &msgs); err == nil {
+			for _, raw := range msgs {
+				var m struct {
+					Type   string `json:"type"`
+					Result string `json:"result"`
+				}
+				if json.Unmarshal(raw, &m) == nil && m.Type == "result" && m.Result != "" {
+					return m.Result
+				}
+			}
+			var sb strings.Builder
+			for _, raw := range msgs {
+				var probe map[string]json.RawMessage
+				if json.Unmarshal(raw, &probe) != nil {
+					continue
+				}
+				if r, ok := probe["role"]; ok && string(r) == `"assistant"` {
+					if text := extractAssistantText(probe); text != "" {
+						if sb.Len() > 0 {
+							sb.WriteString("\n")
+						}
+						sb.WriteString(text)
+					}
+				}
+				if r, ok := probe["type"]; ok && string(r) == `"assistant"` {
+					if text := extractAssistantText(probe); text != "" {
+						if sb.Len() > 0 {
+							sb.WriteString("\n")
+						}
+						sb.WriteString(text)
+					}
+				}
+			}
+			if sb.Len() > 0 {
+				return sb.String()
+			}
+		}
+	}
+
+	// Shape 3: 原样返回。
+	return raw
+}
+
+// extractCodeBuddySession 从 codebuddy 输出里挖 session_id（尽力而为），
+// 兼容单对象 envelope 与 stream 消息数组两种形态；找不到返回空串。
+func extractCodeBuddySession(raw string) string {
+	trimmed := strings.TrimSpace(raw)
+	if trimmed == "" {
+		return ""
+	}
+	// Shape 1: 单对象 envelope。
+	if trimmed[0] == '{' {
+		var single struct {
+			SessionID string `json:"session_id"`
+		}
+		if json.Unmarshal([]byte(trimmed), &single) == nil {
+			return single.SessionID
+		}
+		return ""
+	}
+	// Shape 2: stream 消息数组 —— 优先 type=="result" 行，其次任意带
+	// session_id 的行。
+	if trimmed[0] == '[' {
+		var msgs []json.RawMessage
+		if json.Unmarshal([]byte(trimmed), &msgs) != nil {
+			return ""
+		}
+		fallback := ""
+		for _, m := range msgs {
+			var probe struct {
+				Type      string `json:"type"`
+				SessionID string `json:"session_id"`
+			}
+			if json.Unmarshal(m, &probe) != nil || probe.SessionID == "" {
+				continue
+			}
+			if probe.Type == "result" {
+				return probe.SessionID
+			}
+			if fallback == "" {
+				fallback = probe.SessionID
+			}
+		}
+		return fallback
+	}
+	return ""
+}
+
+// extractAssistantText 从单条 stream 消息里挖 assistant 可见文本。
+func extractAssistantText(msg map[string]json.RawMessage) string {
+	var sb strings.Builder
+	var containers []json.RawMessage
+	// "message" 可能是 {"content":[...]}（包一层），也可能直接是 [...]。
+	if v, ok := msg["message"]; ok {
+		var inner map[string]json.RawMessage
+		if err := json.Unmarshal(v, &inner); err == nil {
+			if c, ok := inner["content"]; ok {
+				containers = append(containers, c)
+			}
+		} else {
+			containers = append(containers, v)
+		}
+	}
+	if v, ok := msg["content"]; ok {
+		containers = append(containers, v)
+	}
+	for _, c := range containers {
+		var blocks []struct {
+			Type string `json:"type"`
+			Text string `json:"text"`
+		}
+		if err := json.Unmarshal(c, &blocks); err != nil {
+			continue
+		}
+		for _, b := range blocks {
+			t := b.Type
+			if t == "" || t == "text" || t == "output_text" {
+				if b.Text != "" {
+					if sb.Len() > 0 {
+						sb.WriteString("\n")
+					}
+					sb.WriteString(b.Text)
+				}
+			}
+		}
+	}
+	return sb.String()
+}