@gajae-code/ai 0.18.11 → 0.18.12

package/src/openai-completions-compat.d.ts

@@ -27,13 +27,14 @@ export declare function isDirectXaiReasoningEffortModel(model: {
     api?: string;
     baseUrl?: string;
 }, resolvedBaseUrl?: string): boolean;
-export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "reservedToolNames">> & {
+export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "supportsUltrafastTier" | "reservedToolNames">> & {
     openRouterRouting?: OpenAICompat["openRouterRouting"];
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
     extraBody?: OpenAICompat["extraBody"];
     toolStrictMode: ResolvedToolStrictMode;
     supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
     supportsServiceTier?: OpenAICompat["supportsServiceTier"];
+    supportsUltrafastTier?: OpenAICompat["supportsUltrafastTier"];
     /** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
     toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
 };

package/src/openai-completions-compat.ts

@@ -146,6 +146,7 @@ export type ResolvedOpenAICompat = Required<
 		| "toolChoiceSupport"
 		| "supportsResponsesSessionAffinity"
 		| "supportsServiceTier"
+		| "supportsUltrafastTier"
 		| "reservedToolNames"
 	>
 > & {
@@ -155,6 +156,7 @@ export type ResolvedOpenAICompat = Required<
 	toolStrictMode: ResolvedToolStrictMode;
 	supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
 	supportsServiceTier?: OpenAICompat["supportsServiceTier"];
+	supportsUltrafastTier?: OpenAICompat["supportsUltrafastTier"];
 	/** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
 	toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
 };
@@ -349,6 +351,8 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		supportsDeveloperRole: !isNonStandard,
 		sendSessionHeaders: false,
 		supportsResponsesSessionAffinity: false,
+		supportsServiceTier: false,
+		supportsUltrafastTier: false,
 		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
 		supportsReasoningEffort:
 			hasAuditedReasoningEffortTransport &&
@@ -422,6 +426,7 @@ export function resolveOpenAICompat(
 				? model.compat.supportsResponsesSessionAffinity
 				: undefined) ?? detected.supportsResponsesSessionAffinity,
 		supportsServiceTier: model.compat.supportsServiceTier ?? detected.supportsServiceTier,
+		supportsUltrafastTier: model.compat.supportsUltrafastTier ?? detected.supportsUltrafastTier,
 		supportsMultipleSystemMessages:
 			model.compat.supportsMultipleSystemMessages ?? detected.supportsMultipleSystemMessages,
 		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,

package/src/provider-models/google.ts

@@ -1,5 +1,5 @@
 import type { ModelManagerOptions } from "../model-manager";
-import { fetchAntigravityDiscoveryModels } from "../utils/discovery/antigravity";
+import { fetchAntigravityDiscoveryModels, getDefaultAntigravityUserAgent } from "../utils/discovery/antigravity";
 import { fetchGeminiModels } from "../utils/discovery/gemini";
 
 export interface GoogleModelManagerConfig {
@@ -48,14 +48,17 @@ export function googleAntigravityModelManagerOptions(
 	config?: GoogleAntigravityModelManagerConfig,
 ): ModelManagerOptions<"google-gemini-cli"> {
 	const token = config?.oauthToken;
+	const ua = getDefaultAntigravityUserAgent();
 	return {
 		providerId: "google-antigravity",
+		discoveryUserAgent: ua,
 		...(token
 			? {
 					fetchDynamicModels: () =>
 						fetchAntigravityDiscoveryModels({
 							token,
 							endpoint: config?.endpoint,
+							userAgent: ua,
 						}),
 				}
 			: undefined),
@@ -67,8 +70,10 @@ export function googleGeminiCliModelManagerOptions(
 ): ModelManagerOptions<"google-gemini-cli"> {
 	const token = config?.oauthToken;
 	const endpoint = config?.endpoint ?? CLOUD_CODE_ASSIST_ENDPOINT;
+	const ua = getDefaultAntigravityUserAgent();
 	return {
 		providerId: "google-gemini-cli",
+		discoveryUserAgent: ua,
 		...(token
 			? {
 					fetchDynamicModels: async () => {
@@ -76,6 +81,7 @@ export function googleGeminiCliModelManagerOptions(
 							token,
 							endpoint,
 							targetProvider: "google-gemini-cli",
+							userAgent: ua,
 						});
 						if (models === null) {
 							return null;

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

@@ -1316,6 +1316,31 @@ export function kiloModelManagerOptions(config?: KiloModelManagerConfig): ModelM
 				provider: "kilo",
 				baseUrl,
 				apiKey,
+				// Kilo serves the OpenRouter catalog shape: nested limits/modalities and
+				// per-token USD string prices (GJC costs are per million tokens).
+				mapModel: (entry, defaults) => {
+					const topProvider = isRecord(entry.top_provider) ? entry.top_provider : undefined;
+					const architecture = isRecord(entry.architecture) ? entry.architecture : undefined;
+					const pricing = isRecord(entry.pricing) ? entry.pricing : undefined;
+					const params = Array.isArray(entry.supported_parameters) ? entry.supported_parameters : [];
+					const perMillion = (value: unknown): number => {
+						const perToken = toNumber(value);
+						return perToken !== undefined && perToken >= 0 ? perToken * 1_000_000 : 0;
+					};
+					return {
+						...defaults,
+						reasoning: params.includes("reasoning"),
+						input: toInputCapabilities(architecture?.input_modalities),
+						cost: {
+							input: perMillion(pricing?.prompt),
+							output: perMillion(pricing?.completion),
+							cacheRead: perMillion(pricing?.input_cache_read),
+							cacheWrite: perMillion(pricing?.input_cache_write),
+						},
+						contextWindow: toPositiveNumber(entry.context_length, defaults.contextWindow),
+						maxTokens: toPositiveNumber(topProvider?.max_completion_tokens, defaults.maxTokens),
+					};
+				},
 			}),
 	};
 }
@@ -2125,6 +2150,7 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 								...(api === "openai-completions"
 									? {
 											compat: {
+												...(reference.compat ?? {}),
 												supportsStore: false,
 												supportsDeveloperRole: false,
 												supportsReasoningEffort: false,

package/src/providers/amazon-bedrock.ts

@@ -52,6 +52,7 @@ import { decodeEventStream } from "./aws-eventstream";
 import type { AwsCredentials } from "./aws-sigv4";
 import { signRequest } from "./aws-sigv4";
 import { transformMessages } from "./transform-messages";
+import { NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard";
 
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 
@@ -673,12 +674,24 @@ function buildSystemPrompt(
 	return blocks;
 }
 
+function convertToolResultContent(
+	content: ToolResultMessage["content"],
+	supportsImages: boolean,
+): Array<TextBlockWire | ImageBlockWire> {
+	return content.map(c => {
+		if (c.type !== "image") return { text: c.text.toWellFormed() };
+		if (!supportsImages) return { text: NON_VISION_IMAGE_PLACEHOLDER };
+		return { image: createImageBlock(c.mimeType, c.data) };
+	});
+}
+
 function convertMessages(
 	context: Context,
 	model: Model<"bedrock-converse-stream">,
 	cacheRetention: CacheRetention,
 ): WireMessage[] {
 	const result: WireMessage[] = [];
+	const supportsImages = model.input.includes("image");
 	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
 
 	for (let i = 0; i < transformedMessages.length; i++) {
@@ -702,7 +715,11 @@ function convertMessages(
 								break;
 							}
 							case "image":
-								contentBlocks.push({ image: createImageBlock(c.mimeType, c.data) });
+								contentBlocks.push(
+									supportsImages
+										? { image: createImageBlock(c.mimeType, c.data) }
+										: { text: NON_VISION_IMAGE_PLACEHOLDER },
+								);
 								break;
 							default:
 								throw new Error("Unknown user content type");
@@ -772,11 +789,7 @@ function convertMessages(
 				toolResults.push({
 					toolResult: {
 						toolUseId: normalizeToolCallId(m.toolCallId),
-						content: m.content.map(c =>
-							c.type === "image"
-								? { image: createImageBlock(c.mimeType, c.data) }
-								: { text: c.text.toWellFormed() },
-						),
+						content: convertToolResultContent(m.content, supportsImages),
 						status: m.isError ? "error" : "success",
 					},
 				});
@@ -787,11 +800,7 @@ function convertMessages(
 					toolResults.push({
 						toolResult: {
 							toolUseId: normalizeToolCallId(nextMsg.toolCallId),
-							content: nextMsg.content.map(c =>
-								c.type === "image"
-									? { image: createImageBlock(c.mimeType, c.data) }
-									: { text: c.text.toWellFormed() },
-							),
+							content: convertToolResultContent(nextMsg.content, supportsImages),
 							status: nextMsg.isError ? "error" : "success",
 						},
 					});

package/src/providers/anthropic.d.ts

@@ -51,6 +51,16 @@ export declare function isAnthropicThinkingBlockMutationError(error: unknown): b
  * than only the latest one.
  */
 export declare function isAnthropicThinkingSignatureInvalidError(error: unknown): boolean;
+/**
+ * 400 shape where Anthropic cannot decode one of the request's images:
+ * `{"type":"invalid_request_error","message":"Could not process image"}`.
+ * Observed for a truncated JPEG (no end-of-image marker) that local resizing
+ * also failed to decode and therefore forwarded unchanged. The body names no
+ * image, and the image stays in history, so without omission every later
+ * request of the session draws the same rejection.
+ */
+export declare function isAnthropicImageUnprocessableError(error: unknown): boolean;
+export declare const ANTHROPIC_OMITTED_IMAGE_PLACEHOLDER = "[Image omitted: Anthropic could not process this image. The file may be corrupt or truncated; re-export or convert it before attaching it again.]";
 /**
  * CLIProxyAPI replaces Anthropic's rejection body wholesale instead of forwarding
  * it: the client only ever sees

package/src/providers/anthropic.ts

@@ -388,6 +388,14 @@ type AnthropicProviderSessionState = ProviderSessionState & {
 	thinkingReplayRepairScope: AnthropicThinkingReplayRepairScope;
 	thinkingReplayRepairAttempts: number;
 	thinkingReplayRejectedPayload?: AnthropicPayloadFingerprint;
+	/**
+	 * sha256 digests of base64 image payloads Anthropic rejected with
+	 * "Could not process image". The image stays in session history, so every
+	 * later build must keep replacing it or each turn draws the same 400.
+	 */
+	omittedImageDigests: Set<string>;
+	/** Image omissions spent since the last completed stream; bounds escalation. */
+	imageOmissionRepairs: number;
 	/**
 	 * Managed-mode escalation for the CPA alias-restore failure (issue #4338):
 	 * corrective steering recorded against one exact turn, applied by the next
@@ -416,6 +424,8 @@ function createAnthropicProviderSessionState(): AnthropicProviderSessionState {
 		warnedUnknownLongCacheRetention: new Set(),
 		thinkingReplayRepairScope: "none",
 		thinkingReplayRepairAttempts: 0,
+		omittedImageDigests: new Set(),
+		imageOmissionRepairs: 0,
 		close: () => {
 			state.strictToolsDisabled = false;
 			state.fastModeDisabled = false;
@@ -424,6 +434,8 @@ function createAnthropicProviderSessionState(): AnthropicProviderSessionState {
 			state.thinkingReplayRepairScope = "none";
 			state.thinkingReplayRepairAttempts = 0;
 			state.thinkingReplayRejectedPayload = undefined;
+			state.omittedImageDigests.clear();
+			state.imageOmissionRepairs = 0;
 			state.cpaToolAliasSteering = undefined;
 		},
 	};
@@ -532,6 +544,86 @@ export function isAnthropicThinkingSignatureInvalidError(error: unknown): boolea
 	);
 }
 
+/**
+ * 400 shape where Anthropic cannot decode one of the request's images:
+ * `{"type":"invalid_request_error","message":"Could not process image"}`.
+ * Observed for a truncated JPEG (no end-of-image marker) that local resizing
+ * also failed to decode and therefore forwarded unchanged. The body names no
+ * image, and the image stays in history, so without omission every later
+ * request of the session draws the same rejection.
+ */
+export function isAnthropicImageUnprocessableError(error: unknown): boolean {
+	if (!isAnthropicInvalidRequestStatus(error)) return false;
+	const message = error instanceof Error ? error.message : String(error);
+	return /invalid_request_error/i.test(message) && /could not process image/i.test(message);
+}
+
+/**
+ * Bounds image omission per stream: the first rejection omits the images of the
+ * newest message that carries any (the request before it was accepted, so the
+ * rejected image is almost always new), the second omits every remaining image.
+ */
+const ANTHROPIC_MAX_IMAGE_OMISSION_REPAIRS = 2;
+
+export const ANTHROPIC_OMITTED_IMAGE_PLACEHOLDER =
+	"[Image omitted: Anthropic could not process this image. The file may be corrupt or truncated; re-export or convert it before attaching it again.]";
+
+type AnthropicImageSite = {
+	digest: string;
+	messageIndex: number;
+	container: unknown[];
+	index: number;
+};
+
+function collectAnthropicImageSites(params: MessageCreateParamsStreaming): AnthropicImageSite[] {
+	const sites: AnthropicImageSite[] = [];
+	const visit = (container: unknown[], messageIndex: number): void => {
+		for (let index = 0; index < container.length; index++) {
+			const block = container[index];
+			if (!isRecord(block)) continue;
+			if (block.type === "tool_result" && Array.isArray(block.content)) {
+				visit(block.content, messageIndex);
+				continue;
+			}
+			if (block.type !== "image" || !isRecord(block.source)) continue;
+			const data = block.source.data;
+			if (typeof data !== "string") continue;
+			const digest = nodeCrypto.createHash("sha256").update(data).digest("hex");
+			sites.push({ digest, messageIndex, container, index });
+		}
+	};
+	params.messages.forEach((message, messageIndex) => {
+		if (Array.isArray(message.content)) visit(message.content as unknown[], messageIndex);
+	});
+	return sites;
+}
+
+/** Replace every image whose payload digest is listed, keeping its cache breakpoint. */
+function omitAnthropicImages(params: MessageCreateParamsStreaming, digests: ReadonlySet<string>): void {
+	for (const site of collectAnthropicImageSites(params)) {
+		if (!digests.has(site.digest)) continue;
+		const image = site.container[site.index] as Record<string, unknown>;
+		site.container[site.index] = {
+			type: "text",
+			text: ANTHROPIC_OMITTED_IMAGE_PLACEHOLDER,
+			...(image.cache_control === undefined ? {} : { cache_control: image.cache_control }),
+		};
+	}
+}
+
+/** Digests to omit after a rejection: the newest image-bearing message first, then everything. */
+function selectAnthropicImagesToOmit(
+	params: MessageCreateParamsStreaming,
+	omitted: ReadonlySet<string>,
+	scope: "latest" | "all",
+): string[] {
+	const remaining = collectAnthropicImageSites(params).filter(site => !omitted.has(site.digest));
+	if (remaining.length === 0) return [];
+	const newest = Math.max(...remaining.map(site => site.messageIndex));
+	const selected = scope === "latest" ? remaining.filter(site => site.messageIndex === newest) : remaining;
+	return [...new Set(selected.map(site => site.digest))];
+}
+
 /**
  * CLIProxyAPI replaces Anthropic's rejection body wholesale instead of forwarding
  * it: the client only ever sees
@@ -1640,6 +1732,7 @@ function getAnthropicCompat(
 		supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
 		supportsToolChoice: model.compat?.supportsToolChoice ?? true,
 		supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? true,
+		supportsUltrafastTier: model.compat?.supportsUltrafastTier ?? false,
 		promptCacheMode: model.compat?.promptCacheMode ?? "none",
 		toolChoiceSupport: model.compat?.toolChoiceSupport,
 	};
@@ -2095,6 +2188,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 		let activeAbortTracker = createAbortSourceTracker(options?.signal);
 
 		try {
+			const idleTimeoutMs =
+				options?.streamIdleTimeoutMs ??
+				getStreamIdleTimeoutMs(model.streamIdleTimeoutMs ?? getProviderStreamIdleTimeoutFallbackMs(model.provider));
 			let client: Anthropic;
 			let isOAuthToken: boolean;
 
@@ -2127,7 +2223,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					requestMaxRetries: options?.requestMaxRetries,
 					maxRetryDelayMs: options?.maxRetryDelayMs,
 					streamFirstEventTimeoutMs: options?.streamFirstEventTimeoutMs,
-					streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
+					streamIdleTimeoutMs: idleTimeoutMs,
 					providerSessionId: options?.providerSessionId,
 				});
 				client = created.client;
@@ -2154,6 +2250,10 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			let thinkingReplayRepairPersistent = thinkingReplayRepairScope !== "none";
 			let generatedCacheBudget: GeneratedCacheBudget = providerSessionState?.generatedCacheBudget ?? 2;
 			let warnedUnknownLongCacheRetention = false;
+			// Shared with the session so later turns keep omitting a rejected image
+			// that is still in history; per-stream when no session state is shared.
+			const omittedImageDigests = providerSessionState?.omittedImageDigests ?? new Set<string>();
+			let imageOmissionRepairs = providerSessionState?.imageOmissionRepairs ?? 0;
 			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
@@ -2196,6 +2296,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				if (dropFastMode) {
 					dropAnthropicFastMode(nextParams);
 				}
+				if (omittedImageDigests.size > 0) {
+					omitAnthropicImages(nextParams, omittedImageDigests);
+				}
 				const replacementPayload = await options?.onPayload?.(
 					nextParams,
 					model,
@@ -2315,9 +2418,6 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				firstTokenTime = undefined;
 				truncatedToolCalls.clear();
 			};
-			const idleTimeoutMs =
-				options?.streamIdleTimeoutMs ??
-				getStreamIdleTimeoutMs(getProviderStreamIdleTimeoutFallbackMs(model.provider));
 			const firstEventFallbackMs = getProviderFirstEventTimeoutFallbackMs(model.provider);
 			const firstEventTimeoutMs =
 				options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs, firstEventFallbackMs);
@@ -2786,6 +2886,11 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						providerSessionState.thinkingReplayRepairScope = "none";
 						providerSessionState.thinkingReplayRepairAttempts = 0;
 					}
+					// Omitted digests stay recorded (the images are still in history); only
+					// the escalation budget re-arms for a different image rejected later.
+					if (providerSessionState && imageOmissionRepairs > 0) {
+						providerSessionState.imageOmissionRepairs = 0;
+					}
 					// Release a recorded CPA steering once any stream completes: a
 					// successful stream consumed it, and a failed one ends the turn (a
 					// later turn's different user prompt would expire it anyway).
@@ -2889,6 +2994,36 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						resetOutputForRetry();
 						continue;
 					}
+					// An image Anthropic cannot decode fails the whole request and stays in
+					// history, so the session never recovers on its own. Record the omission
+					// before deciding who retries: unmanaged streams resend here, managed
+					// attempts leave the retry to the fallback controller, whose next attempt
+					// rebuilds from the shared session state without the rejected image.
+					if (
+						firstTokenTime === undefined &&
+						imageOmissionRepairs < ANTHROPIC_MAX_IMAGE_OMISSION_REPAIRS &&
+						isAnthropicImageUnprocessableError(streamFailure)
+					) {
+						const scope = imageOmissionRepairs === 0 ? "latest" : "all";
+						const digests = selectAnthropicImagesToOmit(params, omittedImageDigests, scope);
+						if (digests.length > 0) {
+							for (const digest of digests) omittedImageDigests.add(digest);
+							imageOmissionRepairs++;
+							if (providerSessionState) providerSessionState.imageOmissionRepairs = imageOmissionRepairs;
+							logger.warn("anthropic: provider could not process an image; omitting it from the request", {
+								model: model.id,
+								scope,
+								omittedImages: digests.length,
+								managed: options?.fallbackManaged === true,
+							});
+							if (!options?.fallbackManaged && !options?.disableProviderRetries) {
+								params = await prepareParams();
+								providerUploadCount++;
+								resetOutputForRetry();
+								continue;
+							}
+						}
+					}
 					const thinkingSignatureInvalid = isAnthropicThinkingSignatureInvalidError(streamFailure);
 					const thinkingBlocksImmutable = isAnthropicThinkingBlockMutationError(streamFailure);
 					const maskedProxyRejection = isAnthropicMaskedProxyRejection(streamFailure);

package/src/providers/aws-credential-config.d.ts

@@ -1,3 +1,4 @@
+import type { FetchImpl } from "../types";
 import type { AwsCredentials } from "./aws-sigv4";
 export type AwsIniFile = Record<string, Record<string, string>>;
 export interface AwsCredentialSourceOptions {
@@ -16,4 +17,8 @@ export declare function classifyAwsProfileCapability(profile: string, credential
 export declare function hasResolvableAwsProfileSource(options?: AwsCredentialSourceOptions & {
     onScan?: () => void;
 }, now?: number): boolean;
+/** Probe only the IMDSv2 token and role endpoints; never request role credentials for status. */
+export declare function hasAwsInstanceProfileCredentialSource(options?: {
+    fetch?: FetchImpl;
+}): Promise<boolean>;
 export declare function isValidBedrockBearerToken(token: string | undefined): token is string;

package/src/providers/aws-credential-config.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { $credentialEnv, getTrustedHomeDir } from "@gajae-code/utils";
+import { $credentialEnv, $env, getTrustedHomeDir } from "@gajae-code/utils";
+import type { FetchImpl } from "../types";
 import type { AwsCredentials } from "./aws-sigv4";
 
 export type AwsIniFile = Record<string, Record<string, string>>;
@@ -122,6 +123,33 @@ export function hasResolvableAwsProfileSource(
 	return value;
 }
 
+/** Probe only the IMDSv2 token and role endpoints; never request role credentials for status. */
+export async function hasAwsInstanceProfileCredentialSource(options?: { fetch?: FetchImpl }): Promise<boolean> {
+	if ($env.AWS_EC2_METADATA_DISABLED?.toLowerCase() === "true") return false;
+	const fetchImpl = options?.fetch ?? globalThis.fetch.bind(globalThis);
+	const signal = AbortSignal.timeout(1000);
+	try {
+		const tokenResponse = await fetchImpl("http://169.254.169.254/latest/api/token", {
+			method: "PUT",
+			headers: { "x-aws-ec2-metadata-token-ttl-seconds": "21600" },
+			redirect: "error",
+			signal,
+		});
+		if (!tokenResponse.ok) return false;
+		const token = (await tokenResponse.text()).trim();
+		if (!token) return false;
+
+		const rolesResponse = await fetchImpl("http://169.254.169.254/latest/meta-data/iam/security-credentials/", {
+			headers: { "x-aws-ec2-metadata-token": token },
+			redirect: "error",
+			signal,
+		});
+		return rolesResponse.ok && Boolean((await rolesResponse.text()).trim());
+	} catch {
+		return false;
+	}
+}
+
 export function isValidBedrockBearerToken(token: string | undefined): token is string {
 	if (!token) return false;
 	return !/[\x00-\x1f\x7f]/.test(token);

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

@@ -14,8 +14,15 @@
  * (default 60s). Concurrent callers waiting on a refresh share the same in-flight promise.
  */
 import type { FetchImpl } from "../types";
+export type VertexCredentialSource = "explicit-file" | "default-file" | "metadata-server";
+/** Match the region-label constraint used before Vertex interpolates a location into the request host. */
+export declare function isValidVertexLocation(location: string): boolean;
 /** Test seam: the ADC credentials file path as resolved from trusted env. */
 export declare function resolveAdcCredentialsPathForTest(): string | undefined;
+/** Resolve the source of a currently usable ADC credential without acquiring an access token. */
+export declare function getVertexCredentialSource(options?: {
+    fetch?: FetchImpl;
+}): Promise<VertexCredentialSource | undefined>;
 /**
  * Returns a Bearer access token suitable for the `Authorization` header on Vertex AI calls.
  * The token is cached in module scope and refreshed `GOOGLE_VERTEX_REFRESH_SKEW_MS` ms before it expires.