magic-agent 2.4.2 → 2.6.0

package/internal/agent/fallback_test.go

@@ -0,0 +1,340 @@
+package agent
+
+// fallback_test.go - 主备降级（2026-10-24；2026-10-26 按真机报障补口径）。
+//
+// 钉子：同引擎换模型也降级 / 换引擎不把主引擎的模型带过去 / 只有正文算产出 /
+// 降级要发 fallback 帧且不带主引擎残留的终帧 / 降级清会话锚点且只降一级 /
+// 没降级要给得出原因（原因进 FallbackInfo）。
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+)
+
+type fallbackFakeEngine struct {
+	name   string
+	text   string
+	events []string
+	err    error
+	// 记录最后一次收到的请求（验降级时清掉了会话锚点 / 模型怎么传的）。
+	lastReq Request
+}
+
+func (f *fallbackFakeEngine) Name() string           { return f.name }
+func (f *fallbackFakeEngine) Detect() (bool, string) { return true, "fake://" + f.name }
+func (f *fallbackFakeEngine) Complete(_ context.Context, req Request) (Response, error) {
+	f.lastReq = req
+	return Response{Engine: f.name, Model: req.Model, Text: f.text}, f.err
+}
+
+// Stream 默认可用 —— 与内置引擎一致（它们都是 Streamer）。
+func (f *fallbackFakeEngine) Stream(_ context.Context, req Request, onEvent func(StreamEvent)) (StreamResult, error) {
+	f.lastReq = req
+	// 先以「思考」形态吐一遍（纯过程不拦降级），再把 events 当正文吐。
+	if len(f.events) > 0 {
+		onEvent(StreamEvent{Kind: KindThinking, Text: "让我想想"})
+	}
+	for _, s := range f.events {
+		onEvent(StreamEvent{Kind: KindText, Text: s})
+	}
+	return StreamResult{Response: Response{Engine: f.name, Model: req.Model, Text: f.text}}, f.err
+}
+
+// fallbackFakeNonStream 不支持流式的引擎（只有 Engine 接口，没有 Stream）。
+type fallbackFakeNonStream struct {
+	name string
+	text string
+	req  Request
+}
+
+func (f *fallbackFakeNonStream) Name() string           { return f.name }
+func (f *fallbackFakeNonStream) Detect() (bool, string) { return true, "fake://" + f.name }
+func (f *fallbackFakeNonStream) Complete(_ context.Context, req Request) (Response, error) {
+	f.req = req
+	return Response{Engine: f.name, Text: f.text}, nil
+}
+
+// withFallbackEngines 临时替换注册表：Lookup 只认这里登记的假引擎，测完还原
+// （别让内置引擎的惰性注册被这个用例打断，见 engine.go 的 registry 注释）。
+func withFallbackEngines(t *testing.T, engines ...Engine) {
+	t.Helper()
+	old := registry
+	registry = append([]Engine(nil), engines...)
+	t.Cleanup(func() { registry = old })
+}
+
+// collectFallback 收事件的助手：按 kind 分类存下来。
+type fallbackRecorder struct {
+	notices  []string
+	fallback []FallbackEvent
+	texts    []string
+	turnEnds int
+}
+
+func (r *fallbackRecorder) on(ev StreamEvent) {
+	switch ev.Kind {
+	case KindNotice:
+		r.notices = append(r.notices, ev.Text)
+	case KindFallback:
+		if ev.Fallback != nil {
+			r.fallback = append(r.fallback, *ev.Fallback)
+		}
+	case KindText:
+		r.texts = append(r.texts, ev.Text)
+	case KindTurnEnd:
+		r.turnEnds++
+	}
+}
+
+func TestStreamWithFallbackOnZeroOutput(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-primary", err: errors.New("402 insufficient_balance_error")}
+	backup := &fallbackFakeEngine{name: "fb-backup", text: "备用答案"}
+	withFallbackEngines(t, primary, backup)
+
+	rec := &fallbackRecorder{}
+	res, info, err := StreamWithFallback(context.Background(), primary, Request{
+		Model:          "m1",
+		FallbackEngine: "fb-backup",
+		FallbackModel:  "m2",
+	}, rec.on)
+	if err != nil {
+		t.Fatalf("主引擎失败、备用成功时不该报错：%v", err)
+	}
+	if res.Text != "备用答案" {
+		t.Errorf("应返回备用引擎的正文，得到 %q", res.Text)
+	}
+	if len(rec.fallback) != 1 {
+		t.Fatalf("应发一条 fallback 帧，得到 %#v", rec.fallback)
+	}
+	fe := rec.fallback[0]
+	if fe.FromEngine != "fb-primary" || fe.ToEngine != "fb-backup" || !fe.Switched || fe.FromModel != "m1" {
+		t.Errorf("fallback 帧两端不对：%#v", fe)
+	}
+	if !strings.Contains(fe.Reason, "402") {
+		t.Errorf("fallback 帧应带主引擎失败原因：%q", fe.Reason)
+	}
+	/* 换引擎：备用模型属于主引擎的清单，不能带过去（z 以前把 codebuddy 的 hy3 喂给 dsh）。 */
+	if backup.lastReq.Model != "" || !backup.lastReq.FallbackDown {
+		t.Errorf("换引擎时模型应清空并标记 FallbackDown：model=%q down=%v",
+			backup.lastReq.Model, backup.lastReq.FallbackDown)
+	}
+	if backup.lastReq.FallbackEngine != "" {
+		t.Error("降级请求里不该再留着备用字段（只降一级）")
+	}
+	if !info.Used || info.Engine != "fb-backup" || info.SwitchedEngine != true {
+		t.Errorf("FallbackInfo 应记录降级已生效：%#v", info)
+	}
+}
+
+// 同引擎换模型（手机上最常见的配法：dsh 主 modelverse、备 volcengine）——
+// 2026-10-26 真机作业记录里这一路以前被直接判成「没配备用」。
+func TestStreamWithFallbackSameEngineOtherModel(t *testing.T) {
+	var calls []string
+	primary := &fallbackFakeEngine{name: "fb-same", err: errors.New("402 Token Plan 用量上限")}
+	backup := &fallbackFakeEngine{name: "fb-same", text: "备用模型给的答案"}
+	withFallbackEngines(t, backup)
+
+	rec := &fallbackRecorder{}
+	res, info, err := StreamWithFallback(context.Background(), primary, Request{
+		Model:          "modelverse/x",
+		FallbackEngine: "fb-same",
+		FallbackModel:  "volcengine/x",
+	}, func(ev StreamEvent) {
+		if ev.Kind == KindFallback {
+			calls = append(calls, "fallback")
+		}
+		rec.on(ev)
+	})
+	if err != nil {
+		t.Fatalf("同引擎换模型应能降级：%v", err)
+	}
+	if res.Text != "备用模型给的答案" {
+		t.Errorf("应返回备用模型的正文，得到 %q", res.Text)
+	}
+	if backup.lastReq.Model != "volcengine/x" {
+		t.Errorf("同引擎换模型时必须带上备用模型，得到 %q", backup.lastReq.Model)
+	}
+	if len(rec.fallback) != 1 || rec.fallback[0].Switched || rec.fallback[0].ToModel != "volcengine/x" {
+		t.Fatalf("fallback 帧应说明是同引擎换模型：%#v", rec.fallback)
+	}
+	if !info.Used || info.SwitchedEngine {
+		t.Errorf("FallbackInfo：%#v", info)
+	}
+	// 人话里要能看到模型名 —— 用户配的正是模型。
+	if !strings.Contains(FallbackNoticeText(rec.fallback[0]), "volcengine/x") {
+		t.Errorf("提示里应带备用模型名：%q", FallbackNoticeText(rec.fallback[0]))
+	}
+}
+
+// 只有过程没有正文（思考 / 空 delta）也降级：已流出的思考是过程，不是答案。
+func TestStreamWithFallbackIgnoresThinkingOnly(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-think", err: errors.New("余额不足")}
+	// 主引擎只吐了思考与空白正文，没给答案。
+	primary.events = []string{"", "   "}
+	backup := &fallbackFakeEngine{name: "fb-think-backup", text: "答案"}
+	withFallbackEngines(t, primary, backup)
+
+	rec := &fallbackRecorder{}
+	_, info, err := StreamWithFallback(context.Background(), primary, Request{
+		FallbackEngine: "fb-think-backup",
+	}, rec.on)
+	if err != nil {
+		t.Fatalf("只吐过思考时仍应降级：%v", err)
+	}
+	if !info.Used {
+		t.Errorf("只吐过思考时仍应降级：%#v", info)
+	}
+}
+
+// 已经吐过正文：不降级，保留原始错误，并给出原因。
+func TestStreamWithFallbackKeepsPartialOutput(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-partial", events: []string{"已经写了一"}, err: errors.New("boom")}
+	backup := &fallbackFakeEngine{name: "fb-backup2", text: "不该出现"}
+	withFallbackEngines(t, primary, backup)
+
+	rec := &fallbackRecorder{}
+	_, info, err := StreamWithFallback(context.Background(), primary, Request{
+		FallbackEngine: "fb-backup2",
+	}, rec.on)
+	if err == nil {
+		t.Fatal("已经产出正文时应当保留原始错误")
+	}
+	if len(rec.fallback) != 0 {
+		t.Error("已经产出正文时不该降级（会出现两段互相矛盾的答案）")
+	}
+	if !strings.Contains(info.Reason, "正文") {
+		t.Errorf("没降级要给原因：%q", info.Reason)
+	}
+}
+
+func TestStreamWithFallbackClearsSession(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-sess", err: errors.New("expired")}
+	backup := &fallbackFakeEngine{name: "fb-sess2", text: "ok"}
+	withFallbackEngines(t, primary, backup)
+
+	_, _, err := StreamWithFallback(context.Background(), primary, Request{
+		SessionID:      "sess-of-primary",
+		Continue:       true,
+		FallbackEngine: "fb-sess2",
+	}, func(StreamEvent) {})
+	if err != nil {
+		t.Fatalf("降级应成功：%v", err)
+	}
+	if backup.lastReq.SessionID != "" || backup.lastReq.Continue {
+		t.Errorf("降级必须清掉会话锚点：session=%q continue=%v", backup.lastReq.SessionID, backup.lastReq.Continue)
+	}
+}
+
+// 主引擎残留的终帧不能漏给调用方：否则这一轮在备用开口前就被画成「已结束」。
+func TestStreamWithFallbackDropsPrimaryTerminalFrames(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-term", err: errors.New("boom")}
+	backup := &fallbackFakeEngine{name: "fb-term2", text: "ok"}
+	withFallbackEngines(t, primary, backup)
+
+	rec := &fallbackRecorder{}
+	_, _, err := StreamWithFallback(context.Background(), primary, Request{
+		FallbackEngine: "fb-term2",
+	}, rec.on)
+	if err != nil {
+		t.Fatalf("应降级成功：%v", err)
+	}
+	// 假引擎的 Stream 不走 accumulator、不会自己发终帧；这里直接验过滤口径。
+	if _, keep := stripNonResetKinds(StreamEvent{Kind: KindTurnEnd}); keep {
+		t.Error("turn_end 应被吞掉")
+	}
+	if _, keep := stripNonResetKinds(StreamEvent{Kind: KindTurnFailed}); keep {
+		t.Error("turn_failed 应被吞掉")
+	}
+	if _, keep := stripNonResetKinds(StreamEvent{Kind: KindThinking, Text: "思考"}); !keep {
+		t.Error("思考等过程事件应照常转发")
+	}
+}
+
+func TestRunWithFallback(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-c1", err: errors.New("quota")}
+	backup := &fallbackFakeEngine{name: "fb-c2", text: "完成"}
+	withFallbackEngines(t, primary, backup)
+
+	var note string
+	resp, info, err := RunWithFallback(context.Background(), primary, Request{FallbackEngine: "fb-c2"},
+		RunOptions{}, func(fe FallbackEvent) { note = FallbackNoticeText(fe) })
+	if err != nil {
+		t.Fatalf("应降级成功：%v", err)
+	}
+	if resp.Text != "完成" || !strings.Contains(note, "降级") || !strings.Contains(note, "fb-c2") {
+		t.Errorf("resp=%q note=%q", resp.Text, note)
+	}
+	if !info.Used || info.Engine != "fb-c2" {
+		t.Errorf("FallbackInfo：%#v", info)
+	}
+}
+
+// 同引擎换模型（非流式路径同样要生效）。
+func TestRunWithFallbackSameEngineOtherModel(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-rm", err: errors.New("402")}
+	backup := &fallbackFakeEngine{name: "fb-rm", text: "备用"}
+	withFallbackEngines(t, backup)
+
+	_, info, err := RunWithFallback(context.Background(), primary, Request{
+		Model: "a", FallbackEngine: "fb-rm", FallbackModel: "b",
+	}, RunOptions{}, nil)
+	if err != nil {
+		t.Fatalf("应降级成功：%v", err)
+	}
+	if backup.lastReq.Model != "b" {
+		t.Errorf("同引擎换模型应带上备用模型：%q", backup.lastReq.Model)
+	}
+	if !info.Used || info.Model != "b" {
+		t.Errorf("FallbackInfo.Model 应是备用模型：%#v", info)
+	}
+}
+
+// 引擎与模型都相同 = 没有可降级的目标：不白跑一次，原因说出来。
+func TestFallbackNoopWhenIdentical(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-id", err: errors.New("boom")}
+	withFallbackEngines(t, primary)
+
+	_, info, err := RunWithFallback(context.Background(), primary, Request{
+		FallbackEngine: "fb-id", FallbackModel: "",
+	}, RunOptions{}, nil)
+	if err == nil {
+		t.Fatal("引擎与模型都相同时应返回原始错误")
+	}
+	if !strings.Contains(info.Reason, "没有可降级") {
+		t.Errorf("应说明没有降级目标：%q", info.Reason)
+	}
+}
+
+func TestFallbackIgnoresUnknownEngine(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-only", err: errors.New("boom")}
+	withFallbackEngines(t, primary)
+
+	_, info, err := StreamWithFallback(context.Background(), primary, Request{
+		FallbackEngine: "不存在的引擎",
+	}, func(StreamEvent) {})
+	if err == nil {
+		t.Fatal("备用引擎不存在时应返回原始错误")
+	}
+	if !strings.Contains(info.Reason, "不存在") {
+		t.Errorf("应说明备用引擎不存在：%q", info.Reason)
+	}
+}
+
+// 备用没有流式能力：流式路径不降级（原因说出来）。
+func TestFallbackStreamNeedsStreamer(t *testing.T) {
+	primary := &fallbackFakeEngine{name: "fb-ns-p", err: errors.New("boom")}
+	backup := &fallbackFakeNonStream{name: "fb-ns", text: "非流式答案"}
+	withFallbackEngines(t, primary, backup)
+
+	_, info, err := StreamWithFallback(context.Background(), primary, Request{
+		FallbackEngine: "fb-ns",
+	}, func(StreamEvent) {})
+	if err == nil {
+		t.Fatal("备用不支持流式时应返回原始错误")
+	}
+	if !strings.Contains(info.Reason, "流式") {
+		t.Errorf("应说明备用不支持流式：%q", info.Reason)
+	}
+}

package/internal/agent/launch.go

@@ -8,7 +8,7 @@ package agent
 //
 //	npm 全局装的 shim：Windows 上是 claude.cmd / codebuddy.cmd（批处理），
 //	                  macOS/Linux 上是 claude / codebuddy（无扩展名的脚本）
-//	独立安装的原生二进制：trae-cli.exe / dsh 等
+//	独立安装的原生二进制：traex.exe / dsh 等
 //
 // **批处理不能被直接 exec**。Windows 的 exec.Command 遇到 `.cmd` 会走
 // cmd.exe 解析层，参数里的非 ASCII 字符会被代码页转换吃掉（中文 → 乱码），
@@ -112,6 +112,48 @@ func launchWrap(bin string, args []string) launchSpec {
 	}
 }
 
+/* WrapLaunch 把「可执行文件 + 参数」变成**可直接 exec** 的形式，供本仓之外的
+ * 调用方使用（目前是 internal/client 的脚本管理，见 scripts.go）。
+ *
+ * 与 launchWrap 的区别（三条，都重要）：
+ *
+ *  1. **不做 emptyStringFlags 改写**。那张表登记的是**引擎 prompt flag**
+ *     （--tools），是引擎语义的一部分；脚本的参数是用户自己填的定长参数，
+ *     套上引擎的白名单只会莫名其妙地改写用户的参数。
+ *  2. **返回两个值而不是 launchSpec**。launchSpec 是引擎内部的启动决策，
+ *     带上 wrapped 诊断位；对外只需要「拿这俩去 exec」。
+ *  3. **会传播退出码**（launchWrap 不会）。见下面那段说明。
+ *
+ * 为什么需要它：Windows 上 `.cmd/.bat/.ps1` **不能直接 exec** ——
+ * cmd.exe 解析层会把参数里的中文、& | ^ % 拆坏（见本文件头）。
+ * 脚本管理要跑用户登记的脚本文件，Windows 上多半就是 `.cmd` / `.ps1`，
+ * 不走这层包装就会静默失败。
+ *
+ * ── 为什么要传播退出码 ──
+ *
+ * 实测（2026-10-24）：PowerShell 用 `& 'script.cmd'` 调一个 `exit /b 3` 的
+ * 批处理时，**PowerShell 自己的退出码是 1，不是 3** —— 脚本的退出码被
+ * PowerShell 吞掉了。后果是「脚本失败」在界面上显示成退出码 1，
+ * 具体的 3 看不到（用户排查时少一条关键信息）。
+ *
+ * 补一句 `exit $LASTEXITCODE` 就能把它带出来（实测退出码变回 3）。
+ * 引擎路径不需要这个 —— 引擎的成败看的是输出与 `result` 事件，不是退出码。
+ */
+func WrapLaunch(bin string, args []string) (string, []string) {
+	if !platformIsWindows() {
+		return bin, args
+	}
+	if !needsPowerShellWrap(bin) {
+		return bin, args
+	}
+	script := powershellInvokeScript(bin, args)
+	// 退出码透传：$LASTEXITCODE 是「最近一次原生命令」的退出码。
+	// 对 .ps1 它是 $null（PowerShell 脚本没有原生退出码）—— 那时
+	// `exit $null` 等于 exit 0，也合理（PowerShell 脚本正常跑完就是成功）。
+	script += "; exit $LASTEXITCODE"
+	return powershellBin(), []string{"-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script}
+}
+
 // emptyStringFlags 全局登记：本项目里哪些 flag 会以**空串**作为值。
 //
 // 为什么要全局而不是按引擎传：改写发生在 launchWrap 这一层，

package/internal/agent/llmhttp.go

@@ -94,13 +94,55 @@ func buildConfiguredBody(m LLMConfigModel, req Request, stream bool) (map[string
 	}
 	if req.NoThinking && !LLMModelDisablesThinking(m) {
 		// 没有同线 no-think 变体时，用 llm/OpenAI 兼容端点认的官方参数。
-		// 若端点不支持该参数会返回 400 —— 这是显式 --disable-thinking 的预期失败，
-		// 不静默退回「假装关闭」。
+		// 个别模型不接受 `none`（如 MiniMax-M3.1-Flash 要求 adaptive thinking，
+		// 端点回 400 / 2013）—— 那不是「不能少思考」，只是这个档位不被允许：
+		// 由 doConfiguredRequestThinkingAware 换成它允许的最低档重试一次。
 		body["reasoning_effort"] = "none"
 	}
 	return body, nil
 }
 
+// noThinkingFallbackEffort 是「模型不接受完全关闭思考」时退而使用的最低档。
+//
+// 2026-10-24 用户纠正过一处误判：「invalid params ... requires adaptive thinking;
+// reasoning effort none is not allowed」**不代表模型不能少思考**，只是 `none` 这个
+// 档位不被允许。实测 MiniMax-M3.1-Flash：`none` → 400；`minimal` → 200；
+// `thinking.type=adaptive` → 200；`thinking.type=disabled` → 400。所以正确的做法是
+// 换档重试，而不是把用户选的模型换掉、也不是让整条链路失败。
+const noThinkingFallbackEffort = "minimal"
+
+// rejectsNoThinking 判断错误是不是「这个模型不接受关闭思考的写法」。
+// 认两条签名：`requires adaptive thinking` 与 `reasoning effort ... not allowed`；
+// 其它 4xx（鉴权、模型不存在、额度…）一律原样返回，不瞎重试。
+func rejectsNoThinking(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := strings.ToLower(err.Error())
+	if strings.Contains(msg, "requires adaptive thinking") {
+		return true
+	}
+	return strings.Contains(msg, "reasoning effort") && strings.Contains(msg, "not allowed")
+}
+
+// doConfiguredRequestThinkingAware 发一次请求；若模型拒绝 `reasoning_effort=none`，
+// 换成它允许的最低档（minimal）重试一次。
+//
+// 只在「我们主动塞了 none」时才换档：配置里显式声明的不思考变体
+// （extraBody.thinking.type=disabled）走的是另一条路，端点拒绝它是配置错误，
+// 换档只会把真正的原因盖住。
+func doConfiguredRequestThinkingAware(ctx context.Context, m LLMConfigModel, req Request, body map[string]any) (*http.Response, error) {
+	resp, err := doConfiguredRequest(ctx, m, req, body)
+	if err == nil || !rejectsNoThinking(err) {
+		return resp, err
+	}
+	if !req.NoThinking || LLMModelDisablesThinking(m) {
+		return nil, err
+	}
+	body["reasoning_effort"] = noThinkingFallbackEffort
+	return doConfiguredRequest(ctx, m, req, body)
+}
+
 // attachToLastUserMessage 把附件塞进最后一条 user 消息的 content：
 //
 //	图片  → {"type":"image_url","image_url":{"url":"data:<mime>;base64,<...>"}}（在前）
@@ -207,7 +249,7 @@ func (e *LLMEngine) completeConfigured(ctx context.Context, m LLMConfigModel, re
 	}
 	cctx, cancel := context.WithTimeout(ctx, llmConfiguredTimeout(m, req))
 	defer cancel()
-	resp, err := doConfiguredRequest(cctx, m, req, body)
+	resp, err := doConfiguredRequestThinkingAware(cctx, m, req, body)
 	if err != nil {
 		return Response{}, err
 	}
@@ -309,7 +351,7 @@ func (e *LLMEngine) streamConfigured(ctx context.Context, m LLMConfigModel, req
 	}
 	cctx, cancel := context.WithTimeout(ctx, llmConfiguredTimeout(m, req))
 	defer cancel()
-	resp, err := doConfiguredRequest(cctx, m, req, body)
+	resp, err := doConfiguredRequestThinkingAware(cctx, m, req, body)
 	if err != nil {
 		return StreamResult{}, err
 	}

package/internal/agent/llmhttp_test.go

@@ -20,6 +20,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 )
@@ -301,6 +302,162 @@ func TestBuildConfiguredBodyNoThinking(t *testing.T) {
 	}
 }
 
+// 2026-10-24 用户纠正的判定：「invalid params ... requires adaptive thinking;
+// reasoning effort none is not allowed」**不代表模型不能少思考**，只是 `none` 这个档位
+// 不被允许（实测 MiniMax-M3.1-Flash：none → 400，minimal / thinking.type=adaptive → 200）。
+// 所以应当**换档重试**，而不是把用户选的模型换掉、也不是让整条链路失败。
+func TestConfiguredNoThinkingFallsBackToAllowedEffort(t *testing.T) {
+	var mu sync.Mutex
+	var bodies []map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		raw, _ := io.ReadAll(r.Body)
+		var b map[string]any
+		_ = json.Unmarshal(raw, &b)
+		mu.Lock()
+		bodies = append(bodies, b)
+		mu.Unlock()
+		if b["reasoning_effort"] == "none" {
+			w.WriteHeader(http.StatusBadRequest)
+			fmt.Fprint(w, `{"type":"error","error":{"type":"bad_request_error",`+
+				`"message":"invalid params, model \"MiniMax-M3.1-Flash\" requires adaptive thinking; `+
+				`reasoning effort none is not allowed (2013)","http_code":"400"}}`)
+			return
+		}
+		fmt.Fprint(w, `{"choices":[{"message":{"content":"处理过期 token","reasoning_content":"内部思路"}}]}`)
+	}))
+	defer srv.Close()
+	writeModelsJSON(t, []map[string]any{
+		{"id": "MiniMax-M3.1-Flash", "url": srv.URL + "/v1", "apiKey": "k"},
+	})
+
+	resp, err := (&LLMEngine{BinPath: "/nonexistent/llm"}).Complete(context.Background(), Request{
+		Engine: "llm", Model: "MiniMax-M3.1-Flash", NoThinking: true,
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	})
+	if err != nil {
+		t.Fatalf("拒绝 none 时应换档重试而不是报错：%v", err)
+	}
+	if resp.Text != "处理过期 token" {
+		t.Errorf("正文应正常返回，得 %q", resp.Text)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(bodies) != 2 {
+		t.Fatalf("应请求两次（none 失败 → minimal 重试），得 %d 次", len(bodies))
+	}
+	if bodies[0]["reasoning_effort"] != "none" {
+		t.Errorf("第一次应仍按原口径传 none，得 %v", bodies[0]["reasoning_effort"])
+	}
+	if bodies[1]["reasoning_effort"] != noThinkingFallbackEffort {
+		t.Errorf("重试应换成 %q，得 %v", noThinkingFallbackEffort, bodies[1]["reasoning_effort"])
+	}
+	// 关键：换的是档位，不是模型 —— 用户选的就是这一条配置。
+	if bodies[1]["model"] != "MiniMax-M3.1-Flash" {
+		t.Errorf("不该换模型，得 %v", bodies[1]["model"])
+	}
+}
+
+// 与「关闭思考」无关的 4xx（鉴权 / 模型不存在…）必须原样报错，不许瞎重试。
+func TestConfiguredBadRequestUnrelatedNotRetried(t *testing.T) {
+	var mu sync.Mutex
+	calls := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		calls++
+		mu.Unlock()
+		w.WriteHeader(http.StatusBadRequest)
+		fmt.Fprint(w, `{"error":{"message":"model not found"}}`)
+	}))
+	defer srv.Close()
+	writeModelsJSON(t, []map[string]any{{"id": "m1", "url": srv.URL + "/v1", "apiKey": "k"}})
+
+	_, err := (&LLMEngine{BinPath: "/nonexistent/llm"}).Complete(context.Background(), Request{
+		Engine: "llm", Model: "m1", NoThinking: true,
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	})
+	if err == nil || !strings.Contains(err.Error(), "HTTP 400") {
+		t.Fatalf("无关的 400 应原样报错，得 %v", err)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if calls != 1 {
+		t.Errorf("无关错误不该重试，实际请求 %d 次", calls)
+	}
+}
+
+// 配置里显式声明的不思考变体（extraBody.thinking.type=disabled）被端点拒绝时，
+// 那是**配置错误** —— 不许把它悄悄改成 minimal 把真实原因盖住。
+func TestConfiguredDisabledVariantErrorNotRewritten(t *testing.T) {
+	var mu sync.Mutex
+	calls := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		calls++
+		mu.Unlock()
+		w.WriteHeader(http.StatusBadRequest)
+		fmt.Fprint(w, `{"error":{"message":"model \"x\" requires adaptive thinking; `+
+			`thinking.type=\"disabled\" (including reasoning.effort=none) is not allowed (2013)"}}`)
+	}))
+	defer srv.Close()
+	writeModelsJSON(t, []map[string]any{
+		{"id": "x-nothink", "model": "x", "url": srv.URL + "/v1", "apiKey": "k",
+			"extraBody": map[string]any{"thinking": map[string]any{"type": "disabled"}}},
+	})
+
+	_, err := (&LLMEngine{BinPath: "/nonexistent/llm"}).Complete(context.Background(), Request{
+		Engine: "llm", Model: "x-nothink", NoThinking: true,
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	})
+	if err == nil || !strings.Contains(err.Error(), "is not allowed") {
+		t.Fatalf("配置错误应如实报出，得 %v", err)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if calls != 1 {
+		t.Errorf("配置声明的不思考变体不该被改写重试，实际请求 %d 次", calls)
+	}
+}
+
+// 流式路径同样要换档重试（两条路径共用 doConfiguredRequestThinkingAware）。
+func TestStreamConfiguredNoThinkingFallsBack(t *testing.T) {
+	var mu sync.Mutex
+	var bodies []map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		raw, _ := io.ReadAll(r.Body)
+		var b map[string]any
+		_ = json.Unmarshal(raw, &b)
+		mu.Lock()
+		bodies = append(bodies, b)
+		mu.Unlock()
+		if b["reasoning_effort"] == "none" {
+			w.WriteHeader(http.StatusBadRequest)
+			fmt.Fprint(w, `{"error":{"message":"requires adaptive thinking; reasoning effort none is not allowed (2013)"}}`)
+			return
+		}
+		w.Header().Set("Content-Type", "text/event-stream")
+		fmt.Fprint(w, "data: {\"choices\":[{\"delta\":{\"content\":\"好\"}}]}\n\n")
+		fmt.Fprint(w, "data: [DONE]\n\n")
+	}))
+	defer srv.Close()
+	writeModelsJSON(t, []map[string]any{{"id": "MiniMax-M3.1-Flash", "url": srv.URL + "/v1", "apiKey": "k"}})
+
+	res, err := (&LLMEngine{BinPath: "/nonexistent/llm"}).Stream(context.Background(), Request{
+		Engine: "llm", Model: "MiniMax-M3.1-Flash", NoThinking: true,
+		Messages: []Message{{Role: "user", Content: "hi"}},
+	}, nil)
+	if err != nil {
+		t.Fatalf("流式也应在换档后成功：%v", err)
+	}
+	if res.Response.Text != "好" {
+		t.Errorf("正文应为「好」，得 %q", res.Response.Text)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if len(bodies) != 2 || bodies[1]["reasoning_effort"] != noThinkingFallbackEffort {
+		t.Errorf("流式路径也应换档重试，实际 %d 次、第二次档位 %v", len(bodies), bodies[1]["reasoning_effort"])
+	}
+}
+
 func TestExpandEnvKeep(t *testing.T) {
 	t.Setenv("LLM_TEST_KEY", "secret")
 	cases := map[string]string{