@gajae-code/ai 0.9.6 → 0.10.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-07-12
+### Fixed
+
+- Made Bedrock model visibility reflect credential-only static/shared AWS sources with supported profile shapes, authenticated real bearer-token requests, and stopped advertising unsupported ECS/IRSA sources (#1934).
+- Added a typed provider safety-stop classification across Anthropic, OpenAI-compatible, and Google streams so callers can distinguish policy terminations from generic provider errors without parsing display text.
+
 ## [0.9.6] - 2026-07-10
 ### Fixed
 

package/dist/types/providers/aws-credential-config.d.ts

@@ -0,0 +1,19 @@
+import type { AwsCredentials } from "./aws-sigv4";
+export type AwsIniFile = Record<string, Record<string, string>>;
+export interface AwsCredentialSourceOptions {
+    profile?: string;
+}
+export interface AwsCredentialSource {
+    profile: string;
+    credentialsPath: string;
+    configPath: string;
+}
+export type AwsProfileCapability = "static" | "process" | "sso" | undefined;
+export declare function parseAwsIni(text: string): AwsIniFile;
+export declare function resolveAwsCredentialSource(options?: AwsCredentialSourceOptions): AwsCredentialSource;
+export declare function readAwsStaticEnvironmentCredentials(): AwsCredentials | undefined;
+export declare function classifyAwsProfileCapability(profile: string, credentialsIni: AwsIniFile | undefined, configIni: AwsIniFile | undefined): AwsProfileCapability;
+export declare function hasResolvableAwsProfileSource(options?: AwsCredentialSourceOptions & {
+    onScan?: () => void;
+}, now?: number): boolean;
+export declare function isValidBedrockBearerToken(token: string | undefined): token is string;

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

@@ -8,6 +8,12 @@ import type { Content, FinishReason, FunctionCallingConfigMode, GenerateContentP
 export type { Content, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, ThinkingConfig, } from "./google-types";
 export { normalizeSchemaForGoogle };
 type GoogleApiType = "google-generative-ai" | "google-gemini-cli" | "google-vertex";
+export declare const PROVIDER_SAFETY_STOP = "provider_safety_stop";
+export declare function isGoogleCandidateSafetyStopReason(reason: string): boolean;
+export declare function isGooglePromptSafetyStopReason(reason: string): boolean;
+export declare function getGooglePromptBlockReason(promptFeedback: {
+    blockReason?: unknown;
+} | undefined): string | undefined;
 /**
  * Thinking level for Gemini 3 models. Mirrors Google's `ThinkingLevel` enum values.
  * Defined here (not in any specific provider) so all Google providers can reference it

package/dist/types/types.d.ts

@@ -393,6 +393,7 @@ export interface Usage {
     };
 }
 export type StopReason = "stop" | "length" | "toolUse" | "error" | "aborted";
+export type AssistantErrorKind = "provider_safety_stop";
 export interface OpenAIResponsesHistoryPayload {
     type: "openaiResponsesHistory";
     provider?: string;
@@ -430,6 +431,7 @@ export interface AssistantMessage {
     usage: Usage;
     stopReason: StopReason;
     errorMessage?: string;
+    errorKind?: AssistantErrorKind;
     /** HTTP status surfaced by the provider when the request failed. Populated by every provider's catch block alongside `errorMessage` so consumers (auth retry, telemetry, UI) can branch without regex-scraping the message. */
     errorStatus?: number;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.9.6",
+	"version": "0.10.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -30,7 +30,7 @@
 	},
 	"scripts": {
 		"check": "biome check . && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"check:types": "tsc -p tsconfig.json --noEmit",
 		"lint": "biome lint .",
 		"test": "bun test",
 		"fix": "biome check --write --unsafe .",
@@ -40,7 +40,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/utils": "0.9.6",
+		"@gajae-code/utils": "0.10.0",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/providers/amazon-bedrock.ts

@@ -7,7 +7,7 @@
  * Bun's native `HTTPS_PROXY` support.
  */
 
-import { $env, $flag, extractHttpStatusFromError, fetchWithRetry } from "@gajae-code/utils";
+import { $credentialEnv, $env, $flag, extractHttpStatusFromError, fetchWithRetry } from "@gajae-code/utils";
 import type { Effort } from "../model-thinking";
 import { mapEffortToAnthropicAdaptiveEffort, requireSupportedEffort } from "../model-thinking";
 import { calculateCost } from "../models";
@@ -39,8 +39,10 @@ import {
 	markToolChoiceIncapability,
 	resolveToolChoice,
 } from "../utils/tool-choice-capability";
+import { isValidBedrockBearerToken } from "./aws-credential-config";
 import { resolveAwsCredentials } from "./aws-credentials";
 import { decodeEventStream } from "./aws-eventstream";
+import type { AwsCredentials } from "./aws-sigv4";
 import { signRequest } from "./aws-sigv4";
 import { transformMessages } from "./transform-messages";
 
@@ -162,6 +164,8 @@ interface MetadataEvent {
 	};
 }
 
+type BedrockAuthMode = { kind: "bearer"; token: string } | { kind: "sigv4"; credentials: AwsCredentials };
+
 export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 	model: Model<"bedrock-converse-stream">,
 	context: Context,
@@ -233,34 +237,44 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				body: commandInput,
 			};
 
-			let credentials: { accessKeyId: string; secretAccessKey: string; sessionToken?: string };
-			if ($flag("AWS_BEDROCK_SKIP_AUTH")) {
-				credentials = { accessKeyId: "dummy-access-key", secretAccessKey: "dummy-secret-key" };
-			} else {
-				credentials = await resolveAwsCredentials({
-					profile: options.profile,
-					region,
-					signal: options.signal,
-				});
+			const bearerToken = $credentialEnv("AWS_BEARER_TOKEN_BEDROCK");
+			if (bearerToken && !isValidBedrockBearerToken(bearerToken)) {
+				throw new Error("AWS_BEARER_TOKEN_BEDROCK contains unsafe control characters.");
 			}
-
+			const authMode: BedrockAuthMode = bearerToken
+				? { kind: "bearer", token: bearerToken }
+				: {
+						kind: "sigv4",
+						credentials: $flag("AWS_BEDROCK_SKIP_AUTH")
+							? { accessKeyId: "dummy-access-key", secretAccessKey: "dummy-secret-key" }
+							: await resolveAwsCredentials({ profile: options.profile, region, signal: options.signal }),
+					};
 			const bodyText = JSON.stringify(commandInput);
 			const body = new TextEncoder().encode(bodyText);
 			const baseHeaders: Record<string, string> = {
 				"content-type": "application/json",
 				accept: "application/vnd.amazon.eventstream",
 			};
-			const signed = await signRequest({
-				method: "POST",
-				host,
-				path: urlPath,
-				body,
-				region,
-				service: "bedrock",
-				credentials,
-				headers: baseHeaders,
-			});
-			const requestHeaders: Record<string, string> = { ...baseHeaders, ...signed };
+			const buildRequestHeaders = async (requestBody: Uint8Array): Promise<Record<string, string>> => {
+				const headers = new Headers(baseHeaders);
+				if (authMode.kind === "bearer") {
+					headers.set("authorization", `Bearer ${authMode.token}`);
+					return Object.fromEntries(headers);
+				}
+				const signed = await signRequest({
+					method: "POST",
+					host,
+					path: urlPath,
+					body: requestBody,
+					region,
+					service: "bedrock",
+					credentials: authMode.credentials,
+					headers: baseHeaders,
+				});
+				for (const [name, value] of Object.entries(signed)) headers.set(name, value);
+				return Object.fromEntries(headers);
+			};
+			const requestHeaders = await buildRequestHeaders(body);
 			const sentForcedToolChoice = Boolean(toolConfig?.toolChoice?.any || toolConfig?.toolChoice?.tool);
 			let fallbackRan = false;
 			const retryWithoutForcedToolChoice = async (reason: string) => {
@@ -279,20 +293,10 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				stripBedrockForcedToolChoiceForRetry(commandInput);
 				const retryBodyText = JSON.stringify(commandInput);
 				const retryBody = new TextEncoder().encode(retryBodyText);
-				const retrySigned = await signRequest({
-					method: "POST",
-					host,
-					path: urlPath,
-					body: retryBody,
-					region,
-					service: "bedrock",
-					credentials,
-					headers: baseHeaders,
-				});
 				if (rawRequestDump) rawRequestDump.body = commandInput;
 				return fetchWithRetry(url, {
 					method: "POST",
-					headers: { ...baseHeaders, ...retrySigned },
+					headers: await buildRequestHeaders(retryBody),
 					body: retryBody,
 					signal: options.signal,
 					maxAttempts: 1,

package/src/providers/anthropic.ts

@@ -1341,6 +1341,17 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				}
 				blocksByAnthropicIndex.set(anthropicIndex, block);
 			};
+			const resetOutputForRetry = () => {
+				output.content.length = 0;
+				output.responseId = undefined;
+				output.errorKind = undefined;
+				output.errorStatus = undefined;
+				output.errorMessage = strictFallbackErrorMessage;
+				output.providerPayload = undefined;
+				output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
+				output.stopReason = "stop";
+				firstTokenTime = undefined;
+			};
 			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getStreamIdleTimeoutMs();
 			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs);
 			stream.push({ type: "start", partial: output });
@@ -1360,6 +1371,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				const { requestSignal } = activeAbortTracker;
 				const anthropicRequest = client.messages.create({ ...params, stream: true }, { signal: requestSignal });
 				let streamedReplayUnsafeContent = false;
+				let sawProviderSafetyStop = false;
 
 				try {
 					const {
@@ -1386,6 +1398,12 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						abortSignal: options?.signal,
 					})) {
 						sawEvent = true;
+						if (sawProviderSafetyStop) {
+							if (event.type === "message_stop") {
+								sawTerminalEnvelope = true;
+							}
+							continue;
+						}
 
 						if (event.type === "message_start") {
 							if (sawMessageStart) {
@@ -1545,26 +1563,34 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							}
 						} else if (event.type === "message_delta") {
 							const rawStopReason = event.delta.stop_reason as string | null | undefined;
+							const stopDetails = event.delta.stop_details;
+							const isProviderSafetyStop =
+								rawStopReason === "refusal" || rawStopReason === "sensitive" || stopDetails?.type === "refusal";
 							if (rawStopReason) {
-								output.stopReason = mapStopReason(rawStopReason);
+								output.stopReason = isProviderSafetyStop ? "error" : mapStopReason(rawStopReason);
 								sawTerminalEnvelope = true;
 							}
-							const stopDetails = event.delta.stop_details;
-							if (stopDetails && stopDetails.type === "refusal") {
-								const explanation = stopDetails.explanation?.trim();
-								const category = stopDetails.category;
-								const label = category ? `Refusal (${category})` : "Refusal";
-								output.errorMessage = explanation ? `${label}: ${explanation}` : label;
+							if (isProviderSafetyStop) {
+								sawProviderSafetyStop = true;
+								sawTerminalEnvelope = true;
+								output.stopReason = "error";
+								output.errorKind = "provider_safety_stop";
+								if (stopDetails?.type === "refusal") {
+									const explanation = stopDetails.explanation?.trim();
+									const category = stopDetails.category;
+									const label = category ? `Refusal (${category})` : "Refusal";
+									output.errorMessage = explanation ? `${label}: ${explanation}` : label;
+								} else if (!output.errorMessage) {
+									output.errorMessage =
+										rawStopReason === "refusal"
+											? "Refusal (no details provided)"
+											: "Content flagged by safety filters";
+								}
 							} else if (output.stopReason === "error" && !output.errorMessage) {
-								// Anthropic flagged an error-class stop (refusal / sensitive) without
-								// populating stop_details. Surface the raw reason instead of falling
-								// through to the generic "unknown error" string when we throw below.
-								output.errorMessage =
-									rawStopReason === "refusal"
-										? "Refusal (no details provided)"
-										: rawStopReason === "sensitive"
-											? "Content flagged by safety filters"
-											: `Anthropic stream ended with stop_reason: ${rawStopReason ?? "unknown"}`;
+								// Anthropic flagged an error-class stop without populating stop_details.
+								// Surface the raw reason instead of falling through to the generic
+								// "unknown error" string when we throw below.
+								output.errorMessage = `Anthropic stream ended with stop_reason: ${rawStopReason ?? "unknown"}`;
 							}
 							if (event.usage.input_tokens != null) {
 								output.usage.input = event.usage.input_tokens;
@@ -1607,6 +1633,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					break;
 				} catch (streamError) {
 					const streamFailure = activeAbortTracker.getLocalAbortReason() ?? streamError;
+					if (sawProviderSafetyStop) {
+						throw streamFailure;
+					}
 					if (
 						!disableStrictTools &&
 						firstTokenTime === undefined &&
@@ -1614,19 +1643,13 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						isAnthropicStrictGrammarTooLargeError(streamFailure)
 					) {
 						strictFallbackErrorMessage = await finalizeErrorMessage(streamFailure, rawRequestDump);
-						output.errorMessage = strictFallbackErrorMessage;
 						if (providerSessionState) {
 							providerSessionState.strictToolsDisabled = true;
 						}
 						disableStrictTools = true;
 						params = await prepareParams();
 						providerRetryAttempt = 0;
-						output.content.length = 0;
-						output.responseId = undefined;
-						output.providerPayload = undefined;
-						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-						output.stopReason = "stop";
-						firstTokenTime = undefined;
+						resetOutputForRetry();
 						continue;
 					}
 					if (
@@ -1654,12 +1677,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						droppedForcedToolChoice = true;
 						params = await prepareParams({ dropForcedToolChoice: true });
 						providerRetryAttempt = 0;
-						output.content.length = 0;
-						output.responseId = undefined;
-						output.providerPayload = undefined;
-						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-						output.stopReason = "stop";
-						firstTokenTime = undefined;
+						resetOutputForRetry();
 						continue;
 					}
 					if (
@@ -1674,12 +1692,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						thinkingRepairAttempted = true;
 						params = await prepareParams({ repairLatestAssistantThinking: true });
 						providerRetryAttempt = 0;
-						output.content.length = 0;
-						output.responseId = undefined;
-						output.providerPayload = undefined;
-						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-						output.stopReason = "stop";
-						firstTokenTime = undefined;
+						resetOutputForRetry();
 						continue;
 					}
 					if (
@@ -1698,12 +1711,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						dropFastMode = true;
 						params = await prepareParams();
 						providerRetryAttempt = 0;
-						output.content.length = 0;
-						output.responseId = undefined;
-						output.providerPayload = undefined;
-						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-						output.stopReason = "stop";
-						firstTokenTime = undefined;
+						resetOutputForRetry();
 						continue;
 					}
 					const isTransientEnvelopeFailure =
@@ -1725,13 +1733,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					} else {
 						await scheduler.wait(delayMs, { signal: options?.signal });
 					}
-					output.content.length = 0;
-					output.responseId = undefined;
-					output.errorMessage = strictFallbackErrorMessage;
-					output.providerPayload = undefined;
-					output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
-					output.stopReason = "stop";
-					firstTokenTime = undefined;
+					resetOutputForRetry();
 				}
 			}
 
@@ -1750,7 +1752,10 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			const firstEventTimeoutError = activeAbortTracker.getLocalAbortReason();
 			output.stopReason = activeAbortTracker.wasCallerAbort() ? "aborted" : "error";
 			output.errorStatus = extractHttpStatusFromError(error);
-			output.errorMessage = firstEventTimeoutError?.message ?? (await finalizeErrorMessage(error, rawRequestDump));
+			if (output.errorKind !== "provider_safety_stop" || !output.errorMessage) {
+				output.errorMessage =
+					firstEventTimeoutError?.message ?? (await finalizeErrorMessage(error, rawRequestDump));
+			}
 			output.errorMessage = rewriteCopilotError(output.errorMessage, error, model.provider);
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;

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

@@ -0,0 +1,180 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $credentialEnv } from "@gajae-code/utils";
+import type { AwsCredentials } from "./aws-sigv4";
+
+export type AwsIniFile = Record<string, Record<string, string>>;
+
+export interface AwsCredentialSourceOptions {
+	profile?: string;
+}
+
+export interface AwsCredentialSource {
+	profile: string;
+	credentialsPath: string;
+	configPath: string;
+}
+
+export type AwsProfileCapability = "static" | "process" | "sso" | undefined;
+
+const AVAILABILITY_CACHE_MAX_AGE_MS = 1_000;
+const MAX_AWS_INI_FILE_BYTES = 1024 * 1024;
+
+interface FileFingerprint {
+	exists: boolean;
+	size?: number;
+	mtimeMs?: number;
+	ctimeMs?: number;
+	ino?: number;
+}
+
+interface AvailabilityCacheEntry {
+	source: AwsCredentialSource;
+	credentials: FileFingerprint;
+	config: FileFingerprint;
+	value: boolean;
+	checkedAt: number;
+}
+
+let availabilityCache: AvailabilityCacheEntry | undefined;
+
+export function parseAwsIni(text: string): AwsIniFile {
+	const out: AwsIniFile = {};
+	let current: Record<string, string> | undefined;
+	for (const rawLine of text.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+		if (line.startsWith("[") && line.endsWith("]")) {
+			let name = line.slice(1, -1).trim();
+			if (name.startsWith("profile ")) name = name.slice(8).trim();
+			if (name.startsWith("sso-session ")) name = `sso-session:${name.slice(12).trim()}`;
+			current = out[name] ??= {};
+			continue;
+		}
+		if (!current) continue;
+		const equals = line.indexOf("=");
+		if (equals === -1) continue;
+		const key = line.slice(0, equals).trim();
+		const value = line.slice(equals + 1).trim();
+		if (key) current[key] = value;
+	}
+	return out;
+}
+
+export function resolveAwsCredentialSource(options: AwsCredentialSourceOptions = {}): AwsCredentialSource {
+	const profile = options.profile || $credentialEnv("AWS_PROFILE") || "default";
+	const home = os.homedir();
+	return {
+		profile,
+		credentialsPath: path.resolve(
+			$credentialEnv("AWS_SHARED_CREDENTIALS_FILE") || path.join(home, ".aws", "credentials"),
+		),
+		configPath: path.resolve($credentialEnv("AWS_CONFIG_FILE") || path.join(home, ".aws", "config")),
+	};
+}
+
+export function readAwsStaticEnvironmentCredentials(): AwsCredentials | undefined {
+	const accessKeyId = $credentialEnv("AWS_ACCESS_KEY_ID");
+	const secretAccessKey = $credentialEnv("AWS_SECRET_ACCESS_KEY");
+	if (!accessKeyId || !secretAccessKey) return undefined;
+	const sessionToken = $credentialEnv("AWS_SESSION_TOKEN");
+	return sessionToken ? { accessKeyId, secretAccessKey, sessionToken } : { accessKeyId, secretAccessKey };
+}
+
+export function classifyAwsProfileCapability(
+	profile: string,
+	credentialsIni: AwsIniFile | undefined,
+	configIni: AwsIniFile | undefined,
+): AwsProfileCapability {
+	const merged = { ...(configIni?.[profile] ?? {}), ...(credentialsIni?.[profile] ?? {}) };
+	if (merged.aws_access_key_id && merged.aws_secret_access_key) return "static";
+	if (merged.sso_account_id && merged.sso_role_name) {
+		if (merged.sso_start_url && merged.sso_region) return "sso";
+		const session = merged.sso_session ? configIni?.[`sso-session:${merged.sso_session}`] : undefined;
+		if (session?.sso_start_url && session.sso_region) return "sso";
+	}
+	if (merged.credential_process) return "process";
+	return undefined;
+}
+
+export function hasResolvableAwsProfileSource(
+	options: AwsCredentialSourceOptions & { /** @internal Test-only cache scan observer. */ onScan?: () => void } = {},
+	now = Date.now(),
+): boolean {
+	const source = resolveAwsCredentialSource(options);
+	const credentials = fingerprint(source.credentialsPath);
+	const config = fingerprint(source.configPath);
+	if (
+		availabilityCache &&
+		now >= availabilityCache.checkedAt &&
+		now - availabilityCache.checkedAt < AVAILABILITY_CACHE_MAX_AGE_MS &&
+		sameSource(availabilityCache.source, source) &&
+		sameFingerprint(availabilityCache.credentials, credentials) &&
+		sameFingerprint(availabilityCache.config, config)
+	) {
+		return availabilityCache.value;
+	}
+	options.onScan?.();
+	const credentialsIni = readAwsIniSync(source.credentialsPath);
+	const configIni = readAwsIniSync(source.configPath);
+	const value = classifyAwsProfileCapability(source.profile, credentialsIni, configIni) !== undefined;
+	availabilityCache = { source, credentials, config, value, checkedAt: now };
+	return value;
+}
+
+export function isValidBedrockBearerToken(token: string | undefined): token is string {
+	if (!token) return false;
+	return !/[\x00-\x1f\x7f]/.test(token);
+}
+
+function readAwsIniSync(filePath: string): AwsIniFile | undefined {
+	let fd: number | undefined;
+	try {
+		fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+		const stat = fs.fstatSync(fd);
+		if (!stat.isFile() || stat.size > MAX_AWS_INI_FILE_BYTES) return undefined;
+		const contents = Buffer.allocUnsafe(MAX_AWS_INI_FILE_BYTES + 1);
+		let bytesRead = 0;
+		while (bytesRead < contents.length) {
+			const count = fs.readSync(fd, contents, bytesRead, contents.length - bytesRead, bytesRead);
+			if (count === 0) break;
+			bytesRead += count;
+		}
+		if (bytesRead > MAX_AWS_INI_FILE_BYTES) return undefined;
+		return parseAwsIni(contents.toString("utf8", 0, bytesRead));
+	} catch {
+		return undefined;
+	} finally {
+		if (fd !== undefined) {
+			try {
+				fs.closeSync(fd);
+			} catch {
+				// Ignore close errors because file availability has already been determined.
+			}
+		}
+	}
+}
+
+function fingerprint(filePath: string): FileFingerprint {
+	try {
+		const stat = fs.statSync(filePath);
+		return { exists: true, size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, ino: stat.ino };
+	} catch {
+		return { exists: false };
+	}
+}
+
+function sameSource(a: AwsCredentialSource, b: AwsCredentialSource): boolean {
+	return a.profile === b.profile && a.credentialsPath === b.credentialsPath && a.configPath === b.configPath;
+}
+
+function sameFingerprint(a: FileFingerprint, b: FileFingerprint): boolean {
+	return (
+		a.exists === b.exists &&
+		a.size === b.size &&
+		a.mtimeMs === b.mtimeMs &&
+		a.ctimeMs === b.ctimeMs &&
+		a.ino === b.ino
+	);
+}

package/src/providers/aws-credentials.ts

@@ -23,6 +23,13 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $env, isEnoent, logger } from "@gajae-code/utils";
+import {
+	type AwsIniFile,
+	classifyAwsProfileCapability,
+	parseAwsIni,
+	readAwsStaticEnvironmentCredentials,
+	resolveAwsCredentialSource,
+} from "./aws-credential-config";
 import type { AwsCredentials } from "./aws-sigv4";
 
 export interface ResolvedCredentials extends AwsCredentials {
@@ -48,7 +55,7 @@ interface CacheEntry {
 const cache: Map<string, CacheEntry> = new Map();
 
 export async function resolveAwsCredentials(opts: CredentialResolveOptions = {}): Promise<ResolvedCredentials> {
-	const profile = opts.profile || $env.AWS_PROFILE || "default";
+	const profile = resolveAwsCredentialSource({ profile: opts.profile }).profile;
 	const region = opts.region || $env.AWS_REGION || $env.AWS_DEFAULT_REGION || "us-east-1";
 	const cacheKey = `${profile}\x00${region}`;
 
@@ -62,7 +69,7 @@ export async function resolveAwsCredentials(opts: CredentialResolveOptions = {})
 
 async function resolveFresh(profile: string, region: string, signal?: AbortSignal): Promise<ResolvedCredentials> {
 	// 1. Environment first — matches the AWS SDK chain order.
-	const envCreds = readEnvCredentials();
+	const envCreds = readAwsStaticEnvironmentCredentials();
 	if (envCreds) return envCreds;
 
 	// 2. Profile (static or SSO).
@@ -81,52 +88,10 @@ async function resolveFresh(profile: string, region: string, signal?: AbortSigna
 	);
 }
 
-function readEnvCredentials(): ResolvedCredentials | undefined {
-	const ak = $env.AWS_ACCESS_KEY_ID;
-	const sk = $env.AWS_SECRET_ACCESS_KEY;
-	if (!ak || !sk) return undefined;
-	const token = $env.AWS_SESSION_TOKEN;
-	return token
-		? { accessKeyId: ak, secretAccessKey: sk, sessionToken: token }
-		: { accessKeyId: ak, secretAccessKey: sk };
-}
-
-// ---------- INI parsing ----------
-
-/** Map of section name -> map of key -> value. Section names are stripped of
- * any leading `profile ` (so `~/.aws/config` aligns with `~/.aws/credentials`). */
-type IniFile = Record<string, Record<string, string>>;
-
-function parseIni(text: string): IniFile {
-	const out: IniFile = {};
-	let current: Record<string, string> | null = null;
-	for (const rawLine of text.split(/\r?\n/)) {
-		const line = rawLine.trim();
-		if (!line || line.startsWith("#") || line.startsWith(";")) continue;
-		if (line.startsWith("[") && line.endsWith("]")) {
-			let name = line.slice(1, -1).trim();
-			if (name.startsWith("profile ")) name = name.slice(8).trim();
-			if (name.startsWith("sso-session ")) name = `sso-session:${name.slice(12).trim()}`;
-			let section = out[name];
-			if (!section) {
-				section = {};
-				out[name] = section;
-			}
-			current = section;
-			continue;
-		}
-		if (!current) continue;
-		const eq = line.indexOf("=");
-		if (eq === -1) continue;
-		current[line.slice(0, eq).trim()] = line.slice(eq + 1).trim();
-	}
-	return out;
-}
-
-async function readIniFile(p: string): Promise<IniFile | undefined> {
+async function readIniFile(p: string): Promise<AwsIniFile | undefined> {
 	try {
 		const text = await fs.promises.readFile(p, "utf8");
-		return parseIni(text);
+		return parseAwsIni(text);
 	} catch (err) {
 		if (isEnoent(err)) return undefined;
 		throw err;
@@ -140,9 +105,7 @@ async function readProfileCredentials(
 	region: string,
 	signal: AbortSignal | undefined,
 ): Promise<ResolvedCredentials | undefined> {
-	const home = os.homedir();
-	const credentialsPath = $env.AWS_SHARED_CREDENTIALS_FILE || path.join(home, ".aws", "credentials");
-	const configPath = $env.AWS_CONFIG_FILE || path.join(home, ".aws", "config");
+	const { credentialsPath, configPath } = resolveAwsCredentialSource({ profile });
 
 	const credentialsIni = await readIniFile(credentialsPath);
 	const configIni = await readIniFile(configPath);
@@ -152,22 +115,16 @@ async function readProfileCredentials(
 	const merged: Record<string, string> = { ...(configIni?.[profile] ?? {}), ...(credentialsIni?.[profile] ?? {}) };
 	if (Object.keys(merged).length === 0) return undefined;
 
-	if (merged.aws_access_key_id && merged.aws_secret_access_key) {
-		const out: ResolvedCredentials = {
-			accessKeyId: merged.aws_access_key_id,
-			secretAccessKey: merged.aws_secret_access_key,
-		};
+	const capability = classifyAwsProfileCapability(profile, credentialsIni, configIni);
+	if (capability === "static") {
+		const { aws_access_key_id: accessKeyId, aws_secret_access_key: secretAccessKey } = merged;
+		if (!accessKeyId || !secretAccessKey) return undefined;
+		const out: ResolvedCredentials = { accessKeyId, secretAccessKey };
 		if (merged.aws_session_token) out.sessionToken = merged.aws_session_token;
 		return out;
 	}
-
-	if (merged.sso_account_id && merged.sso_role_name) {
-		return readSsoCredentials(merged, configIni, region, signal);
-	}
-
-	if (merged.credential_process) {
-		return readCredentialProcess(profile, merged.credential_process, signal);
-	}
+	if (capability === "sso") return readSsoCredentials(merged, configIni, region, signal);
+	if (capability === "process") return readCredentialProcess(profile, merged.credential_process, signal);
 
 	return undefined;
 }
@@ -181,7 +138,7 @@ interface SsoCachedToken {
 
 async function readSsoCredentials(
 	profileCfg: Record<string, string>,
-	configIni: IniFile | undefined,
+	configIni: AwsIniFile | undefined,
 	defaultRegion: string,
 	signal: AbortSignal | undefined,
 ): Promise<ResolvedCredentials | undefined> {

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

@@ -40,10 +40,14 @@ import {
 	convertMessages,
 	convertTools,
 	type GoogleThinkingLevel,
+	getGooglePromptBlockReason,
+	isGoogleCandidateSafetyStopReason,
+	isGooglePromptSafetyStopReason,
 	isThinkingPart,
 	mapStopReasonString,
 	mapToolChoice,
 	nextToolCallId,
+	PROVIDER_SAFETY_STOP,
 	pushBlockEndEvent,
 	pushToolCallEvents,
 	retainThoughtSignature,
@@ -255,6 +259,9 @@ interface CloudCodeAssistResponseChunk {
 			};
 			finishReason?: string;
 		}>;
+		promptFeedback?: {
+			blockReason?: string;
+		};
 		usageMetadata?: {
 			promptTokenCount?: number;
 			candidatesTokenCount?: number;
@@ -537,9 +544,26 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 					}
 
 					if (candidate?.finishReason) {
-						output.stopReason = mapStopReasonString(candidate.finishReason);
-						if (output.content.some(b => b.type === "toolCall")) {
-							output.stopReason = "toolUse";
+						if (isGoogleCandidateSafetyStopReason(candidate.finishReason)) {
+							hasContent = true;
+							output.errorKind = PROVIDER_SAFETY_STOP;
+							output.stopReason = "error";
+						} else if (output.errorKind !== PROVIDER_SAFETY_STOP) {
+							output.stopReason = mapStopReasonString(candidate.finishReason);
+							if (output.stopReason === "stop" && output.content.some(b => b.type === "toolCall")) {
+								output.stopReason = "toolUse";
+							}
+						}
+					}
+
+					const blockReason = getGooglePromptBlockReason(responseData.promptFeedback);
+					if (blockReason) {
+						hasContent = true;
+						if (isGooglePromptSafetyStopReason(blockReason)) {
+							output.errorKind = PROVIDER_SAFETY_STOP;
+							output.stopReason = "error";
+						} else if (output.errorKind !== PROVIDER_SAFETY_STOP) {
+							output.stopReason = "error";
 						}
 					}
 

package/src/providers/google-shared.ts

@@ -51,6 +51,43 @@ export type {
 export { normalizeSchemaForGoogle };
 
 type GoogleApiType = "google-generative-ai" | "google-gemini-cli" | "google-vertex";
+export const PROVIDER_SAFETY_STOP = "provider_safety_stop";
+
+export function isGoogleCandidateSafetyStopReason(reason: string): boolean {
+	switch (reason) {
+		case "SAFETY":
+		case "IMAGE_SAFETY":
+		case "PROHIBITED_CONTENT":
+		case "IMAGE_PROHIBITED_CONTENT":
+		case "SPII":
+		case "BLOCKLIST":
+		case "RECITATION":
+		case "IMAGE_RECITATION":
+		case "MODEL_ARMOR":
+			return true;
+		default:
+			return false;
+	}
+}
+
+export function isGooglePromptSafetyStopReason(reason: string): boolean {
+	switch (reason) {
+		case "SAFETY":
+		case "IMAGE_SAFETY":
+		case "PROHIBITED_CONTENT":
+		case "BLOCKLIST":
+		case "MODEL_ARMOR":
+		case "JAILBREAK":
+			return true;
+		default:
+			return false;
+	}
+}
+
+export function getGooglePromptBlockReason(promptFeedback: { blockReason?: unknown } | undefined): string | undefined {
+	const blockReason = promptFeedback?.blockReason;
+	return typeof blockReason === "string" && blockReason.length > 0 ? blockReason : undefined;
+}
 
 /**
  * Thinking level for Gemini 3 models. Mirrors Google's `ThinkingLevel` enum values.
@@ -607,9 +644,24 @@ export async function consumeGoogleStream<T extends GoogleApiType>(args: {
 		}
 
 		if (candidate?.finishReason) {
-			output.stopReason = mapStopReason(candidate.finishReason);
-			if (output.content.some(b => b.type === "toolCall")) {
-				output.stopReason = "toolUse";
+			if (isGoogleCandidateSafetyStopReason(candidate.finishReason)) {
+				output.errorKind = PROVIDER_SAFETY_STOP;
+				output.stopReason = "error";
+			} else if (output.errorKind !== PROVIDER_SAFETY_STOP) {
+				output.stopReason = mapStopReason(candidate.finishReason);
+				if (output.stopReason === "stop" && output.content.some(b => b.type === "toolCall")) {
+					output.stopReason = "toolUse";
+				}
+			}
+		}
+
+		const blockReason = getGooglePromptBlockReason(chunk.promptFeedback);
+		if (blockReason) {
+			if (isGooglePromptSafetyStopReason(blockReason)) {
+				output.errorKind = PROVIDER_SAFETY_STOP;
+				output.stopReason = "error";
+			} else if (output.errorKind !== PROVIDER_SAFETY_STOP) {
+				output.stopReason = "error";
 			}
 		}
 

package/src/providers/openai-completions.ts

@@ -332,6 +332,19 @@ function isCompiledGrammarTooLargeStrictError(
 		/too large/i.test(messageParts)
 	);
 }
+function hasContentFilterSafetyCode(capturedErrorResponse: CapturedHttpErrorResponse | undefined): boolean {
+	const bodyJson = capturedErrorResponse?.bodyJson;
+	if (typeof bodyJson !== "object" || bodyJson === null || Array.isArray(bodyJson)) return false;
+	if (Reflect.get(bodyJson, "code") === "content_filter") return true;
+
+	const error = Reflect.get(bodyJson, "error");
+	return (
+		typeof error === "object" &&
+		error !== null &&
+		!Array.isArray(error) &&
+		Reflect.get(error, "code") === "content_filter"
+	);
+}
 
 // LIMITATION: The think tag parser uses naive string matching for <think>/<thinking> tags.
 // If MiniMax models output these literal strings in code blocks, XML examples, or explanations,
@@ -720,6 +733,13 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				const calls = kimiHealer.drainCompleted();
 				for (const call of calls) emitHealedToolCall(call);
 			};
+			let providerSafetyStop = false;
+			const markProviderSafetyStop = (errorMessage?: string): void => {
+				providerSafetyStop = true;
+				output.errorKind = "provider_safety_stop";
+				output.stopReason = "error";
+				if (errorMessage) output.errorMessage = errorMessage;
+			};
 
 			for await (const chunk of iterateWithIdleTimeout(openaiStream, {
 				watchdog: firstEventWatchdog,
@@ -751,13 +771,23 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 
 				if (choice.finish_reason) {
 					const finishReasonResult = mapStopReason(choice.finish_reason);
-					output.stopReason = finishReasonResult.stopReason;
-					if (finishReasonResult.errorMessage) {
-						output.errorMessage = finishReasonResult.errorMessage;
+					if (choice.finish_reason === "content_filter") {
+						markProviderSafetyStop(finishReasonResult.errorMessage);
+					} else if (!providerSafetyStop) {
+						output.stopReason = finishReasonResult.stopReason;
+						if (finishReasonResult.errorMessage) {
+							output.errorMessage = finishReasonResult.errorMessage;
+						}
 					}
 				}
 
 				if (choice.delta) {
+					if (typeof choice.delta.refusal === "string" && choice.delta.refusal.length > 0) {
+						appendTextDelta(choice.delta.refusal);
+						if (!providerSafetyStop) {
+							markProviderSafetyStop("Provider returned a safety refusal");
+						}
+					}
 					const normalizedDeltaText = normalizeStreamingContentText(choice.delta.content);
 					if (normalizedDeltaText.length > 0) {
 						if (!firstTokenTime) firstTokenTime = Date.now();
@@ -927,15 +957,19 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 		} catch (error) {
 			for (const block of output.content) delete (block as any).index;
 			const firstEventTimeoutError = abortTracker.getLocalAbortReason();
+			const capturedErrorResponse = getCapturedErrorResponse?.();
 			output.stopReason = abortTracker.wasCallerAbort() ? "aborted" : "error";
-			output.errorStatus = extractHttpStatusFromError(error) ?? getCapturedErrorResponse?.()?.status;
+			output.errorStatus = extractHttpStatusFromError(error) ?? capturedErrorResponse?.status;
 			output.errorMessage =
 				firstEventTimeoutError?.message ??
-				(await finalizeErrorMessage(error, rawRequestDump, getCapturedErrorResponse?.()));
+				(await finalizeErrorMessage(error, rawRequestDump, capturedErrorResponse));
 			// Some providers via OpenRouter include extra details here.
 			const rawMetadata = (error as { error?: { metadata?: { raw?: string } } })?.error?.metadata?.raw;
 			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
 			output.errorMessage = rewriteCopilotError(output.errorMessage, error, model.provider);
+			if (hasContentFilterSafetyCode(capturedErrorResponse)) {
+				output.errorKind = "provider_safety_stop";
+			}
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			stream.push({ type: "error", reason: output.stopReason, error: output });

package/src/stream.ts

@@ -11,6 +11,11 @@ import {
 } from "./model-thinking";
 import type { BedrockOptions } from "./providers/amazon-bedrock";
 import type { AnthropicOptions } from "./providers/anthropic";
+import {
+	hasResolvableAwsProfileSource,
+	isValidBedrockBearerToken,
+	readAwsStaticEnvironmentCredentials,
+} from "./providers/aws-credential-config";
 import type { CursorOptions } from "./providers/cursor";
 import type { GoogleOptions } from "./providers/google";
 import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
@@ -121,28 +126,12 @@ const serviceProviderMap: Record<string, KeyResolver> = {
 			return "<authenticated>";
 		}
 	},
-	// Amazon Bedrock supports multiple credential sources:
-	// 1. AWS_PROFILE - named profile from ~/.aws/credentials
-	// 2. AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY - standard IAM keys
-	// 3. AWS_BEARER_TOKEN_BEDROCK - Bedrock API keys (bearer token)
-	// 4. AWS_CONTAINER_CREDENTIALS_* - ECS/Task IAM role credentials
-	// 5. AWS_WEB_IDENTITY_TOKEN_FILE + AWS_ROLE_ARN - IRSA (EKS) web identity
+	// Advertise only credential sources implemented by the Bedrock request path.
+	// ECS and IRSA remain unavailable until matching resolvers are implemented.
 	"amazon-bedrock": () => {
-		const awsProfile = $credentialEnv("AWS_PROFILE");
-		const awsAccessKeyId = $credentialEnv("AWS_ACCESS_KEY_ID");
-		const awsSecretAccessKey = $credentialEnv("AWS_SECRET_ACCESS_KEY");
-		const awsBearerToken = $credentialEnv("AWS_BEARER_TOKEN_BEDROCK");
-		const hasEcsCredentials =
-			!!$credentialEnv("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") ||
-			!!$credentialEnv("AWS_CONTAINER_CREDENTIALS_FULL_URI");
-		const hasWebIdentity = !!$credentialEnv("AWS_WEB_IDENTITY_TOKEN_FILE") && !!$credentialEnv("AWS_ROLE_ARN");
-		if (
-			awsProfile ||
-			(awsAccessKeyId && awsSecretAccessKey) ||
-			awsBearerToken ||
-			hasEcsCredentials ||
-			hasWebIdentity
-		) {
+		const bearerToken = $credentialEnv("AWS_BEARER_TOKEN_BEDROCK");
+		if (bearerToken) return isValidBedrockBearerToken(bearerToken) ? "<authenticated>" : undefined;
+		if (readAwsStaticEnvironmentCredentials() || hasResolvableAwsProfileSource()) {
 			return "<authenticated>";
 		}
 	},

package/src/types.ts

@@ -552,6 +552,7 @@ export interface Usage {
 }
 
 export type StopReason = "stop" | "length" | "toolUse" | "error" | "aborted";
+export type AssistantErrorKind = "provider_safety_stop";
 
 export interface OpenAIResponsesHistoryPayload {
 	type: "openaiResponsesHistory";
@@ -594,6 +595,7 @@ export interface AssistantMessage {
 	usage: Usage;
 	stopReason: StopReason;
 	errorMessage?: string;
+	errorKind?: AssistantErrorKind;
 	/** HTTP status surfaced by the provider when the request failed. Populated by every provider's catch block alongside `errorMessage` so consumers (auth retry, telemetry, UI) can branch without regex-scraping the message. */
 	errorStatus?: number;
 	/**