@gajae-code/ai 0.18.5 → 0.18.7

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/google-gemini-cli.ts

@@ -16,6 +16,7 @@ import type {
 	Api,
 	AssistantMessage,
 	Context,
+	GoogleGeminiCliDiagnostics,
 	Model,
 	StreamFunction,
 	StreamOptions,
@@ -27,6 +28,7 @@ import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { transportFailureFacts } from "../utils/fallback-transport";
 import { appendRawHttpRequestDumpFor400, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
+import { FirstEventTimeoutError } from "../utils/idle-iterator";
 import { resolveRetryBudget } from "../utils/retry-budget";
 // Refresh is the sole responsibility of AuthStorage (broker-aware, single-flighted);
 // the stream provider trusts the access token threaded through `options.apiKey`.
@@ -325,6 +327,29 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			timestamp: Date.now(),
 		};
 		let rawRequestDump: RawHttpRequestDump | undefined;
+		const googleGeminiCliDiagnostics: GoogleGeminiCliDiagnostics = {
+			chunkCounts: { content: 0, thinking: 0, functionCall: 0, usageOnly: 0, other: 0 },
+		};
+		(
+			stream as AssistantMessageEventStream & { googleGeminiCliDiagnostics?: GoogleGeminiCliDiagnostics }
+		).googleGeminiCliDiagnostics = googleGeminiCliDiagnostics;
+		const recordTimeoutDiagnostics = (): void => {
+			const reason = options?.signal?.reason;
+			if (!(reason instanceof FirstEventTimeoutError)) return;
+			googleGeminiCliDiagnostics.firstEventTimeoutMs = reason.firstEventTimeoutMs;
+			googleGeminiCliDiagnostics.firstEventTimeoutSource = reason.firstEventTimeoutSource;
+			(
+				reason as FirstEventTimeoutError & {
+					googleGeminiCliDiagnostics?: GoogleGeminiCliDiagnostics;
+				}
+			).googleGeminiCliDiagnostics = googleGeminiCliDiagnostics;
+		};
+		options?.signal?.addEventListener("abort", recordTimeoutDiagnostics, { once: true });
+		const recordResponse = (): void => {
+			if (googleGeminiCliDiagnostics.responseAtMs === undefined) {
+				googleGeminiCliDiagnostics.responseAtMs = Date.now() - startTime;
+			}
+		};
 
 		try {
 			const apiKeyRaw = options?.apiKey;
@@ -405,6 +430,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 					fetch: options?.fetch,
 				},
 			);
+			recordResponse();
 			if (!response.ok && sentForcedToolChoice) {
 				const errorText = await response.text();
 				const error = createGeminiCliHttpError(response, errorText);
@@ -447,6 +473,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 							fetch: options?.fetch,
 						},
 					);
+					recordResponse();
 				} else {
 					throw error;
 				}
@@ -496,20 +523,29 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				for await (const chunk of readSseJson<CloudCodeAssistResponseChunk>(
 					activeResponse.body!,
 					options?.signal,
-					event =>
+					event => {
+						if (googleGeminiCliDiagnostics.firstRawSseAtMs === undefined) {
+							googleGeminiCliDiagnostics.firstRawSseAtMs = Date.now() - startTime;
+						}
 						options?.onSseEvent?.(
 							{ event: event.event, data: event.data, raw: [...event.raw] },
 							model,
 							options?.attemptScope,
-						),
+						);
+					},
 				)) {
 					const responseData = chunk.response;
-					if (!responseData) continue;
+					if (!responseData) {
+						googleGeminiCliDiagnostics.chunkCounts.other += 1;
+						continue;
+					}
 
 					const candidate = responseData.candidates?.[0];
+					let chunkKind: keyof GoogleGeminiCliDiagnostics["chunkCounts"] = "other";
 					if (candidate?.content?.parts) {
 						for (const part of candidate.content.parts) {
 							if (part.text !== undefined) {
+								chunkKind = isThinkingPart(part) ? "thinking" : "content";
 								hasContent = true;
 								const isThinking = isThinkingPart(part);
 								if (
@@ -550,6 +586,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 							}
 
 							if (part.functionCall) {
+								chunkKind = "functionCall";
 								hasContent = true;
 								if (currentBlock) {
 									pushBlockEndEvent(currentBlock, blockIndex(), output, stream);
@@ -618,6 +655,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 					}
 
 					if (responseData.usageMetadata) {
+						if (chunkKind === "other") chunkKind = "usageOnly";
 						// promptTokenCount includes cachedContentTokenCount, so subtract to get fresh input
 						const promptTokens = responseData.usageMetadata.promptTokenCount || 0;
 						const cacheReadTokens = responseData.usageMetadata.cachedContentTokenCount || 0;
@@ -639,6 +677,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						};
 						calculateCost(model, output.usage);
 					}
+					googleGeminiCliDiagnostics.chunkCounts[chunkKind] += 1;
 				}
 
 				if (currentBlock) {
@@ -676,6 +715,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						body: requestBodyJson,
 						signal: options?.signal,
 					});
+					recordResponse();
 
 					if (!currentResponse.ok) {
 						const retryErrorText = await currentResponse.text();
@@ -711,6 +751,11 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			stream.push({ type: "done", reason: output.stopReason, message: output });
 			stream.end();
 		} catch (error) {
+			const timeoutError = options?.signal?.reason;
+			if (timeoutError instanceof FirstEventTimeoutError) {
+				googleGeminiCliDiagnostics.firstEventTimeoutMs = timeoutError.firstEventTimeoutMs;
+				googleGeminiCliDiagnostics.firstEventTimeoutSource = timeoutError.firstEventTimeoutSource;
+			}
 			for (const block of output.content) {
 				if ("index" in block) {
 					delete (block as { index?: number }).index;
@@ -719,6 +764,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
 			output.errorStatus = extractHttpStatusFromError(error);
 			output.transportFailure = transportFailureFacts(error);
+			output.googleGeminiCliDiagnostics = googleGeminiCliDiagnostics;
 			output.errorMessage = await appendRawHttpRequestDumpFor400(
 				error instanceof Error ? error.message : JSON.stringify(error),
 				error,

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