feat(types): 统一格式落地为内核实际使用的类型 —— 私有字段泄漏归零

Phase 2 收尾（入向）。ChatRequest 从"客户端发什么就是什么"改为
UnifiedRequest（最大集合）的别名，内核真正用上了那个超集类型。

改掉的具体缺陷：

1. 私有字段泄漏归零（v1 的核心问题）
   v1 的 disable_thinking 是内核私有开关，却被序列化进交给适配器的 body，
   迫使 10 个适配器各自写 req.disable_thinking = nil 来清理。
   现在它是中立的 thinking 字段（{enabled, budget_tokens}），客户端与
   适配器都认这个词：
   - gateway/chat.go：thinkingFromClient() 把 disable_thinking 翻译成
     thinking.enabled=false；冲突时中立字段优先（它能带预算，布尔不能）
   - deepseek.lua：thinking.enabled=false → extra_body.thinking.type=disabled
   - anthropic.lua：thinking.enabled=true + budget → 原生 {type,budget_tokens}
     （enabled=false 时不传该字段——Anthropic 没有 type=disabled 这个写法）
   - 其余 7 个适配器：把"清理内核私有字段"改成"清理中立字段"

2. Tools/ToolChoice 改 json.RawMessage
   原为 []interface{}（OpenAI 原始形状 = 内核在假设某个协议）。
   内核从不解释工具 schema——它原样交给适配器，所以原始形状不损失任何
   内核侧统一性。ToolDef 结构化类型保留在包内供新适配器选用。

3. 删除 MarshalJSON 后门
   v1 手工 splice ExtraBody 进 OpenAI 形状的 body；现在 ExtraBody 是
   UnifiedRequest 上一个正正经经声明的字段。

渐进迁移：ChatRequest 保留为别名（不是新类型），49 处引用零改动编译，
语义变更不被机械改名淹没。

测试：新增 thinking_test.go（翻译链 4 例 + 泄漏回归 + tools 透传）；
vm_test.go 两处迁移到中立语义。golden 字节级未漂移。

internal/lua/adapters/anthropic.lua

@@ -254,12 +254,24 @@ function adapter.transform_request(raw_body)
         end
     end
 
-    -- ── thinking (opt-in via extra_body) ──────────────────────
-    -- Default: OFF. Client sends extra_body.thinking to enable.
-    -- Example: {"extra_body": {"thinking": {"type": "enabled", "budget_tokens": 4096}}}
-    if type(req.extra_body) == "table" and type(req.extra_body.thinking) == "table" then
+    -- ── thinking ─────────────────────────────────────────────
+    -- Anthropic 的原生字段就是 {type, budget_tokens}，所以中立语义几乎直译。
+    --
+    -- 中立格式（v2）：{ enabled = true/false, budget_tokens = N }
+    --   enabled=false → 不传该字段（Anthropic 默认关闭思考，传 type=disabled
+    --                  是非法的，这也是过去只能「不传」的原因）
+    --   enabled=true  → { type="enabled", budget_tokens=N 或默认 }
+    --
+    -- 仍接受 extra_body.thinking 的原生写法：已有部署的配置不因此失效。
+    local th = req.thinking
+    if type(th) == "table" and th.enabled ~= false then
+        local budget = th.budget_tokens
+        if budget == nil or budget <= 0 then budget = 4096 end  -- Anthropic 必填
+        anthropic_req.thinking = { type = "enabled", budget_tokens = budget }
+    elseif type(req.extra_body) == "table" and type(req.extra_body.thinking) == "table" then
         anthropic_req.thinking = req.extra_body.thinking
     end
+    req.thinking = nil
 
     -- ── system ───────────────────────────────────────────────
     if system ~= "" then

internal/lua/adapters/deepseek.lua

@@ -15,11 +15,18 @@ function adapter.transform_request(raw_body)
         req.model = "deepseek-v4-flash"
     end
     req.stream = req.stream or false
-    if req.disable_thinking then
+    -- 中立的 thinking 语义 → DeepSeek 自己的协议写法。
+    -- 客户端说「关掉思考」时 thinking.enabled == false；上游的表达方式是
+    -- extra_body.thinking.type = "disabled"。v2 之前这里读的是内核私有字段
+    -- req.disable_thinking，而那个字段曾被内核泄漏进本函数收到的 body。
+    if type(req.thinking) == "table" and req.thinking.enabled == false then
         req.extra_body = req.extra_body or {}
         req.extra_body.thinking = { type = "disabled" }
+    elseif type(req.thinking) == "table" and req.thinking.budget_tokens ~= nil then
+        req.extra_body = req.extra_body or {}
+        req.extra_body.thinking = { type = "enabled", budget_tokens = req.thinking.budget_tokens }
     end
-    req.disable_thinking = nil
+    req.thinking = nil
 
     -- V4 thinking 模式要求：带 tool_calls 的 assistant 消息必须回传 reasoning_content。
     -- OpenAI 兼容客户端不会发该字段，补空串即可通过校验。

internal/lua/adapters/github.lua

@@ -14,7 +14,13 @@ function adapter.transform_request(raw_body)
     req.temperature = req.temperature or 0.7
     req.max_tokens = req.max_tokens or 4096
     req.stream = req.stream or false
-    req.disable_thinking = nil
+    -- The gateway's private control fields are GONE from the body (v2): the
+    -- neutral `thinking` field carries that intent and each adapter maps it in
+    -- its own protocol terms. These upstreams have no thinking switch at all,
+    -- so the field is simply dropped here — which is what the nil-ing below
+    -- used to do, except the field being dropped is no longer the kernel's
+    -- private one.
+    req.thinking = nil
     req.extra_body = nil
     return json.encode(req)
 end

internal/lua/adapters/groq.lua

@@ -13,7 +13,13 @@ function adapter.transform_request(raw_body)
     req.temperature = req.temperature or 0.7
     req.max_tokens = req.max_tokens or 4096
     req.stream = req.stream or false
-    req.disable_thinking = nil
+    -- The gateway's private control fields are GONE from the body (v2): the
+    -- neutral `thinking` field carries that intent and each adapter maps it in
+    -- its own protocol terms. These upstreams have no thinking switch at all,
+    -- so the field is simply dropped here — which is what the nil-ing below
+    -- used to do, except the field being dropped is no longer the kernel's
+    -- private one.
+    req.thinking = nil
     req.extra_body = nil
     return json.encode(req)
 end

internal/lua/adapters/kimicode.lua

@@ -19,7 +19,13 @@ function adapter.transform_request(raw_body)
     local ok, req = pcall(json.decode, raw_body)
     if not ok then return raw_body end
     req.model = req.model or "kimi-k2"
-    req.disable_thinking = nil
+    -- The gateway's private control fields are GONE from the body (v2): the
+    -- neutral `thinking` field carries that intent and each adapter maps it in
+    -- its own protocol terms. These upstreams have no thinking switch at all,
+    -- so the field is simply dropped here — which is what the nil-ing below
+    -- used to do, except the field being dropped is no longer the kernel's
+    -- private one.
+    req.thinking = nil
     req.extra_body = nil
     return json.encode(req)
 end

internal/lua/adapters/mistral.lua

@@ -13,7 +13,13 @@ function adapter.transform_request(raw_body)
     req.temperature = req.temperature or 0.7
     req.max_tokens = req.max_tokens or 4096
     req.stream = req.stream or false
-    req.disable_thinking = nil
+    -- The gateway's private control fields are GONE from the body (v2): the
+    -- neutral `thinking` field carries that intent and each adapter maps it in
+    -- its own protocol terms. These upstreams have no thinking switch at all,
+    -- so the field is simply dropped here — which is what the nil-ing below
+    -- used to do, except the field being dropped is no longer the kernel's
+    -- private one.
+    req.thinking = nil
     req.extra_body = nil
     return json.encode(req)
 end

internal/lua/adapters/openai.lua

@@ -39,7 +39,13 @@ end
 function adapter.transform_request(raw_body)
     local ok, req = pcall(json.decode, raw_body)
     if not ok then return raw_body end
-    req.disable_thinking = nil
+    -- The gateway's private control fields are GONE from the body (v2): the
+    -- neutral `thinking` field carries that intent and each adapter maps it in
+    -- its own protocol terms. These upstreams have no thinking switch at all,
+    -- so the field is simply dropped here — which is what the nil-ing below
+    -- used to do, except the field being dropped is no longer the kernel's
+    -- private one.
+    req.thinking = nil
     req.extra_body = nil
     if req.messages then
         for _, msg in ipairs(req.messages) do

internal/lua/adapters/sensenova.lua

@@ -12,7 +12,13 @@ adapter.headers = {}
 function adapter.transform_request(raw_body)
     local ok, req = pcall(json.decode, raw_body)
     if not ok then return raw_body end
-    req.disable_thinking = nil
+    -- The gateway's private control fields are GONE from the body (v2): the
+    -- neutral `thinking` field carries that intent and each adapter maps it in
+    -- its own protocol terms. These upstreams have no thinking switch at all,
+    -- so the field is simply dropped here — which is what the nil-ing below
+    -- used to do, except the field being dropped is no longer the kernel's
+    -- private one.
+    req.thinking = nil
     req.extra_body = nil
     if req.messages then
         for _, msg in ipairs(req.messages) do

internal/lua/adapters/trae.lua

@@ -15,7 +15,13 @@ adapter.headers = {}
 function adapter.transform_request(raw_body)
     local ok, req = pcall(json.decode, raw_body)
     if not ok then return raw_body end
-    req.disable_thinking = nil
+    -- The gateway's private control fields are GONE from the body (v2): the
+    -- neutral `thinking` field carries that intent and each adapter maps it in
+    -- its own protocol terms. These upstreams have no thinking switch at all,
+    -- so the field is simply dropped here — which is what the nil-ing below
+    -- used to do, except the field being dropped is no longer the kernel's
+    -- private one.
+    req.thinking = nil
     req.extra_body = nil
     if req.messages then
         for _, msg in ipairs(req.messages) do

internal/lua/billing_test.go

@@ -1067,7 +1067,7 @@ func TestReasoningBilledAtCompletionRateByDefault(t *testing.T) {
 		"model": "m", "source": "s", "key": "***aaaaaa", "ok": true,
 		"prompt_tokens": 1000, "completion_tokens": 1000,
 		"reasoning_tokens": 800, // all of it thinking; still billed as output
-		"time": 1750000000000,
+		"time":             1750000000000,
 	})
 	st := stateOf(t, ps)
 	cost := st["total"].(map[string]interface{})["cost"].(float64)

internal/lua/billing_ui_test.go

@@ -427,11 +427,11 @@ func TestBillingUIShowsRecentUnpriced(t *testing.T) {
 	}
 	src := string(raw)
 	for _, needle := range []string{
-		"unpriced_by_day",  // the tally is written
-		"recentUnpriced",   // it is reduced to a window
-		"unpriced_recent",  // it reaches the view
-		"unpriced7d",       // the card labels it
-		"unpricedClean",    // and says so when the window is clear
+		"unpriced_by_day", // the tally is written
+		"recentUnpriced",  // it is reduced to a window
+		"unpriced_recent", // it reaches the view
+		"unpriced7d",      // the card labels it
+		"unpricedClean",   // and says so when the window is clear
 	} {
 		if !strings.Contains(src, needle) {
 			t.Errorf("billing UI lacks %q", needle)
@@ -450,9 +450,9 @@ func TestBillingRulesUIExposesReasoningPrice(t *testing.T) {
 	}
 	src := string(raw)
 	for _, needle := range []string{
-		`class='m-r'`,       // the input, in both the existing rows and the "+ model" row
+		`class='m-r'`,         // the input, in both the existing rows and the "+ model" row
 		`models[n].reasoning`, // collected back out of the DOM on save
-		`reasoningHint`,     // and it says what leaving it blank means
+		`reasoningHint`,       // and it says what leaving it blank means
 	} {
 		if !strings.Contains(src, needle) {
 			t.Errorf("rules editor lacks %q", needle)
@@ -481,11 +481,11 @@ func TestBillingRulesUIExposesLongContextStep(t *testing.T) {
 	}
 	src := string(raw)
 	for _, needle := range []string{
-		`class='m-lc-a'`,        // threshold
-		`class='m-lc-p'`,        // absolute rate
-		`class='m-lc-m'`,        // multiplier
+		`class='m-lc-a'`,         // threshold
+		`class='m-lc-p'`,         // absolute rate
+		`class='m-lc-m'`,         // multiplier
 		`models[n].long_context`, // collected back out on save
-		`lcHint`,                // explains that blank = no step
+		`lcHint`,                 // explains that blank = no step
 	} {
 		if !strings.Contains(src, needle) {
 			t.Errorf("rules editor lacks %q", needle)

internal/lua/plugin_access_persist.go

@@ -112,4 +112,4 @@ func (ps *Plugins) sortedOverrideKeys() []string {
 	}
 	sort.Strings(keys)
 	return keys
-}
+}

internal/lua/plugin_http.go

@@ -245,4 +245,4 @@ func flattenHeaders(h http.Header) map[string]string {
 		out[strings.ToLower(k)] = h.Get(k)
 	}
 	return out
-}
+}

internal/lua/plugin_http_args.go

@@ -119,4 +119,4 @@ func asFloat(v interface{}) (float64, bool) {
 	default:
 		return 0, false
 	}
-}
+}

internal/lua/plugin_http_handler_test.go

@@ -335,10 +335,10 @@ func TestHandlerResponseFramingIsKernelOwned(t *testing.T) {
 	writeHTTPHandlerResponse(w, &HandlerResponse{
 		Status: 200, Body: "hello",
 		Headers: map[string]string{
-			"Content-Length":   "99999",
-			"Connection":       "close",
+			"Content-Length":    "99999",
+			"Connection":        "close",
 			"Transfer-Encoding": "chunked",
-			"X-Custom":         "kept",
+			"X-Custom":          "kept",
 		},
 	})
 	if got := w.Header().Get("Content-Length"); got != "" {
@@ -398,6 +398,7 @@ func TestParseHandlerResponseShapes(t *testing.T) {
 		t.Errorf("decoded %+v", r)
 	}
 }
+
 // TestEndpointAccessReportsPerEndpointOverride guards the reporting side of the
 // override store.
 //

internal/lua/plugin_http_test.go

@@ -149,6 +149,7 @@ func TestPluginHTTPErrorPathIsPairNotRaise(t *testing.T) {
 		t.Fatal("a missing argument table must be an error, not a panic")
 	}
 }
+
 // The bridge must be reachable under the name plugins actually call.
 //
 // This exists because the registration once used the CONSTANT'S IDENTIFIER as

internal/lua/plugin_visibility_test.go

@@ -190,4 +190,4 @@ func pageIDs(pages []*UIPage) []string {
 		}
 	}
 	return out
-}
+}

internal/lua/quota_opendesign_test.go

@@ -20,8 +20,9 @@ import (
 // notice.
 //
 // Live responses this fixture copies (both 200, ~1.3s):
-//   GET https://amr-api.open-design.ai/api/v1/wallet/balance
-//   GET https://amr-api.open-design.ai/api/v1/billing/summary
+//
+//	GET https://amr-api.open-design.ai/api/v1/wallet/balance
+//	GET https://amr-api.open-design.ai/api/v1/billing/summary
 const (
 	odWallet = `{"balanceUsd":"15.7062","expiresAt":"2026-10-08T23:01:06.662Z",` +
 		`"updatedAt":"2026-10-06T08:02:20.167Z","billingScopeVersion":2,` +

internal/lua/usage_plugin_test.go

@@ -9,17 +9,17 @@ import (
 // usage plugin safe to ship, and both are easy to break by accident because they
 // live in a Lua file nobody compiles.
 //
-// 1) SHIPPED. `usage` is the reason /v1/usage exists at all, and it only exists
-//    for deployments that receive it. A gateway build that does not embed it
-//    answers 404 and the frontend shows "后台未开放消费接口" — which reads as a
-//    bug rather than as a missing optional feature. Same reasoning billing.lua and
-//    quota.lua are embedded.
+//  1. SHIPPED. `usage` is the reason /v1/usage exists at all, and it only exists
+//     for deployments that receive it. A gateway build that does not embed it
+//     answers 404 and the frontend shows "后台未开放消费接口" — which reads as a
+//     bug rather than as a missing optional feature. Same reasoning billing.lua and
+//     quota.lua are embedded.
 //
-// 2) SELF-SCOPED. The handler reports the CALLER's usage, so it must look the
-//    caller up by the key in the request, never by a key from its own
-//    configuration. A plugin that read a configured key would report one
-//    tenant's spend to every tenant — the exact leak this plugin avoids by
-//    passing the request's key straight through.
+//  2. SELF-SCOPED. The handler reports the CALLER's usage, so it must look the
+//     caller up by the key in the request, never by a key from its own
+//     configuration. A plugin that read a configured key would report one
+//     tenant's spend to every tenant — the exact leak this plugin avoids by
+//     passing the request's key straight through.
 func TestUsagePluginShipsAndGuardsItsOwnKey(t *testing.T) {
 	src := readShippedPlugin(t, "usage.lua")
 
@@ -109,4 +109,4 @@ func TestUsagePeriodIsAll(t *testing.T) {
 	if !strings.Contains(readShippedPlugin(t, "usage.lua"), `local PERIOD = "all"`) {
 		t.Error(`usage.lua no longer defaults to period "all"`)
 	}
-}
+}

internal/lua/vm_test.go

@@ -88,12 +88,15 @@ func TestTransformRequest(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer vm.Stop()
-	out, err := vm.Transform("openai", "transform_request", `{"model":"x","disable_thinking":true,"messages":[]}`)
+	// v2: adapters strip the NEUTRAL field, because that is what the kernel now
+	// hands them. (The v1 assertion checked disable_thinking, which was the
+	// kernel's own private field — it no longer appears in the body at all.)
+	out, err := vm.Transform("openai", "transform_request", `{"model":"x","thinking":{"enabled":true},"messages":[]}`)
 	if err != nil {
 		t.Fatalf("transform: %v", err)
 	}
-	if strings.Contains(out, "disable_thinking") {
-		t.Fatalf("disable_thinking not stripped: %s", out)
+	if strings.Contains(out, "thinking") {
+		t.Fatalf("中立 thinking 字段未被剥除，会泄给上游: %s", out)
 	}
 }
 
@@ -148,33 +151,56 @@ func TestDisableThinkingPassthrough(t *testing.T) {
 		t.Fatal(err)
 	}
 	defer vm.Stop()
-	body := `{"model":"x","disable_thinking":true,"messages":[{"role":"user","content":"hi"}]}`
+	// v2: the client speaks the NEUTRAL field. disable_thinking was the kernel's
+	// private spelling and no longer reaches an adapter at all.
+	body := `{"model":"x","thinking":{"enabled":false},"messages":[{"role":"user","content":"hi"}]}`
 	out, err := vm.Transform("deepseek", "transform_request", body)
 	if err != nil {
 		t.Fatalf("deepseek transform: %v", err)
 	}
 	var req struct {
 		ExtraBody map[string]interface{} `json:"extra_body"`
+		Thinking  map[string]interface{} `json:"thinking"`
 	}
 	if err := json.Unmarshal([]byte(out), &req); err != nil {
 		t.Fatalf("unmarshal: %v (%s)", err, out)
 	}
 	thinking, ok := req.ExtraBody["thinking"].(map[string]interface{})
 	if !ok {
-		t.Fatalf("deepseek should emit extra_body.thinking on disable_thinking: %s", out)
+		t.Fatalf("deepseek 应把中立的 thinking.enabled=false 映射成 extra_body.thinking: %s", out)
 	}
 	if thinking["type"] != "disabled" {
 		t.Fatalf("thinking.type = %v", thinking["type"])
 	}
+	// 关键回归：映射之后，中立字段本身必须已被剥掉，不能随 body 泄给上游。
+	if req.Thinking != nil {
+		t.Fatalf("中立 thinking 字段未被剥除，泄漏进了上游 body: %s", out)
+	}
 
-	// anthropic: thinking is opt-in (Issue 3) — never emitted by default, and
-	// disable_thinking is not a trigger either.
+	// anthropic: thinking 是 opt-in —— enabled=false 时不传该字段
+	// （Anthropic 没有 type=disabled 这个写法，传了会被拒）。
 	out2, err := vm.Transform("anthropic", "transform_request", body)
 	if err != nil {
 		t.Fatalf("anthropic transform: %v", err)
 	}
 	if strings.Contains(out2, "thinking") {
-		t.Fatalf("anthropic should drop thinking when disable_thinking: %s", out2)
+		t.Fatalf("anthropic 在 thinking.enabled=false 时不应发出 thinking: %s", out2)
+	}
+
+	// 新增覆盖：enabled=true + budget 应直译成 Anthropic 的原生形状
+	outThinking, err := vm.Transform("anthropic", "transform_request",
+		`{"model":"x","messages":[{"role":"user","content":"hi"}],"thinking":{"enabled":true,"budget_tokens":2048}}`)
+	if err != nil {
+		t.Fatalf("anthropic transform: %v", err)
+	}
+	var ar struct {
+		Thinking map[string]interface{} `json:"thinking"`
+	}
+	if err := json.Unmarshal([]byte(outThinking), &ar); err != nil {
+		t.Fatalf("unmarshal: %v (%s)", err, outThinking)
+	}
+	if ar.Thinking["type"] != "enabled" || ar.Thinking["budget_tokens"] != float64(2048) {
+		t.Fatalf("anthropic 原生 thinking 未按中立语义直译: %s", outThinking)
 	}
 	out3, err := vm.Transform("anthropic", "transform_request", `{"model":"x","messages":[{"role":"user","content":"hi"}]}`)
 	if err != nil {