@gajae-code/coding-agent 0.18.7 → 0.18.8

package/src/config/model-registry.ts

@@ -13,6 +13,7 @@ import {
 	type Context,
 	codexContextOverrideKey,
 	createModelManager,
+	createTrustedStrippedModelClone,
 	Effort,
 	enrichModelThinking,
 	getBundledModels,
@@ -49,6 +50,8 @@ import {
 	readBoundedModelsJson,
 	resolveLoopbackOpenAIBaseUrl,
 } from "@gajae-code/ai/utils/discovery/openai-compatible";
+// Internal-only: registerFinalizedModelClone is not part of the public @gajae-code/ai surface
+import { registerFinalizedModelClone } from "@gajae-code/ai/utils/trusted-model-clone";
 
 // Sentinels for local-only OAuth tokens — declared inline to avoid loading provider
 // modules at startup. Must match the provider OAuth modules.
@@ -1771,9 +1774,6 @@ export class ModelRegistry {
 		{
 			fresh: boolean;
 			modelIds: ReadonlySet<string>;
-			profileModelIds?: ReadonlySet<string>;
-			profileFresh?: boolean;
-			profileEndpoint?: string;
 			authGeneration: string;
 			endpoint: string;
 		}
@@ -2746,20 +2746,7 @@ export class ModelRegistry {
 		}));
 	}
 	#stripModelBaseUrlQueries(models: readonly Model<Api>[]): Model<Api>[] {
-		return models.map(model => {
-			if (!model.baseUrl) return model;
-			try {
-				const parsed = new URL(model.baseUrl);
-				parsed.username = "";
-				parsed.password = "";
-				parsed.search = "";
-				parsed.hash = "";
-				return { ...model, baseUrl: parsed.toString().replace(/\/$/, "") };
-			} catch {
-				const { baseUrl: _baseUrl, ...withoutBaseUrl } = model;
-				return withoutBaseUrl as Model<Api>;
-			}
-		});
+		return models.map(model => createTrustedStrippedModelClone(model));
 	}
 	#stripUrlUserinfo(url: string | undefined): string | undefined {
 		if (!url) return url;
@@ -3288,6 +3275,11 @@ export class ModelRegistry {
 									result.provider,
 									this.#providerEvidenceApiKeys.get(result.provider),
 								) &&
+							result.configurationGeneration ===
+								this.authStorage.getProviderConfigurationGeneration(
+									result.provider,
+									this.#authStorageConfigOwner,
+								) &&
 							result.endpoint ===
 								this.#normalizeDiscoveryEvidenceEndpoint(
 									this.#effectiveDiscoveryProviderConfig(providerConfig).baseUrl ?? "",
@@ -3309,7 +3301,10 @@ export class ModelRegistry {
 									this.#providerEvidenceApiKeys.get(result.provider),
 								) ||
 							result.configurationGeneration !==
-								this.authStorage.getProviderConfigurationGeneration(result.provider) ||
+								this.authStorage.getProviderConfigurationGeneration(
+									result.provider,
+									this.#authStorageConfigOwner,
+								) ||
 							result.endpoint !==
 								this.#normalizeDiscoveryEvidenceEndpoint(
 									this.#effectiveDiscoveryProviderConfig(providerConfig).baseUrl ?? "",
@@ -3334,9 +3329,6 @@ export class ModelRegistry {
 				| {
 						fresh: boolean;
 						modelIds: ReadonlySet<string>;
-						profileModelIds?: ReadonlySet<string>;
-						profileFresh?: boolean;
-						profileEndpoint?: string;
 						authGeneration: string;
 						endpoint: string;
 				  }
@@ -3481,12 +3473,9 @@ export class ModelRegistry {
 				.map(([provider, evidence]) => [
 					provider,
 					evidence.fresh,
-					evidence.profileFresh,
 					evidence.authGeneration,
 					evidence.endpoint,
-					evidence.profileEndpoint,
 					[...evidence.modelIds].sort(),
-					evidence.profileModelIds === undefined ? undefined : [...evidence.profileModelIds].sort(),
 				]),
 			configured: [...this.#configuredDiscoveryEvidence.entries()]
 				.sort(([left], [right]) => left.localeCompare(right))
@@ -3540,7 +3529,10 @@ export class ModelRegistry {
 			? this.authStorage.has(provider) ||
 				this.authStorage.hasAuth(provider, undefined, { owner: this.#authStorageConfigOwner })
 			: !this.#isCredentiallessProvider(provider);
-		let preflightAuthConfigurationGeneration = this.authStorage.getProviderConfigurationGeneration(provider);
+		let preflightAuthConfigurationGeneration = this.authStorage.getProviderConfigurationGeneration(
+			provider,
+			this.#authStorageConfigOwner,
+		);
 		let preflightOAuthRefreshGeneration = this.authStorage.getProviderOAuthRefreshGeneration(provider);
 		if (shouldPreflightAuth) {
 			if (optionalAuth && isCurrentPreflight()) this.#credentiallessAuthFallbackProviders.delete(provider);
@@ -3555,7 +3547,10 @@ export class ModelRegistry {
 						credentialSessionId,
 					}),
 				);
-				const currentAuthConfigurationGeneration = this.authStorage.getProviderConfigurationGeneration(provider);
+				const currentAuthConfigurationGeneration = this.authStorage.getProviderConfigurationGeneration(
+					provider,
+					this.#authStorageConfigOwner,
+				);
 				if (preflightAuthConfigurationGeneration !== currentAuthConfigurationGeneration) {
 					const currentOAuthRefreshGeneration = this.authStorage.getProviderOAuthRefreshGeneration(provider);
 					if (
@@ -3633,6 +3628,9 @@ export class ModelRegistry {
 		const isCurrentEndpoint = () =>
 			endpoint ===
 			this.#normalizeDiscoveryEvidenceEndpoint(this.#effectiveDiscoveryProviderConfig(providerConfig).baseUrl ?? "");
+		const isCurrentAuthConfiguration = () =>
+			preflightAuthConfigurationGeneration ===
+			this.authStorage.getProviderConfigurationGeneration(provider, this.#authStorageConfigOwner);
 		const isCurrentProviderRefresh = () =>
 			providerRefresh === undefined ||
 			("providerId" in providerRefresh
@@ -3704,7 +3702,7 @@ export class ModelRegistry {
 			},
 			getEvidenceGeneration: provider => this.#getProviderEvidenceGeneration(provider.provider, preflightApiKey),
 			cacheDynamicModelProvenance: cacheLookupProvenance,
-			canPublishCache: () => isCurrentEndpoint() && isCurrentProviderRefresh(),
+			canPublishCache: () => isCurrentAuthConfiguration() && isCurrentEndpoint() && isCurrentProviderRefresh(),
 		});
 		const authGeneration =
 			mergeInput.authGeneration ??
@@ -3712,6 +3710,7 @@ export class ModelRegistry {
 		const current =
 			mergeInput.current &&
 			authGeneration === this.#getProviderEvidenceGeneration(effectiveProviderConfig.provider, preflightApiKey) &&
+			isCurrentAuthConfiguration() &&
 			isCurrentEndpoint();
 		if (!current) {
 			return {
@@ -3899,9 +3898,15 @@ export class ModelRegistry {
 		// The token is only needed if the dynamic fetch fires (cache miss),
 		// and failures there are handled gracefully.
 		const peekKey = async (descriptor: { providerId: string }) => {
-			const configurationGeneration = this.authStorage.getProviderConfigurationGeneration(descriptor.providerId);
+			const configurationGeneration = this.authStorage.getProviderConfigurationGeneration(
+				descriptor.providerId,
+				this.#authStorageConfigOwner,
+			);
 			const apiKey = await this.#peekApiKeyForProvider(descriptor.providerId, { credentialSessionId });
-			if (configurationGeneration !== this.authStorage.getProviderConfigurationGeneration(descriptor.providerId)) {
+			if (
+				configurationGeneration !==
+				this.authStorage.getProviderConfigurationGeneration(descriptor.providerId, this.#authStorageConfigOwner)
+			) {
 				return { apiKey: undefined, authGeneration: undefined };
 			}
 			return {
@@ -4071,13 +4076,6 @@ export class ModelRegistry {
 				this.#descriptorDiscoveryEvidence.set(options.providerId, {
 					fresh: result.fetched,
 					modelIds: new Set(models.map(model => model.id)),
-					...(result.dynamicModelIds === undefined
-						? {}
-						: {
-								profileModelIds: new Set(result.dynamicModelIds),
-								profileFresh: !result.stale,
-								profileEndpoint: endpoint,
-							}),
 					authGeneration,
 					endpoint: this.#normalizeDiscoveryEvidenceEndpoint(models[0]?.baseUrl ?? endpoint),
 				});
@@ -5005,6 +5003,14 @@ export class ModelRegistry {
 			}
 			const generated = this.#generatedAuthHeaders.get(models[index]!);
 			if (generated) this.#generatedAuthHeaders.set(result[index]!, generated);
+			// Register finalized clone as trusted if the original is trusted
+			// registerFinalizedModelClone builds a fresh trusted object from the original's snapshot
+			if (result[index]) {
+				const registeredClone = registerFinalizedModelClone(models[index]!, result[index]);
+				if (registeredClone) {
+					result[index] = registeredClone;
+				}
+			}
 		}
 		return result;
 	}
@@ -5648,9 +5654,10 @@ export class ModelRegistry {
 
 	/**
 	 * Get selectable models with auth configured.
-	 * This is a fast check that doesn't refresh OAuth tokens. A current,
-	 * authoritative live catalog also limits each provider to its enrolled ids;
-	 * bundled entries remain the fallback until that evidence exists.
+	 * This is a fast check that doesn't refresh OAuth tokens. The bundled catalog
+	 * is authoritative for visibility: live discovery only enriches entries and
+	 * adds unknown ids, and never removes a bundled model. A provider that cannot
+	 * serve a model reports its own error when the model is used.
 	 */
 	getAvailable(): Model<Api>[] {
 		this.#synchronizeEnvironmentCredentials();
@@ -5664,82 +5671,12 @@ export class ModelRegistry {
 		) {
 			return this.#availableModelsCache;
 		}
-		const authoritativeDiscoveryIds = new Map<string, ReadonlySet<string> | undefined>();
-		const bundledIdsByProvider = new Map<string, Set<string>>();
-		this.#availableModelsCache = this.#models.filter(model => {
-			if (!this.#isModelAvailable(model, disabledProviders)) return false;
-
-			let liveIds = authoritativeDiscoveryIds.get(model.provider);
-			if (!authoritativeDiscoveryIds.has(model.provider)) {
-				liveIds = this.#getAuthoritativeDiscoveredModelIds(model.provider);
-				authoritativeDiscoveryIds.set(model.provider, liveIds);
-			}
-			// Undefined means discovery has not run successfully for the current
-			// provider context. Keep the bundled catalog as the explicit fallback.
-			if (liveIds === undefined) return true;
-			if (this.#hasCustomModelOverlay(model.provider, model.id)) return true;
-
-			const activity = this.#providerActivity.get(model.provider);
-			if (!activity?.staticModelIds.has(model.id)) return liveIds.has(model.id);
-
-			let bundledIds = bundledIdsByProvider.get(model.provider);
-			if (!bundledIds) {
-				bundledIds = new Set(
-					(getBundledModels(model.provider as Parameters<typeof getBundledModels>[0]) as Model<Api>[]).map(
-						candidate => candidate.id,
-					),
-				);
-				bundledIdsByProvider.set(model.provider, bundledIds);
-			}
-			return !bundledIds.has(model.id) || liveIds.has(model.id);
-		});
+		this.#availableModelsCache = this.#models.filter(model => this.#isModelAvailable(model, disabledProviders));
 		this.#availableModelsDisabledProviders = disabledProviderKey;
 		this.#availableModelsEnvFingerprint = envFingerprint;
 		return this.#availableModelsCache;
 	}
 
-	/**
-	 * Return the current live model ids only when discovery produced an
-	 * authoritative catalog for the provider and endpoint. An unavailable or
-	 * failed discovery returns undefined so callers retain the bundled fallback.
-	 */
-	#getAuthoritativeDiscoveredModelIds(provider: string): ReadonlySet<string> | undefined {
-		const descriptorEvidence = this.#descriptorDiscoveryEvidence.get(provider);
-		if (descriptorEvidence?.profileFresh && descriptorEvidence.profileModelIds !== undefined) {
-			try {
-				if (
-					descriptorEvidence.authGeneration === this.#getProviderEvidenceGeneration(provider) &&
-					descriptorEvidence.profileEndpoint ===
-						this.#normalizeDiscoveryEvidenceEndpoint(this.#getProviderBaseUrlForDiscovery(provider) ?? "")
-				) {
-					return descriptorEvidence.profileModelIds;
-				}
-			} catch {
-				// A provider context that can no longer be verified must use its fallback.
-			}
-		}
-
-		const configuredEvidence = this.#configuredDiscoveryEvidence.get(provider);
-		if (!configuredEvidence) return undefined;
-		const discoveryState = this.#discoveryManager.getState(provider);
-		if (
-			discoveryState?.status !== "ok" &&
-			discoveryState?.status !== "cached" &&
-			discoveryState?.status !== "empty"
-		) {
-			return undefined;
-		}
-		try {
-			return configuredEvidence.authGeneration === this.#getProviderEvidenceGeneration(provider) &&
-				configuredEvidence.endpoint ===
-					this.#normalizeDiscoveryEvidenceEndpoint(this.#getProviderBaseUrlForDiscovery(provider) ?? "")
-				? configuredEvidence.modelIds
-				: undefined;
-		} catch {
-			return undefined;
-		}
-	}
-
 	#synchronizeEnvironmentCredentials(): void {
 		// Runtime registrations own a provider while their credential is present.
 		// Refresh them first so a missing runtime env key can hand ownership back to
@@ -5753,49 +5690,6 @@ export class ModelRegistry {
 		}
 	}
 
-	/**
-	 * Get authenticated models, excluding bundled entries that a fresh provider
-	 * catalog has positively shown to be unavailable. Bundled entries remain
-	 * usable until live catalog evidence exists so offline startup is unchanged.
-	 */
-	getAvailableForProfileActivation(): Model<Api>[] {
-		const bundledIdsByProvider = new Map<string, Set<string>>();
-		// Evidence staleness depends only on the provider, and resolving it scans the
-		// catalog for the provider base URL. Decide it once per provider per call so a
-		// multi-thousand-model catalog is not rescanned for every model.
-		const staleEvidenceByProvider = new Map<string, boolean>();
-		return this.getAvailable().filter(model => {
-			const evidence = this.#descriptorDiscoveryEvidence.get(model.provider);
-			if (!evidence?.profileFresh || evidence.profileModelIds === undefined) return true;
-			if (this.#hasCustomModelOverlay(model.provider, model.id)) return true;
-			let bundledModelIds = bundledIdsByProvider.get(model.provider);
-			if (!bundledModelIds) {
-				bundledModelIds = new Set(
-					(getBundledModels(model.provider as Parameters<typeof getBundledModels>[0]) as Model<Api>[]).map(
-						candidate => candidate.id,
-					),
-				);
-				bundledIdsByProvider.set(model.provider, bundledModelIds);
-			}
-			if (!bundledModelIds.has(model.id)) return true;
-			let staleEvidence = staleEvidenceByProvider.get(model.provider);
-			if (staleEvidence === undefined) {
-				staleEvidence =
-					evidence.authGeneration !== this.#getProviderEvidenceGeneration(model.provider) ||
-					evidence.profileEndpoint !==
-						this.#normalizeDiscoveryEvidenceEndpoint(this.#getProviderBaseUrlForDiscovery(model.provider) ?? "");
-				staleEvidenceByProvider.set(model.provider, staleEvidence);
-			}
-			if (staleEvidence) return true;
-			return evidence.profileModelIds.has(model.id);
-		});
-	}
-
-	#hasCustomModelOverlay(provider: string, id: string): boolean {
-		const matches = (overlay: CustomModelOverlay) => overlay.provider === provider && overlay.id === id;
-		return this.#customModelOverlays.some(matches) || this.#runtimeModelOverlays.some(matches);
-	}
-
 	#hasFreshOrStaticModelEvidence(model: Model<Api>): boolean {
 		const evidence = this.#providerActivity.get(model.provider);
 		if (

package/src/config/skill-settings-defaults.ts

@@ -51,6 +51,13 @@ export function resolveSkillScopeTrust(
 	return DEFAULT_SKILL_SCOPE_TRUST;
 }
 
+/** Resolve permission to read a user's external skill symlinks from user-owned config only. */
+export function resolveGlobalUserSkillLinkTrust(
+	settings: Pick<SkillDiscoverySettings, "trustUserSkills" | "enablePiUser">,
+): boolean {
+	return resolveSkillScopeTrust(settings, "user");
+}
+
 export const DEFAULT_SKILL_DISCOVERY_SETTINGS: SkillDiscoverySettings = {
 	enabled: true,
 	enableSkillCommands: true,

package/src/coordinator-mcp/policy.ts

@@ -122,8 +122,9 @@ function parseRootList(value: string | undefined): string[] {
 }
 
 function resolveManagedWorktreeRoot(root: string, configured: string | undefined): string {
-	const template = (configured?.trim() || "{repo}/.worktrees").replace(/^~(?=\/|$)/, os.homedir());
-	const resolved = template.replaceAll("{repo}", path.basename(root));
+	// Function replacers so a `$` in the home or repository path is kept verbatim.
+	const template = (configured?.trim() || "{repo}/.worktrees").replace(/^~(?=\/|$)/, () => os.homedir());
+	const resolved = template.replaceAll("{repo}", () => path.basename(root));
 	return path.resolve(path.isAbsolute(resolved) ? resolved : path.join(path.dirname(root), resolved));
 }
 

package/src/cursor-delete-path.ts

@@ -0,0 +1,10 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+
+export async function assertDeleteInsideWorkspace(cwd: string, filePath: string): Promise<void> {
+	const root = await fs.realpath(cwd);
+	const target = await fs.realpath(filePath);
+	if (target !== root && !target.startsWith(`${root}${path.sep}`)) {
+		throw new Error(`Delete escapes the workspace: ${filePath}`);
+	}
+}

package/src/cursor-mcp-name.ts

@@ -0,0 +1,15 @@
+/**
+ * Tools Cursor already runs on a dedicated exec channel.
+ * Keep this aligned with CURSOR_NATIVE_TOOL_NAMES in packages/ai/src/providers/cursor.ts.
+ */
+const CURSOR_DEDICATED_CHANNEL_TOOLS = new Set(["bash", "read", "write", "delete", "ls", "grep", "lsp", "todo_write"]);
+
+/**
+ * Name to dispatch from a Cursor MCP call.
+ * Dedicated-channel tools are refused here. Advertised session tools such as eval stay allowed.
+ */
+export function cursorMcpDispatchName(call: { toolName?: string; name?: string }): string | null {
+	const toolName = call.toolName || call.name || "";
+	if (toolName.length === 0 || CURSOR_DEDICATED_CHANNEL_TOOLS.has(toolName)) return null;
+	return toolName;
+}

package/src/cursor.ts

@@ -23,6 +23,8 @@ import {
 	piTimeout,
 } from "@gajae-code/ai/providers/cursor/exec-modern";
 import { sanitizeText } from "@gajae-code/utils";
+import { assertDeleteInsideWorkspace } from "./cursor-delete-path";
+import { cursorMcpDispatchName } from "./cursor-mcp-name";
 import { resolveToCwd } from "./tools/path-utils";
 
 /**
@@ -184,6 +186,7 @@ async function executeDelete(
 			throw new Error(`Path is not a file: ${pathArg}`);
 		}
 
+		await assertDeleteInsideWorkspace(options.cwd, absolutePath);
 		fs.rmSync(absolutePath);
 
 		const sizeText = fileStat.size ? ` (${fileStat.size} bytes)` : "";
@@ -646,11 +649,19 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 
 	async mcp(call: CursorMcpCall, signal?: AbortSignal, markNonAbortable?: () => void) {
 		const options = this.#optionsForCall();
-		const toolName = call.toolName || call.name;
+		const requestedName = call.toolName || call.name || "";
+		const toolName = cursorMcpDispatchName(call);
 		const toolCallId = decodeToolCallId(call.toolCallId);
+		const availableTools = Array.from(options.tools.keys()).filter(
+			name => cursorMcpDispatchName({ toolName: name }) !== null,
+		);
+		if (!toolName) {
+			const message = formatMcpToolErrorMessage(requestedName, availableTools);
+			const result = buildToolErrorResult(message);
+			return createToolResultMessage(toolCallId, requestedName || "mcp", result, true);
+		}
 		const tool = options.tools.get(toolName);
 		if (!tool) {
-			const availableTools = Array.from(options.tools.keys()).filter(name => name.startsWith("mcp__"));
 			const message = formatMcpToolErrorMessage(toolName, availableTools);
 			const result = buildToolErrorResult(message);
 			return createToolResultMessage(toolCallId, toolName, result, true);

package/src/customization/inventory.ts

@@ -35,6 +35,8 @@ export interface LoadCustomizationInventoryOptions {
 	home?: string;
 	/** Skill management policy snapshot (trust, include/ignore, disabledExtensions). */
 	policy?: SkillManagementPolicy;
+	/** User-owned permission to follow external user skill symlinks. */
+	allowExternalUserSkillSymlinks?: boolean;
 	/** Disabled extension ids (`skill:<name>` / `mcp:<name>`) from settings. */
 	disabledExtensions?: string[];
 }
@@ -94,6 +96,7 @@ async function loadSkillRows(options: LoadCustomizationInventoryOptions, _warnin
 		cwd: options.cwd,
 		home: options.home,
 		policy: options.policy,
+		allowExternalUserSkillSymlinks: options.allowExternalUserSkillSymlinks,
 	});
 	const managedPaths = new Set<string>();
 	for (const record of records) {

package/src/debug/report-bundle-parent.ts

@@ -0,0 +1,22 @@
+/** True when a session header names this parent file or its basename. */
+export function sessionBelongsToParent(headerLine: string, parentBasename: string): boolean {
+	let parentSession: unknown;
+	try {
+		parentSession = (JSON.parse(headerLine) as { parentSession?: unknown }).parentSession;
+	} catch {
+		return false;
+	}
+	if (typeof parentSession !== "string" || parentSession.length === 0) return false;
+	const normalized = parentSession.replaceAll("\\", "/");
+	const base =
+		normalized
+			.split("/")
+			.pop()
+			?.replace(/\.jsonl$/, "") ?? "";
+	return (
+		normalized === parentBasename ||
+		base === parentBasename ||
+		normalized.endsWith(`/${parentBasename}`) ||
+		normalized.endsWith(`/${parentBasename}.jsonl`)
+	);
+}

package/src/debug/report-bundle.ts

@@ -17,6 +17,7 @@ import {
 	resolveEquivalentPath,
 } from "@gajae-code/utils";
 import type { CpuProfile, HeapSnapshot } from "./profiler";
+import { sessionBelongsToParent } from "./report-bundle-parent";
 import { collectSystemInfo, sanitizeEnv } from "./system-info";
 
 /** Maximum number of log lines to load into memory at once. */
@@ -283,6 +284,8 @@ async function addSubagentSessions(
 			const archivePath = `subagents/${filename}`;
 			try {
 				const content = await Bun.file(filePath).text();
+				const headerLine = content.split("\n", 1)[0] ?? "";
+				if (!sessionBelongsToParent(headerLine, parentBasename)) continue;
 				data[archivePath] = content;
 				files.push(archivePath);
 

package/src/debug/system-info.ts

@@ -99,7 +99,19 @@ export function formatSystemInfo(info: SystemInfo): string {
 
 /** Sanitize environment variables by redacting sensitive values */
 export function sanitizeEnv(env: Record<string, string | undefined>): Record<string, string> {
-	const SENSITIVE_PATTERNS = [/key/i, /secret/i, /token/i, /pass/i, /auth/i, /credential/i, /api/i, /private/i];
+	const SENSITIVE_PATTERNS = [
+		/key/i,
+		/secret/i,
+		/token/i,
+		/pass/i,
+		/auth/i,
+		/credential/i,
+		/api/i,
+		/private/i,
+		/cookie/i,
+		/dsn/i,
+		/url$/i,
+	];
 
 	const result: Record<string, string> = {};
 	for (const [k, v] of Object.entries(env)) {

package/src/defaults/gjc/extensions/grok-cli-vendor/src/provider/stream.ts

@@ -2,12 +2,18 @@ import type {
   Api,
   AssistantMessageEventStream,
   Context,
+  FetchImpl,
   Model,
   SimpleStreamOptions,
 } from '@gajae-code/ai/core';
 import { streamOpenAIResponses } from '@gajae-code/ai/providers/openai-responses';
+import {
+  getGrokCliVersion,
+  parseMinimumVersionFrom426,
+  updateVersionFromError,
+} from './version-manager';
 
-const GROK_CLI_VERSION = '0.2.33';
+type FetchInput = Parameters<FetchImpl>[0];
 
 /**
  * Stream function that adds Grok CLI-specific headers to requests.
@@ -16,6 +22,7 @@ const GROK_CLI_VERSION = '0.2.33';
  *   - x-grok-conv-id: <session/conversation ID>
  *   - x-grok-model-override: <model ID>
  *   - x-xai-token-auth: xai-grok-cli
+ *   - x-grok-client-version: learned from HTTP 426 responses; defaults to 1.0.13 and retries once on upgrade
  */
 export function streamGrokCli(
   model: Model<Api>,
@@ -23,10 +30,14 @@ export function streamGrokCli(
   options?: SimpleStreamOptions,
 ): AssistantMessageEventStream {
   const sessionId = options?.sessionId;
+
+  // Get the Grok CLI version: learned from 426 responses or fallback
+  const grokCliVersion = getGrokCliVersion();
+
   const headers: Record<string, string> = {
     ...options?.headers,
     'x-grok-client-identifier': 'gjc-grok-cli',
-    'x-grok-client-version': GROK_CLI_VERSION,
+    'x-grok-client-version': grokCliVersion,
     'x-xai-token-auth': 'xai-grok-cli',
     'x-grok-model-override': model.id,
   };
@@ -40,11 +51,63 @@ export function streamGrokCli(
     api: 'openai-responses',
   } as Model<'openai-responses'>;
 
+  // Wrap fetch to intercept 426 errors and extract version info
+  const baseFetch = options?.fetch ?? (globalThis.fetch.bind(globalThis) as FetchImpl);
+  const wrappedFetch = wrapFetchForVersionHandling(baseFetch);
+
   return streamOpenAIResponses(responsesModel, context, {
     ...options,
     headers,
-    onResponse(response) {
-      options?.onResponse?.(response, model);
+    fetch: wrappedFetch,
+    onResponse(response, _responseModel, scope, signal) {
+      return options?.onResponse?.(response, model, scope, signal);
     },
   });
 }
+
+/**
+ * Wraps a fetch function to learn from HTTP 426 responses and retry once with a newer version.
+ */
+function wrapFetchForVersionHandling(baseFetch: FetchImpl): FetchImpl {
+  return Object.assign(
+    async (input: FetchInput, init?: RequestInit): Promise<Response> => {
+      const firstInput =
+        input instanceof Request ? (input.clone() as unknown as FetchInput) : input;
+      const response = await baseFetch(firstInput, init);
+
+      if (response.status !== 426) return response;
+
+      let errorText: string;
+      try {
+        errorText = await response.clone().text();
+      } catch {
+        return response;
+      }
+
+      if (!parseMinimumVersionFrom426(errorText)) return response;
+
+      const retryHeaders = new Headers(
+        init?.headers ?? (input instanceof Request ? input.headers : undefined),
+      );
+      const requestedVersion = retryHeaders.get('x-grok-client-version');
+      const learnedVersion = updateVersionFromError(errorText);
+      if (!requestedVersion || learnedVersion === requestedVersion) return response;
+
+      retryHeaders.set('x-grok-client-version', learnedVersion);
+      const retryInput =
+        input instanceof Request ? (input.clone() as unknown as FetchInput) : input;
+      const retryResponse = await baseFetch(retryInput, { ...init, headers: retryHeaders });
+
+      if (retryResponse.status === 426) {
+        try {
+          updateVersionFromError(await retryResponse.clone().text());
+        } catch {
+          // Keep the retry response intact if its body cannot be inspected.
+        }
+      }
+
+      return retryResponse;
+    },
+    { preconnect: baseFetch.preconnect },
+  ) as FetchImpl;
+}