@gajae-code/ai 0.18.5 → 0.18.6

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]");

package/src/providers/kiro-codewhisperer.ts

@@ -26,11 +26,11 @@ import type {
 	ToolResultMessage,
 } from "../types";
 import { AssistantMessageEventStream } from "../utils/event-stream";
-import { transportFailureFacts } from "../utils/fallback-transport";
+import { PROVIDER_PROTOCOL_MISMATCH_ERROR_CODE, transportFailureFacts } from "../utils/fallback-transport";
 import { withHttpStatus } from "../utils/http-inspector";
 import { captureUnicodeEscapeEvidence } from "../utils/json-parse";
 import { decodeEventStream } from "./aws-eventstream";
-import { isKiroApiKey, streamKiroApiKey, toKiroModelId } from "./kiro-api-key";
+import { isKiroApiKey, sanitizeKiroError, streamKiroApiKey, toKiroModelId } from "./kiro-api-key";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Provider options
@@ -78,7 +78,7 @@ interface WireUserMessage {
 			toolResults?: WireToolResult[];
 			editorStateContext?: Record<string, unknown>;
 		};
-		origin?: string;
+		origin: typeof KIRO_ORIGIN;
 	};
 }
 
@@ -142,6 +142,12 @@ interface ErrorPayload {
 
 const DEFAULT_REGION = "us-east-1";
 
+/**
+ * Without `origin` the service ignores `modelId` and routes every request to
+ * `auto`; with it, response frames report the requested model.
+ */
+const KIRO_ORIGIN = "AI_EDITOR";
+
 type Block = (TextContent | ToolCall) & { index?: number; partialJson?: string };
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -240,14 +246,29 @@ export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"
 			});
 
 			if (!response.ok) {
-				const errBody = await response.text().catch(() => "");
+				const errBody = await readBodyPrefix(response);
 				throw withHttpStatus(
-					new Error(`Kiro CodeWhisperer HTTP ${response.status}: ${errBody.slice(0, 1000)}`),
+					new Error(sanitizeKiroError(`Kiro CodeWhisperer HTTP ${response.status}: ${errBody}`, bearerToken)),
 					response.status,
 				);
 			}
 
-			if (!response.body) throw new Error("Kiro CodeWhisperer response has no body");
+			// Verify content-type is eventstream; if not, read and report the actual error
+			const contentType = response.headers.get("content-type") ?? "";
+			const mediaType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+			if (!response.body || mediaType !== "application/vnd.amazon.eventstream") {
+				const errBody = await readBodyPrefix(response);
+				// Deliberately no HTTP status metadata and no "HTTP <code>" wording: a 2xx
+				// protocol mismatch is deterministic, and a status would materialize
+				// transport-failure facts that session fallback retries.
+				// Sanitize each untrusted part on its own so the fixed prefix does not eat
+				// into the body's 1000-character diagnostic budget.
+				const safeContentType = contentType ? sanitizeKiroError(contentType, bearerToken) : "";
+				const safeBody = errBody ? sanitizeKiroError(errBody, bearerToken) : "";
+				throw new KiroNonEventStreamError(
+					`Kiro CodeWhisperer returned a non-eventstream ${response.status} response (${safeContentType}): ${safeBody}`,
+				);
+			}
 
 			// Decode eventstream
 			for await (const message of decodeEventStream(response.body)) {
@@ -348,8 +369,10 @@ export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"
 				delete (block as Block).partialJson;
 			}
 			output.stopReason = options.signal?.aborted ? "aborted" : "error";
-			output.errorStatus = extractHttpStatusFromError(error);
+			// The non-eventstream diagnostic embeds untrusted body text; never parse a status out of it.
+			output.errorStatus = error instanceof KiroNonEventStreamError ? undefined : extractHttpStatusFromError(error);
 			output.transportFailure = transportFailureFacts(error);
+			if (error instanceof KiroNonEventStreamError) output.errorCode = PROVIDER_PROTOCOL_MISMATCH_ERROR_CODE;
 			const baseMessage = error instanceof Error ? error.message : JSON.stringify(error);
 			output.errorMessage = baseMessage;
 			output.duration = Date.now() - startTime;
@@ -386,7 +409,20 @@ function buildConversationState(
 	const history: WireHistoryMessage[] = [];
 	const systemPrompt = context.systemPrompt?.join("\n") ?? "";
 
-	for (let i = 0; i < messages.length - 1; i++) {
+	// Parallel tool calls end the conversation with several consecutive toolResult
+	// messages. They all answer the last assistant turn, so they must travel
+	// together in currentMessage; leaving the earlier ones as a separate history
+	// entry is rejected upstream with TOOL_USE_RESULT_MISMATCH.
+	let currentStart = messages.length - 1;
+	while (
+		currentStart > 0 &&
+		messages[currentStart].role === "toolResult" &&
+		messages[currentStart - 1].role === "toolResult"
+	) {
+		currentStart--;
+	}
+
+	for (let i = 0; i < currentStart; i++) {
 		const msg = messages[i];
 		const previous = history[history.length - 1];
 		// Parallel tool calls produce consecutive toolResult messages; they answer one
@@ -406,9 +442,14 @@ function buildConversationState(
 		history.push(convertToWireMessage(msg, modelId, i === 0 ? systemPrompt : undefined));
 	}
 
-	// Convert the last message as currentMessage
+	// Convert the last message as currentMessage, carrying every trailing parallel result.
 	const lastMsg = messages[messages.length - 1];
 	const currentMessage = convertToWireUserMessage(lastMsg, modelId, systemPrompt);
+	if (currentStart < messages.length - 1) {
+		currentMessage.userInputMessage.userInputMessageContext = {
+			toolResults: messages.slice(currentStart).map(msg => convertToolResult(msg as ToolResultMessage)),
+		};
+	}
 
 	// Add tools to the current message context
 	if (context.tools && context.tools.length > 0) {
@@ -480,6 +521,7 @@ function convertToWireUserMessage(
 		userInputMessage: {
 			content,
 			modelId,
+			origin: KIRO_ORIGIN,
 		},
 	};
 
@@ -603,6 +645,42 @@ function handleToolUseEvent(
 // Helpers
 // ─────────────────────────────────────────────────────────────────────────────
 
+/** A 2xx response that is not an AWS event stream: a deterministic protocol error, never a transport failure. */
+class KiroNonEventStreamError extends Error {
+	override name = "KiroNonEventStreamError";
+}
+
+/** Byte cap for diagnostic error bodies; the rest of the stream is cancelled unread. */
+const ERROR_BODY_PREFIX_BYTES = 4096;
+
+/** Read at most {@link ERROR_BODY_PREFIX_BYTES} of a response body for diagnostics, then cancel the remainder. */
+async function readBodyPrefix(response: Response): Promise<string> {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const chunks: Uint8Array[] = [];
+	let total = 0;
+	try {
+		while (total < ERROR_BODY_PREFIX_BYTES) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			const take = value.subarray(0, ERROR_BODY_PREFIX_BYTES - total);
+			chunks.push(take);
+			total += take.length;
+		}
+	} catch {
+		// Diagnostic read only; report whatever prefix arrived.
+	} finally {
+		reader.cancel().catch(() => {});
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return new TextDecoder().decode(bytes);
+}
+
 function resolveBearerToken(apiKey: string | undefined): string | undefined {
 	if (!apiKey) {
 		return $credentialEnv("KIRO_API_KEY") ?? $credentialEnv("AWS_BEARER_TOKEN_KIRO") ?? undefined;

package/src/providers/openai-codex-responses.d.ts

@@ -11,6 +11,8 @@ export interface OpenAICodexResponsesOptions extends StreamOptions {
     preferWebsockets?: boolean;
     serviceTier?: ServiceTier;
 }
+/** @internal Exported for tests. */
+export declare function createCodexStreamProgressClassifier(): (event: unknown) => boolean;
 type CodexTransport = "sse" | "websocket";
 export interface OpenAICodexWebSocketDebugStats {
     fullContextRequests: number;