@@ -52,6 +52,26 @@ export const GLM53_MIN_THINKING_BUDGET = 1_024;
  */
 export const GLM53_ANSWER_RESERVE = 1_024;
 
+/**
+ * Effort level that replaces `thinking:{type:"disabled"}` for this family.
+ *
+ * Z.AI documents thinking as impossible to turn off here — `thinking.type`
+ * accepts only `"enabled"` — and prescribes an explicit migration: switch to
+ * `enabled` and set the effort to `low`, "otherwise the request will fail".
+ * @see https://docs.z.ai/guides/llm/glm-5.3 (Migration Notice)
+ * @see https://docs.z.ai/guides/vlm/glm-5.3-flash
+ *
+ * Live probing against the Anthropic gateway did *not* reproduce that
+ * failure (a disabled request returned 200, with 54 chars of thinking for
+ * glm-5.3 and none for glm-5.3-flash), so this rewrite is not about a fault
+ * we have observed. It is about not sending a shape the vendor documents as
+ * unsupported: the OpenAI-protocol upstream used on start-plan is exactly
+ * where that warning applies, and a gateway is free to start enforcing it.
+ * `low` is also the closest honest approximation of "off" — it measured zero
+ * thinking on glm-5.3-flash and the family minimum on glm-5.3.
+ */
+export const GLM53_DISABLED_REPLACEMENT_EFFORT: Glm53Effort = "low";
+
 /**
  * Match the GLM-5.3 model family, including `glm-5.3-flash`, case-insensitively
  * (the upstream also accepts `GLM-5.3`). Deliberately excludes `glm-5`,
 
@@ -345,3 +345,105 @@ describe("transformRequestBody — metadata.user_id (Anthropic)", () => {
     expect(parsed.metadata).toBeUndefined();
   });
 });
+
+
+// A client body reaches the upstream verbatim on two routes — an Anthropic
+// client on coding-plan, and an OpenAI client on start-plan — so the
+// translators' GLM-5.3 rewrite would not cover them. Z.AI documents
+// thinking:{type:"disabled"} as unsupported for this family and prescribes
+// enabled + low effort. https://docs.z.ai/guides/llm/glm-5.3
+describe("transformRequestBody — GLM-5.3 disabled-thinking rewrite", () => {
+  it("Anthropic passthrough: rewrites disabled to enabled with the low-effort budget", () => {
+    const body = JSON.stringify({
+      model: "glm-5.3",
+      max_tokens: 40_000,
+      thinking: { type: "disabled" },
+      messages: [{ role: "user", content: "hi" }],
+    });
+    const parsed = JSON.parse(transformRequestBody(body, { format: "anthropic" }) as string);
+    expect(parsed.thinking).toEqual({ type: "enabled", budget_tokens: 8_000 });
+    expect(parsed.output_config).toEqual({ effort: "low" });
+  });
+
+  it("Anthropic passthrough: fits the budget to a small max_tokens", () => {
+    const body = JSON.stringify({
+      model: "glm-5.3",
+      max_tokens: 4_096,
+      thinking: { type: "disabled" },
+      messages: [{ role: "user", content: "hi" }],
+    });
+    const parsed = JSON.parse(transformRequestBody(body, { format: "anthropic" }) as string);
+    expect(parsed.thinking).toEqual({ type: "enabled", budget_tokens: 3_072 });
+  });
+
+  it("Anthropic passthrough: drops the budget rather than starving the answer", () => {
+    const body = JSON.stringify({
+      model: "glm-5.3",
+      max_tokens: 1_500,
+      thinking: { type: "disabled" },
+      messages: [{ role: "user", content: "hi" }],
+    });
+    const parsed = JSON.parse(transformRequestBody(body, { format: "anthropic" }) as string);
+    expect(parsed.thinking).toEqual({ type: "enabled" });
+  });
+
+  it("Anthropic passthrough: leaves an output_config the client already set", () => {
+    const body = JSON.stringify({
+      model: "glm-5.3",
+      max_tokens: 40_000,
+      thinking: { type: "disabled" },
+      output_config: { effort: "max" },
+      messages: [{ role: "user", content: "hi" }],
+    });
+    const parsed = JSON.parse(transformRequestBody(body, { format: "anthropic" }) as string);
+    expect(parsed.output_config).toEqual({ effort: "max" });
+  });
+
+  it("OpenAI passthrough: rewrites disabled to enabled + reasoning_effort", () => {
+    const body = JSON.stringify({
+      model: "glm-5.3-flash",
+      thinking: { type: "disabled" },
+      messages: [{ role: "user", content: "hi" }],
+    });
+    const parsed = JSON.parse(transformRequestBody(body, { format: "openai", startPlan: true }) as string);
+    expect(parsed.thinking).toEqual({ type: "enabled" });
+    expect(parsed.reasoning_effort).toBe("low");
+  });
+
+  it("OpenAI passthrough: keeps a reasoning_effort the client already set", () => {
+    const body = JSON.stringify({
+      model: "glm-5.3",
+      thinking: { type: "disabled" },
+      reasoning_effort: "max",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    const parsed = JSON.parse(transformRequestBody(body, { format: "openai", startPlan: true }) as string);
+    expect(parsed.thinking).toEqual({ type: "enabled" });
+    expect(parsed.reasoning_effort).toBe("max");
+  });
+
+  it("leaves non-GLM-5.3 models alone — glm-4.7 genuinely supports disabling", () => {
+    const body = JSON.stringify({
+      model: "glm-4.7",
+      max_tokens: 40_000,
+      thinking: { type: "disabled" },
+      messages: [{ role: "user", content: "hi" }],
+    });
+    const parsed = JSON.parse(transformRequestBody(body, { format: "anthropic" }) as string);
+    expect(parsed.thinking).toEqual({ type: "disabled" });
+    expect(parsed.output_config).toBeUndefined();
+  });
+
+  it("leaves an already-enabled GLM-5.3 body untouched", () => {
+    const body = JSON.stringify({
+      model: "glm-5.3",
+      max_tokens: 40_000,
+      thinking: { type: "enabled", budget_tokens: 32_000 },
+      output_config: { effort: "max" },
+      messages: [{ role: "user", content: "hi" }],
+    });
+    const parsed = JSON.parse(transformRequestBody(body, { format: "anthropic" }) as string);
+    expect(parsed.thinking).toEqual({ type: "enabled", budget_tokens: 32_000 });
+    expect(parsed.output_config).toEqual({ effort: "max" });
+  });
+});
@@ -16,11 +16,21 @@
  *      is safe and matches ZCode's `applyCacheControl: true` default.
  *   4. Anthropic format + `ctx.userId` set → inject `metadata: { user_id }`.
  *      Mirrors `user_id: B.metadata.userId` at bundle offset ~4760586.
+ *   5. GLM-5.3 family + `thinking: { type: "disabled" }` → rewrite to the
+ *      enabled/low-effort form Z.AI documents, in whichever shape the
+ *      upstream expects. Only reachable on the two routes that forward a
+ *      client body verbatim; the translators handle the rest.
  *
  * @see _reverse/NOTEPAD.md "How Credential is Used for LLM Calls"
  */
 import type { Format } from "../translator/types.js";
 import { buildStartPlanSystem } from "./system-prompt.js";
+import {
+  isGlm53Model,
+  buildGlm53Reasoning,
+  fitGlm53Budget,
+  GLM53_DISABLED_REPLACEMENT_EFFORT,
+} from "../provider/reasoning.js";
 
 interface TransformContext {
   format: Format;
@@ -52,12 +62,14 @@ export function transformRequestBody(body: string | undefined, ctx: TransformCon
       modified = applyStartPlanOpenAISystem(parsed as Record<string, unknown>) || modified;
     }
     modified = applyStreamOptionsIncludeUsage(parsed as Record<string, unknown>) || modified;
+    modified = applyGlm53OpenAIThinkingCompat(parsed as Record<string, unknown>) || modified;
   }
   if (ctx.format === "anthropic") {
     const obj = parsed as Record<string, unknown>;
     if (ctx.startPlan) {
       modified = applyStartPlanSystem(obj) || modified;
     }
+    modified = applyGlm53AnthropicThinkingCompat(obj) || modified;
     modified = applyAnthropicCacheControl(obj) || modified;
     if (ctx.userId) {
       modified = applyAnthropicUserId(obj, ctx.userId) || modified;
@@ -84,6 +96,56 @@ function isPlainObject(v: unknown): v is Record<string, unknown> {
   return typeof v === "object" && v !== null;
 }
 
+/**
+ * Both of the transforms below exist because a client body can reach an
+ * upstream without passing through a translator at all: an Anthropic client
+ * on coding-plan and an OpenAI client on start-plan are each forwarded
+ * verbatim. The translators already rewrite `thinking:{type:"disabled"}` for
+ * GLM-5.3 models; these close the two passthrough gaps so the rewrite holds
+ * on every route rather than only the translated ones.
+ *
+ * Z.AI documents `"disabled"` as unsupported for this family — `thinking.type`
+ * accepts only `"enabled"` — and prescribes enabled + `low` effort instead.
+ * @see https://docs.z.ai/guides/llm/glm-5.3 (Migration Notice)
+ */
+function glm53Model(body: Record<string, unknown>): boolean {
+  return isGlm53Model(typeof body.model === "string" ? body.model : undefined);
+}
+
+function thinkingIsDisabled(body: Record<string, unknown>): boolean {
+  return isPlainObject(body.thinking) && body.thinking.type === "disabled";
+}
+
+/** OpenAI-format passthrough (start-plan): `disabled` -> enabled + reasoning_effort. */
+function applyGlm53OpenAIThinkingCompat(body: Record<string, unknown>): boolean {
+  if (!glm53Model(body) || !thinkingIsDisabled(body)) return false;
+  body.thinking = { type: "enabled" };
+  if (body.reasoning_effort === undefined) {
+    body.reasoning_effort = GLM53_DISABLED_REPLACEMENT_EFFORT;
+  }
+  return true;
+}
+
+/**
+ * Anthropic-format passthrough (coding-plan): `disabled` -> enabled with the
+ * effort's paired budget. The budget is fitted to `max_tokens` so it cannot
+ * consume the whole output allowance; when no usable budget survives, the
+ * bare `{type:"enabled"}` still beats sending an unsupported `"disabled"`.
+ * An `output_config` the client already set is left alone.
+ */
+function applyGlm53AnthropicThinkingCompat(body: Record<string, unknown>): boolean {
+  if (!glm53Model(body) || !thinkingIsDisabled(body)) return false;
+  const legal = buildGlm53Reasoning(GLM53_DISABLED_REPLACEMENT_EFFORT);
+  const budget = fitGlm53Budget(legal.thinking.budget_tokens, body.max_tokens);
+  body.thinking = budget === undefined
+    ? { type: "enabled" }
+    : { type: "enabled", budget_tokens: budget };
+  if (!isPlainObject(body.output_config)) {
+    body.output_config = legal.output_config;
+  }
+  return true;
+}
+
 /**
  * Anthropic: add `cache_control: { type: "ephemeral" }` to the last content
  * block of the last non-system message. Mirrors ZCode's `HLr` algorithm.
 
@@ -46,3 +46,51 @@ describe("translateRequestAnthropicToOpenAI: output_config.effort", () => {
     expect(result.reasoning_effort).toBeUndefined();
   });
 });
+
+
+// This translator feeds the OpenAI-protocol upstream on start-plan — the exact
+// path where Z.AI says a disabled GLM-5.3 request "will fail".
+describe("translateRequestAnthropicToOpenAI — GLM-5.3 disabled thinking", () => {
+  it("rewrites disabled to enabled + reasoning_effort low", () => {
+    const req: AnthropicMessagesRequest = {
+      model: "glm-5.3",
+      messages: [{ role: "user", content: "Hi" }],
+      max_tokens: 100,
+      thinking: { type: "disabled" },
+    };
+
+    const result = translateRequestAnthropicToOpenAI(req);
+
+    expect(result.thinking).toEqual({ type: "enabled" });
+    expect(result.reasoning_effort).toBe("low");
+  });
+
+  it("lets an explicit output_config.effort win over the substitute", () => {
+    const req: AnthropicMessagesRequest = {
+      model: "glm-5.3",
+      messages: [{ role: "user", content: "Hi" }],
+      max_tokens: 100,
+      thinking: { type: "disabled" },
+      output_config: { effort: "high" },
+    };
+
+    const result = translateRequestAnthropicToOpenAI(req);
+
+    expect(result.thinking).toEqual({ type: "enabled" });
+    expect(result.reasoning_effort).toBe("high");
+  });
+
+  it("leaves glm-4.7 disabled thinking untouched", () => {
+    const req: AnthropicMessagesRequest = {
+      model: "glm-4.7",
+      messages: [{ role: "user", content: "Hi" }],
+      max_tokens: 100,
+      thinking: { type: "disabled" },
+    };
+
+    const result = translateRequestAnthropicToOpenAI(req);
+
+    expect(result.thinking).toEqual({ type: "disabled" });
+    expect(result.reasoning_effort).toBeUndefined();
+  });
+});
@@ -15,6 +15,7 @@ import type {
   AnthropicContentBlock,
   AnthropicUsage,
 } from "./types.js";
+import { isGlm53Model, GLM53_DISABLED_REPLACEMENT_EFFORT } from "../provider/reasoning.js";
 
 /** Translate an Anthropic messages request into an OpenAI chat request. */
 export function translateRequestAnthropicToOpenAI(req: AnthropicMessagesRequest): OpenAIChatRequest {
@@ -55,6 +56,16 @@ export function translateRequestAnthropicToOpenAI(req: AnthropicMessagesRequest)
     result.reasoning_effort = req.output_config.effort as OpenAIChatRequest["reasoning_effort"];
   }
 
+  // This translator feeds the OpenAI-protocol upstream, which is precisely
+  // where Z.AI documents `thinking:{type:"disabled"}` on a GLM-5.3 model as
+  // fatal ("otherwise the request will fail") and prescribes enabled + low
+  // effort instead. Rewrite rather than forward. An effort the caller set
+  // explicitly via output_config wins over the substitute.
+  if (isGlm53Model(req.model) && req.thinking?.type === "disabled") {
+    result.thinking = { type: "enabled" };
+    result.reasoning_effort ??= GLM53_DISABLED_REPLACEMENT_EFFORT;
+  }
+
   if (req.tools?.length) {
     result.tools = req.tools.map((t) => ({
       type: "function" as const,
 
@@ -631,9 +631,43 @@ describe("translateRequestOpenAIToAnthropic", () => {
       expect(result.max_tokens).toBe(4096);
     });
 
-    it("glm-5.3: explicit thinking:{type:'disabled'} is forwarded as-is, not overridden to an effort level", () => {
+    // Z.AI documents thinking as impossible to disable for this family, and
+    // prescribes enabled + low effort as the migration ("otherwise the
+    // request will fail"). Never forward "disabled" for a GLM-5.3 model.
+    // https://docs.z.ai/guides/llm/glm-5.3
+    it("glm-5.3: thinking:{type:'disabled'} is rewritten to enabled + low effort, never forwarded", () => {
       const req = {
         model: "glm-5.3",
+        max_tokens: 40_000,
+        messages: [{ role: "user", content: "Hi" }],
+        thinking: { type: "disabled" },
+      } as OpenAIChatRequest;
+
+      const result = translateRequestOpenAIToAnthropic(req);
+
+      expect(result.thinking).toEqual({ type: "enabled", budget_tokens: 8_000 });
+      expect(result.output_config).toEqual({ effort: "low" });
+    });
+
+    it("glm-5.3-flash: thinking:{type:'disabled'} is rewritten the same way", () => {
+      const req = {
+        model: "glm-5.3-flash",
+        max_tokens: 40_000,
+        messages: [{ role: "user", content: "Hi" }],
+        thinking: { type: "disabled" },
+      } as OpenAIChatRequest;
+
+      const result = translateRequestOpenAIToAnthropic(req);
+
+      expect(result.thinking).toEqual({ type: "enabled", budget_tokens: 8_000 });
+      expect(result.output_config).toEqual({ effort: "low" });
+    });
+
+    // The rewrite is scoped to GLM-5.3: glm-4.7 genuinely supports disabling,
+    // and live probing measured zero thinking when it is sent.
+    it("glm-4.7: thinking:{type:'disabled'} is still forwarded untouched", () => {
+      const req = {
+        model: "glm-4.7",
         messages: [{ role: "user", content: "Hi" }],
         thinking: { type: "disabled" },
       } as OpenAIChatRequest;
 
@@ -21,6 +21,7 @@ import {
   normalizeGlm53Effort,
   buildGlm53Reasoning,
   fitGlm53Budget,
+  GLM53_DISABLED_REPLACEMENT_EFFORT,
 } from "../provider/reasoning.js";
 
 /** Default max_tokens if the OpenAI request doesn't specify one. */
@@ -125,23 +126,24 @@ function resolveDefaultMaxTokens(model: string): number {
  * live testing), so routing it through the effort channel is the closer
  * approximation across the whole family.
  *
- * An explicit `req.thinking:{type:"disabled"}` is still forwarded as-is
- * (rather than overridden to an effort level) since it does work for
- * glm-5.3-flash, and is the closest available signal for plain glm-5.3.
- * An explicit `req.thinking` budget is respected over the effort-level
- * default budget, but `output_config.effort` is still attached — without it
- * the upstream runs at its own near-zero default regardless of budget.
+ * An explicit `req.thinking:{type:"disabled"}` is rewritten to the effort
+ * level named by `GLM53_DISABLED_REPLACEMENT_EFFORT` rather than forwarded:
+ * Z.AI documents `"disabled"` as unsupported for this family and prescribes
+ * exactly that migration. An explicit `req.thinking` budget is respected over
+ * the effort-level default budget, but `output_config.effort` is still
+ * attached — without it the upstream runs at its own near-zero default
+ * regardless of budget.
  */
 function translateGlm53Reasoning(
   req: OpenAIChatRequest,
   maxTokens: number,
 ): { thinking: AnthropicThinkingConfig; output_config?: AnthropicOutputConfig } {
   const explicit = req.thinking;
-  if (explicit && typeof explicit === "object" && explicit.type === "disabled") {
-    return { thinking: { type: "disabled" } };
-  }
+  const disabled = explicit !== undefined && typeof explicit === "object" && explicit.type === "disabled";
 
-  const effort = normalizeGlm53Effort(req.reasoning_effort);
+  const effort = disabled
+    ? GLM53_DISABLED_REPLACEMENT_EFFORT
+    : normalizeGlm53Effort(req.reasoning_effort);
   const base = buildGlm53Reasoning(effort);
 
   let budget: number = base.thinking.budget_tokens;