magic-agent 1.0.3 → 1.0.49

package/internal/agent/limitnotice_test.go

@@ -0,0 +1,211 @@
+package agent
+
+// limitnotice_test.go - 「限流/额度通告被当正文发回来」的判据与收尾验收（2026-10-10）。
+//
+// 钉三件事：
+//  ① splitLimitNotice 认得两条**实测原文**（中英各一，见 limitnotice.go 文件头）；
+//  ② 不误伤正常回答（用户真在问「429 是什么意思」时模型的科普句）；
+//  ③ 接上了：命中时**不发 turn_end、改发一条 turn_failed**（原因 = 通告原文，
+//     Text = 剥掉通告的正文），并且 Stream 返回错误（CLI 据此写失败信封、非零退出）。
+//
+// 为什么值得单测（而不是只靠真机跑一次）：判断的两个方向都很难看 —— 判太宽 = 把
+// 「用户真在问 429」的正常回答整段吞掉并报错；判太窄 = 又变成用户报的那个
+// 「通告混在回复里」。真机复现要等一个额度用尽的时刻，单测一秒跑完且能钉住边界。
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const (
+	// 实测英文通告（前面没有换行，请求 id 尾巴跟在最后）。
+	limitNoticeEN = "429 usage exceeds frequency limit, but don't worry, your usage will reset at " +
+		"2026-10-11 10:32:59 UTC+8, alternatively, you can switch to the other models to continue using it."
+	limitNoticeENID = " (0l1a124d77d077ef98bb9427957af8f2/0l1a123c3-17c1-71f8-835c-3c15cbe5c7f95)"
+	// 实测中文通告（整条正文就是它）。
+	limitNoticeZH = "429 您的使用量已超出频率限制，将在 2026-09-19 17:49:56 UTC+8 重置，" +
+		"您也可以切换其他模型继续使用。"
+	limitNoticeNarration = "Let me read the file's end."
+)
+
+func TestSplitLimitNoticeRealSamples(t *testing.T) {
+	notice, body, ok := splitLimitNotice(limitNoticeNarration + limitNoticeEN + limitNoticeENID)
+	if !ok {
+		t.Fatalf("实测英文原文没认出来（粘在正文末尾、无换行、带请求 id 尾巴）")
+	}
+	if !strings.HasPrefix(notice, "429 usage exceeds") {
+		t.Errorf("notice = %q，应以状态码开头", notice)
+	}
+	if strings.Contains(notice, "0l1a") {
+		t.Errorf("notice = %q，请求 id 尾巴应被剥掉", notice)
+	}
+	if body != limitNoticeNarration {
+		t.Errorf("body = %q，want %q（通告之前的正文要完整留下）", body, limitNoticeNarration)
+	}
+
+	notice, body, ok = splitLimitNotice(limitNoticeZH)
+	if !ok {
+		t.Fatalf("实测中文原文没认出来")
+	}
+	if !strings.HasPrefix(notice, "429 您的使用量") {
+		t.Errorf("notice = %q", notice)
+	}
+	if body != "" {
+		t.Errorf("body = %q，want 空串（这一轮只回了通告）", body)
+	}
+
+	// 通告单独占一行（前面是正文）→ 正文照旧留下。
+	if _, b, ok := splitLimitNotice(limitNoticeNarration + "\n" + limitNoticeEN); !ok || b != limitNoticeNarration {
+		t.Errorf("通告独占一行时 body = %q ok=%v，want %q/true", b, ok, limitNoticeNarration)
+	}
+	// 超长正文末尾才是通告 → 判据只看通告那一段的长度，不该整段吞掉。
+	long := strings.Repeat("前面的正文。", 200)
+	if _, b, ok := splitLimitNotice(long + "\n" + limitNoticeEN); !ok || b != long {
+		t.Errorf("长正文末尾夹通告时没认出，或把正文吞了（body 长度 %d）", len(b))
+	}
+	// 各种状态码都算这一类。
+	for _, code := range []string{"502", "503", "402", "403"} {
+		if _, _, ok := splitLimitNotice(code + " quota exceeded, will reset at 2026-10-11 10:00:00 UTC+8"); !ok {
+			t.Errorf("状态码 %s 没认出来", code)
+		}
+	}
+	// 空值不抛。
+	for _, in := range []string{"", "   \n ", "\r\n"} {
+		if _, _, ok := splitLimitNotice(in); ok {
+			t.Errorf("%q 不该命中", in)
+		}
+	}
+}
+
+func TestSplitLimitNoticeNoFalsePositive(t *testing.T) {
+	cases := map[string]string{
+		"科普句（无限流措辞）":         "HTTP 429 是「请求过多」，服务端让你慢一点。",
+		"科普句（有措辞、无恢复时刻）":     "HTTP 429 是限流，等额度重置即可。",
+		"科普句（有时刻、前面是普通空格）":   "HTTP 429 是限流，额度会在 2026-10-11 重置。",
+		"正文里出现过 429、后面还有别的话": "日志里出现了 429。先看限流配置，额度在 2026-10-11 重置。建议改用另一个模型。",
+		"端口号不是状态码":           "端口 8080 与 usage 有关。",
+		"普通回答":               "已按你的要求改完 3 个文件。",
+	}
+	for name, in := range cases {
+		if _, _, ok := splitLimitNotice(in); ok {
+			t.Errorf("%s：不该被当成通告 → %q", name, in)
+		}
+	}
+}
+
+// codebuddyStreamWithResult 造一个假 codebuddy CLI：只吐一条给定正文的 result 行。
+// 正文里带单引号（英文通告的 don't）时没法直接写进 shell 脚本，所以落成文件再 cat。
+func codebuddyStreamWithResult(t *testing.T, text string) string {
+	t.Helper()
+	dir := t.TempDir()
+	line, err := json.Marshal(map[string]any{
+		"type": "result", "subtype": "success", "is_error": false,
+		"result": text, "model": "hy3", "session_id": "sid-notice",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	payload := filepath.Join(dir, "out.ndjson")
+	if err := os.WriteFile(payload, []byte(string(line)+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	cli := filepath.Join(dir, "codebuddy")
+	if err := os.WriteFile(cli, []byte("#!/bin/sh\ncat "+payload+"\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return cli
+}
+
+func TestCodeBuddyStreamLimitNoticeBecomesTurnFailed(t *testing.T) {
+	cli := codebuddyStreamWithResult(t, limitNoticeNarration+limitNoticeEN+limitNoticeENID)
+	e := &CodeBuddyEngine{BinPath: cli}
+	events, onEvent := collectEvents()
+
+	_, err := e.Stream(context.Background(), Request{
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	}, onEvent)
+	if err == nil {
+		t.Fatal("命中通告时必须返回错误（CLI 据此写失败信封、非零退出）")
+	}
+	if !strings.Contains(err.Error(), "429 usage exceeds") {
+		t.Errorf("err = %v，应带上通告原文（它才是给用户看的原因）", err)
+	}
+
+	var failed []StreamEvent
+	for _, ev := range *events {
+		if ev.Kind == KindTurnEnd {
+			t.Errorf("命中通告时不该发 turn_end（它的语义是「成功收尾」，发了就是假成功）")
+		}
+		if ev.Kind == KindTurnFailed {
+			failed = append(failed, ev)
+		}
+	}
+	if len(failed) != 1 {
+		t.Fatalf("turn_failed 事件 %d 条，want 1", len(failed))
+	}
+	ev := failed[0]
+	if !strings.HasPrefix(ev.Reason, "429 usage exceeds") || ev.Reason != ev.Error {
+		t.Errorf("Reason/Error = %q / %q，want 都是通告原文", ev.Reason, ev.Error)
+	}
+	if ev.Text != limitNoticeNarration {
+		t.Errorf("Text = %q，want %q（消费方拿它覆盖气泡，通告不该留在回复里）", ev.Text, limitNoticeNarration)
+	}
+	if ev.SessionID != "sid-notice" {
+		t.Errorf("SessionID = %q，want sid-notice（会话锚点不能丢）", ev.SessionID)
+	}
+	if ev.Status != StatusFailed {
+		t.Errorf("Status = %q，want failed", ev.Status)
+	}
+}
+
+// 正常回答不许受影响：照旧一条 turn_end，没有 turn_failed。
+func TestCodeBuddyStreamNormalResultUnaffected(t *testing.T) {
+	cli := codebuddyStreamWithResult(t, "已经改完了，3 个文件。")
+	e := &CodeBuddyEngine{BinPath: cli}
+	events, onEvent := collectEvents()
+
+	res, err := e.Stream(context.Background(), Request{
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	}, onEvent)
+	if err != nil {
+		t.Fatalf("Stream: %v", err)
+	}
+	if res.Text != "已经改完了，3 个文件。" {
+		t.Errorf("Text = %q", res.Text)
+	}
+	var turnEnd, turnFailed int
+	for _, ev := range *events {
+		switch ev.Kind {
+		case KindTurnEnd:
+			turnEnd++
+		case KindTurnFailed:
+			turnFailed++
+		}
+	}
+	if turnEnd != 1 || turnFailed != 0 {
+		t.Errorf("turn_end=%d turn_failed=%d，want 1/0", turnEnd, turnFailed)
+	}
+}
+
+// claude 走同一份协议 → 同一条判据。这里只钉「也接上了」。
+func TestClaudeStreamLimitNoticeBecomesTurnFailed(t *testing.T) {
+	cli := codebuddyStreamWithResult(t, limitNoticeZH)
+	e := &ClaudeEngine{BinPath: cli}
+	events, onEvent := collectEvents()
+
+	_, err := e.Stream(context.Background(), Request{
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	}, onEvent)
+	if err == nil || !strings.Contains(err.Error(), "429 您的使用量") {
+		t.Fatalf("err = %v，want 带通告原文的错误", err)
+	}
+	for _, ev := range *events {
+		if ev.Kind == KindTurnEnd {
+			t.Error("claude 命中通告时也不该发 turn_end")
+		}
+	}
+}

package/internal/agent/llmengine.go

@@ -69,8 +69,8 @@ type LLMEngine struct {
 // Name 实现 Engine。
 func (e *LLMEngine) Name() string { return "llm" }
 
-// DefaultLLMTimeout llm 引擎单次尝试默认超时。
-const DefaultLLMTimeout = 10 * time.Minute
+// DefaultLLMTimeout llm 引擎单次尝试默认超时（2026-10-10 由 10 分钟统一上调到 1 小时）。
+const DefaultLLMTimeout = time.Hour
 
 // DefaultLLMModel 默认模型：空串 = 配置文件里的首条（有配置文件时，见 llmmodels.go），
 // 否则交给 llm CLI 自己的默认模型。

package/internal/agent/models.go

@@ -16,8 +16,9 @@ package agent
 //	codex     `codex debug models`（raw model catalog）
 //	openclaw  `openclaw models list --json`
 //	arkclaw   无 —— 模型由网关按 claw_id 绑定，返回 ErrNoModelSource ②
-//	dsh       `$DSH_HOME/settings.yaml` 里已配置的模型（llm-pi-ai.providers.<route>.models，
-//	          无则回落 agent-default-model）；输出 `route/model`，SDK 通道下就是 -m 的可取值
+//	dsh       配置文件里已配置的模型（无则回落 agent-default-model）：0.1.7+ 读各
+//	          profile 的 cordis.patch.yml，更早读 $DSH_HOME/settings.yaml；
+//	          输出 `route/model`，SDK 通道下就是 -m 的可取值
 //
 // ① claude 没有 models 子命令（--help 只有 agents/auth/doctor/mcp/plugin/
 //    project/... ），可用的模型标识只能从用户配置里读：settings.json 的

package/internal/agent/openclaw.go

@@ -118,8 +118,9 @@ type OpenClawEngine struct {
 // Name 实现 Engine。
 func (e *OpenClawEngine) Name() string { return "openclaw" }
 
-// DefaultOpenClawTimeout 单次尝试默认超时（与 openclaw 自身 --timeout 默认 600s 对齐）。
-const DefaultOpenClawTimeout = 10 * time.Minute
+// DefaultOpenClawTimeout 单次尝试默认超时（2026-10-10 由 10 分钟统一上调到 1 小时）。
+// 未显式给 -t 时按它拼 openclaw 自身的 --timeout（见 buildArgsMode）。
+const DefaultOpenClawTimeout = time.Hour
 
 // bin 探测 openclaw CLI 路径（委托 cliBase 统一探测链）。
 func (e *OpenClawEngine) bin() string {
@@ -510,7 +511,7 @@ func (e *OpenClawEngine) buildArgsMode(req Request, sessionID string, msgArgs []
 		}
 		args = append(args, "--timeout", fmt.Sprintf("%d", secs))
 	} else {
-		args = append(args, "--timeout", "600")
+		args = append(args, "--timeout", fmt.Sprintf("%d", int(DefaultOpenClawTimeout/time.Second)))
 	}
 	// 统一参数矩阵:MaxTokens / Temperature / Tools / JSONSchema 静默忽略(JSONSchema 走
 	// 输出后处理,Tools 是 openclaw 内嵌能力,调用方无法逐工具控)

package/internal/agent/openclaw_acp.go

@@ -660,6 +660,13 @@ func (e *OpenClawEngine) streamACPSession(
 	if strings.TrimSpace(st.text.String()) == "" && strings.TrimSpace(st.lastText) == "" {
 		return nil, fmt.Errorf("openclaw acp 返回空正文（stopReason=%s）", st.stopReason)
 	}
+	if st.stopReason == "max_tokens" {
+		// 截断收尾（2026-10-10，跨引擎渲染覆盖 P0-4）：正文有了、但被 max_tokens
+		// 掐断 —— 补一条 notice，让用户知道「不是说完，是被掐断」。与 claude 流式
+		// 路径的 message_delta 分支同语义（见 stream.go）；stopReason 只在收尾
+		// 出现一次，无需去重。
+		st.emit(StreamEvent{Kind: KindNotice, Text: "本轮输出在 max_tokens 上限处被截断"})
+	}
 	return st, nil
 }
 

package/internal/agent/openclaw_test.go

@@ -41,8 +41,8 @@ func TestOpenClawBuildArgsNewSession(t *testing.T) {
 		"--local",
 		"--agent main",
 		"--json",
-		"hi", // FlattenPrompt 后正文是 "【用户】\nhi",至少含 "hi"
-		"--timeout 600",
+		"hi",             // FlattenPrompt 后正文是 "【用户】\nhi",至少含 "hi"
+		"--timeout 3600", // 未给 -t → 用 DefaultOpenClawTimeout（1 小时）
 	} {
 		if !strings.Contains(args, want) {
 			t.Errorf("want %q in args, got %q", want, args)

package/internal/agent/permission.go

@@ -160,11 +160,12 @@ func PermissionTiers() []string {
 //
 //	"flag:--permission-mode"  claude / codebuddy / codebuddy-ai：CLI 有原生 --permission-mode，
 //	                          沙箱与 autoMode 经 --settings 注入（同族 flag 面）
+//	"env:DSH_PERMISSION_MODE" dsh：档位走**子进程环境变量**（dsh 是 profile 启动器，
+//	                          没有逐调用的权限 flag；shipped 的 sdk profile 直接读
+//	                          这个变量决定沙箱模式与审批策略）。映射见 dshPermissionMode。
 //	"none"                    其余引擎暂未接线（trae 的档位在 yaml 配置里、codex 是
 //	                          「沙箱 × 审批」两轴、llm 无工具语义、openclaw 走
-//	                          exec.mode 五档、arkclaw 由网关侧决定；dsh 只有
-//	                          read-only / workspace-write 两个配置层预设，没有
-//	                          「沙箱关闭 / 无审批」那一档，四档无法一一落地；
+//	                          exec.mode 五档、arkclaw 由网关侧决定；
 //	                          codebuddy-gateway 的档位由**网关进程**的 --permission-mode
 //	                          决定，且网关会把远程任务的权限强制切到 bypassPermissions
 //	                          —— per-call 传四档没有落地通道）
@@ -176,6 +177,8 @@ func PermissionSupportOf(engine string) string {
 	switch engine {
 	case "claude", "codebuddy", "codebuddy-ai":
 		return "flag:--permission-mode"
+	case "dsh":
+		return "env:" + DshPermissionModeEnv
 	default:
 		return "none"
 	}
@@ -205,18 +208,102 @@ func claudePermissionMode(t PermissionTier) string {
 	return "default"
 }
 
-// sandboxSettings 构造 settings.sandbox 子对象。第 4 档返回显式关闭。
+// DshPermissionModeEnv 是 dsh 侧选择沙箱档位的环境变量。
+//
+// 为什么不是 CLI flag：dsh 是 **profile 启动器**（`dsh --profile <name>`），它的
+// 权限旋钮不在命令行上。shipped 的 `sdk` profile 里两处配置**直接读这个变量**
+// （2026-10-14 用 `dsh --profile sdk --dump-config` 核对，本机 dsh 0.2.0-rc.2）：
+//
+//   - id: sandbox-policy   （@deepseek-ai/dsh-sandbox-policy）
+//     mode: process.env.DSH_PERMISSION_MODE ?? 'workspace-write'
+//   - id: approval         （@deepseek-ai/dsh-user-approval）
+//     policy: DSH_PERMISSION_MODE === 'danger-full-access' ? 'never' : 'ask'
+//
+// 取值即 dsh 的 `SandboxMode` 封闭词表（见 @deepseek-ai/dsh-sandbox-policy 的
+// README：read-only / workspace-write / danger-full-access）。
+const DshPermissionModeEnv = "DSH_PERMISSION_MODE"
+
+// dshPermissionMode 把四档映射到 dsh 的 SandboxMode；空档位返回空串（= 不注入）。
+//
+// 核实来源（2026-10-14，本机 dsh 0.2.0-rc.2）：
+//
+//   - `dsh --profile sdk --dump-config` 的 permission-presets 预设表：
+//     read-only → (read-only, ask) / workspace-write → (workspace-write, ask) /
+//     **danger-full-access → (danger-full-access, never)**
+//
+//   - @deepseek-ai/dsh-permission-presets README：一个预设 = 沙箱模式 + 审批策略的捆绑
+//
+//     档位            DSH_PERMISSION_MODE    成效（沙箱 / 审批）
+//     manual          read-only              read-only / ask
+//     accept-edits    workspace-write        workspace-write / ask
+//     auto            workspace-write        workspace-write / ask
+//     full            danger-full-access     danger-full-access / never  ← 「沙箱关闭 + 无审批」
+//
+// ⚠️ 两处**不假装等价**的差异，写在这里以免下一个人误读：
+//
+//  1. dsh 的审批策略只有 `ask` / `never` 两种，**没有 LLM 分类器** —— 第 3 档
+//     在 dsh 上退化成「沙箱内放行」，不再是「越界交 Guardian 判定」。
+//  2. `ask` 要求 Host 侧组合一个应答者，而 magic-agent 走的 SDK 通道**拿不到审批请求**：
+//     官方 @deepseek-ai/dsh-sdk-protocol README 的「已知限制」原文是
+//     「server→client 请求是未使用的能力——传输层支持，但服务器从不发送；
+//     Python SDK 的应答接口为未来审批流程预留」，协议里也确实没有审批方法。
+//     加上 @deepseek-ai/dsh-user-approval「应答者缺失…返回 unavailable，使操作以
+//     拒绝方式关闭」，于是第 1/2/3 档下**越界/提权操作会被 fail-closed 拒绝**。
+//     这不是静默降级（拒绝是可见的工具结果），是 dsh 在无应答者时的既定语义；
+//     要放行越界操作就用第 4 档。
+//
+// ⚠️ 空档位必须返回空串、**不能**走 permissionOrDefault：DefaultPermissionTier 是 full，
+// 若在这里兜默认值，`magic-agent -e dsh`（未显式传档）会静默把 dsh 的沙箱整个关掉。
+func dshPermissionMode(t PermissionTier) string {
+	if strings.TrimSpace(string(t)) == "" {
+		return ""
+	}
+	switch permissionOrDefault(t) {
+	case PermissionManual:
+		return "read-only"
+	case PermissionAcceptEdits, PermissionAuto:
+		return "workspace-write"
+	case PermissionFull:
+		return "danger-full-access"
+	}
+	return ""
+}
+
+// dshPermissionEnv 返回要追加给 dsh 子进程的环境变量；空档位 → nil（用 dsh 自己的默认）。
+// 追加在继承环境之后，Go exec 对重复 key 取后者 → 覆盖调用方环境里可能存在的同名值。
+func dshPermissionEnv(t PermissionTier) []string {
+	mode := dshPermissionMode(t)
+	if mode == "" {
+		return nil
+	}
+	return []string{DshPermissionModeEnv + "=" + mode}
+}
+
+// sandboxSettings 构造 settings.sandbox 子对象。
+//
+//	第 1/2/3 档（manual / accept-edits / auto）—— 返回 `{"enabled": true, ...}`，
+//	                        配合 --permission-mode 让模型知道「沙箱里运行」+ 哪些操作免确认
+//	第 4 档（full / bypassPermissions）—— **返回 nil，让外层不写 sandbox 段
+//	                        整段都不下发**：
+//	                        1. bypassPermissions 与 sandbox 互斥（开了也是空跑）；
+//	                        2. 实测 2026-10-01：claude CLI 在 tools=default +
+//	                           bypassPermissions + `--settings {"sandbox":{"enabled":false}}`
+//	                           组合下报「Invalid JSON provided to --settings」、
+//	                           exit 0 零输出。bypassPermissions 本身就意味着不沙箱，
+//	                           显式写 enabled=false 反而触发那个 bug。
+//	                        3. 用户的 ~/.claude/settings.json 若开了 sandbox，
+//	                           第 4 档「--settings 优先级更高」这条契约靠的是把整段
+//	                           覆盖成空 sandbox，不是不写。两段都不写 = 沙箱启用 + 第 4 档，
+//	                           是 bug。
+//	                        见 magic-stock `.workbuddy/memory/2026-10-01.md` 的「Invalid JSON
+//	                        provided to --settings」一节。
 //
 // engine 用于区分两家文档确认过的键集：CodeBuddy 文档未列 `failIfUnavailable`，
 // 未知键的行为没有保证，故只在 claude 上注入。
 func sandboxSettings(tier PermissionTier, opts PermissionOptions, engine string) map[string]any {
 	if permissionOrDefault(tier) == PermissionFull {
-		// 第 4 档：显式关闭沙箱。
-		// 不只是「保持与改造前一致」—— 显式写出来才真正保证档位语义：
-		// 若用户的 ~/.claude/settings.json 里开着 sandbox.enabled=true，
-		// 不写这一项会让第 4 档继承到沙箱，与「沙箱关闭」的档位承诺矛盾。
-		// --settings 属于 flag 层，优先级高于 user settings，故能覆盖它。
-		return map[string]any{"enabled": false}
+		// 第 4 档：sandbox 整段都不写（见上方注释）
+		return nil
 	}
 	sb := map[string]any{
 		"enabled": true,
@@ -299,7 +386,9 @@ func agentSettingsPayload(req Request, engine string) (string, bool) {
 
 	// 沙箱 / autoMode / 权限规则只在真会调用工具时注入。
 	if !toolsIsOff(req) {
-		settings["sandbox"] = sandboxSettings(tier, opts, engine)
+		if sb := sandboxSettings(tier, opts, engine); sb != nil {
+			settings["sandbox"] = sb
+		}
 		if am := autoModeSettings(tier, opts); am != nil {
 			settings["autoMode"] = am
 		}