magic-agent 2.3.0 → 2.3.9

package/internal/session/workspace_lock_test.go

@@ -0,0 +1,90 @@
+package session
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"testing"
+	"time"
+)
+
+// 工作空间串行锁：同一 workspace 的第二轮必须等第一轮 Finish 之后才能 Begin。
+func TestWorkspaceLockSerializesRuns(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	t.Setenv(EnvWorkspaceLock, "1")
+	t.Setenv(EnvWorkspaceLockWait, "5s")
+	ws := t.TempDir()
+
+	h1, err := Begin(BeginOptions{NoPersist: true, Workspace: ws, Engine: "claude"})
+	if err != nil {
+		t.Fatalf("第一轮 Begin 失败：%v", err)
+	}
+
+	got := make(chan *Handle, 1)
+	go func() {
+		h2, err := Begin(BeginOptions{NoPersist: true, Workspace: ws, Engine: "claude"})
+		if err != nil {
+			got <- nil
+			return
+		}
+		got <- h2
+	}()
+
+	select {
+	case h := <-got:
+		if h != nil {
+			h.Finish("", StateDone)
+		}
+		t.Fatal("第一轮还没结束，第二轮不应拿到锁")
+	case <-time.After(400 * time.Millisecond):
+	}
+
+	h1.Finish("", StateDone)
+	select {
+	case h2 := <-got:
+		if h2 == nil {
+			t.Fatal("第一轮结束后，第二轮应拿到锁")
+		}
+		h2.Finish("", StateDone)
+	case <-time.After(4 * time.Second):
+		t.Fatal("第一轮结束后，第二轮仍未拿到锁")
+	}
+}
+
+// 持锁进程已不在（崩溃 / 被 kill）：下一次 Begin 要能回收陈旧锁。
+func TestWorkspaceLockReapsDeadOwner(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir)
+	t.Setenv(EnvWorkspaceLock, "1")
+	t.Setenv(EnvWorkspaceLockWait, "2s")
+	ws := t.TempDir()
+
+	_, name := workspaceLockKey(ws)
+	lockDir := filepath.Join(dir, "locks")
+	if err := os.MkdirAll(lockDir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	// 一个几乎不可能存活、但格式合法的 pid。
+	if err := os.WriteFile(filepath.Join(lockDir, name+".lock"), []byte("999999\n"+strconv.FormatInt(time.Now().UnixNano(), 10)+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	done := make(chan *Handle, 1)
+	go func() {
+		h, err := Begin(BeginOptions{NoPersist: true, Workspace: ws})
+		if err != nil {
+			done <- nil
+			return
+		}
+		done <- h
+	}()
+	select {
+	case h := <-done:
+		if h == nil {
+			t.Fatal("陈旧锁应被回收，第二轮应拿到锁")
+		}
+		h.Finish("", StateDone)
+	case <-time.After(3 * time.Second):
+		t.Fatal("陈旧锁未被回收：第二轮一直等")
+	}
+}

package/internal/suggest/suggest.go

@@ -162,6 +162,13 @@ func Parse(raw string, count int) []string {
 }
 
 // Generate 跑一次旁路生成。失败时返回空建议 + error（调用方如实降级：不画按钮）。
+//
+// 2026-10-23 用户定调：「建议的生成要走引擎的不启用工具 json 返回的方式，提高速度」。
+// 这里的主路径就是如此：当前引擎（in.Engine）+ ToolsOff + JSONSchema + NoThinking，
+// 各引擎都通过 NoThinking 走官方关闭参数；失败/超时再降级到 llm 的 no-think 变体
+// （纯文本、无工具、1-2s），保证界面不会跟着主引擎的 CLI 一起卡到 20s。
+// `ToolsOff` / `JSONSchema` / `NoThinking` 不是可选项 —— 少任何一条都会把建议变成
+// 一次带工具痕迹（或默认高档思考）的完整 agent 轮次。
 func Generate(ctx context.Context, in Request) (Result, error) {
 	reply := strings.TrimSpace(in.Reply)
 	if reply == "" {
@@ -171,8 +178,7 @@ func Generate(ctx context.Context, in Request) (Result, error) {
 	if name == "" {
 		name = DefaultEngine
 	}
-	engine := agent.Lookup(name)
-	if engine == nil {
+	if agent.Lookup(name) == nil {
 		return Result{}, fmt.Errorf("建议生成：未知引擎 %q", name)
 	}
 	timeout := in.Timeout
@@ -182,11 +188,99 @@ func Generate(ctx context.Context, in Request) (Result, error) {
 	cctx, cancel := context.WithTimeout(ctx, timeout)
 	defer cancel()
 	start := time.Now()
-	runner := &agent.Runner{Engine: engine, Timeout: timeout}
-	resp, err := runner.Run(cctx, agent.Request{
-		Model:      strings.TrimSpace(in.Model),
-		Tools:      agent.ToolsOff,
-		Reasoning:  "off", // 建议要快；思考过程只会拖长等待
+
+	/* 建议一律不思考；所有引擎都尽量走官方开关：
+	   llm 传 reasoning_effort=none，claude --thinking disabled，
+	   codex effort=none，codebuddy settings alwaysThinkingEnabled=false，
+	   dsh InitializeParams.reasoningEffort=off。没有可靠开关的引擎（trae/openclaw/arkclaw）
+	   仍会被 NoThinking 标记，失败后再降级 llm；不在这里预先改道。 */
+	/* 主引擎：优先当前引擎（用户要的“引擎 JSON 返回”）。claude / codex 给 10s ——
+	   这是「CLI 启动 + 一次短 JSON」的实测上限；超过 10s 多半是凭据/主会话占用，
+	   继续等只会把界面的 20s 预算吃光。之后才降级到 llm（1-2s），并清掉当前引擎的 model。 */
+	primaryBudget := timeout
+	if name != DefaultEngine && primaryBudget > 10*time.Second {
+		primaryBudget = 10 * time.Second
+	}
+	res, err := tryGenerate(cctx, in, name, primaryBudget, start)
+	if err == nil {
+		return res, nil
+	}
+	if name == DefaultEngine {
+		return Result{}, err
+	}
+
+	/* 降级：给 llm 留一段独立预算（整体仍受 timeout 约束）。主引擎的错误不丢，
+	   只有 fallback 也失败时才报它 —— 至少让调用方知道不是“没有建议”，是真失败。 */
+	remain := timeout - time.Since(start)
+	if remain < 2*time.Second {
+		remain = 2 * time.Second
+	}
+	if remain > 8*time.Second {
+		remain = 8 * time.Second
+	}
+	fallbackIn := in
+	fallbackIn.Model = "" // model 是当前引擎的，不能拿去喂 llm
+	fallback, ferr := tryGenerate(cctx, fallbackIn, DefaultEngine, remain, start)
+	if ferr != nil {
+		return Result{}, err
+	}
+	return fallback, nil
+}
+
+// fastLLMModel 找 models.json 里第一条「不思考」的变体（extraBody.thinking.type=disabled）。
+// 仅用于**没有显式选模型**的建议默认值：M3.1-Flash 明确拒绝 reasoning_effort=none，
+// 默认走首条会直接 400。显式选中的模型只传参数，不换模型。
+func fastLLMModel() string {
+	list, err := agent.LoadLLMConfigModels()
+	if err != nil {
+		return ""
+	}
+	for _, m := range list {
+		if llmModelDisablesThinking(m) {
+			return m.ID
+		}
+	}
+	return ""
+}
+
+// llmModelDisablesThinking 判断 models.json 条目是否声明了不思考变体。
+func llmModelDisablesThinking(m agent.LLMConfigModel) bool {
+	if strings.TrimSpace(m.ID) == "" || m.ExtraBody == nil {
+		return false
+	}
+	th, ok := m.ExtraBody["thinking"].(map[string]any)
+	if !ok {
+		return false
+	}
+	return strings.EqualFold(strings.TrimSpace(fmt.Sprint(th["type"])), "disabled")
+}
+
+// tryGenerate 用指定引擎跑一次 ToolsOff + JSONSchema 的短调用。
+func tryGenerate(ctx context.Context, in Request, name string, budget time.Duration, start time.Time) (Result, error) {
+	engine := agent.Lookup(name)
+	if engine == nil {
+		return Result{}, fmt.Errorf("建议生成：未知引擎 %q", name)
+	}
+	reply := strings.TrimSpace(in.Reply)
+	attemptCtx, cancel := context.WithTimeout(ctx, budget)
+	defer cancel()
+	/* 建议是纯文本短任务，**一律不思考**。Reasoning 只作为没有 NoThinking 通道的
+	   引擎的兜底（minimal 仍比默认高档轻）；能真正关闭的引擎看 NoThinking。 */
+	reasoning := "minimal"
+	model := strings.TrimSpace(in.Model)
+	if name == DefaultEngine && model == "" {
+		// 仅默认值：显式选了模型就只传 reasoning_effort=none，不换模型。
+		model = fastLLMModel()
+	}
+	runner := &agent.Runner{Engine: engine, Timeout: budget}
+	resp, err := runner.Run(attemptCtx, agent.Request{
+		Model: model,
+		Tools: agent.ToolsOff,
+		/* NoThinking：claude → --thinking disabled，codex → effort none，
+		   codebuddy → settings:false，dsh → initialize.reasoningEffort=off，
+		   llm → reasoning_effort=none（不自动换模型）。 */
+		NoThinking: true,
+		Reasoning:  reasoning,
 		MaxTokens:  300,
 		Messages:   []agent.Message{{Role: "user", Content: Prompt(in.User, reply, in.Count)}},
 		JSONSchema: Schema(),

package/internal/suggest/suggest_test.go

@@ -2,6 +2,8 @@ package suggest
 
 import (
 	"context"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 
@@ -130,6 +132,12 @@ func TestGenerateUsesToolsOffAndNoSession(t *testing.T) {
 	if f.got.JSONSchema == nil || len(f.got.JSONSchema.Required) != 1 {
 		t.Fatalf("缺少结构化输出契约")
 	}
+	if f.got.Reasoning != "minimal" {
+		t.Fatalf("建议调用必须用 minimal 兜底档：%q", f.got.Reasoning)
+	}
+	if !f.got.NoThinking {
+		t.Fatalf("建议调用必须显式 NoThinking（claude/codebuddy/codex/dsh 各自关闭思考）")
+	}
 }
 
 func TestDropCreativeRestarts(t *testing.T) {
@@ -216,3 +224,39 @@ func TestGenerateEmptyReplyShortCircuits(t *testing.T) {
 		t.Fatalf("空正文不该调引擎：%#v %#v", res.Suggestions, f.got.Messages)
 	}
 }
+
+func TestEverySuggestionEngineUsesNoThinking(t *testing.T) {
+	// 官方文档确认 codebuddy 的 alwaysThinkingEnabled / dsh 的 reasoningEffort=off
+	// 都能关思考；建议链路不再把它们预先改道到 llm，而是让引擎自己按 NoThinking 执行。
+	for _, name := range []string{"llm", "claude", "codex", "codebuddy", "dsh"} {
+		f := &fakeEngine{name: name, text: `{"suggestions":["继续"]}`}
+		agent.Register(f)
+		res, err := Generate(context.Background(), Request{Reply: "要我继续吗？", Engine: name})
+		if err != nil {
+			t.Fatalf("%s: Generate: %v", name, err)
+		}
+		if !f.got.NoThinking || len(f.got.Messages) == 0 {
+			t.Fatalf("%s 必须真的执行且带 NoThinking：%#v", name, f.got)
+		}
+		if res.Engine != name {
+			t.Fatalf("%s: 不应预先改道，got engine %q", name, res.Engine)
+		}
+	}
+}
+
+func TestFastLLMModelPicksNoThinkVariant(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "models.json")
+	raw := `[
+		{"id":"slow","model":"MiniMax-M3.1-Flash","url":"http://x/v1","apiKey":"k"},
+		{"id":"fast-nothink","model":"MiniMax-M3","url":"http://x/v1","apiKey":"k",
+		 "extraBody":{"thinking":{"type":"disabled"}}}
+	]`
+	if err := os.WriteFile(p, []byte(raw), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("MAGIC_AGENT_MODELS", p)
+	if got := fastLLMModel(); got != "fast-nothink" {
+		t.Fatalf("fastLLMModel = %q, want fast-nothink", got)
+	}
+}

package/npm/apk/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.3.0",
-  "versionCode": 20300,
-  "builtAt": "2026-10-23T00:29:48.082Z"
+  "version": "2.3.9",
+  "versionCode": 20309,
+  "builtAt": "2026-10-23T11:12:09.067Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magic-agent",
-  "version": "2.3.0",
+  "version": "2.3.9",
   "description": "专业的 agent CLI 代理工具 - 统一 claude / codebuddy / trae / llm / codex / openclaw 引擎",
   "license": "MIT",
   "bin": {
@@ -19,7 +19,8 @@
     "check:conv-host": "node tests/check-conv-shared-host.mjs",
     "check:conv-mobile": "node tests/check-conv-mobile-host.mjs",
     "check:conv-comp": "node tests/check-conv-component.mjs",
-    "check:conv-queue": "node tests/check-conv-queue.mjs"
+    "check:conv-queue": "node tests/check-conv-queue.mjs",
+    "check:follow": "node tests/check-follow-retry.mjs"
   },
   "files": [
     "npm/bin/",