@gajae-code/ai 0.7.0 → 0.7.2

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.7.2] - 2026-06-24
+
+### Fixed
+
+- Reject truncated or incomplete streamed tool calls instead of executing them with partial arguments, so a cut-off tool-call payload fails fast rather than running against a mismatched schema.
+
+## [0.7.1] - 2026-06-23
+
+### Changed
+
+- Reworked the unofficial, opt-in `glm-zcode` provider to mirror how the ZCode desktop app actually reaches GLM: after the ZCode OAuth handshake it now auto-provisions a real Z.AI API key and calls `api.z.ai/api/anthropic` directly, instead of the `zcode.z.ai` coding-plan gateway that required an Aliyun captcha and a ZCode-JWT-bound plan entitlement. Requests also carry ZCode client source headers (`User-Agent: ZCode/<ver>`, `X-ZCode-Agent: glm`, plus platform/locale/timezone), so Z.AI recognizes the caller as the ZCode client (#1013, #1016, #1017).
+
 ## [0.7.0] - 2026-06-22
 
 ### Added

package/dist/types/providers/anthropic.d.ts

@@ -9,9 +9,24 @@ export type AnthropicHeaderOptions = {
     stream?: boolean;
     modelHeaders?: Record<string, string>;
     isCloudflareAiGateway?: boolean;
+    /**
+     * Attach ZCode client "source" headers (User-Agent: ZCode/<ver>, X-Title,
+     * X-ZCode-Agent: glm, X-Platform, etc.) so api.z.ai recognizes the caller as
+     * the ZCode client, exactly like ZCode's `buildZCodeSourceHeaders` does for
+     * GLM providers. glm-zcode only.
+     */
+    zcodeSourceHeaders?: boolean;
 };
 export declare function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined;
 export declare function buildBetaHeader(baseBetas: string[], extraBetas: string[]): string;
+/**
+ * Replicates ZCode's `buildZCodeSourceHeaders()` + GLM `X-ZCode-Agent` tag
+ * (host bundle `Bl` / `buildConnectivitySourceHeaders` for GLM providers), so
+ * api.z.ai sees gjc's glm-zcode requests as the ZCode client. Dynamic values
+ * (platform/arch, locale, timezone, OS version) are resolved at runtime exactly
+ * as ZCode does; printable-ASCII-only and conditionally omitted when empty.
+ */
+export declare function buildZCodeSourceHeaders(): Record<string, string>;
 export declare function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<string, string>;
 type AnthropicCacheControl = {
     type: "ephemeral";

package/dist/types/providers/mock.d.ts

@@ -60,6 +60,8 @@ export type MockContent = string | {
     name: string;
     /** Object form is preferred; strings are passed through verbatim. */
     arguments: Record<string, unknown> | string;
+    /** Simulate a provider-flagged truncated call (cut off mid-arguments). */
+    incompleteArguments?: boolean;
 };
 /** One scripted response. */
 export interface MockResponse {

package/dist/types/providers/openai-responses-shared.d.ts

@@ -1,6 +1,6 @@
 import type OpenAI from "openai";
 import type { ResponseInput, ResponseInputContent, ResponseOutputItem } from "openai/resources/responses/responses";
-import { type Api, type AssistantMessage, type ImageContent, type Model, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ToolResultMessage } from "../types";
+import { type Api, type AssistantMessage, type ImageContent, type Model, type ServiceTier, type StopReason, type StreamOptions, type TextContent, type TextSignatureV1, type ToolCall, type ToolResultMessage } from "../types";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
 export declare function encodeTextSignatureV1(id: string, phase?: TextSignatureV1["phase"]): string;
 export declare function parseTextSignature(signature: string | undefined): {
@@ -44,6 +44,21 @@ export interface ProcessResponsesStreamOptions {
     onOutputItemDone?: (item: ResponseOutputItem) => void;
 }
 export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<void>;
+/**
+ * Mark tool-call blocks left incomplete by a length-truncated response so the
+ * agent loop rejects them instead of executing a best-effort partial parse.
+ *
+ * The universal signal is finalization: a call that never received its terminal
+ * `output_item.done` (passed in via `isFinalized`) was cut off mid-arguments.
+ * This covers both JSON function calls and raw-input custom tools without
+ * mis-flagging a *completed* custom tool whose raw input is not valid JSON. As a
+ * defensive secondary, a finalized JSON function call whose buffered arguments
+ * still don't parse (e.g. a misbehaving relay) is flagged too. No-op unless the
+ * turn stopped for length.
+ *
+ * Shared by both Responses providers (`openai-responses`, `openai-codex-responses`).
+ */
+export declare function flagTruncatedToolCalls(output: AssistantMessage, stopReason: StopReason, isFinalized: (block: ToolCall) => boolean): void;
 export declare function mapOpenAIResponsesStopReason(status: OpenAI.Responses.ResponseStatus | undefined): StopReason;
 /** Initial empty `AssistantMessage` that streaming providers accumulate into. */
 export declare function createInitialResponsesAssistantMessage(api: Api, provider: string, modelId: string): AssistantMessage;

package/dist/types/types.d.ts

@@ -338,6 +338,14 @@ export interface ToolCall {
      * JSON function tools.
      */
     customWireName?: string;
+    /**
+     * Set when the provider detected the argument JSON was truncated — the model
+     * hit its output-token limit (or the response was otherwise cut short) before
+     * emitting a complete arguments object. The `arguments` field then holds a
+     * best-effort partial parse and must not be executed as-is; the agent loop
+     * rejects the call with a retryable error instead.
+     */
+    incompleteArguments?: boolean;
 }
 export interface Usage {
     /** Non-cached input tokens (matches the bucket the provider bills as new input). */

package/dist/types/utils/json-parse.d.ts

@@ -8,3 +8,11 @@ export declare function parseJsonWithRepair<T>(json: string): T;
  * @returns Parsed object or empty object if parsing fails
  */
 export declare function parseStreamingJson<T = Record<string, unknown>>(partialJson: string | undefined): T;
+/**
+ * Whether a string is a complete, well-formed JSON document (strict parse, no
+ * repair). Used to distinguish a tool-call argument blob that finished cleanly
+ * from one that was cut off mid-stream (truncation). An empty / whitespace-only
+ * string is treated as complete: a tool invoked with no arguments legitimately
+ * streams an empty buffer and must not be flagged as truncated.
+ */
+export declare function isCompleteJson(text: string | undefined): boolean;

package/dist/types/utils/oauth/glm-zcode.d.ts

@@ -1,35 +1,32 @@
 /**
  * GLM ZCode OAuth flow (UNOFFICIAL, opt-in).
  *
- * Replicates the reverse-engineered ZCode desktop-app login to Z.AI/GLM. This
- * is NOT an official Z.AI OAuth client: it reuses ZCode's authorize page,
- * broker, and a custom-protocol redirect. It may break at any time and may
- * violate ZCode/Z.AI Terms of Service. Endpoints and the client id are
- * overridable via `ZCODE_OAUTH_*` environment variables.
+ * Replicates how the ZCode desktop app turns a Z.AI login into usable GLM model
+ * access. This is NOT an official Z.AI OAuth client: it reuses ZCode's authorize
+ * page, broker, and a custom-protocol redirect. It may break at any time and may
+ * violate ZCode/Z.AI Terms of Service. Endpoints/client id are overridable via
+ * `ZCODE_OAUTH_*` environment variables.
  *
- * Login flow:
- *   1. Authorize:  GET  {authorize}?redirect_uri=zcode://oauth/callback&response_type=code&client_id=...&state=...
- *                  (custom-protocol redirect → a CLI cannot catch it, so the user pastes the code/redirect URL)
- *   2. Broker:     POST {broker}  { provider: "zai", code, redirect_uri, state }
- *                       → { code: 0, data: { token: <ZCode JWT>, zai: { access_token: <upstream Z.AI token> }, expires_in } }
+ * Verified end-to-end against the ZCode host bundle (`resolveZaiApiKey` /
+ * `resolveBizApiKey`) and live traffic:
+ *   1. Authorize: GET {authorize}?redirect_uri=zcode://oauth/callback&response_type=code&client_id=...&state=...
+ *      (custom-protocol redirect → a CLI cannot catch it, so the user pastes the code/redirect URL)
+ *   2. Broker:    POST {broker} { provider:"zai", code, redirect_uri, state }
+ *                  → { data: { token: <ZCode JWT>, zai: { access_token: <upstream Z.AI token> } } }
+ *   3. Business:  POST {z/login} { token: <upstream Z.AI token> } → { data: { access_token: <business token> } }
+ *   4. Provision: with the business token, GET getCustomerInfo → default org/project,
+ *      GET/POST .../api_keys (find/create a key named "zcode-api-key"),
+ *      GET .../api_keys/copy/{id} → secretKey ⇒ a real Z.AI API key "{id}.{secret}".
  *
- * Credential mapping (verified against the ZCode host bundle):
- *   - `access`  = the **ZCode JWT** (`data.token`). This is the GLM coding-plan
- *                 model credential: ZCode stores it under the `zcodejwttoken`
- *                 key and sends it as `Authorization: Bearer` to the coding-plan
- *                 gateway `${ZCODE_PLAN_ANTHROPIC_BASE_URL}` (default
- *                 https://zcode.z.ai/api/v1/zcode-plan/anthropic), which
- *                 validates the ZCode session and injects the upstream GLM key
- *                 server-side. Model traffic does NOT go to api.z.ai directly.
- *   - `refresh` = the upstream Z.AI OAuth access token (`data.zai.access_token`),
- *                 kept for identity/userinfo only. ZCode's separate z/login
- *                 "business token" is used by ZCode for billing/userinfo, NOT
- *                 model calls, so it is intentionally never minted here.
+ * Credential mapping:
+ *   - `access`  = the provisioned **Z.AI API key** ("{id}.{secret}"). Model requests go to
+ *                 `https://api.z.ai/api/anthropic/v1/messages` with `Authorization: Bearer <key>`
+ *                 (exactly like a dashboard key) — NO zcode.z.ai gateway, NO captcha.
+ *   - `refresh` = the upstream Z.AI OAuth access token (used to re-provision the key).
+ * The API key is long-lived, so `expires` is set far in the future.
  *
- * The ZCode JWT reaches the Anthropic-messages request as a plain bearer
- * automatically (the gateway base is not api.anthropic.com). This provider must
- * NEVER force `isOAuth=true`, which would route GLM into the Claude-Code OAuth
- * header branch (claude-cli UA, `claude_` tool prefixes, Claude system prompt).
+ * This provider must NEVER force `isOAuth=true`: the key is a plain Z.AI API key, and
+ * api.z.ai is not api.anthropic.com, so the Anthropic path already emits a plain bearer.
  */
 import { OAuthCallbackFlow } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";
@@ -39,19 +36,14 @@ export declare const GLM_ZCODE_OAUTH_AUTHORIZE_URL = "https://chat.z.ai/api/oaut
 export declare const GLM_ZCODE_OAUTH_CLIENT_ID = "client_P8X5CMWmlaRO9gyO-KSqtg";
 export declare const GLM_ZCODE_OAUTH_REDIRECT_URI = "zcode://oauth/callback";
 export declare const GLM_ZCODE_OAUTH_BROKER_TOKEN_URL = "https://zcode.z.ai/api/v1/oauth/token";
+export declare const GLM_ZCODE_ZAI_LOGIN_URL = "https://api.z.ai/api/auth/z/login";
 export declare const GLM_ZCODE_USERINFO_URL = "https://chat.z.ai/api/oauth/userinfo";
-/**
- * Default coding-plan ("start plan") Anthropic gateway base. ZCode derives this
- * as `${zcodeBackend}/api/v1/zcode-plan/anthropic`. Model requests go here
- * (NOT api.z.ai), authenticated with the ZCode JWT. Override via
- * `ZCODE_PLAN_ANTHROPIC_BASE_URL`. Exported for the model descriptor / catalog.
- */
-export declare const GLM_ZCODE_PLAN_ANTHROPIC_BASE_URL = "https://zcode.z.ai/api/v1/zcode-plan/anthropic";
+/** Z.AI business API base (customer/org/project/api-key management). */
+export declare const GLM_ZCODE_ZAI_API_BASE = "https://api.z.ai";
+/** Model API base — the provisioned key is used here, exactly like a dashboard key. */
+export declare const GLM_ZCODE_ANTHROPIC_BASE_URL = "https://api.z.ai/api/anthropic";
 type FetchImpl = typeof globalThis.fetch;
-/**
- * The provider is configured whenever a client id is available. The real ZCode
- * client id ships as the default, so this is true unless explicitly cleared.
- */
+/** Configured whenever a client id is available; the real ZCode client id ships as default. */
 export declare function isGlmZcodeOAuthConfigured(): boolean;
 export interface GlmZcodeOAuthFlowOptions {
     fetch?: FetchImpl;
@@ -71,10 +63,9 @@ export interface GlmZcodeRefreshOptions {
     fetch?: FetchImpl;
 }
 /**
- * The ZCode session JWT is the model credential. ZCode mints it from a one-time
- * authorization code via the broker and exposes no documented refresh grant, so
- * there is no autonomous refresh: an expired credential requires re-login
- * (`/login glm-zcode`). Never return an expired credential as valid.
+ * Re-provision the Z.AI API key from the stored upstream token. The key itself is
+ * long-lived, so this is rarely needed; if the upstream token has expired it fails
+ * loudly and the user must re-login.
  */
-export declare function refreshGlmZcodeToken(_credentials: OAuthCredentials, _options?: AbortSignal | GlmZcodeRefreshOptions): Promise<OAuthCredentials>;
+export declare function refreshGlmZcodeToken(credentials: OAuthCredentials, options?: AbortSignal | GlmZcodeRefreshOptions): Promise<OAuthCredentials>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.7.0",
+	"version": "0.7.2",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -43,7 +43,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/utils": "0.7.0",
+		"@gajae-code/utils": "0.7.2",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/models.json

@@ -75704,14 +75704,7 @@
 			"name": "GLM-5.2 (ZCode)",
 			"api": "anthropic-messages",
 			"provider": "glm-zcode",
-			"baseUrl": "https://zcode.z.ai/api/v1/zcode-plan/anthropic",
-			"headers": {
-				"User-Agent": "ZCode/1.0.0",
-				"HTTP-Referer": "https://zcode.z.ai",
-				"X-Title": "Z Code@electron",
-				"X-ZCode-App-Version": "1.0.0",
-				"X-ZCode-Agent": "glm"
-			},
+			"baseUrl": "https://api.z.ai/api/anthropic",
 			"reasoning": true,
 			"input": [
 				"text"

package/src/provider-models/openai-compat.ts

@@ -2282,7 +2282,7 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_CODING_PLANS: readonly ModelsDevProviderDe
 	anthropicMessagesDescriptor(
 		"glm-zcode-coding-plan",
 		"glm-zcode",
-		process.env.ZCODE_PLAN_ANTHROPIC_BASE_URL ?? "https://zcode.z.ai/api/v1/zcode-plan/anthropic",
+		process.env.ZCODE_PLAN_ANTHROPIC_BASE_URL ?? "https://api.z.ai/api/anthropic",
 	),
 	// --- Xiaomi ---
 	openAiCompletionsDescriptor("xiaomi", "xiaomi", "https://api.xiaomimimo.com/v1", {

package/src/providers/anthropic.ts

@@ -1,5 +1,6 @@
 import * as nodeCrypto from "node:crypto";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import { scheduler } from "node:timers/promises";
 import * as tls from "node:tls";
 import Anthropic, { type ClientOptions as AnthropicSdkClientOptions } from "@anthropic-ai/sdk";
@@ -93,6 +94,13 @@ export type AnthropicHeaderOptions = {
 	stream?: boolean;
 	modelHeaders?: Record<string, string>;
 	isCloudflareAiGateway?: boolean;
+	/**
+	 * Attach ZCode client "source" headers (User-Agent: ZCode/<ver>, X-Title,
+	 * X-ZCode-Agent: glm, X-Platform, etc.) so api.z.ai recognizes the caller as
+	 * the ZCode client, exactly like ZCode's `buildZCodeSourceHeaders` does for
+	 * GLM providers. glm-zcode only.
+	 */
+	zcodeSourceHeaders?: boolean;
 };
 
 export function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined {
@@ -161,6 +169,67 @@ const sharedHeaders = {
 	"X-App": "cli",
 };
 
+// ZCode bakes its app version and runtime env at build time. Mirror the values
+// from the analyzed ZCode 3.1.2 desktop bundle (`resolveRuntimeZCodeEnv` returns
+// "production" for non-test builds). Both are overridable for forward-compat.
+const ZCODE_APP_VERSION = process.env.ZCODE_APP_VERSION?.trim() || "3.1.2";
+const ZCODE_RELEASE_CHANNEL = process.env.ZCODE_RELEASE_CHANNEL?.trim() || "production";
+
+// Mirrors ZCode's `normalizePrintableHeaderValue`: only printable ASCII passes.
+function normalizePrintableHeaderValue(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	if (trimmed && /^[\x20-\x7e]+$/.test(trimmed)) return trimmed;
+	return undefined;
+}
+
+// Mirrors ZCode's `normalizeOsCategory`.
+function normalizeOsCategory(platform: NodeJS.Platform): string {
+	switch (platform) {
+		case "darwin":
+			return "macos";
+		case "win32":
+			return "windows";
+		default:
+			return "linux";
+	}
+}
+
+/**
+ * Replicates ZCode's `buildZCodeSourceHeaders()` + GLM `X-ZCode-Agent` tag
+ * (host bundle `Bl` / `buildConnectivitySourceHeaders` for GLM providers), so
+ * api.z.ai sees gjc's glm-zcode requests as the ZCode client. Dynamic values
+ * (platform/arch, locale, timezone, OS version) are resolved at runtime exactly
+ * as ZCode does; printable-ASCII-only and conditionally omitted when empty.
+ */
+export function buildZCodeSourceHeaders(): Record<string, string> {
+	const platform = process.platform;
+	const arch = process.arch;
+	const appVersion = normalizePrintableHeaderValue(ZCODE_APP_VERSION);
+	const releaseChannel = normalizePrintableHeaderValue(ZCODE_RELEASE_CHANNEL);
+	let locale: string | undefined;
+	let timezone: string | undefined;
+	try {
+		const resolved = Intl.DateTimeFormat().resolvedOptions();
+		locale = normalizePrintableHeaderValue(resolved.locale);
+		timezone = normalizePrintableHeaderValue(resolved.timeZone);
+	} catch {}
+	const osVersion = normalizePrintableHeaderValue(os.version());
+	const headers: Record<string, string> = {
+		"User-Agent": `ZCode/${appVersion ?? "unknown"}`,
+		"HTTP-Referer": "https://zcode.z.ai",
+		"X-Title": "Z Code@electron",
+		"X-Platform": `${platform}-${arch}`,
+		"X-Client-Language": locale ?? "unknown",
+		"X-Client-Timezone": timezone ?? "unknown",
+		"X-Os-Category": normalizeOsCategory(platform),
+		"X-ZCode-Agent": "glm",
+	};
+	if (appVersion) headers["X-ZCode-App-Version"] = appVersion;
+	if (releaseChannel) headers["X-Release-Channel"] = releaseChannel;
+	if (osVersion) headers["X-Os-Version"] = osVersion;
+	return headers;
+}
+
 export function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<string, string> {
 	const oauthToken = options.isOAuth ?? isAnthropicOAuthToken(options.apiKey);
 	const extraBetas = options.extraBetas ?? [];
@@ -197,6 +266,9 @@ export function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<s
 		};
 	} else if (!isAnthropicApiBaseUrl(options.baseUrl)) {
 		const incomingUserAgent = getHeaderCaseInsensitive(options.modelHeaders, "User-Agent");
+		// ZCode merges its source headers LAST for GLM providers (`withZCodeSourceHeaders`
+		// → `{ ...base, ...extra, ...source }`), so they win over any incoming User-Agent.
+		const zcodeSourceHeaders = options.zcodeSourceHeaders ? buildZCodeSourceHeaders() : undefined;
 		return {
 			...modelHeaders,
 			Accept: acceptHeader,
@@ -204,6 +276,7 @@ export function buildAnthropicHeaders(options: AnthropicHeaderOptions): Record<s
 			...sharedHeaders,
 			"Anthropic-Beta": betaHeader,
 			...(incomingUserAgent ? { "User-Agent": incomingUserAgent } : {}),
+			...(zcodeSourceHeaders ?? {}),
 		};
 	} else {
 		return {
@@ -678,6 +751,12 @@ function resolveAnthropicBaseUrl(model: Model<"anthropic-messages">, apiKey?: st
 	if (model.provider === "github-copilot") {
 		return normalizeAnthropicBaseUrl(resolveGitHubCopilotBaseUrl(model.baseUrl, apiKey) ?? model.baseUrl);
 	}
+	// glm-zcode logs in via ZCode's OAuth but auto-provisions a real Z.AI API key and
+	// calls api.z.ai directly (no zcode.z.ai gateway, no captcha). Pin the base so dynamic
+	// discovery / stale bundled catalogs / model cache can't redirect it elsewhere.
+	if (model.provider === "glm-zcode") {
+		return normalizeAnthropicBaseUrl(process.env.ZCODE_PLAN_ANTHROPIC_BASE_URL) ?? "https://api.z.ai/api/anthropic";
+	}
 	if (model.provider === "anthropic" && isFoundryEnabled()) {
 		const foundryBaseUrl = normalizeAnthropicBaseUrl($env.FOUNDRY_BASE_URL);
 		if (foundryBaseUrl) {
@@ -1697,6 +1776,7 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 		stream,
 		modelHeaders: mergeHeaders(model.headers, foundryCustomHeaders, headers, dynamicHeaders),
 		isCloudflareAiGateway: model.provider === "cloudflare-ai-gateway",
+		zcodeSourceHeaders: model.provider === "glm-zcode",
 	});
 
 	if (model.provider === "cloudflare-ai-gateway") {

package/src/providers/mock.ts

@@ -73,6 +73,8 @@ export type MockContent =
 			name: string;
 			/** Object form is preferred; strings are passed through verbatim. */
 			arguments: Record<string, unknown> | string;
+			/** Simulate a provider-flagged truncated call (cut off mid-arguments). */
+			incompleteArguments?: boolean;
 	  };
 
 /** One scripted response. */
@@ -416,6 +418,7 @@ function normalizeContent(input: MockContent, state: MockModel): TextContent | T
 			id: input.id ?? generateToolCallId(state),
 			name: input.name,
 			arguments: typeof input.arguments === "string" ? input.arguments : { ...input.arguments },
+			...(input.incompleteArguments ? { incompleteArguments: true } : {}),
 		} as ToolCall;
 	}
 	return input;

package/src/providers/openai-codex-responses.ts

@@ -78,6 +78,7 @@ import {
 	convertResponsesInputContent,
 	encodeResponsesToolCallId,
 	encodeTextSignatureV1,
+	flagTruncatedToolCalls,
 	mapOpenAIResponsesStopReason,
 	populateResponsesUsageFromResponse,
 } from "./openai-responses-shared";
@@ -254,6 +255,8 @@ interface CodexStreamRuntime {
 	providerRetryAttempt: number;
 	sawTerminalEvent: boolean;
 	canSafelyReplayWebsocketOverSse: boolean;
+	/** Ids of tool calls that received their terminal `output_item.done`. */
+	finalizedToolCallIds: Set<string>;
 }
 
 interface CodexStreamProcessingContext {
@@ -910,6 +913,7 @@ function createCodexStreamRuntime(initial: {
 		providerRetryAttempt: 0,
 		sawTerminalEvent: false,
 		canSafelyReplayWebsocketOverSse: true,
+		finalizedToolCallIds: new Set<string>(),
 	};
 }
 
@@ -1267,9 +1271,11 @@ function handleOutputItemDone(
 	}
 
 	if (item.type === "function_call") {
+		const id = encodeResponsesToolCallId(item.call_id, item.id);
+		runtime.finalizedToolCallIds.add(id);
 		const toolCall: ToolCall = {
 			type: "toolCall",
-			id: encodeResponsesToolCallId(item.call_id, item.id),
+			id,
 			name: item.name,
 			arguments: parseStreamingJson(item.arguments || "{}"),
 		};
@@ -1279,13 +1285,15 @@ function handleOutputItemDone(
 	}
 
 	if (item.type === "custom_tool_call") {
+		const id = encodeResponsesToolCallId(item.call_id, item.id);
+		runtime.finalizedToolCallIds.add(id);
 		const rawInput =
 			runtime.currentBlock?.type === "toolCall" && runtime.currentBlock.partialJson
 				? runtime.currentBlock.partialJson
 				: (item.input ?? "");
 		const toolCall: ToolCall = {
 			type: "toolCall",
-			id: encodeResponsesToolCallId(item.call_id, item.id),
+			id,
 			name: item.name,
 			arguments: { input: rawInput },
 			customWireName: item.name,
@@ -1349,6 +1357,10 @@ function handleResponseCompleted(
 	calculateCost(model, output.usage);
 	applyCodexServiceTierPricing(model, output.usage, response?.service_tier, runtime.requestBodyForState.service_tier);
 	output.stopReason = mapOpenAIResponsesStopReason(response?.status as OpenAI.Responses.ResponseStatus | undefined);
+	// A response cut short for length may have stopped mid-tool-call. Flag any
+	// call that never received its `output_item.done` so the agent loop rejects
+	// the truncated arguments instead of executing a best-effort partial parse.
+	flagTruncatedToolCalls(output, output.stopReason, block => runtime.finalizedToolCallIds.has(block.id));
 	if (output.content.some(block => block.type === "toolCall") && output.stopReason === "stop") {
 		output.stopReason = "toolUse";
 	}

package/src/providers/openai-completions.ts

@@ -51,7 +51,7 @@ import {
 	getStreamFirstEventTimeoutMs,
 	iterateWithIdleTimeout,
 } from "../utils/idle-iterator";
-import { parseStreamingJson } from "../utils/json-parse";
+import { isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { getKimiCommonHeaders } from "../utils/oauth/kimi";
 import { notifyProviderResponse } from "../utils/provider-response";
@@ -889,6 +889,17 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				}
 			}
 
+			// A turn cut short for length may have stopped mid-tool-call. The open
+			// block's `partialArgs` would otherwise be repaired into a plausible-
+			// but-wrong object by `finishCurrentBlock`; flag it first so the agent
+			// loop rejects the truncated call instead of executing it.
+			if (output.stopReason === "length" && currentBlock?.type === "toolCall") {
+				const partial = (currentBlock as { partialArgs?: string }).partialArgs;
+				if (partial !== undefined && !isCompleteJson(partial)) {
+					currentBlock.incompleteArguments = true;
+				}
+			}
+
 			finishCurrentBlock(currentBlock);
 
 			const firstEventTimeoutError = abortTracker.getLocalAbortReason();

package/src/providers/openai-responses-shared.ts

@@ -30,7 +30,7 @@ import {
 } from "../types";
 import { normalizeResponsesToolCallId } from "../utils";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
-import { parseStreamingJson } from "../utils/json-parse";
+import { isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { joinTextWithImagePlaceholder, NON_VISION_IMAGE_PLACEHOLDER, partitionVisionContent } from "./vision-guard";
 
 export function encodeTextSignatureV1(id: string, phase?: TextSignatureV1["phase"]): string {
@@ -710,6 +710,13 @@ export async function processResponsesStream<TApi extends Api>(
 							: "Unknown error (no error details in response)";
 				throw new Error(message);
 			}
+			// A response cut short for length (`incomplete`) may have stopped
+			// mid-tool-call. Any tool-call item still tracked in `items` never
+			// received its terminal `output_item.done`, so it was cut off; flag it
+			// (along with any finalized-but-unparseable JSON call) so the agent loop
+			// rejects it instead of executing repaired/partial arguments.
+			const openBlocks = new Set<unknown>(Array.from(items.values(), entry => entry.block));
+			flagTruncatedToolCalls(output, output.stopReason, block => !openBlocks.has(block));
 			if (output.content.some(block => block.type === "toolCall") && output.stopReason === "stop") {
 				output.stopReason = "toolUse";
 			}
@@ -728,6 +735,41 @@ export async function processResponsesStream<TApi extends Api>(
 	}
 }
 
+/**
+ * Mark tool-call blocks left incomplete by a length-truncated response so the
+ * agent loop rejects them instead of executing a best-effort partial parse.
+ *
+ * The universal signal is finalization: a call that never received its terminal
+ * `output_item.done` (passed in via `isFinalized`) was cut off mid-arguments.
+ * This covers both JSON function calls and raw-input custom tools without
+ * mis-flagging a *completed* custom tool whose raw input is not valid JSON. As a
+ * defensive secondary, a finalized JSON function call whose buffered arguments
+ * still don't parse (e.g. a misbehaving relay) is flagged too. No-op unless the
+ * turn stopped for length.
+ *
+ * Shared by both Responses providers (`openai-responses`, `openai-codex-responses`).
+ */
+export function flagTruncatedToolCalls(
+	output: AssistantMessage,
+	stopReason: StopReason,
+	isFinalized: (block: ToolCall) => boolean,
+): void {
+	if (stopReason !== "length") return;
+	for (const block of output.content) {
+		if (block.type !== "toolCall") continue;
+		if (!isFinalized(block)) {
+			block.incompleteArguments = true;
+			continue;
+		}
+		// Finalized: custom tools carry raw (non-JSON) input and are complete once
+		// finalized; only JSON function calls get the parse double-check.
+		if (!block.customWireName) {
+			const partial = (block as { partialJson?: string }).partialJson;
+			if (partial !== undefined && !isCompleteJson(partial)) block.incompleteArguments = true;
+		}
+	}
+}
+
 export function mapOpenAIResponsesStopReason(status: OpenAI.Responses.ResponseStatus | undefined): StopReason {
 	if (!status) return "stop";
 	switch (status) {

package/src/types.ts

@@ -490,6 +490,14 @@ export interface ToolCall {
 	 * JSON function tools.
 	 */
 	customWireName?: string;
+	/**
+	 * Set when the provider detected the argument JSON was truncated — the model
+	 * hit its output-token limit (or the response was otherwise cut short) before
+	 * emitting a complete arguments object. The `arguments` field then holds a
+	 * best-effort partial parse and must not be executed as-is; the agent loop
+	 * rejects the call with a retryable error instead.
+	 */
+	incompleteArguments?: boolean;
 }
 
 export interface Usage {

package/src/utils/json-parse.ts

@@ -146,3 +146,21 @@ export function parseStreamingJson<T = Record<string, unknown>>(partialJson: str
 		}
 	}
 }
+
+/**
+ * Whether a string is a complete, well-formed JSON document (strict parse, no
+ * repair). Used to distinguish a tool-call argument blob that finished cleanly
+ * from one that was cut off mid-stream (truncation). An empty / whitespace-only
+ * string is treated as complete: a tool invoked with no arguments legitimately
+ * streams an empty buffer and must not be flagged as truncated.
+ */
+export function isCompleteJson(text: string | undefined): boolean {
+	const trimmed = text?.trim();
+	if (!trimmed) return true;
+	try {
+		JSON.parse(trimmed);
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/utils/oauth/glm-zcode.ts

@@ -1,56 +1,54 @@
 /**
  * GLM ZCode OAuth flow (UNOFFICIAL, opt-in).
  *
- * Replicates the reverse-engineered ZCode desktop-app login to Z.AI/GLM. This
- * is NOT an official Z.AI OAuth client: it reuses ZCode's authorize page,
- * broker, and a custom-protocol redirect. It may break at any time and may
- * violate ZCode/Z.AI Terms of Service. Endpoints and the client id are
- * overridable via `ZCODE_OAUTH_*` environment variables.
+ * Replicates how the ZCode desktop app turns a Z.AI login into usable GLM model
+ * access. This is NOT an official Z.AI OAuth client: it reuses ZCode's authorize
+ * page, broker, and a custom-protocol redirect. It may break at any time and may
+ * violate ZCode/Z.AI Terms of Service. Endpoints/client id are overridable via
+ * `ZCODE_OAUTH_*` environment variables.
  *
- * Login flow:
- *   1. Authorize:  GET  {authorize}?redirect_uri=zcode://oauth/callback&response_type=code&client_id=...&state=...
- *                  (custom-protocol redirect → a CLI cannot catch it, so the user pastes the code/redirect URL)
- *   2. Broker:     POST {broker}  { provider: "zai", code, redirect_uri, state }
- *                       → { code: 0, data: { token: <ZCode JWT>, zai: { access_token: <upstream Z.AI token> }, expires_in } }
+ * Verified end-to-end against the ZCode host bundle (`resolveZaiApiKey` /
+ * `resolveBizApiKey`) and live traffic:
+ *   1. Authorize: GET {authorize}?redirect_uri=zcode://oauth/callback&response_type=code&client_id=...&state=...
+ *      (custom-protocol redirect → a CLI cannot catch it, so the user pastes the code/redirect URL)
+ *   2. Broker:    POST {broker} { provider:"zai", code, redirect_uri, state }
+ *                  → { data: { token: <ZCode JWT>, zai: { access_token: <upstream Z.AI token> } } }
+ *   3. Business:  POST {z/login} { token: <upstream Z.AI token> } → { data: { access_token: <business token> } }
+ *   4. Provision: with the business token, GET getCustomerInfo → default org/project,
+ *      GET/POST .../api_keys (find/create a key named "zcode-api-key"),
+ *      GET .../api_keys/copy/{id} → secretKey ⇒ a real Z.AI API key "{id}.{secret}".
  *
- * Credential mapping (verified against the ZCode host bundle):
- *   - `access`  = the **ZCode JWT** (`data.token`). This is the GLM coding-plan
- *                 model credential: ZCode stores it under the `zcodejwttoken`
- *                 key and sends it as `Authorization: Bearer` to the coding-plan
- *                 gateway `${ZCODE_PLAN_ANTHROPIC_BASE_URL}` (default
- *                 https://zcode.z.ai/api/v1/zcode-plan/anthropic), which
- *                 validates the ZCode session and injects the upstream GLM key
- *                 server-side. Model traffic does NOT go to api.z.ai directly.
- *   - `refresh` = the upstream Z.AI OAuth access token (`data.zai.access_token`),
- *                 kept for identity/userinfo only. ZCode's separate z/login
- *                 "business token" is used by ZCode for billing/userinfo, NOT
- *                 model calls, so it is intentionally never minted here.
+ * Credential mapping:
+ *   - `access`  = the provisioned **Z.AI API key** ("{id}.{secret}"). Model requests go to
+ *                 `https://api.z.ai/api/anthropic/v1/messages` with `Authorization: Bearer <key>`
+ *                 (exactly like a dashboard key) — NO zcode.z.ai gateway, NO captcha.
+ *   - `refresh` = the upstream Z.AI OAuth access token (used to re-provision the key).
+ * The API key is long-lived, so `expires` is set far in the future.
  *
- * The ZCode JWT reaches the Anthropic-messages request as a plain bearer
- * automatically (the gateway base is not api.anthropic.com). This provider must
- * NEVER force `isOAuth=true`, which would route GLM into the Claude-Code OAuth
- * header branch (claude-cli UA, `claude_` tool prefixes, Claude system prompt).
+ * This provider must NEVER force `isOAuth=true`: the key is a plain Z.AI API key, and
+ * api.z.ai is not api.anthropic.com, so the Anthropic path already emits a plain bearer.
  */
 import { OAuthCallbackFlow, type OAuthCallbackFlowOptions, parseCallbackInput } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";
 
 const TOKEN_REQUEST_TIMEOUT_MS = 30_000;
 export const GLM_ZCODE_REFRESH_SKEW_MS = 2 * 60 * 1000;
+/** Provisioned API keys are long-lived; pin expiry far out so AuthStorage never force-refreshes. */
+const GLM_ZCODE_API_KEY_TTL_MS = 10 * 365 * 24 * 60 * 60 * 1000;
+/** Name ZCode gives the API key it auto-provisions (host bundle constant `FI`). */
+const GLM_ZCODE_API_KEY_NAME = "zcode-api-key";
 
 /** Default endpoints / client id. Override via the matching `ZCODE_OAUTH_*` env vars. */
 export const GLM_ZCODE_OAUTH_AUTHORIZE_URL = "https://chat.z.ai/api/oauth/authorize";
 export const GLM_ZCODE_OAUTH_CLIENT_ID = "client_P8X5CMWmlaRO9gyO-KSqtg";
 export const GLM_ZCODE_OAUTH_REDIRECT_URI = "zcode://oauth/callback";
 export const GLM_ZCODE_OAUTH_BROKER_TOKEN_URL = "https://zcode.z.ai/api/v1/oauth/token";
+export const GLM_ZCODE_ZAI_LOGIN_URL = "https://api.z.ai/api/auth/z/login";
 export const GLM_ZCODE_USERINFO_URL = "https://chat.z.ai/api/oauth/userinfo";
-
-/**
- * Default coding-plan ("start plan") Anthropic gateway base. ZCode derives this
- * as `${zcodeBackend}/api/v1/zcode-plan/anthropic`. Model requests go here
- * (NOT api.z.ai), authenticated with the ZCode JWT. Override via
- * `ZCODE_PLAN_ANTHROPIC_BASE_URL`. Exported for the model descriptor / catalog.
- */
-export const GLM_ZCODE_PLAN_ANTHROPIC_BASE_URL = "https://zcode.z.ai/api/v1/zcode-plan/anthropic";
+/** Z.AI business API base (customer/org/project/api-key management). */
+export const GLM_ZCODE_ZAI_API_BASE = "https://api.z.ai";
+/** Model API base — the provisioned key is used here, exactly like a dashboard key. */
+export const GLM_ZCODE_ANTHROPIC_BASE_URL = "https://api.z.ai/api/anthropic";
 
 type FetchImpl = typeof globalThis.fetch;
 
@@ -71,19 +69,22 @@ function resolveRedirectUri(): string {
 function resolveBrokerTokenUrl(): string {
 	return envOr("ZCODE_OAUTH_BROKER_TOKEN_URL", GLM_ZCODE_OAUTH_BROKER_TOKEN_URL);
 }
+function resolveZaiLoginUrl(): string {
+	return envOr("ZCODE_OAUTH_ZAI_LOGIN_URL", GLM_ZCODE_ZAI_LOGIN_URL);
+}
 function resolveUserinfoUrl(): string {
 	return envOr("ZCODE_OAUTH_USERINFO_URL", GLM_ZCODE_USERINFO_URL);
 }
+function resolveZaiApiBase(): string {
+	return envOr("ZCODE_OAUTH_ZAI_API_BASE", GLM_ZCODE_ZAI_API_BASE).replace(/\/+$/, "");
+}
 
-/**
- * The provider is configured whenever a client id is available. The real ZCode
- * client id ships as the default, so this is true unless explicitly cleared.
- */
+/** Configured whenever a client id is available; the real ZCode client id ships as default. */
 export function isGlmZcodeOAuthConfigured(): boolean {
 	return resolveClientId().length > 0;
 }
 
-/** Mask token-like substrings so broker/upstream/JWT tokens never leak into errors or logs. */
+/** Mask token-like substrings so broker/upstream/business tokens never leak into errors. */
 function redactSecrets(text: string): string {
 	return text
 		.replace(/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "[redacted-jwt]")
@@ -100,7 +101,7 @@ function validateHttpsEndpoint(rawUrl: string, label: string): string {
 	if (parsed.protocol !== "https:") {
 		throw new Error(`GLM ZCode ${label} endpoint must use https`);
 	}
-	return parsed.toString();
+	return parsed.toString().replace(/\/+$/, "");
 }
 
 function requestSignal(signal: AbortSignal | undefined): AbortSignal {
@@ -118,10 +119,13 @@ async function postJson(
 	body: Record<string, unknown>,
 	label: string,
 	signal: AbortSignal | undefined,
+	bearer?: string,
 ): Promise<unknown> {
+	const headers: Record<string, string> = { Accept: "application/json", "Content-Type": "application/json" };
+	if (bearer) headers.Authorization = `Bearer ${bearer}`;
 	const response = await fetchImpl(url, {
 		method: "POST",
-		headers: { Accept: "application/json", "Content-Type": "application/json" },
+		headers,
 		body: JSON.stringify(body),
 		signal: requestSignal(signal),
 	});
@@ -131,14 +135,28 @@ async function postJson(
 	return response.json();
 }
 
+async function getJson(
+	fetchImpl: FetchImpl,
+	url: string,
+	bearer: string,
+	label: string,
+	signal: AbortSignal | undefined,
+): Promise<unknown> {
+	const response = await fetchImpl(url, {
+		headers: { Accept: "application/json", Authorization: `Bearer ${bearer}` },
+		signal: requestSignal(signal),
+	});
+	if (!response.ok) {
+		throw new Error(`GLM ZCode ${label} request failed: ${response.status} ${redactSecrets(await response.text())}`);
+	}
+	return response.json();
+}
+
 interface JwtPayload {
 	sub?: unknown;
 	email?: unknown;
-	account_id?: unknown;
-	uid?: unknown;
 	[key: string]: unknown;
 }
-
 function decodeJwtPayload(token: string): JwtPayload | undefined {
 	const parts = token.split(".");
 	const payload = parts[1];
@@ -155,31 +173,118 @@ interface Identity {
 	accountId?: string;
 }
 
-function identityFromJwts(tokens: readonly string[]): Identity {
-	for (const token of tokens) {
-		const payload = decodeJwtPayload(token);
-		if (!payload) continue;
-		const accountId =
-			(typeof payload.sub === "string" && payload.sub) ||
-			(typeof payload.account_id === "string" && payload.account_id) ||
-			(typeof payload.uid === "string" && payload.uid) ||
-			undefined;
-		const email =
-			typeof payload.email === "string" && payload.email.length > 0 ? payload.email.toLowerCase() : undefined;
-		if (accountId || email) {
-			return { accountId: accountId || undefined, email };
-		}
+function parseBrokerResponse(payload: unknown): { upstreamZaiAccess: string; zcodeToken: string } {
+	const data = isRecord(payload) && isRecord(payload.data) ? payload.data : undefined;
+	const zcodeToken = data && typeof data.token === "string" ? data.token : undefined;
+	const zai = data && isRecord(data.zai) ? data.zai : undefined;
+	const upstreamZaiAccess = zai && typeof zai.access_token === "string" ? zai.access_token : undefined;
+	if (!zcodeToken || !upstreamZaiAccess) {
+		throw new Error("GLM ZCode broker response missing data.token or data.zai.access_token");
 	}
-	return {};
+	return { upstreamZaiAccess, zcodeToken };
+}
+
+async function resolveBusinessToken(
+	fetchImpl: FetchImpl,
+	upstreamZaiAccess: string,
+	signal: AbortSignal | undefined,
+): Promise<string> {
+	const zaiLoginUrl = validateHttpsEndpoint(resolveZaiLoginUrl(), "z/login");
+	const payload = await postJson(fetchImpl, `${zaiLoginUrl}`, { token: upstreamZaiAccess }, "z/login", signal);
+	const data = isRecord(payload) && isRecord(payload.data) ? payload.data : undefined;
+	const access = data && typeof data.access_token === "string" ? data.access_token : undefined;
+	if (!access) throw new Error("GLM ZCode z/login response missing data.access_token");
+	return access;
+}
+
+interface OrgProject {
+	organizationId: string;
+	projectId: string;
+	email?: string;
+	accountId?: string;
+}
+
+function pickDefaultOrgProject(customerInfo: unknown): OrgProject {
+	const data = isRecord(customerInfo) && isRecord(customerInfo.data) ? customerInfo.data : customerInfo;
+	const root = isRecord(data) ? data : {};
+	const orgs = Array.isArray(root.organizations) ? root.organizations : [];
+	const org = (orgs.find(o => isRecord(o) && o.isDefault) ?? orgs[0]) as Record<string, unknown> | undefined;
+	const organizationId = org && typeof org.organizationId === "string" ? org.organizationId : undefined;
+	const projects = org && Array.isArray(org.projects) ? org.projects : [];
+	const proj = (projects.find(p => isRecord(p) && p.isDefault) ?? projects[0]) as Record<string, unknown> | undefined;
+	const projectId = proj && typeof proj.projectId === "string" ? proj.projectId : undefined;
+	if (!organizationId || !projectId) {
+		throw new Error("GLM ZCode getCustomerInfo response missing default organization/project");
+	}
+	const email = typeof root.email === "string" && root.email.length > 0 ? root.email.toLowerCase() : undefined;
+	const accountId = typeof root.id === "string" ? root.id : typeof root.id === "number" ? String(root.id) : undefined;
+	return { organizationId, projectId, email, accountId };
+}
+
+/**
+ * Provision (or reuse) a Z.AI API key named "zcode-api-key" using the business token,
+ * mirroring ZCode's `resolveBizApiKey`. Returns "{apiKeyId}.{secretKey}".
+ */
+async function provisionZaiApiKey(
+	fetchImpl: FetchImpl,
+	businessToken: string,
+	signal: AbortSignal | undefined,
+): Promise<{ apiKey: string; identity: Identity }> {
+	const apiBase = resolveZaiApiBase();
+	const customerInfo = await getJson(
+		fetchImpl,
+		`${apiBase}/api/biz/customer/getCustomerInfo`,
+		businessToken,
+		"getCustomerInfo",
+		signal,
+	);
+	const { organizationId, projectId, email, accountId } = pickDefaultOrgProject(customerInfo);
+	const keysUrl = `${apiBase}/api/biz/v1/organization/${organizationId}/projects/${projectId}/api_keys`;
+
+	const listPayload = await getJson(fetchImpl, keysUrl, businessToken, "api_keys.list", signal);
+	const listData = isRecord(listPayload) && Array.isArray(listPayload.data) ? listPayload.data : [];
+	let entry = listData.find(k => isRecord(k) && k.name === GLM_ZCODE_API_KEY_NAME) as
+		| Record<string, unknown>
+		| undefined;
+
+	if (!entry) {
+		const created = await postJson(
+			fetchImpl,
+			keysUrl,
+			{ name: GLM_ZCODE_API_KEY_NAME },
+			"api_keys.create",
+			signal,
+			businessToken,
+		);
+		entry = (isRecord(created) && isRecord(created.data) ? created.data : created) as Record<string, unknown>;
+	}
+
+	const apiKeyId =
+		typeof entry.apiKey === "string" ? entry.apiKey.trim() : typeof entry.id === "string" ? entry.id : "";
+	if (!apiKeyId) throw new Error("GLM ZCode api_keys response missing apiKey id");
+
+	const copyPayload = await getJson(
+		fetchImpl,
+		`${keysUrl}/copy/${encodeURIComponent(apiKeyId)}`,
+		businessToken,
+		"api_keys.copy",
+		signal,
+	);
+	const copyData = isRecord(copyPayload) && isRecord(copyPayload.data) ? copyPayload.data : copyPayload;
+	const secretKey = isRecord(copyData) && typeof copyData.secretKey === "string" ? copyData.secretKey.trim() : "";
+	if (!secretKey) throw new Error("GLM ZCode api_keys copy response missing secretKey");
+
+	return { apiKey: `${apiKeyId}.${secretKey}`, identity: { email, accountId } };
 }
 
 async function resolveIdentity(
 	fetchImpl: FetchImpl,
 	upstreamZaiAccess: string,
+	fallback: Identity,
 	jwtCandidates: readonly string[],
 	signal: AbortSignal | undefined,
 ): Promise<Identity> {
-	// Best-effort userinfo; never fail login if identity lookup fails.
+	if (fallback.email || fallback.accountId) return fallback;
 	try {
 		const userinfoUrl = validateHttpsEndpoint(resolveUserinfoUrl(), "userinfo");
 		const response = await fetchImpl(userinfoUrl, {
@@ -191,37 +296,47 @@ async function resolveIdentity(
 			const data = isRecord(payload) && isRecord(payload.data) ? payload.data : isRecord(payload) ? payload : {};
 			const email = typeof data.email === "string" && data.email.length > 0 ? data.email.toLowerCase() : undefined;
 			const accountId =
-				(typeof data.id === "string" && data.id) ||
-				(typeof data.account_id === "string" && data.account_id) ||
-				(typeof data.sub === "string" && data.sub) ||
-				undefined;
-			if (email || accountId) {
-				return { email, accountId: accountId || undefined };
-			}
+				(typeof data.id === "string" && data.id) || (typeof data.sub === "string" && data.sub) || undefined;
+			if (email || accountId) return { email, accountId: accountId || undefined };
 		}
 	} catch {
-		// fall through to JWT decode
+		// fall through
 	}
-	return identityFromJwts(jwtCandidates);
+	for (const token of jwtCandidates) {
+		const p = decodeJwtPayload(token);
+		const accountId = p && typeof p.sub === "string" ? p.sub : undefined;
+		const email = p && typeof p.email === "string" ? p.email.toLowerCase() : undefined;
+		if (accountId || email) return { accountId, email };
+	}
+	return {};
 }
 
-interface BrokerResult {
-	zcodeToken: string;
-	upstreamZaiAccess: string;
-	expiresIn: number;
+function credentialsFromApiKey(apiKey: string, upstreamZaiAccess: string, identity: Identity): OAuthCredentials {
+	return {
+		access: apiKey,
+		refresh: upstreamZaiAccess,
+		expires: Date.now() + GLM_ZCODE_API_KEY_TTL_MS,
+		email: identity.email,
+		accountId: identity.accountId,
+	};
 }
 
-function parseBrokerResponse(payload: unknown): BrokerResult {
-	const data = isRecord(payload) && isRecord(payload.data) ? payload.data : undefined;
-	const zcodeToken = data && typeof data.token === "string" ? data.token : undefined;
-	const zai = data && isRecord(data.zai) ? data.zai : undefined;
-	const upstreamZaiAccess = zai && typeof zai.access_token === "string" ? zai.access_token : undefined;
-	if (!zcodeToken || !upstreamZaiAccess) {
-		throw new Error("GLM ZCode broker response missing data.token or data.zai.access_token");
-	}
-	const expiresIn =
-		data && typeof data.expires_in === "number" && Number.isFinite(data.expires_in) ? data.expires_in : 3600;
-	return { zcodeToken, upstreamZaiAccess, expiresIn };
+async function provisionFromUpstream(
+	fetchImpl: FetchImpl,
+	upstreamZaiAccess: string,
+	zcodeTokenForIdentity: string | undefined,
+	signal: AbortSignal | undefined,
+): Promise<OAuthCredentials> {
+	const businessToken = await resolveBusinessToken(fetchImpl, upstreamZaiAccess, signal);
+	const { apiKey, identity: keyIdentity } = await provisionZaiApiKey(fetchImpl, businessToken, signal);
+	const identity = await resolveIdentity(
+		fetchImpl,
+		upstreamZaiAccess,
+		keyIdentity,
+		[zcodeTokenForIdentity ?? "", businessToken].filter(Boolean),
+		signal,
+	);
+	return credentialsFromApiKey(apiKey, upstreamZaiAccess, identity);
 }
 
 async function exchangeGlmZcodeCode(
@@ -229,7 +344,6 @@ async function exchangeGlmZcodeCode(
 	input: { code: string; state: string; redirectUri: string },
 	signal: AbortSignal | undefined,
 ): Promise<OAuthCredentials> {
-	// Defensive: a pasted value may still be a full redirect URL or `code#state`.
 	const parsed = parseCallbackInput(input.code);
 	const code = parsed.code ?? input.code;
 	const brokerUrl = validateHttpsEndpoint(resolveBrokerTokenUrl(), "broker");
@@ -240,17 +354,8 @@ async function exchangeGlmZcodeCode(
 		"broker",
 		signal,
 	);
-	const { zcodeToken, upstreamZaiAccess, expiresIn } = parseBrokerResponse(brokerPayload);
-	const identity = await resolveIdentity(fetchImpl, upstreamZaiAccess, [zcodeToken, upstreamZaiAccess], signal);
-	// access = ZCode JWT (the coding-plan model credential); refresh = upstream
-	// Z.AI token (identity only — there is no documented JWT refresh grant).
-	return {
-		access: zcodeToken,
-		refresh: upstreamZaiAccess,
-		expires: Date.now() + expiresIn * 1000 - GLM_ZCODE_REFRESH_SKEW_MS,
-		email: identity.email,
-		accountId: identity.accountId,
-	};
+	const { upstreamZaiAccess, zcodeToken } = parseBrokerResponse(brokerPayload);
+	return provisionFromUpstream(fetchImpl, upstreamZaiAccess, zcodeToken, signal);
 }
 
 export interface GlmZcodeOAuthFlowOptions {
@@ -262,8 +367,6 @@ export class GlmZcodeOAuthFlow extends OAuthCallbackFlow {
 
 	constructor(ctrl: OAuthController, options: GlmZcodeOAuthFlowOptions = {}) {
 		super(ctrl, {
-			// Port 0 → a free random local port. The custom-protocol redirect
-			// never reaches it; login completes via manual code/redirect paste.
 			preferredPort: 0,
 			callbackPath: "/callback",
 			callbackHostname: "127.0.0.1",
@@ -306,16 +409,25 @@ export interface GlmZcodeRefreshOptions {
 }
 
 /**
- * The ZCode session JWT is the model credential. ZCode mints it from a one-time
- * authorization code via the broker and exposes no documented refresh grant, so
- * there is no autonomous refresh: an expired credential requires re-login
- * (`/login glm-zcode`). Never return an expired credential as valid.
+ * Re-provision the Z.AI API key from the stored upstream token. The key itself is
+ * long-lived, so this is rarely needed; if the upstream token has expired it fails
+ * loudly and the user must re-login.
  */
 export async function refreshGlmZcodeToken(
-	_credentials: OAuthCredentials,
-	_options: AbortSignal | GlmZcodeRefreshOptions = {},
+	credentials: OAuthCredentials,
+	options: AbortSignal | GlmZcodeRefreshOptions = {},
 ): Promise<OAuthCredentials> {
-	throw new Error(
-		"glm-zcode session expired; re-login required (`/login glm-zcode`). The ZCode coding-plan token has no documented refresh endpoint.",
-	);
+	const { signal, fetch: fetchImpl } =
+		options instanceof AbortSignal ? { signal: options, fetch: undefined } : options;
+	const upstream = credentials.refresh;
+	if (!upstream) {
+		throw new Error("glm-zcode credentials require re-login (`/login glm-zcode`); no stored upstream Z.AI token");
+	}
+	try {
+		return await provisionFromUpstream(fetchImpl ?? globalThis.fetch, upstream, undefined, signal);
+	} catch (error) {
+		throw new Error(
+			`glm-zcode credentials require re-login (\`/login glm-zcode\`); re-provisioning the Z.AI API key failed (${redactSecrets(String(error))})`,
+		);
+	}
 }