@gajae-code/ai 0.17.6 → 0.17.7

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.17.7] - 2026-09-25
+
+### Changed
+
+- Bump the spoofed Claude Code version from 2.1.280 to 2.1.281 and Gemini CLI version from 0.60.0 to 0.61.0. Anthropic gates newer models behind a minimum client version, so a stale `claude-cli` fingerprint can return HTTP 400 for an otherwise reachable model; the Gemini CLI fingerprint drifts the same way.
+
+### Fixed
+
+- Anthropic-compatible endpoints that leave `compat.supportsLongCacheRetention` unset no longer downgrade the default `long` prompt-cache retention to the ~5m TTL silently: GJC now logs one warning per provider session naming the provider and model and pointing at the flag. Set it to `true` for gateways that forward `ttl: "1h"`, or to `false` to accept the ~5m lifetime and silence the warning. (#5944)
+
+- Vertex AI Application Default Credentials now accept `type: "external_account"` (Workload Identity Federation): the subject token is read from `credential_source` (file, url, or opt-in executable), exchanged at STS, and optionally impersonated via `service_account_impersonation_url`, so gjc authenticates from GitHub Actions / GitLab CI without a long-lived service-account key. Unrecognised credential types now fail with a clear "Unsupported Google credential type" error instead of a misleading OAuth client error. (#5929)
+
 ## [0.17.6] - 2026-09-24
 
 ## [0.17.5] - 2026-09-24

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

@@ -107,7 +107,7 @@ export interface CpaToolAliasRestoreFailure {
  */
 export declare function parseCpaToolAliasRestoreFailure(error: unknown): CpaToolAliasRestoreFailure | undefined;
 export declare function isCpaToolAliasRestoreFailure(error: unknown): boolean;
-export declare const claudeCodeVersion = "2.1.280";
+export declare const claudeCodeVersion = "2.1.281";
 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.";

package/dist/types/providers/google-auth.d.ts

@@ -3,8 +3,10 @@
  *
  * Replaces `google-auth-library` with a direct WebCrypto + REST implementation.
  * Sources, in priority order:
- *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange)
- *     or `type: "authorized_user"` (refresh-token exchange).
+ *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange),
+ *     `type: "authorized_user"` (refresh-token exchange), or `type: "external_account"` (Workload Identity
+ *     Federation: subject token from `credential_source` → STS token exchange → optional service-account
+ *     impersonation).
  *   2. `~/.config/gcloud/application_default_credentials.json` (user ADC, same authorized_user flow).
  *   3. GCE / Cloud Run metadata server (`metadata.google.internal`).
  *

package/dist/types/providers/google-gemini-headers.d.ts

@@ -5,7 +5,7 @@
  */
 export declare const GEMINI_CLI_VERSION_ENV = "GJC_AI_GEMINI_CLI_VERSION";
 export declare const LEGACY_GEMINI_CLI_VERSION_ENV = "PI_AI_GEMINI_CLI_VERSION";
-export declare const DEFAULT_GEMINI_CLI_VERSION = "0.60.0";
+export declare const DEFAULT_GEMINI_CLI_VERSION = "0.61.0";
 export declare function getGeminiCliUserAgent(modelId?: string): string;
 export declare const getGeminiCliHeaders: (modelId?: string) => {
     "User-Agent": string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.17.6",
+	"version": "0.17.7",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -41,8 +41,8 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/natives": "0.17.6",
-		"@gajae-code/utils": "0.17.6",
+		"@gajae-code/natives": "0.17.7",
+		"@gajae-code/utils": "0.17.7",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/providers/anthropic.d.ts

@@ -107,7 +107,7 @@ export interface CpaToolAliasRestoreFailure {
  */
 export declare function parseCpaToolAliasRestoreFailure(error: unknown): CpaToolAliasRestoreFailure | undefined;
 export declare function isCpaToolAliasRestoreFailure(error: unknown): boolean;
-export declare const claudeCodeVersion = "2.1.280";
+export declare const claudeCodeVersion = "2.1.281";
 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.";

package/src/providers/anthropic.ts

@@ -371,6 +371,8 @@ type AnthropicProviderSessionState = ProviderSessionState & {
 	strictToolsDisabled: boolean;
 	fastModeDisabled: boolean;
 	generatedCacheBudget: GeneratedCacheBudget;
+	/** `provider\0model` keys already warned about a long cache-retention downgrade. */
+	warnedUnknownLongCacheRetention: Set<string>;
 	thinkingReplayRepairScope: AnthropicThinkingReplayRepairScope;
 	thinkingReplayRepairAttempts: number;
 	thinkingReplayRejectedPayload?: AnthropicPayloadFingerprint;
@@ -399,12 +401,14 @@ function createAnthropicProviderSessionState(): AnthropicProviderSessionState {
 		strictToolsDisabled: false,
 		fastModeDisabled: false,
 		generatedCacheBudget: 2,
+		warnedUnknownLongCacheRetention: new Set(),
 		thinkingReplayRepairScope: "none",
 		thinkingReplayRepairAttempts: 0,
 		close: () => {
 			state.strictToolsDisabled = false;
 			state.fastModeDisabled = false;
 			state.generatedCacheBudget = 2;
+			state.warnedUnknownLongCacheRetention.clear();
 			state.thinkingReplayRepairScope = "none";
 			state.thinkingReplayRepairAttempts = 0;
 			state.thinkingReplayRejectedPayload = undefined;
@@ -800,10 +804,14 @@ function getCacheControl(
 	baseUrl: string,
 	cacheRetention?: CacheRetention,
 	generatedCacheBudget: GeneratedCacheBudget = 2,
-): { mode: AnthropicCacheMode; cacheControl?: AnthropicCacheControl } {
-	if (generatedCacheBudget === 0) return { mode: "none" };
+): {
+	mode: AnthropicCacheMode;
+	cacheControl?: AnthropicCacheControl;
+	warnUnknownLongCacheRetention: boolean;
+} {
+	if (generatedCacheBudget === 0) return { mode: "none", warnUnknownLongCacheRetention: false };
 	const retention = resolveCacheRetention(cacheRetention ?? model.cacheRetention, "long");
-	if (retention === "none") return { mode: "none" };
+	if (retention === "none") return { mode: "none", warnUnknownLongCacheRetention: false };
 
 	const isCanonicalApi = isAnthropicApiBaseUrl(baseUrl);
 	const promptCacheMode = model.compat?.promptCacheMode;
@@ -819,13 +827,16 @@ function getCacheControl(
 						: isClaudeFamilyModel(model)
 							? "explicit"
 							: "none";
-	if (mode === "none") return { mode };
+	if (mode === "none") return { mode, warnUnknownLongCacheRetention: false };
+	const warnUnknownLongCacheRetention =
+		!isCanonicalApi && retention === "long" && model.compat?.supportsLongCacheRetention === undefined;
 
 	const supportsLongCacheRetention = isCanonicalApi
 		? getAnthropicCompat(model).supportsLongCacheRetention
 		: model.compat?.supportsLongCacheRetention === true;
 	return {
 		mode,
+		warnUnknownLongCacheRetention,
 		cacheControl: {
 			type: "ephemeral",
 			...(retention === "long" && supportsLongCacheRetention ? { ttl: "1h" } : {}),
@@ -834,7 +845,7 @@ function getCacheControl(
 }
 
 // Stealth mode: Mimic Anthropic Code headers and tool prefixing.
-export const claudeCodeVersion = "2.1.280";
+export const claudeCodeVersion = "2.1.281";
 export const claudeCodeEntrypoint = "sdk-cli";
 export const claudeToolPrefix: string = "proxy_";
 export const claudeCodeSystemInstruction = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
@@ -1972,13 +1983,14 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			// never persisted — so a completed stream must not release it.
 			let thinkingReplayRepairPersistent = thinkingReplayRepairScope !== "none";
 			let generatedCacheBudget: GeneratedCacheBudget = providerSessionState?.generatedCacheBudget ?? 2;
+			let warnedUnknownLongCacheRetention = false;
 			const prepareParams = async (): Promise<MessageCreateParamsStreaming> => {
 				// Degradation state is cumulative: every fallback rebuild must merge all
 				// repairs activated so far. Rebuilding from only the immediate call lets
 				// a later strict/forced-tool/fast-mode fallback reintroduce the rejected
 				// shape (e.g. invalid thinking signatures or forced tool_choice), and
 				// the one-shot thinking-repair guard then blocks recovery.
-				let nextParams = buildParams(
+				const builtParams = buildParams(
 					model,
 					baseUrl,
 					context,
@@ -1991,6 +2003,20 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					},
 					generatedCacheBudget,
 				);
+				let nextParams = builtParams.params;
+				const longCacheWarningKey = `${model.provider}\0${model.id}`;
+				if (
+					builtParams.warnUnknownLongCacheRetention &&
+					!warnedUnknownLongCacheRetention &&
+					!providerSessionState?.warnedUnknownLongCacheRetention.has(longCacheWarningKey)
+				) {
+					warnedUnknownLongCacheRetention = true;
+					providerSessionState?.warnedUnknownLongCacheRetention.add(longCacheWarningKey);
+					logger.warn(
+						'Anthropic-compatible endpoint has unknown long cache-retention support; omitting ttl (default ~5m). Set compat.supportsLongCacheRetention: true to opt into ttl: "1h".',
+						{ provider: model.provider, model: model.id },
+					);
+				}
 				if (droppedForcedToolChoice) {
 					delete nextParams.tool_choice;
 				}
@@ -3554,13 +3580,12 @@ function buildParams(
 	disableStrictTools = false,
 	thinkingRepair?: { repairLatestAssistantThinking?: boolean; repairAllAssistantThinking?: boolean },
 	generatedCacheBudget: GeneratedCacheBudget = 2,
-): MessageCreateParamsStreaming {
-	const { mode: cacheMode, cacheControl } = getCacheControl(
-		model,
-		baseUrl,
-		options?.cacheRetention,
-		generatedCacheBudget,
-	);
+): { params: MessageCreateParamsStreaming; warnUnknownLongCacheRetention: boolean } {
+	const {
+		mode: cacheMode,
+		cacheControl,
+		warnUnknownLongCacheRetention,
+	} = getCacheControl(model, baseUrl, options?.cacheRetention, generatedCacheBudget);
 
 	const params: AnthropicSamplingParams = {
 		model: model.id,
@@ -3731,11 +3756,17 @@ function buildParams(
 		params.system = systemBlocks;
 	}
 	ensureMaxTokensForThinking(params, model);
-	applyPromptCaching(params as AnthropicCacheParams, cacheMode, cacheControl, generatedCacheBudget);
+	const cacheParams = params as AnthropicCacheParams;
+	const cacheBreakpointCountBefore = countCacheControlBreakpoints(cacheParams);
+	applyPromptCaching(cacheParams, cacheMode, cacheControl, generatedCacheBudget);
 	enforceCacheControlLimit(params, 4);
 	normalizeCacheControlTtlOrdering(params);
 
-	return params;
+	return {
+		params,
+		warnUnknownLongCacheRetention:
+			warnUnknownLongCacheRetention && countCacheControlBreakpoints(cacheParams) > cacheBreakpointCountBefore,
+	};
 }
 
 /**

package/src/providers/google-auth.d.ts

@@ -3,8 +3,10 @@
  *
  * Replaces `google-auth-library` with a direct WebCrypto + REST implementation.
  * Sources, in priority order:
- *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange)
- *     or `type: "authorized_user"` (refresh-token exchange).
+ *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange),
+ *     `type: "authorized_user"` (refresh-token exchange), or `type: "external_account"` (Workload Identity
+ *     Federation: subject token from `credential_source` → STS token exchange → optional service-account
+ *     impersonation).
  *   2. `~/.config/gcloud/application_default_credentials.json` (user ADC, same authorized_user flow).
  *   3. GCE / Cloud Run metadata server (`metadata.google.internal`).
  *

package/src/providers/google-auth.ts

@@ -3,8 +3,10 @@
  *
  * Replaces `google-auth-library` with a direct WebCrypto + REST implementation.
  * Sources, in priority order:
- *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange)
- *     or `type: "authorized_user"` (refresh-token exchange).
+ *   1. `GOOGLE_APPLICATION_CREDENTIALS` env → file with `type: "service_account"` (RS256 JWT exchange),
+ *     `type: "authorized_user"` (refresh-token exchange), or `type: "external_account"` (Workload Identity
+ *     Federation: subject token from `credential_source` → STS token exchange → optional service-account
+ *     impersonation).
  *   2. `~/.config/gcloud/application_default_credentials.json` (user ADC, same authorized_user flow).
  *   3. GCE / Cloud Run metadata server (`metadata.google.internal`).
  *
@@ -18,9 +20,17 @@ import { $credentialEnv, $envpos, getTrustedHomeDir, isEnoent, logger } from "@g
 import type { FetchImpl } from "../types";
 
 const OAUTH_TOKEN_URL = "https://oauth2.googleapis.com/token";
+const STS_TOKEN_URL = "https://sts.googleapis.com/v1/token";
 const METADATA_TOKEN_URL = "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token";
 const CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
 const JWT_BEARER_GRANT = "urn:ietf:params:oauth:grant-type:jwt-bearer";
+const TOKEN_EXCHANGE_GRANT = "urn:ietf:params:oauth:grant-type:token-exchange";
+const ACCESS_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:access_token";
+const ID_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:id_token";
+const JWT_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:jwt";
+const SAML_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:saml2";
+const DEFAULT_IMPERSONATION_LIFETIME_SEC = 3600;
+const DEFAULT_EXECUTABLE_TIMEOUT_MS = 30_000;
 
 interface CachedToken {
 	token: string;
@@ -41,7 +51,60 @@ interface AuthorizedUserCredentials {
 	refresh_token: string;
 }
 
-type AdcFileCredentials = ServiceAccountCredentials | AuthorizedUserCredentials;
+/** `credential_source.format` for file/url sources: plain text (default) or a JSON field. */
+interface SubjectTokenFormat {
+	type?: "text" | "json";
+	subject_token_field_name?: string;
+}
+
+interface FileCredentialSource {
+	file: string;
+	format?: SubjectTokenFormat;
+}
+
+interface UrlCredentialSource {
+	url: string;
+	headers?: Record<string, string>;
+	format?: SubjectTokenFormat;
+}
+
+interface ExecutableCredentialSource {
+	executable: {
+		command: string;
+		timeout_millis?: number;
+		output_file?: string;
+	};
+}
+
+type CredentialSource = FileCredentialSource | UrlCredentialSource | ExecutableCredentialSource;
+
+/**
+ * Workload Identity Federation configuration, as written by `gcloud iam workload-identity-pools
+ * create-cred-config` and `google-github-actions/auth`.
+ */
+interface ExternalAccountCredentials {
+	type: "external_account";
+	audience: string;
+	subject_token_type: string;
+	token_url?: string;
+	service_account_impersonation_url?: string;
+	service_account_impersonation?: { token_lifetime_seconds?: number };
+	credential_source: CredentialSource;
+}
+
+type AdcFileCredentials = ServiceAccountCredentials | AuthorizedUserCredentials | ExternalAccountCredentials;
+
+/** Response of the executable credential source, per the external-account spec (version 1). */
+interface ExecutableResponse {
+	version: number;
+	success: boolean;
+	token_type?: string;
+	id_token?: string;
+	saml_response?: string;
+	expiration_time?: number;
+	code?: string;
+	message?: string;
+}
 
 interface TokenResponse {
 	access_token: string;
@@ -200,16 +263,217 @@ async function postForToken(
 	return (await response.json()) as TokenResponse;
 }
 
+/** Pulls the subject token out of a file/url source body according to its declared format. */
+function extractSubjectToken(raw: string, format: SubjectTokenFormat | undefined, origin: string): string {
+	let token: unknown;
+	if (format?.type === "json") {
+		const field = format.subject_token_field_name;
+		if (!field)
+			throw new Error(`external_account credential_source ${origin}: json format requires subject_token_field_name`);
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			throw new Error(`external_account credential_source ${origin}: subject token is not valid JSON`);
+		}
+		token = typeof parsed === "object" && parsed !== null ? (parsed as Record<string, unknown>)[field] : undefined;
+	} else {
+		token = raw.trim();
+	}
+	if (typeof token !== "string" || token.length === 0) {
+		throw new Error(`external_account credential_source ${origin}: subject token is empty`);
+	}
+	return token;
+}
+
+async function readSubjectTokenFromExecutable(
+	creds: ExternalAccountCredentials,
+	source: ExecutableCredentialSource,
+): Promise<string> {
+	// Same opt-in the official client libraries require: the credential file names a
+	// command to run, so the operator must explicitly allow it.
+	if ($credentialEnv("GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES") !== "1") {
+		throw new Error(
+			"external_account executable credential_source requires GOOGLE_EXTERNAL_ACCOUNT_ALLOW_EXECUTABLES=1",
+		);
+	}
+	const { command, timeout_millis, output_file } = source.executable;
+	const argv = command.trim().split(/\s+/);
+	if (!argv[0]) throw new Error("external_account executable credential_source: command is empty");
+	const env: Record<string, string | undefined> = {
+		...process.env,
+		GOOGLE_EXTERNAL_ACCOUNT_AUDIENCE: creds.audience,
+		GOOGLE_EXTERNAL_ACCOUNT_TOKEN_TYPE: creds.subject_token_type,
+		GOOGLE_EXTERNAL_ACCOUNT_INTERACTIVE: "0",
+	};
+	const impersonated = creds.service_account_impersonation_url?.match(/serviceAccounts\/([^/:]+)/)?.[1];
+	if (impersonated) env.GOOGLE_EXTERNAL_ACCOUNT_IMPERSONATED_EMAIL = impersonated;
+	if (output_file) env.GOOGLE_EXTERNAL_ACCOUNT_OUTPUT_FILE = output_file;
+
+	const proc = Bun.spawn(argv, { env, stdout: "pipe", stderr: "ignore", stdin: "ignore" });
+	const timeout = setTimeout(() => proc.kill(), timeout_millis ?? DEFAULT_EXECUTABLE_TIMEOUT_MS);
+	let stdout: string;
+	try {
+		stdout = await new Response(proc.stdout).text();
+		const exitCode = await proc.exited;
+		if (exitCode !== 0) {
+			throw new Error(`external_account executable credential_source exited with code ${exitCode}`);
+		}
+	} finally {
+		clearTimeout(timeout);
+	}
+	// The spec allows the executable to write its response to output_file instead of stdout.
+	const raw = stdout.trim() || (output_file ? await Bun.file(output_file).text() : "");
+	let response: ExecutableResponse;
+	try {
+		response = JSON.parse(raw) as ExecutableResponse;
+	} catch {
+		throw new Error("external_account executable credential_source returned invalid JSON");
+	}
+	if (response.version !== 1) {
+		throw new Error(`external_account executable response version ${response.version} is not supported`);
+	}
+	if (!response.success) {
+		throw new Error(
+			`external_account executable credential_source failed (${response.code ?? "unknown"}): ${response.message ?? ""}`,
+		);
+	}
+	if (response.expiration_time !== undefined && response.expiration_time * 1000 <= Date.now()) {
+		throw new Error("external_account executable credential_source returned an expired subject token");
+	}
+	const token =
+		response.token_type === SAML_TOKEN_TYPE
+			? response.saml_response
+			: response.token_type === ID_TOKEN_TYPE || response.token_type === JWT_TOKEN_TYPE
+				? response.id_token
+				: undefined;
+	if (!token) {
+		throw new Error(
+			`external_account executable credential_source returned unsupported token_type ${response.token_type}`,
+		);
+	}
+	return token;
+}
+
+async function readSubjectToken(
+	creds: ExternalAccountCredentials,
+	signal: AbortSignal | undefined,
+	fetchImpl: FetchImpl,
+): Promise<string> {
+	const source = creds.credential_source;
+	if (!source || typeof source !== "object") {
+		throw new Error("external_account credentials are missing credential_source");
+	}
+	if ("file" in source) {
+		let raw: string;
+		try {
+			raw = await Bun.file(source.file).text();
+		} catch (err) {
+			if (isEnoent(err)) throw new Error(`external_account credential_source file is missing: ${source.file}`);
+			throw err;
+		}
+		return extractSubjectToken(raw, source.format, `file ${source.file}`);
+	}
+	if ("url" in source) {
+		const response = await fetchImpl(source.url, { method: "GET", headers: source.headers ?? {}, signal });
+		if (!response.ok) {
+			throw new Error(`external_account credential_source url returned ${response.status}`);
+		}
+		return extractSubjectToken(await response.text(), source.format, "url");
+	}
+	if ("executable" in source) return readSubjectTokenFromExecutable(creds, source);
+	throw new Error(
+		"external_account credential_source must be one of file, url, or executable (AWS environment_id sources are not supported)",
+	);
+}
+
+/** STS token exchange (RFC 8693) of the federated subject token for a Google access token. */
+async function exchangeSubjectToken(
+	creds: ExternalAccountCredentials,
+	subjectToken: string,
+	signal: AbortSignal | undefined,
+	fetchImpl: FetchImpl,
+): Promise<TokenResponse> {
+	const body = new URLSearchParams({
+		grant_type: TOKEN_EXCHANGE_GRANT,
+		audience: creds.audience,
+		scope: CLOUD_PLATFORM_SCOPE,
+		requested_token_type: ACCESS_TOKEN_TYPE,
+		subject_token: subjectToken,
+		subject_token_type: creds.subject_token_type,
+	});
+	return postForToken(creds.token_url ?? STS_TOKEN_URL, body, signal, fetchImpl);
+}
+
+/** IAM Credentials `generateAccessToken` with the federated token as bearer. */
+async function impersonateServiceAccount(
+	creds: ExternalAccountCredentials,
+	url: string,
+	federatedToken: string,
+	signal: AbortSignal | undefined,
+	fetchImpl: FetchImpl,
+): Promise<TokenResponse> {
+	const lifetime = creds.service_account_impersonation?.token_lifetime_seconds ?? DEFAULT_IMPERSONATION_LIFETIME_SEC;
+	const response = await fetchImpl(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json", Authorization: `Bearer ${federatedToken}` },
+		body: JSON.stringify({ scope: [CLOUD_PLATFORM_SCOPE], lifetime: `${lifetime}s` }),
+		signal,
+	});
+	if (!response.ok) {
+		const detail = await response.text().catch(() => "");
+		throw new Error(`Google service account impersonation failed (${response.status}): ${detail}`);
+	}
+	const payload = (await response.json()) as { accessToken?: string; expireTime?: string };
+	if (!payload.accessToken) throw new Error("Google service account impersonation returned no accessToken");
+	const expiresAtMs = payload.expireTime ? Date.parse(payload.expireTime) : Number.NaN;
+	const expiresIn = Number.isFinite(expiresAtMs)
+		? Math.max(0, Math.floor((expiresAtMs - Date.now()) / 1000))
+		: lifetime;
+	return { access_token: payload.accessToken, expires_in: expiresIn };
+}
+
+async function exchangeExternalAccount(
+	creds: ExternalAccountCredentials,
+	signal: AbortSignal | undefined,
+	fetchImpl: FetchImpl,
+): Promise<TokenResponse> {
+	if (!creds.audience || !creds.subject_token_type) {
+		throw new Error("external_account credentials require audience and subject_token_type");
+	}
+	const subjectToken = await readSubjectToken(creds, signal, fetchImpl);
+	const federated = await exchangeSubjectToken(creds, subjectToken, signal, fetchImpl);
+	const impersonationUrl = creds.service_account_impersonation_url;
+	if (!impersonationUrl) return federated;
+	return impersonateServiceAccount(creds, impersonationUrl, federated.access_token, signal, fetchImpl);
+}
+
+async function exchangeAdcCredentials(
+	creds: AdcFileCredentials,
+	signal: AbortSignal | undefined,
+	fetchImpl: FetchImpl,
+): Promise<TokenResponse> {
+	switch (creds.type) {
+		case "service_account":
+			return exchangeJwtForToken(creds, signal, fetchImpl);
+		case "authorized_user":
+			return exchangeRefreshToken(creds, signal, fetchImpl);
+		case "external_account":
+			return exchangeExternalAccount(creds, signal, fetchImpl);
+		default:
+			throw new Error(
+				`Unsupported Google credential type ${JSON.stringify((creds as { type?: unknown }).type)}; expected service_account, authorized_user, or external_account`,
+			);
+	}
+}
+
 async function resolveAccessTokenUncached(
 	signal: AbortSignal | undefined,
 	fetchImpl: FetchImpl,
 ): Promise<{ source: string; token: TokenResponse }> {
 	const adc = await loadAdcCredentials();
 	if (adc) {
-		const token =
-			adc.creds.type === "service_account"
-				? await exchangeJwtForToken(adc.creds, signal, fetchImpl)
-				: await exchangeRefreshToken(adc.creds, signal, fetchImpl);
+		const token = await exchangeAdcCredentials(adc.creds, signal, fetchImpl);
 		return { source: adc.source, token };
 	}
 	const metadata = await fetchMetadataToken(signal, fetchImpl);

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

@@ -5,7 +5,7 @@
  */
 export declare const GEMINI_CLI_VERSION_ENV = "GJC_AI_GEMINI_CLI_VERSION";
 export declare const LEGACY_GEMINI_CLI_VERSION_ENV = "PI_AI_GEMINI_CLI_VERSION";
-export declare const DEFAULT_GEMINI_CLI_VERSION = "0.60.0";
+export declare const DEFAULT_GEMINI_CLI_VERSION = "0.61.0";
 export declare function getGeminiCliUserAgent(modelId?: string): string;
 export declare const getGeminiCliHeaders: (modelId?: string) => {
     "User-Agent": string;

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

@@ -5,7 +5,7 @@
  */
 export const GEMINI_CLI_VERSION_ENV = "GJC_AI_GEMINI_CLI_VERSION";
 export const LEGACY_GEMINI_CLI_VERSION_ENV = "PI_AI_GEMINI_CLI_VERSION";
-export const DEFAULT_GEMINI_CLI_VERSION = "0.60.0";
+export const DEFAULT_GEMINI_CLI_VERSION = "0.61.0";
 
 export function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview"): string {
 	const version =