@gajae-code/ai 0.18.1 → 0.18.6

package/src/models.json

@@ -964,6 +964,31 @@
 				"maxLevel": "high"
 			}
 		},
+		"anthropic.claude-sonnet-5-5": {
+			"id": "anthropic.claude-sonnet-5-5",
+			"name": "Anthropic Sonnet 5.5",
+			"api": "bedrock-converse-stream",
+			"provider": "amazon-bedrock",
+			"baseUrl": "https://bedrock-runtime.us-east-1.amazonaws.com",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 2,
+				"output": 10,
+				"cacheRead": 0.2,
+				"cacheWrite": 2.5
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 128000,
+			"thinking": {
+				"mode": "anthropic-budget-effort",
+				"minLevel": "minimal",
+				"maxLevel": "high"
+			}
+		},
 		"apac.amazon.nova-lite-v1:0": {
 			"id": "apac.amazon.nova-lite-v1:0",
 			"name": "Nova Lite (APAC)",
@@ -1308,6 +1333,31 @@
 				"maxLevel": "high"
 			}
 		},
+		"au.anthropic.claude-sonnet-5-5": {
+			"id": "au.anthropic.claude-sonnet-5-5",
+			"name": "Anthropic Sonnet 5.5 (AU)",
+			"api": "bedrock-converse-stream",
+			"provider": "amazon-bedrock",
+			"baseUrl": "https://bedrock-runtime.us-east-1.amazonaws.com",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 2.2,
+				"output": 11,
+				"cacheRead": 0.22,
+				"cacheWrite": 2.75
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 128000,
+			"thinking": {
+				"mode": "anthropic-budget-effort",
+				"minLevel": "minimal",
+				"maxLevel": "high"
+			}
+		},
 		"ca.amazon.nova-lite-v1:0": {
 			"id": "ca.amazon.nova-lite-v1:0",
 			"name": "Nova Lite (CA)",
@@ -2072,6 +2122,31 @@
 				"maxLevel": "high"
 			}
 		},
+		"eu.anthropic.claude-sonnet-5-5": {
+			"id": "eu.anthropic.claude-sonnet-5-5",
+			"name": "Anthropic Sonnet 5.5 (EU)",
+			"api": "bedrock-converse-stream",
+			"provider": "amazon-bedrock",
+			"baseUrl": "https://bedrock-runtime.us-east-1.amazonaws.com",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 2.2,
+				"output": 11,
+				"cacheRead": 0.22,
+				"cacheWrite": 2.75
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 128000,
+			"thinking": {
+				"mode": "anthropic-budget-effort",
+				"minLevel": "minimal",
+				"maxLevel": "high"
+			}
+		},
 		"eu.mistral.pixtral-large-2502-v1:0": {
 			"id": "eu.mistral.pixtral-large-2502-v1:0",
 			"name": "Pixtral Large (25.02) (EU)",
@@ -2477,6 +2552,31 @@
 				"maxLevel": "high"
 			}
 		},
+		"global.anthropic.claude-sonnet-5-5": {
+			"id": "global.anthropic.claude-sonnet-5-5",
+			"name": "Anthropic Sonnet 5.5 (Global)",
+			"api": "bedrock-converse-stream",
+			"provider": "amazon-bedrock",
+			"baseUrl": "https://bedrock-runtime.us-east-1.amazonaws.com",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 2,
+				"output": 10,
+				"cacheRead": 0.2,
+				"cacheWrite": 2.5
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 128000,
+			"thinking": {
+				"mode": "anthropic-budget-effort",
+				"minLevel": "minimal",
+				"maxLevel": "high"
+			}
+		},
 		"global.openai.gpt-5.6-luna": {
 			"id": "global.openai.gpt-5.6-luna",
 			"name": "GPT-5.6 Luna (Global)",
@@ -3020,6 +3120,31 @@
 				"maxLevel": "high"
 			}
 		},
+		"jp.anthropic.claude-sonnet-5-5": {
+			"id": "jp.anthropic.claude-sonnet-5-5",
+			"name": "Anthropic Sonnet 5.5 (JP)",
+			"api": "bedrock-converse-stream",
+			"provider": "amazon-bedrock",
+			"baseUrl": "https://bedrock-runtime.us-east-1.amazonaws.com",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 2.2,
+				"output": 11,
+				"cacheRead": 0.22,
+				"cacheWrite": 2.75
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 128000,
+			"thinking": {
+				"mode": "anthropic-budget-effort",
+				"minLevel": "minimal",
+				"maxLevel": "high"
+			}
+		},
 		"meta.llama3-1-405b-instruct-v1:0": {
 			"id": "meta.llama3-1-405b-instruct-v1:0",
 			"name": "Llama 3.1 405B Instruct",
@@ -4501,6 +4626,31 @@
 				"maxLevel": "high"
 			}
 		},
+		"us.anthropic.claude-sonnet-5-5": {
+			"id": "us.anthropic.claude-sonnet-5-5",
+			"name": "Anthropic Sonnet 5.5 (US)",
+			"api": "bedrock-converse-stream",
+			"provider": "amazon-bedrock",
+			"baseUrl": "https://bedrock-runtime.us-east-1.amazonaws.com",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 2.2,
+				"output": 11,
+				"cacheRead": 0.22,
+				"cacheWrite": 2.75
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 128000,
+			"thinking": {
+				"mode": "anthropic-budget-effort",
+				"minLevel": "minimal",
+				"maxLevel": "high"
+			}
+		},
 		"us.deepseek.r1-v1:0": {
 			"id": "us.deepseek.r1-v1:0",
 			"name": "DeepSeek-R1 (US)",
@@ -5656,6 +5806,31 @@
 				"minLevel": "minimal",
 				"maxLevel": "max"
 			}
+		},
+		"claude-sonnet-5-5": {
+			"id": "claude-sonnet-5-5",
+			"name": "Anthropic Sonnet 5.5",
+			"api": "anthropic-messages",
+			"provider": "anthropic",
+			"baseUrl": "https://api.anthropic.com",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 2,
+				"output": 10,
+				"cacheRead": 0.2,
+				"cacheWrite": 2.5
+			},
+			"contextWindow": 1000000,
+			"maxTokens": 128000,
+			"thinking": {
+				"mode": "anthropic-adaptive",
+				"minLevel": "minimal",
+				"maxLevel": "max"
+			}
 		}
 	},
 	"azure-openai": {
@@ -68026,6 +68201,41 @@
 				}
 			}
 		},
+		"gpt-6.1-sol": {
+			"id": "gpt-6.1-sol",
+			"name": "GPT-6.1-Sol",
+			"api": "openai-codex-responses",
+			"provider": "openai-codex",
+			"baseUrl": "https://chatgpt.com/backend-api",
+			"reasoning": true,
+			"input": [
+				"text",
+				"image"
+			],
+			"cost": {
+				"input": 2,
+				"output": 10,
+				"cacheRead": 0.1,
+				"cacheWrite": 2.5
+			},
+			"contextWindow": 272000,
+			"maxTokens": 128000,
+			"preferWebsockets": true,
+			"thinking": {
+				"mode": "effort",
+				"minLevel": "low",
+				"maxLevel": "max"
+			},
+			"longContextPricing": {
+				"threshold": 272000,
+				"cost": {
+					"input": 4,
+					"output": 15,
+					"cacheRead": 0.2,
+					"cacheWrite": 5
+				}
+			}
+		},
 		"gpt-daybreak-blue-latest": {
 			"id": "gpt-daybreak-blue-latest",
 			"name": "Daybreak Blue",

package/src/providers/anthropic.ts

@@ -1764,6 +1764,23 @@ function isTransientStreamEnvelopeError(error: unknown): boolean {
 	);
 }
 
+/**
+ * A request whose connection failed before the server returned any response:
+ * the SDK's connection error, or a reset/closed/refused socket with no HTTP status.
+ */
+function isPreResponseConnectionFailure(error: unknown): boolean {
+	if (!(error instanceof Error)) return false;
+	if (extractHttpStatusFromError(error) !== undefined) return false;
+	if (error instanceof Anthropic.APIConnectionTimeoutError) return false;
+	if (error instanceof Anthropic.APIConnectionError) return true;
+	const code = (error as { code?: unknown }).code;
+	if (typeof code === "string" && /^(?:ECONNRESET|ECONNREFUSED|EPIPE|ENOTFOUND|EAI_AGAIN)$/.test(code)) return true;
+	return (
+		isUnexpectedSocketCloseMessage(error.message) ||
+		/\b(?:ECONNRESET|ECONNREFUSED|EPIPE)\b|^connection error\.?$|other side closed/i.test(error.message)
+	);
+}
+
 function isProviderRetryableStreamEnvelopeError(error: unknown): boolean {
 	if (!(error instanceof Error)) return false;
 	return /stream event order|before message_start/i.test(error.message);
@@ -2672,7 +2689,14 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					// Otherwise the multi-megabyte body is re-uploaded up to the default
 					// streamMaxRetries budget despite the ceiling. Once iteration has
 					// begun, only the grace-clock path above decides.
-					if (requestUploadCeilingBound && firstEventWaitStartedAt === undefined) {
+					// A connection that dropped before any response (reset, socket closed,
+					// connect failure) is exempt: the server never answered, so a retry is
+					// not a re-upload after a stall, and a network blip must not end the turn.
+					if (
+						requestUploadCeilingBound &&
+						firstEventWaitStartedAt === undefined &&
+						!isPreResponseConnectionFailure(streamFailure)
+					) {
 						Object.assign(streamFailure as Error, {
 							requestBytes,
 							endpointClass,

package/src/providers/aws-eventstream.ts

@@ -178,7 +178,8 @@ export async function* decodeEventStream(source: ReadableStream<Uint8Array>): As
 			if (offset > 0) buf = buf.slice(offset);
 			if (done) break;
 		}
-		if (buf.length > 0) throw new Error("eventstream: truncated message at end of stream");
+		if (buf.length > 0)
+			throw new Error(`eventstream: truncated message at end of stream (${buf.length} trailing bytes)`);
 	} finally {
 		reader.releaseLock();
 	}

package/src/providers/cursor.d.ts

@@ -2,8 +2,10 @@ import http2 from "node:http2";
 import { type JsonValue } from "@bufbuild/protobuf";
 import type { AssistantMessage, CursorExecHandlerResult, CursorExecHandlers, CursorToolResultHandler, Message, Model, StreamFunction, StreamOptions, Tool, ToolCall, ToolResultMessage, Usage } from "../types";
 import { kProviderResolvedToolCall } from "../utils/block-symbols";
+import { AssistantMessageEventStream } from "../utils/event-stream";
 import { CURSOR_CLIENT_VERSION } from "./cursor/client-version";
 import type { CursorRule, RequestedModel_ModelParameterbytes } from "./cursor/gen/agent_pb";
+import { type AgentServerMessage } from "./cursor/gen/agent_pb";
 export declare const CURSOR_API_URL = "https://api2.cursor.sh";
 export { CURSOR_CLIENT_VERSION };
 /** Drop all cached state + blob bytes for a conversation (F15 bound + session-teardown hook). */
@@ -46,9 +48,8 @@ export declare function mapH2TransportError(error: unknown, baseUrl: string): un
 export declare const streamCursor: StreamFunction<"cursor-agent">;
 type ToolCallState = ToolCall & {
     index: number;
-    partialJson?: string;
-    kind: "mcp" | "todo_write" | "native" | "cursor-exec";
-    [kProviderResolvedToolCall]?: true;
+    kind: "todo_write" | "native" | "cursor-exec";
+    [kProviderResolvedToolCall]: true;
 };
 interface UsageState {
     sawTokenDelta: boolean;
@@ -56,6 +57,8 @@ interface UsageState {
     checkpointOutputTokens: number;
     hasConversationCheckpoint: boolean;
 }
+/** Offline test seam for the same server-message boundary used by streamCursor. */
+export declare function createCursorServerMessageHandlerForTest(output: AssistantMessage, stream: AssistantMessageEventStream, write: (frame: Uint8Array, done: () => void) => boolean, options?: CursorOptions): (message: AgentServerMessage) => Promise<void>;
 export declare function storeCursorBlobForTest(blobStore: Map<string, Uint8Array>, blobId: Uint8Array, blobData: Uint8Array, limits: {
     maxBytes: number;
 }): boolean;

package/src/providers/cursor.ts

@@ -32,7 +32,6 @@ import { kProviderResolvedToolCall } from "../utils/block-symbols";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { transportFailureFacts } from "../utils/fallback-transport";
 import { FirstEventTimeoutError, getStreamFirstEventTimeoutMs, getStreamIdleTimeoutMs } from "../utils/idle-iterator";
-import { captureUnicodeEscapeEvidence, parseStreamingJson } from "../utils/json-parse";
 import { connectProxiedSocket, getProxyForUrl } from "../utils/proxy";
 import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";
 import { flattenToolRootCombinators, toolWireSchema } from "../utils/schema";
@@ -2288,10 +2287,8 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 			}
 			if (state.currentToolCall) {
 				const idx = output.content.indexOf(state.currentToolCall);
-				state.currentToolCall.arguments = parseStreamingJson(state.currentToolCall.partialJson);
-				captureUnicodeEscapeEvidence(state.currentToolCall, state.currentToolCall.partialJson ?? "");
-				delete (state.currentToolCall as any).partialJson;
-				delete (state.currentToolCall as any).index;
+				delete (state.currentToolCall as Partial<ToolCallState>).index;
+				delete (state.currentToolCall as Partial<ToolCallState>).kind;
 				stream.push({
 					type: "toolcall_end",
 					contentIndex: idx,
@@ -2428,9 +2425,8 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 
 type ToolCallState = ToolCall & {
 	index: number;
-	partialJson?: string;
-	kind: "mcp" | "todo_write" | "native" | "cursor-exec";
-	[kProviderResolvedToolCall]?: true;
+	kind: "todo_write" | "native" | "cursor-exec";
+	[kProviderResolvedToolCall]: true;
 };
 
 interface BlockState {
@@ -2493,6 +2489,57 @@ async function handleServerMessage(
 	}
 }
 
+/** Offline test seam for the same server-message boundary used by streamCursor. */
+export function createCursorServerMessageHandlerForTest(
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+	write: (frame: Uint8Array, done: () => void) => boolean,
+	options: CursorOptions = {},
+): (message: AgentServerMessage) => Promise<void> {
+	const state: BlockState = {
+		currentTextBlock: null,
+		currentThinkingBlock: null,
+		currentToolCall: null,
+		firstTokenTime: undefined,
+		setTextBlock(block) {
+			this.currentTextBlock = block;
+		},
+		setThinkingBlock(block) {
+			this.currentThinkingBlock = block;
+		},
+		setToolCall(block) {
+			this.currentToolCall = block;
+		},
+		setFirstTokenTime() {
+			this.firstTokenTime ??= Date.now();
+		},
+	};
+	const usageState: UsageState = {
+		sawTokenDelta: false,
+		conversationUsedTokens: 0,
+		checkpointOutputTokens: 0,
+		hasConversationCheckpoint: false,
+	};
+	const writer = { write, isActive: () => true } as unknown as CursorRequestWriter;
+	const blobs = new Map<string, Uint8Array>();
+	return message =>
+		handleServerMessage(
+			message,
+			output,
+			stream,
+			state,
+			blobs,
+			writer,
+			options.execHandlers,
+			options.onToolResult,
+			usageState,
+			[],
+			undefined,
+			[],
+			options.signal,
+		);
+}
+
 function handleKvServerMessage(
 	kvMsg: KvServerMessage,
 	blobStore: Map<string, Uint8Array>,
@@ -3164,6 +3211,7 @@ async function handleExecServerMessage(
 		case "mcpArgs": {
 			const args = execMsg.message.value;
 			const mcpCall = decodeMcpCall(args);
+			synthesizeCursorExecToolCall(output, stream, mcpCall.toolCallId, mcpCall.toolName, mcpCall.args);
 			const { execResult } = await resolveExecHandler(
 				mcpCall,
 				execHandlers?.mcp?.bind(execHandlers),
@@ -4063,17 +4111,6 @@ function decodeMcpArgValue(value: Uint8Array): unknown {
 	return parseToolArgsJson(text);
 }
 
-function decodeMcpArgsMap(args?: Record<string, Uint8Array>): Record<string, unknown> | undefined {
-	if (!args) {
-		return undefined;
-	}
-	const decoded: Record<string, unknown> = {};
-	for (const [key, value] of Object.entries(args)) {
-		decoded[key] = decodeMcpArgValue(value);
-	}
-	return decoded;
-}
-
 function decodeMcpCall(args: {
 	name: string;
 	args: Record<string, Uint8Array>;
@@ -4089,7 +4126,7 @@ function decodeMcpCall(args: {
 		name: args.name,
 		providerIdentifier: args.providerIdentifier,
 		toolName: args.toolName || args.name,
-		toolCallId: args.toolCallId,
+		toolCallId: args.toolCallId || crypto.randomUUID(),
 		args: decodedArgs,
 		rawArgs: args.args ?? {},
 	};
@@ -4336,7 +4373,7 @@ const CURSOR_EXEC_OWNED_TOOL_CASES = new Set([
 ]);
 
 function isExecOwnedToolCall(toolCall: any): boolean {
-	return CURSOR_EXEC_OWNED_TOOL_CASES.has(toolCall?.tool?.case);
+	return !!selectMcpToolCall(toolCall) || CURSOR_EXEC_OWNED_TOOL_CASES.has(toolCall?.tool?.case);
 }
 
 export function buildNativeToolCallBlock(
@@ -4358,6 +4395,7 @@ export function buildNativeToolCallBlock(
 					: { raw: convertedArgs },
 			index,
 			kind: "native",
+			[kProviderResolvedToolCall]: true,
 		};
 	}
 	for (const [key, payload] of Object.entries(toolCall)) {
@@ -4380,6 +4418,7 @@ export function buildNativeToolCallBlock(
 			arguments: safeArguments,
 			index,
 			kind: "native",
+			[kProviderResolvedToolCall]: true,
 		};
 	}
 	return null;
@@ -4445,6 +4484,7 @@ function synthesizeCursorExecToolCall(
 	name: string,
 	args: Record<string, unknown>,
 ): void {
+	if (output.content.some(block => block.type === "toolCall" && block.id === toolCallId)) return;
 	const block: ToolCallState = {
 		type: "toolCall",
 		id: toolCallId,
@@ -4518,33 +4558,19 @@ function processInteractionUpdate(
 			state.setThinkingBlock(null);
 		}
 	} else if (updateCase === "toolCallStarted" && isExecOwnedToolCall(update.message.value.toolCall)) {
-		// Pi stream call IDs and exec IDs are distinct namespaces; without a shared
-		// correlation field, suppress the streamed variant and synthesize from exec.
+		// Exec owns MCP and Pi tools. Suppress interaction announcements and
+		// synthesize canonical, provider-resolved blocks before executing them.
 		log("exec", "streamedToolCallOwnedByExec", { case: update.message.value.toolCall?.tool?.case });
 	} else if (updateCase === "toolCallStarted") {
 		const toolCall = update.message.value.toolCall;
 		if (toolCall) {
-			const mcpCall = selectMcpToolCall(toolCall);
-			if (mcpCall) {
-				const args = mcpCall.args || {};
-				const block: ToolCallState = {
-					type: "toolCall",
-					id: args.toolCallId || crypto.randomUUID(),
-					name: args.name || args.toolName || "",
-					arguments: {},
-					index: output.content.length,
-					partialJson: "",
-					kind: "mcp",
-				};
-				output.content.push(block);
-				state.setToolCall(block);
-				stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
-				return;
-			}
+			const callId = update.message.value.callId || crypto.randomUUID();
+			// Repeated announcements describe the same provider-owned execution.
+			if (output.content.some(block => block.type === "toolCall" && block.id === callId)) return;
 
 			const todoArgs = buildTodoWriteArgs(toolCall);
 			if (todoArgs) {
-				const callId = update.message.value.callId || crypto.randomUUID();
+				// Cursor owns its todo state; this snapshot is for display, not local { ops } dispatch.
 				const block: ToolCallState = {
 					type: "toolCall",
 					id: callId,
@@ -4552,6 +4578,7 @@ function processInteractionUpdate(
 					arguments: todoArgs,
 					index: output.content.length,
 					kind: "todo_write",
+					[kProviderResolvedToolCall]: true,
 				};
 				output.content.push(block);
 				state.setToolCall(block);
@@ -4562,44 +4589,26 @@ function processInteractionUpdate(
 			// Fallback: cursor-native tool variants (shell/glob/grep/…) we don't model
 			// explicitly. Render them so the call and its result are visible instead of
 			// vanishing.
-			const nativeBlock = buildNativeToolCallBlock(
-				toolCall,
-				update.message.value.callId || crypto.randomUUID(),
-				output.content.length,
-			);
+			const nativeBlock = buildNativeToolCallBlock(toolCall, callId, output.content.length);
 			if (nativeBlock) {
 				output.content.push(nativeBlock);
 				state.setToolCall(nativeBlock);
 				stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
 			}
 		}
-	} else if (updateCase === "toolCallDelta" || updateCase === "partialToolCall") {
-		if (state.currentToolCall?.kind === "mcp") {
-			const delta = update.message.value.argsTextDelta || "";
-			state.currentToolCall.partialJson = `${state.currentToolCall.partialJson ?? ""}${delta}`;
-			state.currentToolCall.arguments = parseStreamingJson(state.currentToolCall.partialJson ?? "");
-			const idx = output.content.indexOf(state.currentToolCall);
-			stream.push({ type: "toolcall_delta", contentIndex: idx, delta, partial: output });
-		}
 	} else if (updateCase === "toolCallCompleted") {
+		if (isExecOwnedToolCall(update.message.value.toolCall)) return;
 		if (state.currentToolCall) {
 			const toolCall = update.message.value.toolCall;
-			if (state.currentToolCall.kind === "mcp") {
-				captureUnicodeEscapeEvidence(state.currentToolCall, state.currentToolCall.partialJson ?? "");
-				const decodedArgs = decodeMcpArgsMap(selectMcpToolCall(toolCall)?.args?.args);
-				if (decodedArgs) {
-					state.currentToolCall.arguments = decodedArgs;
-				}
-			} else if (state.currentToolCall.kind === "todo_write" && toolCall) {
+			if (state.currentToolCall.kind === "todo_write" && toolCall) {
 				const todoArgs = buildTodoWriteArgs(toolCall);
 				if (todoArgs) {
 					state.currentToolCall.arguments = todoArgs;
 				}
 			}
 			const idx = output.content.indexOf(state.currentToolCall);
-			delete (state.currentToolCall as any).partialJson;
-			delete (state.currentToolCall as any).index;
-			delete (state.currentToolCall as any).kind;
+			delete (state.currentToolCall as Partial<ToolCallState>).index;
+			delete (state.currentToolCall as Partial<ToolCallState>).kind;
 			stream.push({ type: "toolcall_end", contentIndex: idx, toolCall: state.currentToolCall, partial: output });
 			state.setToolCall(null);
 		}

package/src/providers/kiro-api-key.d.ts

@@ -5,6 +5,7 @@ export declare function kiroApiRegion(options?: {
 }): string;
 export declare function kiroApiBaseUrl(region: string): string;
 export declare function toKiroModelId(modelId: string): string;
+export declare function sanitizeKiroError(value: unknown, secret?: string): string;
 export declare function kiroApiStaticModels(): Model<"kiro-codewhisperer-stream">[];
 /** Discover models this API key can use. Returns null when the key is missing. */
 export declare function fetchKiroApiModels(apiKey: string, region?: string): Promise<Model<"kiro-codewhisperer-stream">[]>;

package/src/providers/kiro-api-key.ts

@@ -118,7 +118,7 @@ function kiroApiHeaders(apiKey: string, target: string): Record<string, string>
 	};
 }
 
-function sanitizeKiroError(value: unknown, secret?: string): string {
+export function sanitizeKiroError(value: unknown, secret?: string): string {
 	let message = value instanceof Error ? value.message : String(value);
 	if (secret) message = message.split(secret).join("[redacted]");
 	message = message.replace(/bearer\s+[^\s,;]+/gi, "Bearer [redacted]");