@sayknow-cli/ai 0.3.11 → 0.3.13

package/src/providers/anthropic.ts

@@ -586,15 +586,12 @@ const ANTHROPIC_BUILTIN_TOOL_NAMES = new Set(["web_search", "code_execution", "t
 export const applyClaudeToolPrefix = (name: string, prefixOverride: string = claudeToolPrefix) => {
 	if (!prefixOverride) return name;
 	if (ANTHROPIC_BUILTIN_TOOL_NAMES.has(name.toLowerCase())) return name;
-	const prefix = prefixOverride.toLowerCase();
-	if (name.toLowerCase().startsWith(prefix)) return name;
 	return `${prefixOverride}${name}`;
 };
 
 export const stripClaudeToolPrefix = (name: string, prefixOverride: string = claudeToolPrefix) => {
 	if (!prefixOverride) return name;
-	const prefix = prefixOverride.toLowerCase();
-	if (!name.toLowerCase().startsWith(prefix)) return name;
+	if (!name.startsWith(prefixOverride)) return name;
 	return name.slice(prefixOverride.length);
 };
 
@@ -1325,6 +1322,36 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				| (ToolCall & { partialJson: string })
 			) & { index: number };
 			const blocks = output.content as Block[];
+			const blocksByAnthropicIndex = new Map<number, Block>();
+			const getBlockByAnthropicIndex = (anthropicIndex: number) => {
+				const block = blocksByAnthropicIndex.get(anthropicIndex);
+				if (!block) return { block: undefined, contentIndex: -1 };
+				return { block, contentIndex: blocks.indexOf(block) };
+			};
+			const trackBlockByAnthropicIndex = (anthropicIndex: number, block: Block) => {
+				// A duplicate start for an active index is a provider-envelope violation;
+				// finalize the orphaned block so no internal stream fields leak into output.
+				const orphaned = blocksByAnthropicIndex.get(anthropicIndex);
+				if (orphaned) {
+					if (orphaned.type === "toolCall" && orphaned.partialJson.trim()) {
+						orphaned.arguments = parseStreamingJson(orphaned.partialJson);
+					}
+					delete (orphaned as { index?: number }).index;
+					delete (orphaned as { partialJson?: string }).partialJson;
+				}
+				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 });
@@ -1334,6 +1361,8 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			let providerRetryAttempt = 0;
 			let thinkingRepairAttempted = false;
 			while (true) {
+				// Retries reset output.content; drop stale block correlations from the aborted attempt.
+				blocksByAnthropicIndex.clear();
 				activeAbortTracker = createAbortSourceTracker(options?.signal);
 				const firstEventTimeoutAbortError = new Error(
 					"Anthropic stream timed out while waiting for the first event",
@@ -1342,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 {
@@ -1368,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) {
@@ -1403,6 +1439,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									index: event.index,
 								};
 								output.content.push(block);
+								trackBlockByAnthropicIndex(event.index, block);
 								stream.push({
 									type: "text_start",
 									contentIndex: output.content.length - 1,
@@ -1416,6 +1453,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									index: event.index,
 								};
 								output.content.push(block);
+								trackBlockByAnthropicIndex(event.index, block);
 								stream.push({
 									type: "thinking_start",
 									contentIndex: output.content.length - 1,
@@ -1428,6 +1466,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									index: event.index,
 								};
 								output.content.push(block);
+								trackBlockByAnthropicIndex(event.index, block);
 							} else if (event.content_block.type === "tool_use") {
 								streamedReplayUnsafeContent = true;
 								const block: Block = {
@@ -1441,6 +1480,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									index: event.index,
 								};
 								output.content.push(block);
+								trackBlockByAnthropicIndex(event.index, block);
 								stream.push({
 									type: "toolcall_start",
 									contentIndex: output.content.length - 1,
@@ -1449,8 +1489,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							}
 						} else if (event.type === "content_block_delta") {
 							if (event.delta.type === "text_delta") {
-								const index = blocks.findIndex(b => b.index === event.index);
-								const block = blocks[index];
+								const { block, contentIndex: index } = getBlockByAnthropicIndex(event.index);
 								if (block && block.type === "text") {
 									block.text += event.delta.text;
 									stream.push({
@@ -1461,8 +1500,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									});
 								}
 							} else if (event.delta.type === "thinking_delta") {
-								const index = blocks.findIndex(b => b.index === event.index);
-								const block = blocks[index];
+								const { block, contentIndex: index } = getBlockByAnthropicIndex(event.index);
 								if (block && block.type === "thinking") {
 									block.thinking += event.delta.thinking;
 									stream.push({
@@ -1473,8 +1511,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									});
 								}
 							} else if (event.delta.type === "input_json_delta") {
-								const index = blocks.findIndex(b => b.index === event.index);
-								const block = blocks[index];
+								const { block, contentIndex: index } = getBlockByAnthropicIndex(event.index);
 								if (block && block.type === "toolCall") {
 									block.partialJson += event.delta.partial_json;
 									block.arguments = parseStreamingJson(block.partialJson);
@@ -1486,17 +1523,16 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									});
 								}
 							} else if (event.delta.type === "signature_delta") {
-								const index = blocks.findIndex(b => b.index === event.index);
-								const block = blocks[index];
+								const { block } = getBlockByAnthropicIndex(event.index);
 								if (block && block.type === "thinking") {
 									block.thinkingSignature = block.thinkingSignature || "";
 									block.thinkingSignature += event.delta.signature;
 								}
 							}
 						} else if (event.type === "content_block_stop") {
-							const index = blocks.findIndex(b => b.index === event.index);
-							const block = blocks[index];
+							const { block, contentIndex: index } = getBlockByAnthropicIndex(event.index);
 							if (block) {
+								blocksByAnthropicIndex.delete(event.index);
 								delete (block as { index?: number }).index;
 								if (block.type === "text") {
 									stream.push({
@@ -1513,7 +1549,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 										partial: output,
 									});
 								} else if (block.type === "toolCall") {
-									block.arguments = parseStreamingJson(block.partialJson);
+									if (block.partialJson.trim()) {
+										block.arguments = parseStreamingJson(block.partialJson);
+									}
 									delete (block as { partialJson?: string }).partialJson;
 									stream.push({
 										type: "toolcall_end",
@@ -1525,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;
@@ -1587,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 &&
@@ -1594,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 (
@@ -1634,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 (
@@ -1654,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 (
@@ -1678,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 =
@@ -1705,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();
 				}
 			}
 
@@ -1730,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;
@@ -2243,7 +2268,11 @@ function buildParams(
 		params.tools = convertTools(
 			context.tools,
 			isOAuthToken,
-			disableStrictTools || model.provider === "github-copilot",
+			// The Claude Code OAuth surface mishandles `strict: true` tools:
+			// streamed tool_use blocks arrive with empty/undefined arguments and
+			// occasionally corrupted names (works with PI_NO_STRICT=1). Never
+			// request strict tool use on OAuth requests.
+			disableStrictTools || isOAuthToken || model.provider === "github-copilot",
 			getAnthropicCompat(model).supportsEagerToolInputStreaming,
 		);
 	}

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 "@sayknow-cli/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 "@sayknow-cli/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> {