magic-agent 2.3.0 → 2.3.2

package/client-ui-mobile/reqs.js

@@ -5,7 +5,7 @@
  * 现在 index 只留两个空容器（#reqs / #reqDetail）+ 一次 mount，本文件自包含：
  *   · 一级：空间目录（空间 → 模块，功能点不画）；
  *   · 二级：点模块进去，**只看这个模块**的需求列表；
- *   · 「整理」：POST /desk/requirements/consolidate（全量 / 单空间 / 二级页单空间）。
+ *   · 「整理」：POST /desk/requirements/consolidate（全量 / 单空间 / 二级页单模块）。
  *
  * 与宿主（index.html）的边界：只通过 mount(host) 注入的能力交互 ——
  *   getBase / getToken（切环境后是活的，必须 getter，不能传快照）、
@@ -26,6 +26,7 @@
   var REQ_DATA = null;         // 最近一次清单（重画用，避免每次点都重新拉）
   var REQ_BUSY = false;        // 「整理」进行中（防重复点击）
   var REQ_BUSY_LABEL = '全部整理'; // 顶栏按钮的进行中文案（重渲染后要能恢复）
+  var REQ_BUSY_KEY = '';       // 本次整理的组头（空间 key；空 = 全部整理，所有组头都置忙）
   var REQ_OPEN = {};           // 工作区展开状态（key = 工作区 id），与会话列表的 WS_OPEN 同构
   var REQ_ALIVE = null;        // 仍有会话的空间路径集合；null = 拿不到会话清单（不筛）
   var REQ_DETAIL = null;       // 二级视图：{key: 工作区 key, mod: 模块名, ws: 工作区对象}
@@ -41,7 +42,7 @@
     '<div class="history__top">' +
       '<button class="topbar__icon" id="btnReqDetailBack" aria-label="返回"><svg width="20" height="20"><use href="#i-back"/></svg></button>' +
       '<span class="history__title" id="reqDetailTitle">需求</span>' +
-      '<button class="history__disconnect" id="btnReqDetailSync" type="button">整理</button>' +
+      '<button class="history__disconnect" id="btnReqDetailSync" type="button" title="只整理这个模块">整理</button>' +
     '</div>' +
     '<div class="history__list" id="reqDetailList"></div>';
 
@@ -330,17 +331,19 @@
      服务端按 state 判断走哪条路：
        · 没初始化过 → 先按空间目录反推需求基线（首次可能跑几分钟，按钮要能等）；
        · 已初始化   → 只消费上次整理之后的新会话。
-     入口有两个：
+     入口有三个：
        · 每个空间组头的「整理」——只整理这个空间（用户点哪个就是哪个，不猜）；
-       · 右上角「全部整理」——按空间逐个串行跑一遍，汇总结果（一键触发全部）。
-     两个入口都带「我的 → 默认引擎/模型」，服务端不再自动替换引擎。 */
-  function reqPostConsolidate(ws) {
+       · 二级页右上角「整理」——只整理当前模块（body 带 module，不推进空间游标）；
+       · 一级页右上角「全部整理」——按空间逐个串行跑一遍，汇总结果（一键触发全部）。
+     三个入口都带「我的 → 默认引擎/模型」，服务端不再自动替换引擎。 */
+  function reqPostConsolidate(ws, module) {
     var hdr = { 'Content-Type': 'application/json' };
     if (H.getToken()) hdr['X-Magic-Token'] = H.getToken();
     return fetch(H.getBase() + '/desk/requirements/consolidate', {
       method: 'POST', headers: hdr,
       body: JSON.stringify({
         workspace: ws || '',
+        module: module || '',
         engine: H.getRunPref().engine || '',
         model: (H.getRunPref().engine && H.getRunPref().model) || ''
       })
@@ -354,10 +357,13 @@
       });
   }
 
-  /* 统一置忙：顶部主按钮 + 所有空间组头的「整理」一起禁用。
-     label 只改顶部；组头统一显示「整理中…」/「整理」，不各自变文案。
-     二级页那枚「整理」也跟着禁用 —— 归纳期间它和组头一样不能重复点。 */
-  function reqSetBusy(on, label) {
+  /* 统一置忙：顶部主按钮 + 所有空间组头的「整理」一起禁用（防重复点）。
+     只有**真正在整理的那个入口**显示「整理中…」：
+       · 点某个空间 / 某个模块的「整理」→ 只有这一组的文案变；
+       · 点「全部整理」→ 所有组头一起变（那才是全部在跑）。
+     其余按钮只置灰、保持「整理」—— 否则点一个模块会让人以为所有空间都在整理。 */
+  function reqSetBusy(on, label, busyKey) {
+    if (busyKey === undefined) busyKey = REQ_BUSY_KEY;
     if (on) { if (label !== undefined) REQ_BUSY_LABEL = label; }
     else REQ_BUSY_LABEL = '全部整理';
     var btn = els.sync;
@@ -372,38 +378,43 @@
     }
     Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
       b.disabled = !!on;
-      b.textContent = on ? '整理中…' : '整理';
+      if (!on) { b.textContent = '整理'; return; }
+      b.textContent = (!busyKey || b.getAttribute('data-ws') === busyKey) ? '整理中…' : '整理';
     });
   }
 
-  function consolidateRequirements(target) {
+  /* 整理一个空间（module 为空）或一个模块（module 非空）。
+       · 空间级：消费该空间游标之后的新会话，可能同时更新多个模块；
+       · 模块级：只更新这个模块，**不推进空间游标** —— 别的模块的需求仍留在
+         pending，等空间级「整理」/下一轮自动归纳处理，不会被这一下吞掉。
+     服务端按 state 判断走哪条路：没初始化过 → 先按空间目录反推基线；
+     模块级不会触发首次初始化（目录基线天然是空间级的）。 */
+  function consolidateRequirements(target, module) {
     if (REQ_BUSY || !target) return;
     var ws = target.dir || target.id || '';
     if (!ws) return;
-    var firstTime = target.initialized === false;
-    REQ_BUSY = true;
-    reqSetBusy(true, firstTime ? '初始化中…' : '整理中…');
+    module = String(module || '').trim();
+    var firstTime = target.initialized === false && !module;
     var targetKey = target.id || target.dir || '';
-    var groupBtn = null;
-    Array.prototype.forEach.call(document.querySelectorAll('.wsrow__sync'), function (b) {
-      if (!groupBtn && targetKey && b.getAttribute('data-ws') === targetKey) groupBtn = b;
-    });
-    /* 点的是哪个空间，就只让哪个组头显示「初始化中…」；其它组头保持「整理中…」。 */
-    if (groupBtn) groupBtn.textContent = firstTime ? '初始化中…' : '整理中…';
-    reqPostConsolidate(ws)
+    REQ_BUSY = true;
+    REQ_BUSY_KEY = targetKey;
+    reqSetBusy(true, firstTime ? '初始化中…' : '整理中…', targetKey);
+    reqPostConsolidate(ws, module)
       .then(function (d) {
+        var prefix = module ? '模块「' + module + '」' : '';
         if (d.bootstrap) {
           if (d.created || d.updated) toast('已按空间目录生成需求：新建 ' + (d.created || 0) + ' · 更新 ' + (d.updated || 0));
           else toast('已按空间目录初始化：暂未识别到功能点');
         }
-        else if (d.noop) toast('没有新的对话需要整理');
-        else if (d.updated || d.created) toast('整理完成：更新 ' + (d.updated || 0) + ' · 新建 ' + (d.created || 0));
-        else toast('整理完成');
+        else if (d.noop) toast(prefix ? prefix + '没有新的对话需要整理' : '没有新的对话需要整理');
+        else if (d.updated || d.created) toast((prefix || '整理完成') + '：更新 ' + (d.updated || 0) + ' · 新建 ' + (d.created || 0));
+        else toast(prefix ? prefix + '整理完成' : '整理完成');
         loadRequirements(true);   // 后台刷新（不闪「读取中」）
       })
       .catch(function (e) { toast('整理失败：' + ((e && e.message) || e)); })
       .then(function () {
         REQ_BUSY = false;
+        REQ_BUSY_KEY = '';
         reqSetBusy(false, '全部整理');
       });
   }
@@ -438,10 +449,12 @@
       return;
     }
     REQ_BUSY = true;
+    REQ_BUSY_KEY = '';        // 空 = 全部整理：所有组头一起显示「整理中…」
     reqSetBusy(true, '整理中 0/' + list.length);
     var i = 0, ok = 0, fail = 0, created = 0, updated = 0, firstErr = '';
     function done() {
       REQ_BUSY = false;
+      REQ_BUSY_KEY = '';
       reqSetBusy(false, '全部整理');
       loadRequirements(true);
       if (fail) {
@@ -456,7 +469,7 @@
       REQ_BUSY_LABEL = '整理中 ' + i + '/' + list.length;
       var btn = els.sync;
       if (btn) btn.textContent = REQ_BUSY_LABEL;
-      reqPostConsolidate(w.dir || w.id || '')
+      reqPostConsolidate(w.dir || w.id || '', '')
         .then(function (d) {
           ok++;
           created += Number(d.created) || 0;
@@ -487,13 +500,13 @@
     els.sync = root.querySelector('#btnReqSync');
     els.detailBack = detail.querySelector('#btnReqDetailBack');
     els.detailSync = detail.querySelector('#btnReqDetailSync');
-    /* 两个动作：全部整理 / 返回一级；二级页的「整理」只作用于当前空间
-       （不是全部空间 —— 二级页的作用域就是这个空间，标成「全部整理」会让人以为还是全局动作）。 */
+    /* 两个动作：全部整理 / 返回一级；二级页的「整理」只作用于**当前模块**
+       （不是整空间、更不是全部空间 —— 用户点哪个模块，就只整理哪个模块）。 */
     if (els.sync) els.sync.onclick = function () { consolidateAllRequirements(); };
     if (els.detailBack) els.detailBack.onclick = function () { closeReqDetail(); };
     if (els.detailSync) els.detailSync.onclick = function () {
       if (!REQ_DETAIL || !REQ_DETAIL.ws) return;
-      consolidateRequirements(REQ_DETAIL.ws);
+      consolidateRequirements(REQ_DETAIL.ws, REQ_DETAIL.mod);
     };
   }
 

package/internal/agent/capability.go

@@ -149,6 +149,13 @@ const (
 	FeatureSessionEvents = "feature.session.events"
 	// FeatureSessionControl `--stream --control`：stdin NDJSON 控制通道（打断 / 收工 / 回审批）。
 	FeatureSessionControl = "feature.session.control"
+	// FeatureSessionHosted `--hosted`：这一轮的用户提问由客户端「会话托管」自动发出。
+	//
+	// 为什么归 core：托管本身是**纯客户端策略**（执行仍走普通 ask），但「这句是托管的」
+	// 要写进会话历史，回放时才能把气泡画成「托管发送」而不是「我」—— 历史在 core 手里，
+	// 所以标识只能由 core 落。客户端据此决定要不要把 hosted 透传给 core；老 core 没有
+	// 这个位时插件忽略该字段（实时气泡仍由客户端自己标），不阻断发送。
+	FeatureSessionHosted = "feature.session.hosted"
 	// FeatureSessionTeam `--team`：团队模式（主引擎拆任务、子引擎分头执行、主引擎汇总）。
 	//
 	// 为什么归 core 而不是某个引擎：它是**会话层的一种运行模式**，任何能当主引擎的
@@ -164,5 +171,5 @@ const (
 
 // CoreFeatures 返回 core 自身提供的通道能力（字典序，稳定）。
 func CoreFeatures() []string {
-	return []string{FeatureRequirements, FeatureSessionControl, FeatureSessionEvents, FeatureSessionTeam}
+	return []string{FeatureRequirements, FeatureSessionControl, FeatureSessionEvents, FeatureSessionHosted, FeatureSessionTeam}
 }

package/internal/agent/claude.go

@@ -238,9 +238,11 @@ func (e *ClaudeEngine) buildArgsBase(req Request) []string {
 	if m := stripModelPrefix(req.Model); m != "" {
 		args = append(args, "--model", m)
 	}
-	// 推理档位：claude 的 --effort 只认 low/medium/high/xhigh/max（无 minimal），
-	// 传 minimal 时降级为 low，避免 clap 直接拒绝整轮调用。
-	if lv := ReasoningLevel(req.Reasoning); lv != "" {
+	// 推理 / 思考：建议这类短任务显式关闭（--thinking disabled）；
+	// 其余调用仍按 --effort 档位。两者互斥，关闭时不传 effort，避免又落回默认高档。
+	if req.NoThinking {
+		args = append(args, "--thinking", "disabled")
+	} else if lv := ReasoningLevel(req.Reasoning); lv != "" {
 		if lv == "minimal" {
 			lv = "low"
 		}

package/internal/agent/codebuddy.go

@@ -375,8 +375,12 @@ func (c codebuddyCore) buildArgsBase(req Request) []string {
 		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)
+	// NoThinking 走官方 settings alwaysThinkingEnabled=false（见 agentSettingsPayload），
+	// 不传 --effort off（该值不在 --effort 合法枚举里）。
+	if !req.NoThinking {
+		if lv := ReasoningLevel(req.Reasoning); lv != "" {
+			args = append(args, "--effort", lv)
+		}
 	}
 	// 统一参数矩阵：`--settings` 只接受一份载荷，故 MaxTokens 的 env 注入与
 	// 四档模型的 sandbox / autoMode / permissions 合并进同一个 JSON。

package/internal/agent/codex.go

@@ -540,8 +540,13 @@ func (e *CodexEngine) buildArgs(req Request, prompt, outFile, schemaFile string)
 		}
 	}
 	// 推理档位：`-c` 在 `exec` 与 `exec resume` 下都可用（同 model 覆写），
-	// 故不按子命令分流。codex 的取值：minimal/low/medium/high/xhigh/max。
-	if lv := ReasoningLevel(req.Reasoning); lv != "" {
+	// 故不按子命令分流。codex 的取值：none/minimal/low/medium/high/xhigh/max。
+	// 建议这类短任务用 none 明确关闭思考（不支持 none 的模型会在服务端报错，
+	// 由建议层降级到 llm，不会拖住用户会话）。
+	if req.NoThinking {
+		args = append(args, "-c", "model_reasoning_effort="+tomlBasicString("none"),
+			"-c", "model_reasoning_summary="+tomlBasicString("none"))
+	} else if lv := ReasoningLevel(req.Reasoning); lv != "" {
 		args = append(args, "-c", "model_reasoning_effort="+tomlBasicString(lv))
 	}
 	// SystemPrompt → -c developer_instructions=<TOML 字符串>

package/internal/agent/dsh_sdk.go

@@ -167,6 +167,11 @@ type dshSDKInitParams struct {
 	Provider  string `json:"provider"`
 	Model     string `json:"model"`
 	MaxTokens int    `json:"maxTokens,omitempty"`
+	// ReasoningEffort 为空 = 沿用模型默认；NoThinking 时传官方值 "off"。
+	// 官方依据：dsh-sdk-protocol InitializeParams.reasoningEffort；
+	// dsh-llm-deepseek README："off" 序列化为 thinking.type=disabled。
+	// pi-ai 路由需在 profile 声明 reasoningEfforts.off（本机 sdk patch 已加）。
+	ReasoningEffort string `json:"reasoningEffort,omitempty"`
 }
 
 // dshSDKTextBlock = TextBlock（ContentBlock 的 text 成员）。
@@ -410,6 +415,9 @@ func dshSDKTurn(ctx context.Context, bin, workspace string, req Request, prompt
 
 	// ① initialize：握手失败 = SDK 通道不可用（旧版 dsh 没有该 profile 时会走到这里）。
 	initParams := dshSDKInitParams{Cwd: workspace, Provider: provider, Model: model, MaxTokens: req.MaxTokens}
+	if req.NoThinking {
+		initParams.ReasoningEffort = "off"
+	}
 	initID, err := send("initialize", initParams)
 	if err != nil {
 		return dshSDKTurnResult{}, fmt.Errorf("%w: 写 initialize: %v", errDshSDKUnavailable, err)

package/internal/agent/dsh_sdk_test.go

@@ -261,6 +261,23 @@ func TestDshSDKIgnoresOtherSessions(t *testing.T) {
 	}
 }
 
+// NoThinking：官方 InitializeParams.reasoningEffort=off，不能只靠隐藏事件。
+func TestDshSDKNoThinkingSendsOff(t *testing.T) {
+	dshSDKHome(t, "modelverse", "deepseek-v4.1-flash")
+	dir := t.TempDir()
+	bin, _, stdinLog := dshSDKStub(t, dir, dshSDKStubOpts{})
+
+	if _, err := (&DshEngine{BinPath: bin}).Complete(context.Background(), Request{
+		Messages:   []Message{{Role: "user", Content: "hi"}},
+		NoThinking: true,
+	}); err != nil {
+		t.Fatalf("Complete: %v", err)
+	}
+	if got := readFileString(t, stdinLog); !strings.Contains(got, `"reasoningEffort":"off"`) {
+		t.Errorf("initialize 应带 reasoningEffort=off: %s", got)
+	}
+}
+
 // initialize 被服务端明确拒绝（模型没配）→ **真失败**，不静默回退 headless。
 func TestDshSDKInitializeRejectedIsFatal(t *testing.T) {
 	dshSDKHome(t, "modelverse", "no-such-model")

package/internal/agent/engine.go

@@ -154,6 +154,16 @@ type Request struct {
 	//	trae/llm/openclaw/dsh/arkclaw 无对应参数。
 	Reasoning string
 
+	// NoThinking 请求引擎关闭模型思考：
+	//	claude     --thinking disabled（官方）
+	//	codex      -c model_reasoning_effort="none" + model_reasoning_summary="none"
+	//	codebuddy  settings alwaysThinkingEnabled=false（官方 settings / SDK thinking:disabled）
+	//	dsh        InitializeParams.reasoningEffort="off"（官方 SDK；dsh-llm-deepseek 会发 thinking.type=disabled）
+	//	llm        选同线 thinking.disabled 变体；没有变体时传 reasoning_effort="none"
+	//	           （CLI 委托路径用 llm 的官方 -o reasoning_effort none）
+	// 其余引擎没有已知开关；调用方（建议生成）仍会标记，失败后再降级 llm。
+	NoThinking bool
+
 	// JSONSchema 是可选的结构化输出约束。
 	//
 	// 各引擎行为：
@@ -274,6 +284,16 @@ type Response struct {
 	Attempts int
 }
 
+// NoThinkingSupportOf 引擎是否有已知的关闭思考手段。
+// 只列官方文档/参数确认过的；未知引擎返回 false，调用方应提示而不是假装关闭。
+func NoThinkingSupportOf(name string) bool {
+	switch name {
+	case "claude", "codex", "codebuddy", "codebuddy-ai", "dsh", "llm":
+		return true
+	}
+	return false
+}
+
 // Engine 是一个 agent CLI 后端的统一抽象。
 type Engine interface {
 	// Name 引擎标识（"claude" / "codebuddy" / "trae"）。

package/internal/agent/engine_test.go

@@ -190,6 +190,42 @@ func TestReasoningEffortArgs(t *testing.T) {
 		t.Errorf("codex model_reasoning_effort 未透传: %v", codexArgs)
 	}
 
+	/* NoThinking（建议生成）：每个有原生开关的引擎都要真的关闭，不能只是 minimal。 */
+	claudeNo := (&ClaudeEngine{}).buildArgsBase(Request{NoThinking: true, Reasoning: "max"})
+	if !hasPair(claudeNo, "--thinking", "disabled") || hasPair(claudeNo, "--effort", "max") {
+		t.Errorf("claude NoThinking 应 --thinking disabled 且不传 effort: %v", claudeNo)
+	}
+	// codebuddy：NoThinking 走官方 settings alwaysThinkingEnabled=false，
+	// 不能再传 --effort xhigh（那会把思考档位又打开）。
+	cbNo := (&CodeBuddyEngine{}).buildArgsBase(Request{NoThinking: true, Reasoning: "xhigh"})
+	if hasPair(cbNo, "--effort", "off") || hasPair(cbNo, "--effort", "xhigh") {
+		t.Errorf("codebuddy NoThinking 不应传 --effort: %v", cbNo)
+	}
+	codexNo := (&CodexEngine{}).buildArgs(Request{NoThinking: true, Reasoning: "max"}, "hi", "", "")
+	if !hasPair(codexNo, "-c", `model_reasoning_effort="none"`) ||
+		!hasPair(codexNo, "-c", `model_reasoning_summary="none"`) ||
+		hasPair(codexNo, "-c", `model_reasoning_effort="max"`) {
+		t.Errorf("codex NoThinking 应 none 且不传 max: %v", codexNo)
+	}
+	// dsh 的 launcher/headless 没有 reasoning 开关：NoThinking 对它保持现状，
+	// 不能塞 --effort（实测启动器报 "--profile <name> is required"）。
+	dshNo := dshHeadlessArgs("headless", "", "hi", false)
+	if len(dshNo) < 3 || dshNo[0] != "--profile" || dshNo[1] != "headless" {
+		t.Errorf("dsh 参数不应被 NoThinking 改坏: %v", dshNo)
+	}
+
+	// 官方关闭思考能力表：只列有依据的；trae/openclaw/arkclaw 不假装支持。
+	for _, e := range []string{"claude", "codex", "codebuddy", "dsh", "llm"} {
+		if !NoThinkingSupportOf(e) {
+			t.Errorf("NoThinkingSupportOf(%s) 应为 true", e)
+		}
+	}
+	for _, e := range []string{"trae", "openclaw", "arkclaw"} {
+		if NoThinkingSupportOf(e) {
+			t.Errorf("NoThinkingSupportOf(%s) 应为 false", e)
+		}
+	}
+
 	// off/none/disabled 一律归一为「不传」。
 	for _, v := range []string{"off", "none", "disabled", " OFF "} {
 		if lv := ReasoningLevel(v); lv != "" {
@@ -893,6 +929,22 @@ func TestCodeBuddyMaxTokensSettings(t *testing.T) {
 	}
 }
 
+// TestCodeBuddyNoThinkingSettings 官方 settings 键：NoThinking 时 alwaysThinkingEnabled=false。
+func TestCodeBuddyNoThinkingSettings(t *testing.T) {
+	dir := t.TempDir()
+	w, log := argsCaptureCLI(t, dir, "codebuddy", `echo '{"type":"result","result":"ok"}'`)
+	if _, err := w.codebuddy().Complete(context.Background(), Request{
+		Messages:   []Message{{Role: "user", Content: "hi"}},
+		NoThinking: true,
+	}); err != nil {
+		t.Fatalf("Complete: %v", err)
+	}
+	data, _ := os.ReadFile(log)
+	if !strings.Contains(string(data), `"alwaysThinkingEnabled":false`) {
+		t.Errorf("codebuddy 应写官方 settings alwaysThinkingEnabled=false: %q", data)
+	}
+}
+
 // TestNoSettingsWhenMaxTokensUnset MaxTokens 未设置时不注入 --settings。
 func TestNoSettingsWhenMaxTokensUnset(t *testing.T) {
 	cases := []struct {

package/internal/agent/llmengine.go

@@ -145,6 +145,12 @@ func (e *LLMEngine) buildArgs(req Request, prompt string) []string {
 	if req.Temperature != nil {
 		args = append(args, "-o", "temperature", formatTemperature(*req.Temperature))
 	}
+	if req.NoThinking {
+		// simonw/llm 的官方 model option（llm.datasette.io/en/stable/usage.html：
+		// -o/--option key value，OpenAI 系模型暴露 reasoning_effort）。支持该 option
+		// 的插件会把它发到端点；不支持时直接报错 —— 显式 --disable-thinking 的预期结果。
+		args = append(args, "-o", "reasoning_effort", "none")
+	}
 	return append(args, appendAttachmentSection(prompt, nonImage))
 }
 
@@ -207,6 +213,11 @@ func (e *LLMEngine) ListModels(ctx context.Context) ([]string, error) {
 // --json 输出同 `llm logs --json` 的结构（数组，每项含 response /
 // input_tokens / output_tokens），解析失败时退回纯文本路径，不引入新的失败点。
 func (e *LLMEngine) Complete(ctx context.Context, req Request) (Response, error) {
+	// --disable-thinking：优先换成同一条线上的 no-think 变体（MiniMax-M3.1-Flash
+	// 这类模型对 thinking.disabled 直接 400，不能靠请求体硬塞）。
+	if req.NoThinking {
+		req.Model = NoThinkLLMModel(req.Model)
+	}
 	// 配置文件模型（models.json）：命中 id → 直连端点（见 llmhttp.go）。
 	// 为什么必须按 id：id 唯一，而真实模型名会重复（MiniMax-M3 与 minimax-nothink
 	// 真实名相同，只差 extraBody）—— 用名字做参数就无法区分。
@@ -317,6 +328,9 @@ func parseLLMJSONEntry(raw string) (llmJSONEntry, bool) {
 // Stream 实现 Streamer：llm prompt 默认流式，逐行读纯文本 stdout，
 // thinkSplitter 把标签块路由到 thinking 通道。
 func (e *LLMEngine) Stream(ctx context.Context, req Request, onEvent func(StreamEvent)) (StreamResult, error) {
+	if req.NoThinking {
+		req.Model = NoThinkLLMModel(req.Model)
+	}
 	// 配置文件模型：命中 id → 直连 SSE（见 llmhttp.go / completeConfigured 上方注释）
 	if m, ok := ResolveLLMConfigModel(req.Model); ok {
 		return e.streamConfigured(ctx, m, req, onEvent)

package/internal/agent/llmengine_test.go

@@ -104,6 +104,13 @@ func TestLLMBuildArgsModelOptions(t *testing.T) {
 		t.Errorf("buildArgs = %q, want %q (温度 0 必须透传)", got, want)
 	}
 
+	// NoThinking：llm 官方 model option；只在 CLI 委托路径出现
+	got = e.buildArgs(Request{NoThinking: true}, "hi")
+	want = []string{"prompt", "-o", "reasoning_effort", "none", "hi"}
+	if strings.Join(got, "\x00") != strings.Join(want, "\x00") {
+		t.Errorf("buildArgs = %q, want %q", got, want)
+	}
+
 	// 都不给
 	got = e.buildArgs(Request{Model: "minimax-m3"}, "hi")
 	for _, a := range got {
@@ -549,3 +556,20 @@ func TestLLMDetectMissingCli(t *testing.T) {
 		t.Errorf("note = %q, want the missing path", note)
 	}
 }
+
+func TestNoThinkLLMModelPicksAnyVariant(t *testing.T) {
+	dir := t.TempDir()
+	p := filepath.Join(dir, "models.json")
+	raw := `[
+		{"id":"MiniMax-M3.1-Flash","model":"MiniMax-M3.1-Flash","url":"http://x/v1","apiKey":"k"},
+		{"id":"minimax-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 := NoThinkLLMModel("MiniMax-M3.1-Flash"); got != "minimax-nothink" {
+		t.Fatalf("NoThinkLLMModel = %q, want minimax-nothink", got)
+	}
+}

package/internal/agent/llmhttp.go

@@ -92,6 +92,12 @@ func buildConfiguredBody(m LLMConfigModel, req Request, stream bool) (map[string
 	} else if m.Temperature != nil {
 		body["temperature"] = *m.Temperature
 	}
+	if req.NoThinking && !LLMModelDisablesThinking(m) {
+		// 没有同线 no-think 变体时，用 llm/OpenAI 兼容端点认的官方参数。
+		// 若端点不支持该参数会返回 400 —— 这是显式 --disable-thinking 的预期失败，
+		// 不静默退回「假装关闭」。
+		body["reasoning_effort"] = "none"
+	}
 	return body, nil
 }
 

package/internal/agent/llmhttp_test.go

@@ -274,6 +274,33 @@ func TestUnknownModelFallsBackToCLI(t *testing.T) {
 	}
 }
 
+func TestBuildConfiguredBodyNoThinking(t *testing.T) {
+	m := LLMConfigModel{ID: "x", Model: "x", URL: "http://x/v1"}
+	body, err := buildConfiguredBody(m, Request{
+		Messages:   []Message{{Role: "user", Content: "hi"}},
+		NoThinking: true,
+	}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if body["reasoning_effort"] != "none" {
+		t.Errorf("没有 no-think 变体时应传 reasoning_effort=none: %#v", body["reasoning_effort"])
+	}
+
+	noThink := LLMConfigModel{ID: "x-nothink", Model: "x", URL: "http://x/v1",
+		ExtraBody: map[string]any{"thinking": map[string]any{"type": "disabled"}}}
+	body, err = buildConfiguredBody(noThink, Request{
+		Messages:   []Message{{Role: "user", Content: "hi"}},
+		NoThinking: true,
+	}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := body["reasoning_effort"]; ok {
+		t.Errorf("已有 thinking.disabled 时不应再塞 reasoning_effort: %#v", body)
+	}
+}
+
 func TestExpandEnvKeep(t *testing.T) {
 	t.Setenv("LLM_TEST_KEY", "secret")
 	cases := map[string]string{

package/internal/agent/llmmodels.go

@@ -76,6 +76,54 @@ func (m LLMConfigModel) Endpoint() string {
 	return strings.TrimRight(u, "/") + "/chat/completions"
 }
 
+// LLMModelDisablesThinking 判断 models.json 条目是否声明了不思考变体
+// （extraBody.thinking.type == "disabled"）。
+func LLMModelDisablesThinking(m 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")
+}
+
+// NoThinkLLMModel 给 --disable-thinking 选 no-think 变体：
+// 用户已选 no-think → 原样；否则先找 WireModel 相同、声明 thinking.disabled 的条目，
+// 再退到任意 no-think 条目（M3.1-Flash 只能换模型才能关思考）。都没有则保留原模型
+// （由调用方决定是否再传 reasoning_effort=none）。
+func NoThinkLLMModel(selected string) string {
+	m, ok := ResolveLLMConfigModel(selected)
+	if !ok {
+		return strings.TrimSpace(selected)
+	}
+	if LLMModelDisablesThinking(m) {
+		return m.ID
+	}
+	list, err := LoadLLMConfigModels()
+	if err != nil {
+		return m.ID
+	}
+	// 先找同一条线上的变体（不换真实模型），再退到任意 no-think 变体 ——
+	// 显式 --disable-thinking 的目标是「不思考」，MiniMax-M3.1-Flash 这类模型
+	// 对 thinking.disabled / reasoning_effort=none 直接 400，只能换到 no-think 条目。
+	for _, alt := range list {
+		if alt.ID == m.ID || alt.WireModel() != m.WireModel() {
+			continue
+		}
+		if LLMModelDisablesThinking(alt) {
+			return alt.ID
+		}
+	}
+	for _, alt := range list {
+		if alt.ID != m.ID && LLMModelDisablesThinking(alt) {
+			return alt.ID
+		}
+	}
+	return m.ID
+}
+
 // LLMModelsPath 返回 models.json 的路径（$MAGIC_AGENT_MODELS 优先）。
 func LLMModelsPath() string {
 	if p := strings.TrimSpace(os.Getenv("MAGIC_AGENT_MODELS")); p != "" {

package/internal/agent/permission.go

@@ -383,6 +383,11 @@ func agentSettingsPayload(req Request, engine string) (string, bool) {
 	if env := maxTokensEnv(req.MaxTokens); env != nil {
 		settings["env"] = env
 	}
+	// CodeBuddy 官方 settings 键：始终开启思考。NoThinking 时显式关掉；
+	// 这是 codebuddy CLI 能对模型请求施加的官方开关（SDK 另有 thinking.type=disabled）。
+	if req.NoThinking {
+		settings["alwaysThinkingEnabled"] = false
+	}
 
 	// 沙箱 / autoMode / 权限规则只在真会调用工具时注入。
 	if !toolsIsOff(req) {