@gajae-code/ai 0.18.12 → 0.19.0

package/src/providers/anthropic.d.ts

@@ -117,6 +117,14 @@ export interface CpaToolAliasRestoreFailure {
  */
 export declare function parseCpaToolAliasRestoreFailure(error: unknown): CpaToolAliasRestoreFailure | undefined;
 export declare function isCpaToolAliasRestoreFailure(error: unknown): boolean;
+/**
+ * How many breakpoints we are still willing to generate after a gateway has
+ * rejected a previous attempt. `explicit` mode normally emits two (a reusable
+ * prefix anchor on the last assistant turn plus a refresh point on the current
+ * user turn), so stepping down to one still caches the prefix, and only the
+ * final step gives caching up entirely.
+ */
+type GeneratedCacheBudget = 2 | 1 | 0;
 export declare const claudeCodeEntrypoint = "sdk-cli";
 export declare const claudeToolPrefix: string;
 export declare const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
@@ -228,6 +236,8 @@ export type AnthropicClientOptionsResult = {
     fetchOptions?: AnthropicSdkClientOptions["fetchOptions"];
 };
 export declare function resolveGlmZcodeAnthropicBaseUrl(): string;
+/** Compresses request bodies with gzip for first-party Anthropic endpoints only. */
+export declare function wrapAnthropicFetchForGzip(baseFetch: FetchImpl): FetchImpl;
 export declare function isProviderRetryableError(error: unknown, provider?: string): boolean;
 export type AnthropicUsageLike = {
     cache_creation?: {
@@ -261,6 +271,11 @@ type SystemBlockOptions = {
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];
 export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
+type AnthropicCacheParams = MessageCreateParamsStreaming & {
+    cache_control?: AnthropicCacheControl;
+};
+type AnthropicCacheMode = "automatic" | "explicit" | "none";
+export declare function applyPromptCaching(params: AnthropicCacheParams, cacheMode: AnthropicCacheMode, cacheControl?: AnthropicCacheControl, budget?: GeneratedCacheBudget): void;
 export declare function normalizeCacheControlTtlOrdering(params: MessageCreateParamsStreaming): void;
 export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean, options?: {
     repairLatestAssistantThinking?: boolean;

package/src/providers/anthropic.ts

@@ -3,6 +3,7 @@ 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 { gzipSync } from "node:zlib";
 import Anthropic, { type ClientOptions as AnthropicSdkClientOptions } from "@anthropic-ai/sdk";
 import type {
 	ContentBlockParam,
@@ -34,8 +35,9 @@ import {
 } from "../adapter-internals/provider-safety-stop";
 import {
 	getMiniMaxThinkingMode,
-	hasOpus47ApiRestrictions,
+	hasAnthropicModelSamplingRestrictions,
 	mapEffortToAnthropicAdaptiveEffort,
+	requiresAnthropicThinkingDisableWhenOff,
 	supportsAnthropicAdaptiveThinkingDisplay as supportsAdaptiveThinkingDisplay,
 } from "../model-thinking";
 import { calculateCost } from "../models";
@@ -1586,6 +1588,51 @@ function wrapAnthropicFetchForBoundedRateLimits(baseFetch: FetchImpl, maxRetryDe
 	);
 }
 
+/** Body bytes for a request `BodyInit`, or `undefined` when the body cannot be inspected. */
+function requestBodyBuffer(body: RequestInit["body"]): Buffer | undefined {
+	if (typeof body === "string") return Buffer.from(body, "utf-8");
+	if (body instanceof ArrayBuffer) return Buffer.from(body);
+	if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+	return undefined;
+}
+
+/** Compresses request bodies with gzip for first-party Anthropic endpoints only. */
+export function wrapAnthropicFetchForGzip(baseFetch: FetchImpl): FetchImpl {
+	return Object.assign(
+		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+			const url = new URL(input instanceof Request ? input.url : String(input), "https://api.anthropic.com");
+			const isFirstPartyAnthropicApi =
+				url.protocol.toLowerCase() === "https:" &&
+				url.hostname.toLowerCase() === "api.anthropic.com" &&
+				(url.port === "" || url.port === "443");
+			const bodyBuffer = init?.body ? requestBodyBuffer(init.body) : undefined;
+			if (!isFirstPartyAnthropicApi || !bodyBuffer) return baseFetch(input, init);
+
+			let compressedBody: Buffer;
+			try {
+				compressedBody = gzipSync(bodyBuffer);
+			} catch (error) {
+				logger.debug("anthropic: gzip compression failed, falling back to uncompressed", {
+					error: error instanceof Error ? error.message : String(error),
+				});
+				return baseFetch(input, init);
+			}
+
+			// The caller's Content-Length describes the uncompressed body; drop it so
+			// fetch recomputes the length for the compressed payload.
+			const headers = new Headers(init?.headers ?? {});
+			headers.set("Content-Encoding", "gzip");
+			headers.delete("Content-Length");
+			logger.debug("anthropic: gzip compression", {
+				uncompressed: bodyBuffer.length,
+				compressed: compressedBody.length,
+			});
+			return baseFetch(input, { ...init, body: compressedBody, headers });
+		},
+		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
+	);
+}
+
 // The Anthropic SDK logs malformed SSE frames directly before rethrowing them.
 // We surface the resulting provider error ourselves, so keep the SDK quiet.
 const ANTHROPIC_SDK_LOG_LEVEL = "off" as const;
@@ -2289,6 +2336,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				}
 				if (droppedForcedToolChoice) {
 					delete nextParams.tool_choice;
+					if (options?.thinkingEnabled === false && requiresAnthropicThinkingDisableWhenOff(model.id)) {
+						nextParams.thinking = { type: "disabled" };
+					}
 				}
 				if (disableStrictTools) {
 					dropAnthropicStrictTools(nextParams);
@@ -3477,8 +3527,9 @@ export function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): A
 	const tlsFetchOptions = buildClaudeCodeTlsFetchOptions(model, baseUrl);
 	const baseFetch = args.fetch ?? fetch;
 	const boundedFetch = wrapAnthropicFetchForBoundedRateLimits(baseFetch, args.maxRetryDelayMs);
+	const gzipFetch = wrapAnthropicFetchForGzip(boundedFetch);
 	const openCodeGoSessionId = resolveOpenCodeGoSessionId(model, baseUrl, args.providerSessionId, "anthropic");
-	const providerScopedFetch = wrapFetchForOpenCodeGoSession(boundedFetch, openCodeGoSessionId);
+	const providerScopedFetch = wrapFetchForOpenCodeGoSession(gzipFetch, openCodeGoSessionId);
 	const debugFetch = onSseEvent
 		? wrapFetchForSseDebug(providerScopedFetch, event => onSseEvent(event, model))
 		: providerScopedFetch;
@@ -3614,11 +3665,22 @@ function createClient(
  * request drops `thinking`/`output_config`. Reports whether the forced-choice branch
  * applied so the caller can keep the replayed history consistent with it.
  */
-function disableThinkingIfToolChoiceForced(params: MessageCreateParamsStreaming): boolean {
+function disableThinkingIfToolChoiceForced(params: MessageCreateParamsStreaming, modelId: string): boolean {
 	const toolChoice = params.tool_choice;
 	if (!toolChoice) return false;
 	if (toolChoice.type !== "any" && toolChoice.type !== "tool") return false;
-	delete params.thinking;
+	if (requiresAnthropicThinkingDisableWhenOff(modelId)) {
+		// Haiku 5+ enables adaptive thinking when `thinking` is omitted, which a forced tool
+		// choice rejects, and applies `output_config.effort` to all response tokens including
+		// tool-call arguments. Send an explicit `disabled` and keep the selected effort;
+		// effort is capped at `high` while thinking is disabled.
+		params.thinking = { type: "disabled" };
+		const effort = params.output_config?.effort;
+		if (effort === "xhigh" || effort === "max") params.output_config = { ...params.output_config, effort: "high" };
+		return true;
+	}
+	// An explicit `disabled` is compatible with forced tool use and is kept.
+	if (params.thinking?.type !== "disabled") delete params.thinking;
 	delete params.output_config;
 	return true;
 }
@@ -3862,7 +3924,7 @@ function applyExplicitPromptCaching(
 	}
 }
 
-function applyPromptCaching(
+export function applyPromptCaching(
 	params: AnthropicCacheParams,
 	cacheMode: AnthropicCacheMode,
 	cacheControl?: AnthropicCacheControl,
@@ -3871,9 +3933,22 @@ function applyPromptCaching(
 	if (!cacheControl || cacheMode === "none" || budget === 0) return;
 	validateCacheControls(params);
 	if (cacheMode === "automatic") {
-		// Automatic mode only ever emits one marker, so any non-zero budget
-		// covers it; the zero case already returned above.
-		params.cache_control = { ...cacheControl };
+		// A caller layout that already holds four block markers leaves no room for a new root marker;
+		// adding one anyway made validateCacheControls reject the request. An existing root is still replaced.
+		if (params.cache_control || countCacheControlBreakpoints(params) < 4) {
+			params.cache_control = { ...cacheControl };
+		}
+		// #2383's moving breakpoint reasoning holds within a session, not across
+		// sessions: anchor tools + system so new messages can reuse that prefix.
+		if (
+			budget > 1 &&
+			Array.isArray(params.system) &&
+			!params.system.some(block => block.cache_control) &&
+			countCacheControlBreakpoints(params) < 4
+		) {
+			const lastBlock = params.system.at(-1);
+			if (lastBlock) lastBlock.cache_control = { ...cacheControl };
+		}
 		return;
 	}
 	applyExplicitPromptCaching(params, cacheControl, budget);
@@ -3947,8 +4022,8 @@ function buildParams(
 			seqs.length > ANTHROPIC_STOP_SEQUENCES_MAX ? seqs.slice(0, ANTHROPIC_STOP_SEQUENCES_MAX) : seqs;
 	}
 
-	// Opus 4.7+ rejects non-default sampling parameters with 400 error.
-	if (hasOpus47ApiRestrictions(model.id)) {
+	// Opus 4.7+ and Haiku 5+ reject non-default sampling parameters.
+	if (hasAnthropicModelSamplingRestrictions(model.id)) {
 		delete params.top_p;
 		delete params.top_k;
 		delete params.temperature;
@@ -3968,7 +4043,9 @@ function buildParams(
 	}
 
 	const miniMaxMode = getMiniMaxThinkingMode(model, baseUrl);
-	if (model.reasoning && miniMaxMode === "toggle") {
+	if (options?.thinkingEnabled === false && requiresAnthropicThinkingDisableWhenOff(model.id)) {
+		params.thinking = { type: "disabled" };
+	} else if (model.reasoning && miniMaxMode === "toggle") {
 		// MiniMax's Messages endpoint defaults to off and only supports a
 		// switch. Claude budget_tokens/output_config.effort do not apply.
 		if (options?.thinkingEnabled !== undefined) {
@@ -3984,8 +4061,8 @@ function buildParams(
 
 			const compat = getAnthropicCompat(model);
 			if (mode === "anthropic-adaptive" && !compat.disableAdaptiveThinking) {
-				// Starting with Anthropic model Opus 4.7, adaptive thinking content is omitted from the
-				// response by default. Opt into summarized reasoning so thinking deltas keep
+				// Opus 4.7+, Fable, and Haiku 5+ omit adaptive thinking content by
+				// default. Opt into summarized reasoning so thinking deltas keep
 				// streaming with human-readable content for callers that rely on it.
 				const adaptive: { type: "adaptive"; display?: AnthropicThinkingDisplay } = { type: "adaptive" };
 				if (supportsAdaptiveThinkingDisplay(model.id)) {
@@ -4043,7 +4120,7 @@ function buildParams(
 	// that pair with `thinking`/`redacted_thinking` blocks "cannot be modified", so the
 	// replay has to degrade in the same rebuild. Runs before the billing/system payload
 	// snapshot so the attribution hash covers the messages actually sent.
-	if (disableThinkingIfToolChoiceForced(params) && hasNativeThinkingBlocks(params.messages)) {
+	if (disableThinkingIfToolChoiceForced(params, model.id) && hasNativeThinkingBlocks(params.messages)) {
 		params.messages = convertAnthropicMessages(context.messages, model, isOAuthToken, {
 			...thinkingRepair,
 			repairAllAssistantThinking: true,

package/src/providers/google-gemini-headers.d.ts

@@ -42,7 +42,7 @@ export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION = "You are Antigravity, a po
  *
  * Overridable via PI_AI_ANTIGRAVITY_USER_AGENT environment variable.
  */
-export declare let getAntigravityUserAgent: () => string;
+export declare function getAntigravityUserAgent(): string;
 export declare const getAntigravityRequestHeaders: () => {
     "User-Agent": string;
 };

package/src/providers/google-gemini-headers.ts

@@ -93,12 +93,12 @@ This means you do **NOT** need to poll in a loop while waiting for messages or u
  *
  * Overridable via PI_AI_ANTIGRAVITY_USER_AGENT environment variable.
  */
-export let getAntigravityUserAgent = () => {
-	const override = process.env.PI_AI_ANTIGRAVITY_USER_AGENT;
-	const userAgent = override || "antigravity/cli/1.3.4 (os_type=darwin; arch=arm64; aidev_client; auth_method=oauth)";
-	getAntigravityUserAgent = () => userAgent;
-	return userAgent;
-};
+export function getAntigravityUserAgent(): string {
+	return (
+		process.env.PI_AI_ANTIGRAVITY_USER_AGENT ||
+		"antigravity/cli/1.3.4 (os_type=darwin; arch=arm64; aidev_client; auth_method=oauth)"
+	);
+}
 
 export const getAntigravityRequestHeaders = () => ({
 	"User-Agent": getAntigravityUserAgent(),

package/src/providers/transform-messages.ts

@@ -138,6 +138,34 @@ function compressRepeatedThinkingParagraphs(thinking: string): string {
 	return compressed ? compressedParts.join("") : thinking;
 }
 
+/** Escape untrusted text placed between the stale-tool-result tags. */
+function escapeXmlText(input: string): string {
+	if (!/[&<>]/.test(input)) return input;
+	let output = "";
+	for (const char of input) {
+		if (char === "&") output += "&amp;";
+		else if (char === "<") output += "&lt;";
+		else if (char === ">") output += "&gt;";
+		else output += char;
+	}
+	return output;
+}
+
+/** Escape an untrusted tool name or id used in a double-quoted attribute. */
+function escapeXmlAttribute(input: string): string {
+	if (!/[&<>"']/.test(input)) return input;
+	let output = "";
+	for (const char of input) {
+		if (char === "&") output += "&amp;";
+		else if (char === "<") output += "&lt;";
+		else if (char === ">") output += "&gt;";
+		else if (char === '"') output += "&quot;";
+		else if (char === "'") output += "&apos;";
+		else output += char;
+	}
+	return output;
+}
+
 export function transformMessages<TApi extends Api>(
 	messages: Message[],
 	model: Model<TApi>,
@@ -432,9 +460,12 @@ export function transformMessages<TApi extends Api>(
 				}
 				if (textParts.length > 0) {
 					const errorAttr = msg.isError ? ' is-error="true"' : "";
+					const toolAttr = escapeXmlAttribute(msg.toolName);
+					const idAttr = escapeXmlAttribute(msg.toolCallId);
+					const body = escapeXmlText(textParts.join("\n"));
 					result.push({
 						role: "user",
-						content: `<stale-tool-result tool="${msg.toolName}" id="${msg.toolCallId}"${errorAttr}>\n${textParts.join("\n")}\n</stale-tool-result>`,
+						content: `<stale-tool-result tool="${toolAttr}" id="${idAttr}"${errorAttr}>\n${body}\n</stale-tool-result>`,
 						timestamp: messageTimestamp,
 					} as UserMessage);
 				}

package/src/stream.ts

@@ -1005,7 +1005,7 @@ function resolveBedrockThinkingBudget(
 	model: Model<"bedrock-converse-stream">,
 	options?: SimpleStreamOptions,
 ): { budget: number; level: Effort } | null {
-	if (!options?.reasoning || !model.reasoning) return null;
+	if (!options?.reasoning || options.disableReasoning || !model.reasoning) return null;
 	const level = requireSupportedEffort(model, options.reasoning);
 	const budget = options.thinkingBudgets?.[level] ?? BEDROCK_CLAUDE_THINKING[level];
 	return { budget, level };
@@ -1133,7 +1133,7 @@ function mapOptionsForApi<TApi extends Api>(
 				});
 			}
 			// Explicitly disable thinking when reasoning is not specified or model doesn't support it
-			const reasoning = options?.reasoning;
+			const reasoning = options?.disableReasoning ? undefined : options?.reasoning;
 			if (!reasoning || !model.reasoning) {
 				return castApi<"anthropic-messages">({
 					...base,
@@ -1144,7 +1144,7 @@ function mapOptionsForApi<TApi extends Api>(
 				});
 			}
 
-			let thinkingBudget = options.thinkingBudgets?.[reasoning] ?? ANTHROPIC_THINKING[reasoning];
+			let thinkingBudget = options?.thinkingBudgets?.[reasoning] ?? ANTHROPIC_THINKING[reasoning];
 			if (thinkingBudget <= 0) {
 				return castApi<"anthropic-messages">({
 					...base,
@@ -1238,7 +1238,7 @@ function mapOptionsForApi<TApi extends Api>(
 		case "bedrock-converse-stream": {
 			const bedrockBase: BedrockOptions = {
 				...base,
-				reasoning: options?.reasoning,
+				reasoning: options?.disableReasoning ? undefined : options?.reasoning,
 				thinkingBudgets: options?.thinkingBudgets,
 				toolChoice: mapAnthropicToolChoice(options?.toolChoice),
 				thinkingDisplay: options?.hideThinkingSummary ? "omitted" : undefined,

package/src/utils/discovery/antigravity.ts

@@ -1,6 +1,7 @@
+import { logger } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import { isRetiredModelKey } from "../../model-retirements";
-import { getAntigravityUserAgent } from "../../providers/google-gemini-headers";
+import { getAntigravityUserAgent, getGeminiCliUserAgent } from "../../providers/google-gemini-headers";
 import type { Model } from "../../types";
 
 /**
@@ -171,7 +172,7 @@ export interface FetchAntigravityDiscoveryModelsOptions {
 	token: string;
 	/** Optional endpoint override. Defaults to Antigravity fallback endpoints. */
 	endpoint?: string;
-	/** Deprecated and ignored for antigravity discovery parity. */
+	/** Optional Google Cloud project ID for tier-gated model discovery. */
 	project?: string;
 	/** Optional user agent override. */
 	userAgent?: string;
@@ -185,6 +186,8 @@ export interface FetchAntigravityDiscoveryModelsOptions {
 	 * Default: `google-antigravity`.
 	 */
 	targetProvider?: "google-antigravity" | "google-gemini-cli";
+	/** Optional logger for debug diagnostics. */
+	logger?: Pick<typeof logger, "debug">;
 }
 
 /**
@@ -199,14 +202,20 @@ export async function fetchAntigravityDiscoveryModels(
 	const fetcher = options.fetcher ?? fetch;
 	const signal = options.signal ?? AbortSignal.timeout(5_000);
 	const targetProvider = options.targetProvider ?? "google-antigravity";
-	const userAgent = options.userAgent ?? getAntigravityUserAgent();
+	const userAgent = options.userAgent ?? getAntigravityDiscoveryUserAgent();
 	const endpoints = options.endpoint
 		? [trimTrailingSlashes(options.endpoint)]
 		: DEFAULT_ANTIGRAVITY_DISCOVERY_ENDPOINTS.map(trimTrailingSlashes);
+	const debugLogger = options.logger ?? logger;
 
 	for (const endpoint of endpoints) {
+		const redactedEndpoint = redactAntigravityEndpoint(endpoint);
 		let response: Response;
 		try {
+			const requestBody: Record<string, unknown> = {};
+			if (options.project) {
+				requestBody.project = options.project;
+			}
 			response = await fetcher(`${endpoint}${FETCH_AVAILABLE_MODELS_PATH}`, {
 				method: "POST",
 				headers: {
@@ -214,13 +223,19 @@ export async function fetchAntigravityDiscoveryModels(
 					"Content-Type": "application/json",
 					"User-Agent": userAgent,
 				},
-				body: JSON.stringify({}),
+				body: JSON.stringify(requestBody),
 				signal,
 			});
 		} catch {
 			continue;
 		}
 
+		debugLogger.debug("Antigravity discovery endpoint response", {
+			endpoint: redactedEndpoint,
+			status: response.status,
+			statusText: response.statusText,
+		});
+
 		if (!response.ok) {
 			continue;
 		}
@@ -256,33 +271,37 @@ export async function fetchAntigravityDiscoveryModels(
 		const filteredModelDetails: Record<string, Partial<AntigravityDiscoveryApiModel> & { reason: string }> = {};
 
 		const models: Model<"google-gemini-cli">[] = [];
+		const modelDropReasons: Record<string, string> = {};
 
 		for (const [modelId, model] of Object.entries(parsed.models ?? {})) {
+			let dropReason: string | undefined;
+
 			if (ANTIGRAVITY_DISCOVERY_DENYLIST.has(modelId)) {
-				if (debugEnabled) {
-					filteredByDenylist.push(modelId);
-					filteredModelDetails[modelId] = { ...model, reason: "denylist" };
-				}
-				continue;
-			}
-			if (isRetiredModelKey(targetProvider, modelId)) {
-				if (debugEnabled) {
-					filteredByRetirement.push(modelId);
-					filteredModelDetails[modelId] = { ...model, reason: `retired-${targetProvider}` };
-				}
-				continue;
-			}
-			if (model.disabled === true) {
-				if (debugEnabled) {
-					filteredByDisabled.push(modelId);
-					filteredModelDetails[modelId] = { ...model, reason: "disabled" };
-				}
-				continue;
+				dropReason = "denylist";
+			} else if (isRetiredModelKey(targetProvider, modelId)) {
+				dropReason = "retired";
+			} else if (model.disabled === true) {
+				dropReason = "disabled";
+			} else if (model.isInternal === true && !surfacedModelIds.has(modelId)) {
+				dropReason = "isInternal-not-surfaced";
 			}
-			if (model.isInternal === true && !surfacedModelIds.has(modelId)) {
+
+			if (dropReason) {
+				modelDropReasons[modelId] = dropReason;
 				if (debugEnabled) {
-					filteredByInternal.push(modelId);
-					filteredModelDetails[modelId] = { ...model, reason: "internal-not-surfaced" };
+					if (dropReason === "denylist") filteredByDenylist.push(modelId);
+					else if (dropReason === "retired") filteredByRetirement.push(modelId);
+					else if (dropReason === "disabled") filteredByDisabled.push(modelId);
+					else filteredByInternal.push(modelId);
+					filteredModelDetails[modelId] = {
+						...model,
+						reason:
+							dropReason === "retired"
+								? `retired-${targetProvider}`
+								: dropReason === "isInternal-not-surfaced"
+									? "internal-not-surfaced"
+									: dropReason,
+					};
 				}
 				continue;
 			}
@@ -317,6 +336,18 @@ export async function fetchAntigravityDiscoveryModels(
 			});
 		}
 
+		if (Object.keys(modelDropReasons).length > 0) {
+			debugLogger.debug("Antigravity discovery dropped models", {
+				endpoint: redactedEndpoint,
+				dropReasons: modelDropReasons,
+			});
+		}
+
+		debugLogger.debug("Antigravity discovery kept models", {
+			endpoint: redactedEndpoint,
+			keptModelIds: models.map(m => m.id),
+		});
+
 		models.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
 
 		if (debugEnabled) {
@@ -425,3 +456,15 @@ function toPositiveNumber(value: unknown, fallback: number): number {
 function trimTrailingSlashes(value: string): string {
 	return value.replace(/\/+$/, "");
 }
+
+export function getAntigravityDiscoveryUserAgent(): string {
+	return process.env.PI_AI_ANTIGRAVITY_USER_AGENT ? getAntigravityUserAgent() : getGeminiCliUserAgent();
+}
+
+function redactAntigravityEndpoint(value: string): string {
+	try {
+		return new URL(value).origin;
+	} catch {
+		return "invalid endpoint";
+	}
+}

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

@@ -1,33 +1,3 @@
-/**
- * GLM ZCode OAuth flow (UNOFFICIAL, opt-in).
- *
- * 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.
- *
- * 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:
- *   - `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.
- *
- * 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";
 export declare const GLM_ZCODE_REFRESH_SKEW_MS: number;

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

@@ -4,8 +4,9 @@
  * 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.
+ * violate ZCode/Z.AI Terms of Service. Endpoints and the client id are
+ * overridable via `ZCODE_OAUTH_*` from the launching shell or user-owned env
+ * files. A project `.env` is not a trusted source for those values.
  *
  * Verified end-to-end against the ZCode host bundle (`resolveZaiApiKey` /
  * `resolveBizApiKey`) and live traffic:
@@ -28,6 +29,7 @@
  * 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 { $credentialEnv } from "@gajae-code/utils";
 import { OAuthCallbackFlow, type OAuthCallbackFlowOptions, parseCallbackInput } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";
 
@@ -52,9 +54,18 @@ export const GLM_ZCODE_ANTHROPIC_BASE_URL = "https://api.z.ai/api/anthropic";
 
 type FetchImpl = typeof globalThis.fetch;
 
+/**
+ * Trusted override for one `ZCODE_OAUTH_*` name.
+ *
+ * These values choose where the authorization code and upstream token are sent.
+ * `$credentialEnv` keeps the launching shell and user-owned env files and skips
+ * a project `.env`. A shell value is also skipped when it repeats that file
+ * or the project declaration is dynamic, and when no other trusted source
+ * sets the name an empty value still uses the built-in endpoint.
+ */
 function envOr(name: string, fallback: string): string {
-	const value = process.env[name];
-	return value && value.trim().length > 0 ? value.trim() : fallback;
+	const value = $credentialEnv(name)?.trim();
+	return value ? value : fallback;
 }
 
 function resolveAuthorizeUrl(): string {

package/src/utils/oauth/openai-codex.ts

@@ -63,6 +63,41 @@ interface PKCE {
 	challenge: string;
 }
 
+/**
+ * Extract a readable error message from OpenAI OAuth error response.
+ * Handles both string errors (error + error_description) and object errors (code/type + message).
+ */
+function extractOpenAIErrorMessage(body: unknown): string {
+	if (typeof body !== "object" || body === null) return "";
+
+	const obj = body as Record<string, unknown>;
+	const error = obj.error;
+
+	if (typeof error === "string") {
+		// String error: "invalid_grant", optionally explained by error_description.
+		// Parts are joined so an empty error string never leaves a dangling separator.
+		const desc = obj.error_description;
+		const parts = desc !== undefined && typeof desc === "string" && desc.length > 0 ? [error, desc] : [error];
+		return parts.filter(part => part.length > 0).join(": ");
+	}
+
+	if (typeof error === "object" && error !== null) {
+		// Object error: {message, type, code}. `code` wins over `type`, but only when
+		// it is a usable string — a numeric or empty code must fall back to the type
+		// rather than silently dropping both.
+		const err = error as Record<string, unknown>;
+		const code = typeof err.code === "string" && err.code.length > 0 ? err.code : err.type;
+		const msg = err.message;
+
+		const parts: string[] = [];
+		if (typeof code === "string" && code.length > 0) parts.push(code);
+		if (typeof msg === "string" && msg.length > 0) parts.push(msg);
+		return parts.join(": ");
+	}
+
+	return "";
+}
+
 class OpenAICodexOAuthFlow extends OAuthCallbackFlow {
 	constructor(
 		ctrl: OAuthController,
@@ -120,9 +155,9 @@ async function exchangeCodeForToken(code: string, verifier: string, redirectUri:
 	if (!tokenResponse.ok) {
 		let detail = `${tokenResponse.status}`;
 		try {
-			const body = (await tokenResponse.json()) as { error?: string; error_description?: string };
-			if (body.error)
-				detail = `${tokenResponse.status} ${body.error}${body.error_description ? `: ${body.error_description}` : ""}`;
+			const body = await tokenResponse.json();
+			const errorMsg = extractOpenAIErrorMessage(body);
+			if (errorMsg) detail = `${tokenResponse.status} ${errorMsg}`;
 		} catch {}
 		throw new Error(`Token exchange failed: ${detail}`);
 	}
@@ -272,9 +307,9 @@ export async function refreshOpenAICodexToken(refreshToken: string): Promise<OAu
 	if (!response.ok) {
 		let detail = `${response.status}`;
 		try {
-			const body = (await response.json()) as { error?: string; error_description?: string };
-			if (body.error)
-				detail = `${response.status} ${body.error}${body.error_description ? `: ${body.error_description}` : ""}`;
+			const body = await response.json();
+			const errorMsg = extractOpenAIErrorMessage(body);
+			if (errorMsg) detail = `${response.status} ${errorMsg}`;
 		} catch {}
 		throw new Error(`OpenAI Codex token refresh failed: ${detail}`);
 	}