@gajae-code/ai 0.13.1 → 0.13.3

package/src/providers/openai-completions.ts

@@ -54,7 +54,7 @@ import {
 	iterateWithIdleTimeout,
 	resolveOpenAISdkRequestTimeoutMs,
 } from "../utils/idle-iterator";
-import { isCompleteJson, parseStreamingJson } from "../utils/json-parse";
+import { findUnnecessaryUnicodeEscape, isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { getKimiCommonHeaders } from "../utils/oauth/kimi";
 import { notifyProviderResponse } from "../utils/provider-response";
@@ -676,6 +676,8 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 					return;
 				}
 				block.arguments = parseStreamingJson(block.partialArgs);
+				// Raw-wire check: after decode the escape is invisible.
+				if (findUnnecessaryUnicodeEscape(block.partialArgs)) block.escapedNonAsciiArguments = true;
 				delete (block as { partialArgs?: string }).partialArgs;
 				stream.push({ type: "toolcall_end", contentIndex, toolCall: block, partial: output });
 			};
@@ -804,6 +806,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 					partialArgs: call.arguments,
 				};
 				block.arguments = parseStreamingJson(call.arguments);
+				if (findUnnecessaryUnicodeEscape(call.arguments)) block.escapedNonAsciiArguments = true;
 				currentBlock = block;
 				output.content.push(block);
 				stream.push({ type: "toolcall_start", contentIndex: blockIndex(block), partial: output });

package/src/providers/openai-responses-shared.ts

@@ -30,7 +30,7 @@ import {
 } from "../types";
 import { normalizeResponsesToolCallId, sanitizeJsonStrings } from "../utils";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
-import { isCompleteJson, parseStreamingJson } from "../utils/json-parse";
+import { findUnnecessaryUnicodeEscape, isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { joinTextWithImagePlaceholder, NON_VISION_IMAGE_PLACEHOLDER, partitionVisionContent } from "./vision-guard";
 
 const OPENAI_RESPONSES_PROGRESS_EVENT_TYPES = new Set([
@@ -735,20 +735,28 @@ export async function processResponsesStream<TApi extends Api>(
 				// Finalize onto the same block object stored in output.content, reading
 				// the matching entry's buffered partialJson first and only then the done
 				// item's arguments — never an adjacent item's buffer.
-				const args =
+				const rawArguments =
 					entry?.block.type === "toolCall" && entry.block.partialJson
-						? parseStreamingJson(entry.block.partialJson)
-						: parseStreamingJson(item.arguments || "{}");
+						? entry.block.partialJson
+						: item.arguments || "{}";
+				const args = parseStreamingJson(rawArguments);
+				// Detected on the raw wire text: after JSON decode an unnecessary
+				// `\uXXXX` escape is indistinguishable from legitimate literal UTF-8,
+				// so this is the only point where the defect is still observable.
+				const escapedNonAscii = findUnnecessaryUnicodeEscape(rawArguments) !== undefined;
 				const toolCall: ToolCall = {
 					type: "toolCall",
 					id: encodeResponsesToolCallId(item.call_id, item.id),
 					name: item.name,
 					arguments: args,
+					...(escapedNonAscii ? { escapedNonAsciiArguments: true } : {}),
 				};
 				if (entry?.block.type === "toolCall") {
 					entry.block.id = toolCall.id;
 					entry.block.name = toolCall.name;
 					entry.block.arguments = args;
+					if (escapedNonAscii) entry.block.escapedNonAsciiArguments = true;
+					else delete entry.block.escapedNonAsciiArguments;
 				}
 				const contentIndex = entry?.blockContentIndex ?? output.content.length - 1;
 				dropEntry(item.id, event.output_index);

package/src/providers/register-builtins.ts

@@ -37,6 +37,7 @@ import type { CursorOptions } from "./cursor";
 import type { GoogleOptions } from "./google";
 import type { GoogleGeminiCliOptions } from "./google-gemini-cli";
 import type { GoogleVertexOptions } from "./google-vertex";
+import type { KiroCodeWhispererOptions } from "./kiro-codewhisperer";
 import type { OllamaChatOptions } from "./ollama";
 import type { OpenAICodexResponsesOptions } from "./openai-codex-responses";
 import type { OpenAICompletionsOptions } from "./openai-completions";
@@ -153,6 +154,14 @@ interface BedrockProviderModule {
 	) => AssistantMessageEventStream;
 }
 
+interface KiroCodeWhispererProviderModule {
+	streamKiroCodeWhisperer: (
+		model: Model<"kiro-codewhisperer-stream">,
+		context: Context,
+		options: KiroCodeWhispererOptions,
+	) => AssistantMessageEventStream;
+}
+
 // ---------------------------------------------------------------------------
 // Module-level lazy promise caches
 // ---------------------------------------------------------------------------
@@ -168,6 +177,7 @@ let openAIResponsesProviderModulePromise: Promise<LazyProviderModule<"openai-res
 let ollamaProviderModulePromise: Promise<LazyProviderModule<"ollama-chat">> | undefined;
 let cursorProviderModulePromise: Promise<LazyProviderModule<"cursor-agent">> | undefined;
 let bedrockProviderModuleOverride: LazyProviderModule<"bedrock-converse-stream"> | undefined;
+let kiroCodeWhispererProviderModulePromise: Promise<LazyProviderModule<"kiro-codewhisperer-stream">> | undefined;
 let bedrockProviderModulePromise: Promise<LazyProviderModule<"bedrock-converse-stream">> | undefined;
 
 export function setBedrockProviderModule(module: BedrockProviderModule): void {
@@ -443,6 +453,13 @@ function loadBedrockProviderModule(): Promise<LazyProviderModule<"bedrock-conver
 	});
 	return bedrockProviderModulePromise;
 }
+function loadKiroCodeWhispererProviderModule(): Promise<LazyProviderModule<"kiro-codewhisperer-stream">> {
+	kiroCodeWhispererProviderModulePromise ||= Promise.resolve().then(() => {
+		const provider = require("./kiro-codewhisperer") as KiroCodeWhispererProviderModule;
+		return { stream: provider.streamKiroCodeWhisperer };
+	});
+	return kiroCodeWhispererProviderModulePromise;
+}
 
 /**
  * Lazy provider descriptors used by core consumers that need to inspect or
@@ -459,6 +476,7 @@ export const PROVIDER_RUNTIME_DESCRIPTORS: readonly ProviderRuntimeDescriptor<Ap
 	{ api: "openai-responses", load: loadOpenAIResponsesProviderModule },
 	{ api: "ollama-chat", load: loadOllamaProviderModule },
 	{ api: "cursor-agent", load: loadCursorProviderModule },
+	{ api: "kiro-codewhisperer-stream", load: loadKiroCodeWhispererProviderModule },
 	{ api: "bedrock-converse-stream", load: loadBedrockProviderModule },
 ] as readonly ErasedProviderRuntimeDescriptor[];
 
@@ -507,3 +525,4 @@ export const streamCursor = createLazyStream(loadCursorProviderModule);
 export const streamOllama = createLazyStream(loadOllamaProviderModule);
 
 export const streamBedrock = createLazyStream(loadBedrockProviderModule);
+export const streamKiroCodeWhisperer = createLazyStream(loadKiroCodeWhispererProviderModule);

package/src/providers/transform-messages.ts

@@ -98,8 +98,15 @@ export function transformMessages<TApi extends Api>(
 					if (dropAssistantThinkingForRepair && replaysAsNativeThinking) return [];
 					if (mustPreserveLatestAnthropicThinking) return sanitized;
 					// For same model: keep thinking blocks with signatures (needed for replay)
-					// even if the thinking text is empty (OpenAI encrypted reasoning)
-					if (isSameModel && sanitized.thinkingSignature) return sanitized;
+					// even if the thinking text is empty — but only for non-Anthropic APIs where
+					// the signature represents OpenAI encrypted reasoning. For anthropic-messages,
+					// a signed block with empty text means clear_thinking_20251015 stripped the
+					// content server-side while the stale signature remained; replaying it
+					// produces `thinking ... cannot be modified` 400s on every turn (#4247).
+					if (isSameModel && sanitized.thinkingSignature) {
+						if (sanitized.thinking.trim() === "" && model.api === "anthropic-messages") return [];
+						return sanitized;
+					}
 					// Skip empty thinking blocks, convert others to plain text
 					if (!sanitized.thinking || sanitized.thinking.trim() === "") return [];
 					if (isSameModel) return sanitized;

package/src/stream.ts

@@ -32,6 +32,7 @@ import type { CursorOptions } from "./providers/cursor";
 import type { GoogleOptions } from "./providers/google";
 import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
 import type { GoogleVertexOptions } from "./providers/google-vertex";
+import type { KiroCodeWhispererOptions } from "./providers/kiro-codewhisperer";
 import type { OllamaChatOptions } from "./providers/ollama";
 import type { OpenAICompletionsOptions } from "./providers/openai-completions";
 // Heavy provider stream functions are imported lazily via register-builtins,
@@ -46,6 +47,7 @@ import {
 	streamGoogle,
 	streamGoogleGeminiCli,
 	streamGoogleVertex,
+	streamKiroCodeWhisperer,
 	streamOllama,
 	streamOpenAICodexResponses,
 	streamOpenAICompletions,
@@ -119,6 +121,11 @@ const serviceProviderMap: Record<string, KeyResolver> = {
 	tavily: "TAVILY_API_KEY",
 	parallel: "PARALLEL_API_KEY",
 	kagi: "KAGI_API_KEY",
+	// Kiro uses AWS SSO OIDC OAuth flow; bearer token is stored as the OAuth access token.
+	kiro: () => {
+		const bearerToken = $credentialEnv("AWS_BEARER_TOKEN_KIRO");
+		if (bearerToken) return bearerToken;
+	},
 	// GitHub Copilot uses GitHub personal access token
 	"github-copilot": () => $pickCredentialEnv("COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"),
 	// Foundry mode optionally switches Anthropic auth to enterprise gateway credentials.
@@ -330,6 +337,12 @@ export function stream<TApi extends Api>(
 	} else if (model.api === "bedrock-converse-stream") {
 		// Bedrock doesn't have any API keys instead it sources credentials from standard AWS env variables or from given AWS profile.
 		return streamBedrock(model as Model<"bedrock-converse-stream">, context, (options || {}) as BedrockOptions);
+	} else if (model.api === "kiro-codewhisperer-stream") {
+		return streamKiroCodeWhisperer(
+			model as Model<"kiro-codewhisperer-stream">,
+			context,
+			(options || {}) as KiroCodeWhispererOptions,
+		);
 	}
 
 	const apiKey = options?.apiKey || (model.provider === "opencodex" ? "local" : getEnvApiKey(model.provider));

package/src/types.ts

@@ -23,6 +23,7 @@ import type {
 import type { GoogleOptions } from "./providers/google";
 import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
 import type { GoogleVertexOptions } from "./providers/google-vertex";
+import type { KiroCodeWhispererOptions } from "./providers/kiro-codewhisperer";
 import type { OllamaChatOptions } from "./providers/ollama";
 import type { OpenAICodexResponsesOptions } from "./providers/openai-codex-responses";
 import type { OpenAICompletionsOptions } from "./providers/openai-completions";
@@ -43,7 +44,8 @@ export type KnownApi =
 	| "google-gemini-cli"
 	| "google-vertex"
 	| "ollama-chat"
-	| "cursor-agent";
+	| "cursor-agent"
+	| "kiro-codewhisperer-stream";
 export type Api = KnownApi | (string & {});
 export interface ApiOptionsMap {
 	"anthropic-messages": AnthropicOptions;
@@ -57,6 +59,7 @@ export interface ApiOptionsMap {
 	"google-vertex": GoogleVertexOptions;
 	"ollama-chat": OllamaChatOptions;
 	"cursor-agent": CursorOptions;
+	"kiro-codewhisperer-stream": KiroCodeWhispererOptions;
 }
 // Compile-time exhaustiveness check - this will fail if ApiOptionsMap doesn't have all KnownApi keys
 type _CheckExhaustive =
@@ -116,6 +119,7 @@ export interface ThinkingConfig {
 export const KNOWN_PROVIDERS = [
 	"alibaba-token-plan",
 	"amazon-bedrock",
+	"kiro",
 	"azure-openai",
 	"anthropic",
 	"google",
@@ -584,6 +588,16 @@ export interface ToolCall {
 	 * rejects the call with a retryable error instead.
 	 */
 	incompleteArguments?: boolean;
+	/**
+	 * Set when the provider saw the argument JSON spell a printable non-ASCII
+	 * character as a `\uXXXX` escape instead of literal UTF-8. Hand-written hex
+	 * is where models mistype digits, and a mistyped nibble decodes to a
+	 * different but equally valid character, so the decoded arguments cannot be
+	 * verified or repaired after parsing. The agent loop treats such a turn as a
+	 * sampling accident: managed runs discard and re-request it, and execution
+	 * rejects the call rather than running on silently corrupted text.
+	 */
+	escapedNonAsciiArguments?: boolean;
 }
 
 export interface Usage {

package/src/utils/json-parse.ts

@@ -110,6 +110,86 @@ export function repairJson(json: string): string {
 	return parts.join("");
 }
 
+/**
+ * First unnecessary `\uXXXX` escape in a JSON document, or `undefined` when the
+ * document contains none.
+ *
+ * "Unnecessary" means the escape encodes a character JSON can carry literally:
+ * any non-ASCII printable character. Control characters (< U+0020) MUST be
+ * escaped, and an unpaired surrogate CANNOT be written literally, so neither
+ * counts. A `\\uXXXX` sequence is a literal backslash followed by `u` — the
+ * intended source syntax when the model is writing code or a nested JSON
+ * document — and is skipped, which is why this scans the raw text with the same
+ * string/escape state machine as {@link repairJson} instead of using a regex.
+ *
+ * Models that spell non-ASCII text as hand-written hex instead of literal UTF-8
+ * mistype the digits, and every mistyped nibble silently decodes to a different
+ * but perfectly valid character (`\uc7a5` vs `\uc7a4`). The resulting arguments
+ * parse cleanly and cannot be repaired after the fact, so the escape itself is
+ * the only observable evidence that the payload is untrustworthy.
+ */
+export function findUnnecessaryUnicodeEscape(json: string): string | undefined {
+	const len = json.length;
+	let inString = false;
+	let i = 0;
+
+	const hexAt = (start: number): number | undefined => {
+		if (start + 3 >= len) return undefined;
+		for (let k = start; k <= start + 3; k++) if (!isHexDigit(json.charCodeAt(k))) return undefined;
+		return Number.parseInt(json.slice(start, start + 4), 16);
+	};
+
+	while (i < len) {
+		if (!inString) {
+			const open = json.indexOf('"', i);
+			if (open === -1) return undefined;
+			inString = true;
+			i = open + 1;
+			continue;
+		}
+
+		// Jump straight to the next quote or backslash. A per-character walk costs
+		// ~40ms on a 1MB literal-UTF-8 payload (a large `write`), and every byte in
+		// between is by definition uninteresting.
+		const nextQuote = json.indexOf('"', i);
+		const nextBackslash = json.indexOf("\\", i);
+		if (nextQuote === -1 && nextBackslash === -1) return undefined;
+		i = nextBackslash === -1 || (nextQuote !== -1 && nextQuote < nextBackslash) ? nextQuote : nextBackslash;
+
+		if (json.charCodeAt(i) === QUOTE) {
+			inString = false;
+			i++;
+			continue;
+		}
+		if (json.charCodeAt(i + 1) !== U) {
+			// Any other escape (including `\\`) consumes its own second character,
+			// so a literal `\uXXXX` in the decoded value is never misread as one.
+			i += 2;
+			continue;
+		}
+
+		const first = hexAt(i + 2);
+		if (first === undefined) {
+			i += 2;
+			continue;
+		}
+		if (first >= 0xd800 && first <= 0xdbff) {
+			// High surrogate: only a completed pair denotes a real character.
+			const low = json.charCodeAt(i + 6) === BACKSLASH && json.charCodeAt(i + 7) === U ? hexAt(i + 8) : undefined;
+			if (low !== undefined && low >= 0xdc00 && low <= 0xdfff) {
+				return json.slice(i, i + 12);
+			}
+			i += 6;
+			continue;
+		}
+		if (first >= 0x80 && !(first >= 0xdc00 && first <= 0xdfff)) {
+			return json.slice(i, i + 6);
+		}
+		i += 6;
+	}
+	return undefined;
+}
+
 export function parseJsonWithRepair<T>(json: string): T {
 	try {
 		return JSON.parse(json) as T;

package/src/utils/oauth/index.ts

@@ -275,6 +275,11 @@ const builtInOAuthProviders: OAuthProviderInfo[] = [
 		name: "Vercel AI Gateway",
 		available: true,
 	},
+	{
+		id: "kiro",
+		name: "Kiro (Amazon Q Developer / CodeWhisperer)",
+		available: true,
+	},
 ];
 
 const customOAuthProviders = new Map<string, OAuthProviderInterface>();
@@ -375,6 +380,11 @@ export async function refreshOAuthToken(
 			newCredentials = await refreshGlmZcodeToken(credentials);
 			break;
 		}
+		case "kiro": {
+			const { refreshKiroToken } = await import("./kiro");
+			newCredentials = await refreshKiroToken(credentials);
+			break;
+		}
 		case "kilo":
 		case "perplexity":
 		case "huggingface":
@@ -487,7 +497,10 @@ export async function getOAuthApiKey(
 	}
 	// For providers that need request-time credential metadata, return JSON.
 	const needsStructuredApiKey =
-		provider === "github-copilot" || provider === "google-gemini-cli" || provider === "google-antigravity";
+		provider === "github-copilot" ||
+		provider === "google-gemini-cli" ||
+		provider === "google-antigravity" ||
+		provider === "kiro";
 	const apiKey = needsStructuredApiKey
 		? JSON.stringify({
 				token: creds.access,