@gajae-code/ai 0.13.2 → 0.13.3

package/src/openai-completions-compat.ts

@@ -125,6 +125,7 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		baseUrl.includes("fireworks.ai") ||
 		isDirectDeepseekApi;
 	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
+	const isDirectXaiReasoningEffortModel = provider === "xai" && (model.id === "grok-4.5" || model.id === "grok-4.6");
 	const isMistral = provider === "mistral" || baseUrl.includes("mistral.ai");
 
 	// Hosts whose chat-completions endpoints are known to accept multiple
@@ -215,7 +216,7 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 		sendSessionHeaders: false,
 		supportsResponsesSessionAffinity: false,
 		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
-		supportsReasoningEffort: !isGrok && !isZai,
+		supportsReasoningEffort: (!isGrok && !isZai) || isDirectXaiReasoningEffortModel,
 		reasoningEffortMap,
 		supportsUsageInStreaming: !isCerebras,
 		disableReasoningOnForcedToolChoice: isKimiModel || isAnthropicModel || isOpenCodeGoReasoning,

package/src/provider-models/descriptors.ts

@@ -52,6 +52,7 @@ import {
 	cursorModelManagerOptions,
 	glmZcodeModelManagerOptions,
 	jetbrainsJunieModelManagerOptions,
+	kiroModelManagerOptions,
 	openCodexModelManagerOptions,
 	zaiModelManagerOptions,
 } from "./special";
@@ -356,6 +357,7 @@ export const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[] = [
 		config => cursorModelManagerOptions(config),
 		catalog("Cursor", ["CURSOR_API_KEY"], { oauthProvider: "cursor" }),
 	),
+	descriptor("kiro", "CLAUDE_3_7_SONNET_20250219_V1_0", config => kiroModelManagerOptions(config)),
 ] as const;
 
 /** Default model IDs for all known providers, built from descriptors + special providers. */

package/src/provider-models/special.ts

@@ -96,3 +96,15 @@ export function jetbrainsJunieModelManagerOptions(
 ): ModelManagerOptions<"anthropic-messages"> {
 	return { providerId: "jetbrains-junie" };
 }
+
+// ---------------------------------------------------------------------------
+// Kiro (Amazon Q Developer / CodeWhisperer)
+// ---------------------------------------------------------------------------
+
+export interface KiroModelManagerConfig {}
+
+export function kiroModelManagerOptions(
+	_config: KiroModelManagerConfig = {},
+): ModelManagerOptions<"kiro-codewhisperer-stream"> {
+	return { providerId: "kiro" };
+}

package/src/providers/anthropic.ts

@@ -73,7 +73,12 @@ import {
 	getStreamIdleTimeoutMs,
 	iterateWithIdleTimeout,
 } from "../utils/idle-iterator";
-import { isCompleteJson, parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse";
+import {
+	findUnnecessaryUnicodeEscape,
+	isCompleteJson,
+	parseJsonWithRepair,
+	parseStreamingJson,
+} from "../utils/json-parse";
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { isCopilotTransientModelError } from "../utils/retry";
@@ -1835,6 +1840,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 									if (!isCompleteJson(block.partialJson)) truncatedToolCalls.add(block);
 									if (block.partialJson.trim()) {
 										block.arguments = parseStreamingJson(block.partialJson);
+										// Raw-wire check: after decode the escape is invisible.
+										if (findUnnecessaryUnicodeEscape(block.partialJson))
+											block.escapedNonAsciiArguments = true;
 									}
 									delete (block as { partialJson?: string }).partialJson;
 									stream.push({
@@ -2114,6 +2122,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					truncatedToolCalls.add(block);
 					if (block.partialJson.trim()) {
 						block.arguments = parseStreamingJson(block.partialJson);
+						if (findUnnecessaryUnicodeEscape(block.partialJson)) block.escapedNonAsciiArguments = true;
 					}
 					delete (block as { partialJson?: string }).partialJson;
 				}

package/src/providers/kiro-codewhisperer.ts

@@ -0,0 +1,572 @@
+/**
+ * Kiro / Amazon Q Developer / CodeWhisperer streaming transport.
+ *
+ * Talks directly to the CodeWhisperer streaming service over HTTPS using
+ * a bearer token from AWS SSO OIDC. The response is an
+ * `application/vnd.amazon.eventstream`, decoded by the shared
+ * `decodeEventStream` primitive from `aws-eventstream.ts`.
+ *
+ * Clean-room: derived from published Amazon service model shapes
+ * (aws-toolkit-vscode CodeWhisperer streaming + codewhispererruntime-2022-11-11),
+ * not from any AGPL reference implementation.
+ */
+import { $credentialEnv, $env, extractHttpStatusFromError } from "@gajae-code/utils";
+import type {
+	Api,
+	AssistantMessage,
+	Context,
+	Model,
+	StreamFunction,
+	StreamOptions,
+	TextContent,
+	Tool,
+	ToolCall,
+	ToolResultMessage,
+} from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+import { transportFailureFacts } from "../utils/fallback-transport";
+import { withHttpStatus } from "../utils/http-inspector";
+import { decodeEventStream } from "./aws-eventstream";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Provider options
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface KiroCodeWhispererOptions extends StreamOptions {
+	/** AWS region for the CodeWhisperer streaming endpoint. */
+	region?: string;
+	/** Profile ARN for enterprise IAM Identity Center accounts. */
+	profileArn?: string;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// CodeWhisperer streaming wire types
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface WireToolSpec {
+	toolSpecification: {
+		name: string;
+		description?: string;
+		inputSchema: { json: unknown };
+	};
+}
+
+interface WireToolResult {
+	toolResultMessage: {
+		content: string;
+		toolUseId: string;
+		status?: "success" | "error";
+	};
+}
+
+interface WireUserMessage {
+	userInputMessage: {
+		content: string;
+		userInputMessageContext?: {
+			tools?: { tools: WireToolSpec[] };
+			toolResults?: { toolResults: WireToolResult[][] };
+			editorStateContext?: Record<string, unknown>;
+		};
+		origin?: string;
+	};
+}
+
+interface WireAssistantMessage {
+	assistantResponseMessage: {
+		content: string;
+	};
+}
+
+type WireHistoryMessage = WireUserMessage | WireAssistantMessage;
+
+interface ConversationState {
+	chatTriggerType: "MANUAL";
+	currentMessage: WireUserMessage;
+	history?: WireHistoryMessage[];
+	profileArn?: string;
+	customizationArn?: string;
+}
+
+interface GenerateAssistantResponseRequest {
+	conversationState: ConversationState;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Response eventstream types (ChatResponseStream union members)
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface AssistantResponseEvent {
+	assistantResponseEvent?: {
+		content?: string;
+	};
+}
+
+interface ToolUseEventPayload {
+	toolUseEvent?: {
+		toolUseId?: string;
+		name?: string;
+		input?: unknown;
+		stop?: { stopReason?: string };
+	};
+}
+
+interface MessageMetadataEvent {
+	messageMetadataEvent?: {
+		conversationId?: string;
+		utteranceId?: string;
+	};
+}
+
+interface ErrorPayload {
+	error?: {
+		message?: string;
+		code?: string;
+	};
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Constants
+// ─────────────────────────────────────────────────────────────────────────────
+
+const DEFAULT_REGION = "us-east-1";
+const STREAMING_SERVICE_NAME = "amazoncodewhispererstreamingservice";
+
+type Block = (TextContent | ToolCall) & { index?: number; partialJson?: string };
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Stream function
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"> = (
+	model: Model<"kiro-codewhisperer-stream">,
+	context: Context,
+	options: KiroCodeWhispererOptions,
+): AssistantMessageEventStream => {
+	const stream = new AssistantMessageEventStream();
+
+	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
+		const output: AssistantMessage = {
+			role: "assistant",
+			content: [],
+			api: "kiro-codewhisperer-stream" as Api,
+			provider: model.provider,
+			model: model.id,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+			},
+			stopReason: "stop",
+			timestamp: Date.now(),
+		};
+
+		const blocks = output.content as Block[];
+		const region = options.region || $env.KIRO_REGION || $env.AWS_REGION || $env.AWS_DEFAULT_REGION || DEFAULT_REGION;
+
+		try {
+			// Resolve bearer token
+			const bearerToken = resolveBearerToken(options.apiKey);
+			if (!bearerToken) {
+				throw new Error(
+					"No Kiro credentials found. Run 'gjc auth-broker login kiro' to authenticate via AWS Builder ID, or set AWS_BEARER_TOKEN_KIRO.",
+				);
+			}
+
+			// Build request
+			const conversationState = buildConversationState(context, model, options);
+			const requestBody: GenerateAssistantResponseRequest = {
+				conversationState,
+			};
+
+			options?.onPayload?.(requestBody, model, options?.attemptScope);
+
+			const host = `${STREAMING_SERVICE_NAME}.${region}.amazonaws.com`;
+			const url = `https://${host}/`;
+
+			const bodyText = JSON.stringify(requestBody);
+			const body = new TextEncoder().encode(bodyText);
+			const requestHeaders: Record<string, string> = {
+				"content-type": "application/json",
+				accept: "application/vnd.amazon.eventstream",
+				authorization: `Bearer ${bearerToken}`,
+				"amzn-X-amz-target": "AmazonCodeWhispererService.GenerateAssistantResponse",
+			};
+
+			if (options.profileArn) {
+				requestHeaders["x-amzn-codewhisperer-proflearn"] = options.profileArn;
+			}
+
+			// Merge user-provided headers
+			if (options.headers) {
+				Object.assign(requestHeaders, options.headers);
+			}
+
+			const response = await fetch(url, {
+				method: "POST",
+				headers: requestHeaders,
+				body,
+				signal: options.signal,
+			});
+
+			if (!response.ok) {
+				const errBody = await response.text().catch(() => "");
+				throw withHttpStatus(
+					new Error(`Kiro CodeWhisperer HTTP ${response.status}: ${errBody.slice(0, 1000)}`),
+					response.status,
+				);
+			}
+
+			if (!response.body) throw new Error("Kiro CodeWhisperer response has no body");
+
+			// Decode eventstream
+			for await (const message of decodeEventStream(response.body)) {
+				if (options.signal?.aborted) break;
+
+				const messageType = message.headers[":message-type"];
+				const eventType = message.headers[":event-type"];
+
+				if (messageType === "exception") {
+					const exceptionType = message.headers[":exception-type"] || "Exception";
+					const payload = safeParsePayload(message.payload) as { message?: string } | undefined;
+					const errorMessage = payload?.message || new TextDecoder().decode(message.payload);
+					const status = exceptionType === "ValidationException" ? 400 : 0;
+					const err = new Error(`${exceptionType}: ${errorMessage}`);
+					throw status ? withHttpStatus(err, status) : err;
+				}
+
+				if (messageType === "error") {
+					const code = message.headers[":error-code"] || "UnknownError";
+					const errorMessage = message.headers[":error-message"] || new TextDecoder().decode(message.payload);
+					throw new Error(`${code}: ${errorMessage}`);
+				}
+
+				if (messageType !== "event") continue;
+
+				const payload = safeParsePayload(message.payload);
+				if (!payload) continue;
+
+				switch (eventType) {
+					case "assistantResponseEvent": {
+						const ev = payload as AssistantResponseEvent;
+						const content = ev.assistantResponseEvent?.content;
+						if (content) {
+							if (!firstTokenTime) firstTokenTime = Date.now();
+							if (blocks.length === 0) {
+								stream.push({ type: "start", partial: output });
+							}
+							handleTextDelta(content, blocks, output, stream);
+						}
+						break;
+					}
+					case "toolUseEvent": {
+						const ev = payload as ToolUseEventPayload;
+						if (!firstTokenTime) firstTokenTime = Date.now();
+						if (blocks.length === 0) {
+							stream.push({ type: "start", partial: output });
+						}
+						handleToolUseEvent(ev, blocks, output, stream);
+						break;
+					}
+					case "messageMetadataEvent": {
+						const ev = payload as MessageMetadataEvent;
+						if (ev.messageMetadataEvent?.conversationId) {
+							output.responseId = ev.messageMetadataEvent.conversationId;
+						}
+						break;
+					}
+					case "codeReferenceEvent":
+					case "supplementaryWebLinksEvent":
+					case "followupPromptEvent":
+					case "dryRunSucceedEvent":
+					case "citationEvent":
+					case "intentsEvent":
+					case "interactionComponentsEvent":
+					case "invalidStateEvent":
+						// Known but unhandled events — ignore gracefully
+						break;
+					default:
+						// Unknown event types — ignore (forward compatibility)
+						break;
+				}
+
+				const errorPayload = payload as ErrorPayload;
+				if (errorPayload.error?.message) {
+					throw new Error(`Kiro CodeWhisperer stream error: ${errorPayload.error.message}`);
+				}
+			}
+
+			if (options.signal?.aborted) throw new Error("Request was aborted");
+
+			// Finalize blocks
+			for (const block of blocks) {
+				delete block.index;
+				delete block.partialJson;
+			}
+
+			// Determine stop reason
+			const hasToolCall = blocks.some(b => b.type === "toolCall");
+			output.stopReason = hasToolCall ? "toolUse" : "stop";
+
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({ type: "done", reason: output.stopReason as "stop" | "length" | "toolUse", message: output });
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) {
+				delete (block as Block).index;
+				delete (block as Block).partialJson;
+			}
+			output.stopReason = options.signal?.aborted ? "aborted" : "error";
+			output.errorStatus = extractHttpStatusFromError(error);
+			output.transportFailure = transportFailureFacts(error);
+			const baseMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			output.errorMessage = baseMessage;
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+			stream.end();
+		}
+	})();
+
+	return stream;
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Request building
+// ─────────────────────────────────────────────────────────────────────────────
+
+function buildConversationState(
+	context: Context,
+	_model: Model<"kiro-codewhisperer-stream">,
+	options: KiroCodeWhispererOptions,
+): ConversationState {
+	const messages = context.messages;
+	if (messages.length === 0) {
+		throw new Error("Kiro CodeWhisperer requires at least one message");
+	}
+
+	// Build history from all messages except the last
+	const history: WireHistoryMessage[] = [];
+	const systemPrompt = context.systemPrompt?.join("\n") ?? "";
+
+	for (let i = 0; i < messages.length - 1; i++) {
+		const msg = messages[i];
+		history.push(convertToWireMessage(msg, i === 0 ? systemPrompt : undefined));
+	}
+
+	// Convert the last message as currentMessage
+	const lastMsg = messages[messages.length - 1];
+	const currentMessage = convertToWireUserMessage(lastMsg, systemPrompt);
+
+	// Add tools to the current message context
+	if (context.tools && context.tools.length > 0) {
+		if (!currentMessage.userInputMessage.userInputMessageContext) {
+			currentMessage.userInputMessage.userInputMessageContext = {};
+		}
+		currentMessage.userInputMessage.userInputMessageContext.tools = {
+			tools: convertTools(context.tools),
+		};
+	}
+
+	return {
+		chatTriggerType: "MANUAL",
+		currentMessage,
+		history: history.length > 0 ? history : undefined,
+		profileArn: options.profileArn,
+	};
+}
+
+function convertToWireMessage(msg: Context["messages"][number], systemPrompt?: string): WireHistoryMessage {
+	if (msg.role === "user") {
+		return convertToWireUserMessage(msg, systemPrompt);
+	}
+	if (msg.role === "toolResult") {
+		return convertToWireUserMessage(msg, systemPrompt);
+	}
+	// assistant → assistant response
+	const textParts: string[] = [];
+	for (const block of msg.content) {
+		if (typeof block === "string") {
+			textParts.push(block);
+		} else if (block.type === "text") {
+			textParts.push(block.text);
+		} else if (block.type === "toolCall") {
+			textParts.push(JSON.stringify({ toolUseId: block.id, name: block.name, input: block.arguments }));
+		}
+	}
+	return {
+		assistantResponseMessage: {
+			content: textParts.join("\n") || "",
+		},
+	};
+}
+
+function convertToWireUserMessage(msg: Context["messages"][number], systemPrompt?: string): WireUserMessage {
+	let content = extractTextContent(msg);
+	if (systemPrompt) {
+		content = `${systemPrompt}\n\n${content}`;
+	}
+
+	const userMsg: WireUserMessage = {
+		userInputMessage: {
+			content,
+		},
+	};
+
+	// Handle tool results
+	if (msg.role === "toolResult") {
+		const toolResultMsg = msg as ToolResultMessage;
+		const toolResults = (toolResultMsg.content ?? []).map(detail => ({
+			toolResultMessage: {
+				content: detail.type === "text" ? detail.text : "",
+				toolUseId: toolResultMsg.toolCallId,
+				status: toolResultMsg.isError ? ("error" as const) : ("success" as const),
+			},
+		}));
+		if (toolResults.length > 0) {
+			if (!userMsg.userInputMessage.userInputMessageContext) {
+				userMsg.userInputMessage.userInputMessageContext = {};
+			}
+			userMsg.userInputMessage.userInputMessageContext.toolResults = { toolResults: [toolResults] };
+		}
+	}
+
+	return userMsg;
+}
+
+function extractTextContent(msg: Context["messages"][number]): string {
+	if (typeof msg.content === "string") return msg.content;
+	if (Array.isArray(msg.content)) {
+		return msg.content
+			.map(block => {
+				if (typeof block === "string") return block;
+				if (block.type === "text") return block.text;
+				if (block.type === "image") return ""; // Images not supported in text field
+				return "";
+			})
+			.join("");
+	}
+	return "";
+}
+
+function convertTools(tools: Tool[]): WireToolSpec[] {
+	return tools.map(tool => ({
+		toolSpecification: {
+			name: tool.name,
+			description: tool.description ?? "",
+			inputSchema: {
+				json: tool.parameters ?? {},
+			},
+		},
+	}));
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Event handling
+// ─────────────────────────────────────────────────────────────────────────────
+
+function handleTextDelta(
+	delta: string,
+	blocks: Block[],
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+): void {
+	// Find or create the last text block
+	let lastBlock = blocks[blocks.length - 1];
+	if (lastBlock?.type !== "text") {
+		const newBlock: Block = { type: "text", text: "", index: blocks.length };
+		blocks.push(newBlock);
+		lastBlock = newBlock;
+		stream.push({ type: "text_start", contentIndex: newBlock.index!, partial: output });
+	}
+	lastBlock.text += delta;
+	stream.push({ type: "text_delta", contentIndex: lastBlock.index!, delta, partial: output });
+}
+
+function handleToolUseEvent(
+	ev: ToolUseEventPayload,
+	blocks: Block[],
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+): void {
+	const toolEvent = ev.toolUseEvent;
+	if (!toolEvent) return;
+
+	const toolUseId = toolEvent.toolUseId ?? "";
+	const name = toolEvent.name ?? "";
+
+	// If input is provided as a complete object, emit toolcall_end
+	if (toolEvent.input !== undefined && toolEvent.input !== null) {
+		const inputStr = typeof toolEvent.input === "string" ? toolEvent.input : JSON.stringify(toolEvent.input);
+		const toolCall: ToolCall = {
+			type: "toolCall",
+			id: toolUseId,
+			name,
+			arguments: safeParseJson(inputStr) as Record<string, any>,
+		};
+
+		const newBlock: Block = { ...toolCall, index: blocks.length };
+		blocks.push(newBlock);
+		stream.push({ type: "toolcall_end", contentIndex: newBlock.index!, toolCall, partial: output });
+		return;
+	}
+
+	// Otherwise, accumulate partial input (if the service streams it in chunks)
+	// The published model does not document chunked tool input for CodeWhisperer,
+	// so this path handles the case defensively but expects complete input per event.
+	const toolCall: ToolCall = {
+		type: "toolCall",
+		id: toolUseId,
+		name,
+		arguments: {},
+	};
+
+	const newBlock: Block = { ...toolCall, index: blocks.length };
+	blocks.push(newBlock);
+	stream.push({ type: "toolcall_end", contentIndex: newBlock.index!, toolCall, partial: output });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+function resolveBearerToken(apiKey: string | undefined): string | undefined {
+	if (!apiKey) {
+		return $credentialEnv("AWS_BEARER_TOKEN_KIRO") ?? undefined;
+	}
+
+	// Structured API key (from getOAuthApiKey) contains the access token as JSON
+	try {
+		const parsed = JSON.parse(apiKey) as { token?: string };
+		if (parsed.token) return parsed.token;
+	} catch {
+		// Plain bearer token
+	}
+
+	return apiKey;
+}
+
+function safeParsePayload(payload: Uint8Array): unknown {
+	if (payload.length === 0) return {};
+	try {
+		const text = new TextDecoder().decode(payload);
+		return JSON.parse(text);
+	} catch {
+		return undefined;
+	}
+}
+
+function safeParseJson(str: string): unknown {
+	if (!str) return {};
+	try {
+		return JSON.parse(str);
+	} catch {
+		return str;
+	}
+}

package/src/providers/mock.ts

@@ -75,6 +75,8 @@ export type MockContent =
 			arguments: Record<string, unknown> | string;
 			/** Simulate a provider-flagged truncated call (cut off mid-arguments). */
 			incompleteArguments?: boolean;
+			/** Simulate a provider-flagged `\uXXXX`-escaped-arguments call. */
+			escapedNonAsciiArguments?: boolean;
 	  };
 
 /** One scripted response. */
@@ -423,6 +425,7 @@ function normalizeContent(input: MockContent, state: MockModel): TextContent | T
 			name: input.name,
 			arguments: typeof input.arguments === "string" ? input.arguments : { ...input.arguments },
 			...(input.incompleteArguments ? { incompleteArguments: true } : {}),
+			...(input.escapedNonAsciiArguments ? { escapedNonAsciiArguments: true } : {}),
 		} as ToolCall;
 	}
 	return input;

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 });