@gajae-code/ai 0.18.5 → 0.18.7

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

@@ -19,6 +19,8 @@ interface HealthPayload {
 	ok?: unknown;
 	pid?: unknown;
 	port?: unknown;
+	status?: unknown;
+	service?: unknown;
 	version?: unknown;
 }
 
@@ -103,7 +105,10 @@ async function fetchJson(url: string, signal?: AbortSignal): Promise<unknown> {
 function isOpenCodexHealth(payload: unknown, expectedPort: number): boolean {
 	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
 	const health = payload as HealthPayload;
-	return health.ok === true && health.version === "opencodex" && health.port === expectedPort;
+	const identityOk =
+		(health.ok === true && health.version === "opencodex") ||
+		(health.status === "ok" && health.service === "opencodex");
+	return identityOk && health.port === expectedPort;
 }
 
 export async function resolveOpenCodexEndpoint(signal?: AbortSignal): Promise<OpenCodexEndpoint | undefined> {

package/src/providers/openai-responses.ts

@@ -1006,7 +1006,7 @@ export function convertTools(tools: Tool[], strictMode: boolean, model: Model<"o
 			name: tool.name,
 			description: tool.description || "",
 			parameters,
-			...(effectiveStrict && { strict: true }),
+			strict: effectiveStrict,
 		} as OpenAITool;
 	});
 	// Tool definitions bypass the `input`/`instructions` sanitizers, so a

package/src/providers/register-builtins.ts

@@ -11,6 +11,7 @@
  * loader: heavy SDKs stay out of the CLI startup parse graph.
  */
 
+import { $env } from "@gajae-code/utils";
 import type {
 	Api,
 	AssistantMessage,
@@ -280,16 +281,33 @@ function forwardStream<TApi extends Api>(
 					model.provider,
 					limits?.defaultFirstEventTimeoutMs,
 				);
+				const firstEventTimeoutMs =
+					options.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs, firstEventFallbackMs);
+				const firstEventTimeoutSource =
+					options.streamFirstEventTimeoutMs !== undefined
+						? "stream-option"
+						: $env.PI_STREAM_FIRST_EVENT_TIMEOUT_MS !== undefined &&
+								Number.isFinite(Number($env.PI_STREAM_FIRST_EVENT_TIMEOUT_MS))
+							? "env"
+							: idleTimeoutMs !== undefined &&
+									(firstEventFallbackMs === undefined || idleTimeoutMs >= firstEventFallbackMs)
+								? "idle-timeout"
+								: firstEventFallbackMs !== undefined
+									? "provider-fallback"
+									: "default";
 				watchedSource = iterateWithIdleTimeout(source, {
 					idleTimeoutMs,
-					firstItemTimeoutMs:
-						options.streamFirstEventTimeoutMs ??
-						getStreamFirstEventTimeoutMs(idleTimeoutMs, firstEventFallbackMs),
+					firstItemTimeoutMs: firstEventTimeoutMs,
 					errorMessage: LAZY_STREAM_IDLE_TIMEOUT_ERROR,
 					firstItemErrorMessage: LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR,
 					onIdle: () => abortTracker.abortLocally(new Error(LAZY_STREAM_IDLE_TIMEOUT_ERROR)),
 					onFirstItemTimeout: () =>
-						abortTracker.abortLocally(new FirstEventTimeoutError(LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR)),
+						abortTracker.abortLocally(
+							new FirstEventTimeoutError(LAZY_STREAM_FIRST_EVENT_TIMEOUT_ERROR, {
+								firstEventTimeoutMs,
+								firstEventTimeoutSource,
+							}),
+						),
 					abortSignal: options.signal,
 					// Synthetic starts and tool-capability negotiation are control-plane events,
 					// not model progress. Keep the first-event window active until assistant output
@@ -313,7 +331,7 @@ function forwardStream<TApi extends Api>(
 			}
 		} catch (error) {
 			const stopReason = abortTracker.wasCallerAbort() ? "aborted" : "error";
-			const message = createLazyLoadErrorMessage(model, error, stopReason);
+			const message = createLazyLoadErrorMessage(model, error, stopReason, source);
 			target.push({ type: "error", reason: stopReason, error: message });
 			target.end(message);
 		}
@@ -324,8 +342,37 @@ function createLazyLoadErrorMessage<TApi extends Api>(
 	model: Model<TApi>,
 	error: unknown,
 	stopReason: Extract<AssistantMessage["stopReason"], "aborted" | "error"> = "error",
+	source?: AsyncIterable<AssistantMessageEvent>,
 ): AssistantMessage {
 	const transportFailure = transportFailureFacts(error);
+	const carriedDiagnostics =
+		source && typeof source === "object"
+			? (source as { googleGeminiCliDiagnostics?: AssistantMessage["googleGeminiCliDiagnostics"] })
+					.googleGeminiCliDiagnostics
+			: undefined;
+	const diagnostics =
+		carriedDiagnostics ??
+		(error instanceof FirstEventTimeoutError
+			? (
+					error as FirstEventTimeoutError & {
+						googleGeminiCliDiagnostics?: AssistantMessage["googleGeminiCliDiagnostics"];
+					}
+				).googleGeminiCliDiagnostics
+			: undefined);
+	if (diagnostics && typeof error === "object" && error !== null) {
+		const timeoutFacts = error as {
+			firstEventTimeoutMs?: unknown;
+			firstEventTimeoutSource?: unknown;
+		};
+		if (typeof timeoutFacts.firstEventTimeoutMs === "number") {
+			diagnostics.firstEventTimeoutMs = timeoutFacts.firstEventTimeoutMs;
+		}
+		if (typeof timeoutFacts.firstEventTimeoutSource === "string") {
+			diagnostics.firstEventTimeoutSource = timeoutFacts.firstEventTimeoutSource as NonNullable<
+				AssistantMessage["googleGeminiCliDiagnostics"]
+			>["firstEventTimeoutSource"];
+		}
+	}
 	return {
 		role: "assistant",
 		content: [],
@@ -344,6 +391,7 @@ function createLazyLoadErrorMessage<TApi extends Api>(
 		errorMessage:
 			stopReason === "aborted" ? "Request was aborted" : error instanceof Error ? error.message : String(error),
 		...(transportFailure ? { transportFailure } : {}),
+		...(diagnostics ? { googleGeminiCliDiagnostics: diagnostics } : {}),
 		timestamp: Date.now(),
 	};
 }

package/src/stream.ts

@@ -1022,8 +1022,28 @@ function mapOptionsForApi<TApi extends Api>(
 			// For older models: use budget-based thinking
 			if (model.thinking?.mode === "anthropic-adaptive") {
 				const effort = mapEffortToAnthropicAdaptiveEffort(model, reasoning);
+
+				// Adaptive mode sends effort directly (no explicit budget_tokens).
+				// However, the thinking consumes tokens from the overall max_tokens budget.
+				// If max_tokens is capped at DEFAULT_REQUEST_MAX_TOKENS (32k),
+				// high/xhigh/max reasoning consumes all 32k, leaving no output tokens.
+				// Solution: when caller did not explicitly set maxTokens,
+				// increase the cap to model.maxTokens to allow room for output.
+				let adaptiveMaxTokens = base.maxTokens ?? model.maxTokens;
+				const hasExplicitMaxTokens = Number.isSafeInteger(options?.maxTokens) && (options?.maxTokens as number) > 0;
+				if (
+					!hasExplicitMaxTokens &&
+					adaptiveMaxTokens === DEFAULT_REQUEST_MAX_TOKENS &&
+					Number.isSafeInteger(model.maxTokens) &&
+					model.maxTokens > DEFAULT_REQUEST_MAX_TOKENS
+				) {
+					// Increase to model.maxTokens to leave room for both thinking and output
+					adaptiveMaxTokens = model.maxTokens;
+				}
+
 				return castApi<"anthropic-messages">({
 					...base,
+					maxTokens: adaptiveMaxTokens,
 					thinkingEnabled: true,
 					effort,
 					toolChoice: mapAnthropicToolChoice(options?.toolChoice),

package/src/types.d.ts

@@ -640,6 +640,8 @@ export interface AssistantMessage {
      * supplied no trustworthy structured evidence.
      */
     providerDiagnostic?: ProviderDiagnostic;
+    /** Redacted first-event transport timing and chunk-shape diagnostics for Google Gemini CLI. */
+    googleGeminiCliDiagnostics?: GoogleGeminiCliDiagnostics;
     /** Typed upstream failure facts retained for retry classification without parsing errorMessage. */
     transportFailure?: TransportFailureFacts;
     /**
@@ -658,6 +660,19 @@ export interface AssistantMessage {
     /** Prompt-prefix fingerprint of the request that produced this message. */
     promptPrefix?: PromptPrefixTelemetry;
 }
+export interface GoogleGeminiCliDiagnostics {
+    responseAtMs?: number;
+    firstRawSseAtMs?: number;
+    chunkCounts: {
+        content: number;
+        thinking: number;
+        functionCall: number;
+        usageOnly: number;
+        other: number;
+    };
+    firstEventTimeoutMs?: number;
+    firstEventTimeoutSource?: "stream-option" | "env" | "idle-timeout" | "provider-fallback" | "default";
+}
 export interface ToolResultMessage<TDetails = any> {
     role: "toolResult";
     toolCallId: string;
@@ -746,7 +761,7 @@ export type TSchema = ZodType | TJsonSchema;
 export type Static<S> = S extends ZodType ? z.infer<S> : S extends {
     static: infer T;
 } ? T : unknown;
-export type RawArgumentRejectionCode = "ask-deep-interview-question-body-required" | "ask-intent-review-requires-positive-round" | "ask-intent-contract-requires-non-empty-authority" | "ask-deep-interview-metadata-requires-deep-interview-gate" | "ask-round-zero-metadata-requires-full-topology-fields" | "todo-write-unknown-root-key" | "todo-write-unknown-op-entry-key" | "todo-write-unknown-op-value" | "todo-write-done-drop-requires-target" | "todo-write-unknown-init-entry-key";
+export type RawArgumentRejectionCode = "ask-question-body-required" | "ask-deep-interview-metadata-required" | "ask-deep-interview-single-question-required" | "ask-deep-interview-question-body-required" | "ask-intent-review-requires-positive-round" | "ask-intent-contract-requires-non-empty-authority" | "ask-deep-interview-metadata-requires-deep-interview-gate" | "ask-round-zero-metadata-requires-full-topology-fields" | "todo-write-unknown-root-key" | "todo-write-unknown-op-entry-key" | "todo-write-unknown-op-value" | "todo-write-done-drop-requires-target" | "todo-write-unknown-init-entry-key";
 /**
  * Optional structured detail attached to a raw-argument rejection. The fixed
  * per-code guidance in `RAW_ARGUMENT_REJECTION_MESSAGES` explains the shape;

package/src/types.ts

@@ -881,6 +881,8 @@ export interface AssistantMessage {
 	 * supplied no trustworthy structured evidence.
 	 */
 	providerDiagnostic?: ProviderDiagnostic;
+	/** Redacted first-event transport timing and chunk-shape diagnostics for Google Gemini CLI. */
+	googleGeminiCliDiagnostics?: GoogleGeminiCliDiagnostics;
 	/** Typed upstream failure facts retained for retry classification without parsing errorMessage. */
 	transportFailure?: TransportFailureFacts;
 	/**
@@ -900,6 +902,20 @@ export interface AssistantMessage {
 	promptPrefix?: PromptPrefixTelemetry;
 }
 
+export interface GoogleGeminiCliDiagnostics {
+	responseAtMs?: number;
+	firstRawSseAtMs?: number;
+	chunkCounts: {
+		content: number;
+		thinking: number;
+		functionCall: number;
+		usageOnly: number;
+		other: number;
+	};
+	firstEventTimeoutMs?: number;
+	firstEventTimeoutSource?: "stream-option" | "env" | "idle-timeout" | "provider-fallback" | "default";
+}
+
 export interface ToolResultMessage<TDetails = any> {
 	role: "toolResult";
 	toolCallId: string;
@@ -1019,6 +1035,9 @@ export type TSchema = ZodType | TJsonSchema;
 export type Static<S> = S extends ZodType ? z.infer<S> : S extends { static: infer T } ? T : unknown;
 
 export type RawArgumentRejectionCode =
+	| "ask-question-body-required"
+	| "ask-deep-interview-metadata-required"
+	| "ask-deep-interview-single-question-required"
 	| "ask-deep-interview-question-body-required"
 	| "ask-intent-review-requires-positive-round"
 	| "ask-intent-contract-requires-non-empty-authority"

package/src/utils/fallback-transport.d.ts

@@ -23,6 +23,12 @@ export interface FallbackTrigger {
 export declare const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
 /** Stable code for a nominally successful response with no content or token usage. */
 export declare const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
+/**
+ * Terminal error code for a successful HTTP response whose body is not the protocol the
+ * provider speaks (for example a JSON or HTML error returned with 200). Deterministic for
+ * the request, so session retry and managed fallback must surface it instead of replaying.
+ */
+export declare const PROVIDER_PROTOCOL_MISMATCH_ERROR_CODE = "provider_protocol_mismatch";
 /**
  * OpenAI's typed capacity-overload code. It arrives without an HTTP status —
  * inside an HTTP 200 terminal Responses envelope or a Codex error event — so the

package/src/utils/fallback-transport.ts

@@ -26,6 +26,12 @@ export interface FallbackTrigger {
 export const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
 /** Stable code for a nominally successful response with no content or token usage. */
 export const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
+/**
+ * Terminal error code for a successful HTTP response whose body is not the protocol the
+ * provider speaks (for example a JSON or HTML error returned with 200). Deterministic for
+ * the request, so session retry and managed fallback must surface it instead of replaying.
+ */
+export const PROVIDER_PROTOCOL_MISMATCH_ERROR_CODE = "provider_protocol_mismatch";
 /**
  * OpenAI's typed capacity-overload code. It arrives without an HTTP status —
  * inside an HTTP 200 terminal Responses envelope or a Codex error event — so the

package/src/utils/idle-iterator.d.ts

@@ -72,6 +72,7 @@ export interface FirstEventTimeoutFacts {
     requestBytes?: number;
     firstEventElapsedMs?: number;
     firstEventTimeoutMs?: number;
+    firstEventTimeoutSource?: "stream-option" | "env" | "idle-timeout" | "provider-fallback" | "default";
     endpointClass?: "canonical" | "custom";
     retryMaxAttempts?: number;
 }
@@ -80,6 +81,7 @@ export declare class FirstEventTimeoutError extends Error {
     readonly requestBytes?: number;
     readonly firstEventElapsedMs?: number;
     readonly firstEventTimeoutMs?: number;
+    readonly firstEventTimeoutSource?: FirstEventTimeoutFacts["firstEventTimeoutSource"];
     readonly endpointClass?: "canonical" | "custom";
     readonly retryMaxAttempts?: number;
     constructor(message: string, facts?: FirstEventTimeoutFacts);

package/src/utils/idle-iterator.ts

@@ -179,6 +179,7 @@ export interface FirstEventTimeoutFacts {
 	requestBytes?: number;
 	firstEventElapsedMs?: number;
 	firstEventTimeoutMs?: number;
+	firstEventTimeoutSource?: "stream-option" | "env" | "idle-timeout" | "provider-fallback" | "default";
 	endpointClass?: "canonical" | "custom";
 	retryMaxAttempts?: number;
 }
@@ -188,6 +189,7 @@ export class FirstEventTimeoutError extends Error {
 	readonly requestBytes?: number;
 	readonly firstEventElapsedMs?: number;
 	readonly firstEventTimeoutMs?: number;
+	readonly firstEventTimeoutSource?: FirstEventTimeoutFacts["firstEventTimeoutSource"];
 	readonly endpointClass?: "canonical" | "custom";
 	readonly retryMaxAttempts?: number;
 
@@ -197,11 +199,19 @@ export class FirstEventTimeoutError extends Error {
 		this.requestBytes = facts.requestBytes;
 		this.firstEventElapsedMs = facts.firstEventElapsedMs;
 		this.firstEventTimeoutMs = facts.firstEventTimeoutMs;
+		this.firstEventTimeoutSource = facts.firstEventTimeoutSource;
 		this.endpointClass = facts.endpointClass;
 		this.retryMaxAttempts = facts.retryMaxAttempts;
 	}
 }
 
+/**
+ * Longest delay setTimeout honors. Bun, like Node, fires any larger delay after 1 ms,
+ * so a very long timeout (for example an env value meant as "effectively never")
+ * would otherwise abort the stream immediately.
+ */
+const MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
+
 const dummyWatchdog = setTimeout(() => {}, 1);
 clearTimeout(dummyWatchdog);
 
@@ -211,7 +221,7 @@ clearTimeout(dummyWatchdog);
  */
 export function createWatchdog(timeoutMs: number | undefined, onTimeout: () => void): Watchdog {
 	if (timeoutMs !== undefined && timeoutMs > 0) {
-		return setTimeout(onTimeout, timeoutMs);
+		return setTimeout(onTimeout, Math.min(timeoutMs, MAX_TIMER_DELAY_MS));
 	}
 	return undefined;
 }
@@ -335,10 +345,10 @@ export async function* iterateWithIdleTimeout<T>(
 			let timer: NodeJS.Timeout | undefined;
 			let resolveTimeout: ((value: { kind: "timeout" }) => void) | undefined;
 			const enforceTimeout = !noTimeoutEnforced && activeTimeoutMs !== undefined && activeTimeoutMs >= 0;
-			if (enforceTimeout) {
+			if (enforceTimeout && activeTimeoutMs !== undefined) {
 				const { promise, resolve } = Promise.withResolvers<{ kind: "timeout" }>();
 				resolveTimeout = resolve;
-				timer = setTimeout(() => resolve({ kind: "timeout" }), activeTimeoutMs);
+				timer = setTimeout(() => resolve({ kind: "timeout" }), Math.min(activeTimeoutMs, MAX_TIMER_DELAY_MS));
 				racers.push(promise);
 			}
 

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

@@ -57,6 +57,11 @@ export declare class GlmZcodeOAuthFlow extends OAuthCallbackFlow {
     }>;
     exchangeToken(code: string, state: string, redirectUri: string): Promise<OAuthCredentials>;
 }
+/**
+ * Manual-input prompt for the paste fallback. Repeats the redirect-URL shape and
+ * the DevTools pointer so a re-prompt after a rejected paste stays self-contained.
+ */
+export declare const GLM_ZCODE_MANUAL_INPUT_PROMPT = "Paste the full zcode://oauth/callback?code=\u2026&state=\u2026 URL (copy it from browser DevTools \u2192 Network tab; the address bar never shows it) or the authorization code:";
 export declare function loginGlmZcode(ctrl: OAuthController, options?: GlmZcodeOAuthFlowOptions): Promise<OAuthCredentials>;
 export interface GlmZcodeRefreshOptions {
     signal?: AbortSignal;

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

@@ -387,7 +387,7 @@ export class GlmZcodeOAuthFlow extends OAuthCallbackFlow {
 		return {
 			url: `${authorizeUrl}?${params.toString()}`,
 			instructions:
-				"Complete Z.AI login in your browser. This is an UNOFFICIAL ZCode-based login — use at your own risk; it may stop working or violate ZCode/Z.AI Terms of Service. Because this CLI cannot receive the zcode:// redirect, paste the final redirect URL or authorization code when prompted. If the ZCode desktop app is installed, cancel the browser's prompt to open it: the app exchanges the single-use code itself and the pasted code is then rejected (broker error 2007).",
+				"Complete Z.AI login in your browser. This is an UNOFFICIAL ZCode-based login — use at your own risk; it may stop working or violate ZCode/Z.AI Terms of Service. If the ZCode desktop app is installed, cancel the browser's prompt to open it: the app exchanges the single-use code itself and the pasted code is then rejected (broker error 2007). After login the browser redirects to a zcode:// address, which never appears in the address bar — copy it from DevTools instead: open the browser DevTools Network tab (filter: zcode), select the zcode://oauth/callback?code=…&state=… request, and paste that full URL (or just the code) at the prompt.",
 		};
 	}
 
@@ -396,6 +396,13 @@ export class GlmZcodeOAuthFlow extends OAuthCallbackFlow {
 	}
 }
 
+/**
+ * Manual-input prompt for the paste fallback. Repeats the redirect-URL shape and
+ * the DevTools pointer so a re-prompt after a rejected paste stays self-contained.
+ */
+export const GLM_ZCODE_MANUAL_INPUT_PROMPT =
+	"Paste the full zcode://oauth/callback?code=…&state=… URL (copy it from browser DevTools → Network tab; the address bar never shows it) or the authorization code:";
+
 export async function loginGlmZcode(
 	ctrl: OAuthController,
 	options?: GlmZcodeOAuthFlowOptions,

package/src/utils/oauth/index.ts

@@ -9,6 +9,16 @@ import type {
 	OAuthProviderInterface,
 } from "./types";
 
+export class UnknownOAuthProviderError extends Error {
+	readonly provider: string;
+
+	constructor(provider: string) {
+		super(`Unknown OAuth provider: ${provider}`);
+		this.name = "UnknownOAuthProviderError";
+		this.provider = provider;
+	}
+}
+
 const builtInOAuthProviders: OAuthProviderInfo[] = [
 	{
 		id: "anthropic",
@@ -442,7 +452,7 @@ export async function refreshOAuthToken(
 			newCredentials = credentials;
 			break;
 		default:
-			throw new Error(`Unknown OAuth provider: ${provider}`);
+			throw new UnknownOAuthProviderError(provider);
 	}
 	return newCredentials;
 }

package/src/utils/validation.ts

@@ -960,6 +960,11 @@ export function validateToolCall(tools: Tool[], toolCall: ToolCall): ToolCall["a
 }
 
 const RAW_ARGUMENT_REJECTION_MESSAGES: Record<RawArgumentRejectionCode, string> = {
+	"ask-question-body-required": "ask question bodies must contain non-whitespace text; remove empty extra questions",
+	"ask-deep-interview-metadata-required":
+		"active deep-interview questions require structured deepInterview metadata; question prose and workflowGate do not record an answer",
+	"ask-deep-interview-single-question-required":
+		"active deep-interview asks require exactly one question; include metadata on that question, never as an extra question",
 	"ask-deep-interview-question-body-required":
 		"deep-interview question bodies must contain a specific question, not a placeholder",
 	"ask-intent-review-requires-positive-round":