@bubblebrain-ai/bubble 0.0.49 → 0.0.50

package/dist/agent.js

@@ -2,10 +2,10 @@
  * Agent - The core decision loop.
  * It maintains message state, calls the LLM, executes tools, and auto-continues.
  */
-import { compactCurrentTurnToolGroups, compactMessages, isRealUserMessage } from "./context/compact.js";
+import { compactCurrentTurnToolGroups, compactMessages } from "./context/compact.js";
 import { randomUUID } from "node:crypto";
 import { compactMessagesWithLLM } from "./context/compact-llm.js";
-import { estimateContextTokens, getContextBudget } from "./context/budget.js";
+import { getContextBudget } from "./context/budget.js";
 import { buildContextUsageSnapshot } from "./context/usage.js";
 import { isContextOverflowError } from "./context/overflow.js";
 import { computeRetryDelayMs, isProviderStreamInterruption, MAX_STREAM_INTERRUPTION_RETRIES, sleepBeforeRetry, } from "./network/retry.js";
@@ -21,7 +21,12 @@ import { DEFAULT_AGENT_ROUTING, sanitizeAgentRouting } from "./agent/routing-cat
 import { SubagentRouter } from "./agent/subagent/router.js";
 import { normalizeWaitTimeout, SubagentRuntime } from "./agent/subagent/runtime.js";
 import { WorkflowLedger } from "./agent/workflow/runs.js";
-import { AgentAbortError, EMPTY_ASSISTANT_FALLBACK } from "./agent/abort-errors.js";
+import { EMPTY_ASSISTANT_FALLBACK, throwIfAborted, isAbortLikeError, isAbortError } from "./agent/abort-errors.js";
+import { appendProviderContentBlock, buildProviderRequestFingerprint } from "./agent/provider-fingerprint.js";
+import { countUserTurns, estimateResidentChars, estimateToolPayloadChars, getCurrentHeapUsed, RESIDENT_HISTORY_HEAP_HARD_LIMIT, RESIDENT_HISTORY_KEEP_RECENT_TURNS } from "./agent/resident-history.js";
+import { cancelledToolResult, createModelInterruptedMessage, findMissingRequiredArgs, isSubagentLifecycleTool, lastProviderMessage, shouldAppendModelInterruptedBoundary } from "./agent/transcript-helpers.js";
+import { createUpdateQueue } from "./agent/update-queue.js";
+export { createUpdateQueue } from "./agent/update-queue.js";
 import { isHiddenToolResult } from "./agent/tool-visibility.js";
 import { createStreamingInternalReminderSanitizer, sanitizeAssistantProviderMetadata, sanitizeInternalReasoningText, sanitizeInternalReminderBlocks, } from "./agent/internal-reminder-sanitizer.js";
 import { debugReasoningStream, summarizeDebugText } from "./reasoning-debug.js";
@@ -29,8 +34,6 @@ import { buildToolPromptOptions } from "./tools/prompt-metadata.js";
 import { stopAutoServersForSession } from "./tools/server-manager.js";
 import { summarizeAgentEventForTrace, summarizeTraceError, summarizeTraceMessage, summarizeTraceToolResult, summarizeTraceValue, traceEvent, } from "./debug-trace.js";
 const MAX_CONSECUTIVE_OVERFLOW_RECOVERIES = 3;
-const RESIDENT_HISTORY_KEEP_RECENT_TURNS = 3;
-const RESIDENT_HISTORY_HEAP_HARD_LIMIT = 768 * 1024 * 1024;
 const MAX_EMPTY_ASSISTANT_RECOVERIES = 1;
 const EMPTY_ASSISTANT_RECOVERY_REMINDER = "The previous model response contained no user-visible assistant content and no tool calls. " +
     "Respond now with a concise, user-visible answer, or call an available tool if more work is required. " +
@@ -74,7 +77,23 @@ function agentEventFromHookProgress(event) {
     };
 }
 export class Agent {
-    messages = [];
+    /**
+     * Backing store for the public `messages` accessor. All whole-array
+     * rewrites (clear/compact/rewind/session switch/subagent fork) go through
+     * the setter, which notifies `onContextChanged` subscribers — that push
+     * channel is what keeps derived UI (e.g. the footer usage readout) in sync
+     * without per-path refresh calls that are easy to forget.
+     */
+    _messages = [];
+    contextChangedListeners = new Set();
+    notifyingContextChange = false;
+    get messages() {
+        return this._messages;
+    }
+    set messages(value) {
+        this._messages = value;
+        this.notifyContextChanged();
+    }
     provider;
     sessionID;
     /**
@@ -216,7 +235,7 @@ export class Agent {
             persistDir,
         });
         if (options.systemPrompt) {
-            this.messages.push({ role: "system", content: options.systemPrompt });
+            this._messages.push({ role: "system", content: options.systemPrompt });
         }
         for (const tool of options.tools) {
             this.tools.set(tool.name, tool);
@@ -362,6 +381,46 @@ export class Agent {
     renderModelRoutingPromptFor(parent) {
         return this.router.promptSectionFor(parent);
     }
+    /**
+     * Push subscription for derived-context consumers (TUI footer, hosts).
+     * Fires whenever resident context mutates in a way that changes a
+     * `getContextUsageSnapshot()` reading: whole-array message rewrites,
+     * appended messages, system-prompt replacement, or model/provider switches
+     * (window size / estimation basis). Returns an unsubscribe function.
+     */
+    onContextChanged(listener) {
+        this.contextChangedListeners.add(listener);
+        return () => {
+            this.contextChangedListeners.delete(listener);
+        };
+    }
+    notifyContextChanged() {
+        if (this.notifyingContextChange)
+            return;
+        this.notifyingContextChange = true;
+        try {
+            for (const listener of [...this.contextChangedListeners]) {
+                try {
+                    listener();
+                }
+                catch (error) {
+                    // A broken subscriber must never corrupt agent state mid-mutation,
+                    // but leave a trace — otherwise a throwing consumer (e.g. the footer
+                    // readout hitting a pathological message) fails silently forever.
+                    traceEvent("context_listener_error", {
+                        error: error instanceof Error ? error.message : String(error),
+                    }, {
+                        sessionFile: this.sessionID,
+                        provider: this._providerId || "none",
+                        model: this.apiModel || "none",
+                    });
+                }
+            }
+        }
+        finally {
+            this.notifyingContextChange = false;
+        }
+    }
     getContextUsageSnapshot() {
         return buildContextUsageSnapshot({
             providerId: this.providerId,
@@ -434,13 +493,21 @@ export class Agent {
         return this._model;
     }
     set model(value) {
+        if (this._model === value)
+            return;
         this._model = value;
+        // Context window (and thus usage readings) is model-derived.
+        this.notifyContextChanged();
     }
     get providerId() {
         return this._providerId;
     }
     set providerId(value) {
+        if (this._providerId === value)
+            return;
         this._providerId = value;
+        // Token estimation basis is provider-specific.
+        this.notifyContextChanged();
     }
     get apiModel() {
         if (this._model.includes(":")) {
@@ -504,10 +571,14 @@ export class Agent {
     setSystemPrompt(prompt) {
         const systemMessage = { role: "system", content: prompt };
         if (this.messages[0]?.role === "system") {
+            if (this.messages[0].content === prompt)
+                return;
             this.messages[0] = systemMessage;
+            this.notifyContextChanged();
             return;
         }
         this.messages.unshift(systemMessage);
+        this.notifyContextChanged();
     }
     async *run(userInput, cwd, options = {}) {
         const abortSignal = options.abortSignal;
@@ -1836,6 +1907,7 @@ export class Agent {
             model: this.apiModel || "none",
         });
         this.onMessageAppend?.(message);
+        this.notifyContextChanged();
     }
     appendInterruptedAssistantBoundary(currentAssistant, currentAssistantAppended) {
         const last = lastProviderMessage(this.messages);
@@ -1946,293 +2018,3 @@ export class Agent {
         }
     }
 }
-function findMissingRequiredArgs(schema, args) {
-    const required = schema?.required;
-    if (!required || required.length === 0)
-        return [];
-    const missing = [];
-    for (const name of required) {
-        const value = args ? args[name] : undefined;
-        // Empty strings/arrays are intentionally allowed — writing an empty file
-        // or passing an empty list can be legitimate. Only undefined/null counts
-        // as "missing", because the observed failure mode is `finalArgs: "{}"`
-        // where the field is entirely absent.
-        if (value === undefined || value === null) {
-            missing.push(name);
-        }
-    }
-    return missing;
-}
-function estimateResidentChars(messages) {
-    let total = 0;
-    for (const message of messages) {
-        switch (message.role) {
-            case "system":
-            case "meta":
-                total += message.content.length;
-                break;
-            case "tool":
-                total += message.content.length + message.toolCallId.length;
-                break;
-            case "assistant":
-                total += message.content.length + (message.reasoning?.length ?? 0);
-                total += message.toolCalls?.reduce((sum, toolCall) => sum + toolCall.id.length + toolCall.name.length + toolCall.arguments.length, 0) ?? 0;
-                break;
-            case "user":
-                if (typeof message.content === "string") {
-                    total += message.content.length;
-                }
-                else {
-                    total += message.content.reduce((sum, part) => {
-                        if (part.type === "text") {
-                            return sum + part.text.length;
-                        }
-                        return sum + part.image_url.url.length;
-                    }, 0);
-                }
-                break;
-        }
-    }
-    return total;
-}
-function appendProviderContentBlock(message, provider, block) {
-    const current = message.providerMetadata?.[provider]?.contentBlocks ?? [];
-    message.providerMetadata = {
-        ...message.providerMetadata,
-        [provider]: {
-            ...message.providerMetadata?.[provider],
-            contentBlocks: [...current, cloneProviderRawContentBlock(block)],
-        },
-    };
-}
-function buildProviderRequestFingerprint(messages, tools, providerId, toolChoice) {
-    const roleCounts = {};
-    let contentChars = 0;
-    let reasoningChars = 0;
-    let toolResultChars = 0;
-    let maxToolResultChars = 0;
-    let assistantToolCalls = 0;
-    let rawAnthropicBlocks = 0;
-    let rawAnthropicThinkingBlocks = 0;
-    let rawAnthropicSignatureChars = 0;
-    for (const message of messages) {
-        roleCounts[message.role] = (roleCounts[message.role] ?? 0) + 1;
-        if (message.role === "assistant") {
-            contentChars += message.content.length;
-            reasoningChars += message.reasoning?.length ?? 0;
-            assistantToolCalls += message.toolCalls?.length ?? 0;
-            const blocks = message.providerMetadata?.anthropic?.contentBlocks ?? [];
-            rawAnthropicBlocks += blocks.length;
-            for (const block of blocks) {
-                if (block.type === "thinking" || block.type === "redacted_thinking") {
-                    rawAnthropicThinkingBlocks += 1;
-                }
-                if (typeof block.signature === "string") {
-                    rawAnthropicSignatureChars += block.signature.length;
-                }
-            }
-        }
-        else if (message.role === "tool") {
-            toolResultChars += message.content.length;
-            maxToolResultChars = Math.max(maxToolResultChars, message.content.length);
-        }
-        else if (message.role === "user") {
-            contentChars += typeof message.content === "string"
-                ? message.content.length
-                : message.content.reduce((sum, part) => sum + (part.type === "text" ? part.text.length : part.image_url.url.length), 0);
-        }
-        else {
-            contentChars += message.content.length;
-        }
-    }
-    const systemMessages = messages.filter((message) => message.role === "system");
-    const bodyMessages = messages.filter((message) => message.role !== "system");
-    const systemJsonBytes = Buffer.byteLength(JSON.stringify(systemMessages), "utf8");
-    const bodyJsonBytes = Buffer.byteLength(JSON.stringify(bodyMessages), "utf8");
-    const toolSchemaJsonBytes = Buffer.byteLength(JSON.stringify(tools), "utf8");
-    return {
-        roleCounts,
-        estimatedTokens: estimateContextTokens(messages, providerId),
-        projectedJsonBytes: Buffer.byteLength(JSON.stringify(messages), "utf8"),
-        systemJsonBytes,
-        bodyJsonBytes,
-        toolSchemaJsonBytes,
-        staticPrefixJsonBytes: Buffer.byteLength(JSON.stringify({
-            system: systemMessages,
-            tools,
-            tool_choice: toolChoice,
-        }), "utf8"),
-        toolChoice,
-        contentChars,
-        reasoningChars,
-        toolResultChars,
-        maxToolResultChars,
-        assistantToolCalls,
-        rawAnthropicBlocks,
-        rawAnthropicThinkingBlocks,
-        rawAnthropicSignatureChars,
-    };
-}
-function cloneProviderRawContentBlock(block) {
-    return JSON.parse(JSON.stringify(block));
-}
-function throwIfAborted(signal) {
-    if (!signal?.aborted)
-        return;
-    const reason = signal.reason;
-    if (reason instanceof Error)
-        throw reason;
-    throw new AgentAbortError(typeof reason === "string" ? reason : undefined);
-}
-function isAbortLikeError(error, signal) {
-    if (signal?.aborted)
-        return true;
-    if (error instanceof AgentAbortError)
-        return true;
-    if (error instanceof DOMException && error.name === "AbortError")
-        return true;
-    if (typeof error === "object" && error !== null && error.name === "AbortError")
-        return true;
-    return false;
-}
-function isAbortError(error, signal) {
-    return isAbortLikeError(error, signal);
-}
-function shouldAppendModelInterruptedBoundary(messages) {
-    return messages.at(-1)?.role === "tool";
-}
-function createModelInterruptedMessage(error, metadata) {
-    return {
-        role: "assistant",
-        content: `[model request interrupted before a final answer was produced: ${summarizeInterruptError(error)}]`,
-        model: metadata.model,
-        providerId: metadata.providerId,
-        modelId: metadata.modelId,
-    };
-}
-function summarizeInterruptError(error) {
-    const message = error instanceof Error
-        ? error.message
-        : typeof error === "string"
-            ? error
-            : String(error);
-    return message.replace(/\s+/g, " ").trim().slice(0, 240) || "unknown error";
-}
-function lastProviderMessage(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        if (message.role === "system" || message.role === "meta")
-            continue;
-        return message;
-    }
-    return undefined;
-}
-function cancelledToolResult(toolName) {
-    return {
-        content: `Tool "${toolName}" was cancelled.`,
-        isError: true,
-        status: "cancelled",
-        metadata: { reason: "cancelled" },
-    };
-}
-/** Exported for tests: the wake latch below is easiest to pin directly. */
-export function createUpdateQueue() {
-    const items = [];
-    let waiter;
-    let abortCleanup;
-    // Latch for wakes that arrive with no parked waiter — a wake() fired while
-    // the consuming generator is suspended at a yield would otherwise be lost.
-    // Callers today each pair their wake with a synchronously-checked flag
-    // (items / settled / pendingSubagentUpdates), so no wake is currently
-    // dropped; the latch keeps that correctness inside the queue instead of
-    // depending on every future caller repeating the pairing.
-    let signaled = false;
-    return {
-        push(item) {
-            items.push(item);
-            this.wake();
-        },
-        drain() {
-            return items.splice(0, items.length);
-        },
-        hasItems() {
-            return items.length > 0;
-        },
-        wait(signal) {
-            if (items.length > 0)
-                return Promise.resolve("woken");
-            if (signaled) {
-                signaled = false;
-                return Promise.resolve("woken");
-            }
-            if (signal?.aborted)
-                return Promise.resolve("aborted");
-            return new Promise((resolve) => {
-                abortCleanup?.();
-                abortCleanup = undefined;
-                const finish = (status) => {
-                    if (waiter !== resolve)
-                        return;
-                    waiter = undefined;
-                    abortCleanup?.();
-                    abortCleanup = undefined;
-                    resolve(status);
-                };
-                if (signal) {
-                    const onAbort = () => finish("aborted");
-                    signal.addEventListener("abort", onAbort, { once: true });
-                    abortCleanup = () => signal.removeEventListener("abort", onAbort);
-                }
-                waiter = resolve;
-            });
-        },
-        wake() {
-            const resolve = waiter;
-            if (!resolve) {
-                signaled = true;
-                return;
-            }
-            waiter = undefined;
-            abortCleanup?.();
-            abortCleanup = undefined;
-            resolve("woken");
-        },
-    };
-}
-function estimateToolPayloadChars(messages) {
-    return messages.reduce((sum, message) => {
-        if (message.role !== "tool") {
-            return sum;
-        }
-        return sum + message.content.length;
-    }, 0);
-}
-function countUserTurns(messages) {
-    // Real user turns only: projected reminders and summary envelopes are
-    // user-ROLE but not user TURNS — counting them used to shrink the keep
-    // window and fire compaction almost every turn.
-    return messages.reduce((count, message) => count + (isRealUserMessage(message) ? 1 : 0), 0);
-}
-function getCurrentHeapUsed() {
-    try {
-        return process.memoryUsage().heapUsed;
-    }
-    catch {
-        return 0;
-    }
-}
-function isSubagentLifecycleTool(name) {
-    return name === "subagent"
-        || name === "spawn_agent"
-        || name === "wait_agent"
-        || name === "send_input"
-        || name === "close_agent"
-        || name === "list_agents"
-        || name === "run_workflow"
-        || name === "wait_workflow"
-        // Legacy names: still present in transcripts recorded before the tools
-        // were removed (2026-07-06); forked children must not inherit their
-        // dangling tool_calls either.
-        || name === "agent_team"
-        || name === "agent_batch";
-}

package/dist/external-runtime/grok-runtime.js

@@ -530,7 +530,7 @@ export class GrokRuntimeManager {
         try {
             if (!this.lock)
                 temporaryLock = await this.acquireProfileLock();
-            const { profile, env, binary } = await this.prepareAndVerify();
+            const { env, binary } = await this.prepareAndVerify();
             const result = await runGrokCommand(this.spawn, binary.path, ["--no-auto-update", "--cwd", this.workspace, "models"], { cwd: this.workspace, env, maxStdoutBytes: 64 * 1024 });
             if (result.code !== 0) {
                 throw new GrokRuntimeError("protocol_error", "Grok could not list subscription models.", result.stderr);

package/dist/feishu/agent-host/run-driver.js

@@ -301,7 +301,7 @@ export class RunDriver {
             this.opts.approvalUI.cancelForChat(req.chatId, "Run ended");
         }
     }
-    async resolveProvider(session, promptCacheKey) {
+    async resolveProvider(_session, promptCacheKey) {
         const registry = this.opts.deps.providerRegistry;
         const userConfig = this.opts.deps.userConfig;
         // Read session metadata for an explicit model preference, fall back to

package/dist/lsp/service.js

@@ -436,7 +436,7 @@ const TypeScriptServer = {
     extensions: TS_EXTENSIONS,
     root: nearestRoot(NODE_ROOT_MARKERS, DENO_ROOT_MARKERS),
     languageId: languageIdFor,
-    async spawn(root, ctx) {
+    async spawn(root, _ctx) {
         const requireFromRoot = createRequire(join(root, "package.json"));
         const requireFromSelf = createRequire(import.meta.url);
         const tsserverPath = resolveModule(requireFromRoot, "typescript/lib/tsserver.js")
@@ -495,7 +495,7 @@ const ESLintServer = {
     extensions: [...TS_EXTENSIONS, ".vue"],
     root: eslintRoot,
     languageId: languageIdFor,
-    async spawn(root, ctx) {
+    async spawn(root, _ctx) {
         const requireFromRoot = createRequire(join(root, "package.json"));
         const requireFromSelf = createRequire(import.meta.url);
         const eslint = resolveModule(requireFromRoot, "eslint");

package/dist/model-catalog.js

@@ -41,13 +41,12 @@ const OPENAI_CHAT_LEVELS = ["off"];
 // Internal representation for APIs that expose thinking as enabled/disabled.
 // UI code must render supported toggle models as on/off, not as "medium" effort.
 const TOGGLE_THINKING_LEVELS = ["off", "medium"];
-// GLM-5.2 is the first GLM to accept OpenAI-style `reasoning_effort`. The API
-// enum is none/minimal/low/medium/high/xhigh/max; we expose high and max (the
-// two effort tiers worth offering a coding agent) plus "off", which disables
-// thinking outright via `thinking: {type: "disabled"}`. Order matters: "high"
-// is first so it is the default (getDefaultThinkingLevel falls back to levels[0]
-// when "medium" is absent), since GLM-5.2 is a thinking-on-by-default model.
+// GLM-5.2 accepts OpenAI-style `reasoning_effort`. We expose high and max plus
+// "off", which disables thinking outright via `thinking: {type: "disabled"}`.
 const GLM_5_2_LEVELS = ["high", "max", "off"];
+// GLM-5.3 Coding Plan normalizes efforts into exactly three real tiers. Its
+// default is max, and disabling thinking maps to low rather than turning it off.
+const GLM_5_3_LEVELS = ["low", "high", "max"];
 // Kimi K2.7 Code variants only support thinking mode (disabling it errors), so
 // "off" is not offered — the model is always in its thinking variant.
 const KIMI_THINKING_ONLY_LEVELS = ["medium"];
@@ -124,6 +123,9 @@ export const BUILTIN_MODELS = [
     { id: "glm-5.1", name: "GLM-5.1", providerId: "zhipuai", tier: "balanced", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
     { id: "glm-4.6", name: "GLM-4.6", providerId: "zhipuai", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },
+    // Coding Plan exposes GLM-5.3 before GET /models lists it (verified live
+    // 2026-08-14). The standard API is still marked "coming soon" in the docs.
+    { id: "glm-5.3", name: "GLM-5.3", providerId: "zhipuai-coding-plan", tier: "strong", reasoningLevels: GLM_5_3_LEVELS, defaultReasoningLevel: "max", contextWindow: 1000000 },
     { id: "glm-5.2", name: "GLM-5.2", providerId: "zhipuai-coding-plan", tier: "strong", reasoningLevels: GLM_5_2_LEVELS, contextWindow: 1000000 },
     { id: "glm-5.1", name: "GLM-5.1", providerId: "zhipuai-coding-plan", tier: "balanced", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 200000 },
     { id: "glm-4.7", name: "GLM-4.7", providerId: "zhipuai-coding-plan", reasoningLevels: TOGGLE_THINKING_LEVELS, contextWindow: 204800 },

package/dist/permissions/settings.d.ts

@@ -43,7 +43,6 @@ export interface SettingsManagerOptions {
     bubbleHome?: string;
 }
 export declare class SettingsManager {
-    private readonly cwd;
     private readonly paths;
     private raw;
     private fileDiagnostics;

package/dist/permissions/settings.js

@@ -25,7 +25,6 @@ const KNOWN_MODES = new Set([
     "bypassPermissions",
 ]);
 export class SettingsManager {
-    cwd;
     paths;
     raw = {
         user: null,
@@ -34,7 +33,6 @@ export class SettingsManager {
     };
     fileDiagnostics = [];
     constructor(cwd, options = {}) {
-        this.cwd = cwd;
         const bubbleHome = options.bubbleHome ?? getBubbleHome();
         this.paths = {
             user: join(bubbleHome, "settings.json"),

package/dist/provider-registry.js

@@ -458,7 +458,19 @@ export class ProviderRegistry {
         if (!options.forceRefresh) {
             const cached = this.modelDiscoveryCache.get(key);
             if (cached && cached.expiresAt > now) {
-                const result = { ...cached.result, source: "cache" };
+                // A disk cache can outlive the application version that wrote it. Keep
+                // the current curated catalog authoritative over stale cached metadata,
+                // then retain cached remote-only ids for non-authoritative union results.
+                // This lets newly-added builtins surface immediately after an upgrade
+                // without waiting up to 24 hours or requiring a manual Ctrl+R refresh.
+                const local = this.localModelsForProvider(provider);
+                const localIds = new Set(local.map((model) => model.id));
+                const models = cached.result.source === "static"
+                    ? local
+                    : cached.result.authoritative
+                        ? cached.result.models
+                        : [...local, ...cached.result.models.filter((model) => !localIds.has(model.id))];
+                const result = { ...cached.result, models, source: "cache" };
                 const current = this.getConfigured().find((item) => item.id === provider.id);
                 if (!current || this.modelDiscoveryKey(current) === key) {
                     this.applyDynamicDiscoveryMetadata(provider, result);

package/dist/provider-transform.js

@@ -114,16 +114,15 @@ export function resolveProviderRequestConfig(providerId, modelId, requestedLevel
     // Zhipu/Z.AI OpenAI-compatible endpoints expose reasoning via a provider-specific
     // `thinking` block rather than OpenAI's `reasoning_effort` shape.
     if (["zhipuai", "zhipuai-coding-plan", "zai", "zai-coding-plan"].includes(providerId)) {
-        // GLM-5.2 is the only GLM that also accepts `reasoning_effort` (we expose
-        // high/max, which map 1:1 onto the API enum). "off" disables thinking via
-        // `thinking: {type: "disabled"}` — otherwise the server default (thinking
-        // on, effort max) would make "off" a no-op. The effort field rides inside
-        // the body alongside `thinking`, so it goes in extraBody, not the
-        // OpenRouter-style `reasoningEffort` config field.
-        if (modelId === "glm-5.2") {
+        // GLM-5.2+ also accept `reasoning_effort`. GLM-5.2 can disable thinking;
+        // GLM-5.3 requires thinking and Coding Plan normalizes its effort into
+        // low/high/max. The catalog clamps 5.3 choices before this serialization
+        // boundary. The effort field rides inside the body alongside `thinking`,
+        // so it goes in extraBody, not the OpenRouter-style config field.
+        if (modelId === "glm-5.2" || modelId === "glm-5.3") {
             return {
                 effectiveThinkingLevel,
-                extraBody: effectiveThinkingLevel === "off"
+                extraBody: modelId === "glm-5.2" && effectiveThinkingLevel === "off"
                     ? { thinking: { type: "disabled" } }
                     : {
                         thinking: { type: "enabled", clear_thinking: false },