@gajae-code/ai 0.18.1 → 0.18.6

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
@@ -58,11 +58,15 @@ interface WireToolSpec {
 }
 
 interface WireToolResult {
-	toolResultMessage: {
-		content: string;
-		toolUseId: string;
-		status?: "success" | "error";
-	};
+	toolUseId: string;
+	status: "success" | "error";
+	content: Array<{ text: string }>;
+}
+
+interface WireToolUse {
+	toolUseId: string;
+	name: string;
+	input: Record<string, unknown>;
 }
 
 interface WireUserMessage {
@@ -71,16 +75,17 @@ interface WireUserMessage {
 		modelId?: string;
 		userInputMessageContext?: {
 			tools?: { tools: WireToolSpec[] };
-			toolResults?: { toolResults: WireToolResult[][] };
+			toolResults?: WireToolResult[];
 			editorStateContext?: Record<string, unknown>;
 		};
-		origin?: string;
+		origin: typeof KIRO_ORIGIN;
 	};
 }
 
 interface WireAssistantMessage {
 	assistantResponseMessage: {
 		content: string;
+		toolUses?: WireToolUse[];
 	};
 }
 
@@ -137,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 };
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -235,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)) {
@@ -343,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;
@@ -381,14 +409,47 @@ 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
+		// assistant turn, so their results share a single user entry.
+		if (
+			msg.role === "toolResult" &&
+			messages[i - 1]?.role === "toolResult" &&
+			previous &&
+			"userInputMessage" in previous
+		) {
+			previous.userInputMessage.userInputMessageContext ??= {};
+			const context = previous.userInputMessage.userInputMessageContext;
+			context.toolResults ??= [];
+			context.toolResults.push(convertToolResult(msg as ToolResultMessage));
+			continue;
+		}
 		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) {
@@ -419,20 +480,27 @@ function convertToWireMessage(
 	if (msg.role === "toolResult") {
 		return convertToWireUserMessage(msg, modelId, systemPrompt);
 	}
-	// assistant → assistant response
+	// assistant → assistant response; tool calls stay structured so later tool
+	// results can reference the toolUseId they answer.
 	const textParts: string[] = [];
+	const toolUses: WireToolUse[] = [];
 	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 }));
+			toolUses.push({
+				toolUseId: block.id,
+				name: block.name,
+				input: (block.arguments ?? {}) as Record<string, unknown>,
+			});
 		}
 	}
 	return {
 		assistantResponseMessage: {
-			content: textParts.join("\n") || "",
+			content: textParts.join("\n"),
+			...(toolUses.length > 0 ? { toolUses } : {}),
 		},
 	};
 }
@@ -442,7 +510,9 @@ function convertToWireUserMessage(
 	modelId: string,
 	systemPrompt?: string,
 ): WireUserMessage {
-	let content = extractTextContent(msg);
+	// A tool result travels in userInputMessageContext.toolResults; repeating it as
+	// message text would show the model each result twice.
+	let content = msg.role === "toolResult" ? "Tool results provided." : extractTextContent(msg);
 	if (systemPrompt) {
 		content = `${systemPrompt}\n\n${content}`;
 	}
@@ -451,30 +521,32 @@ function convertToWireUserMessage(
 		userInputMessage: {
 			content,
 			modelId,
+			origin: KIRO_ORIGIN,
 		},
 	};
 
-	// 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] };
-		}
+		userMsg.userInputMessage.userInputMessageContext = {
+			toolResults: [convertToolResult(msg as ToolResultMessage)],
+		};
 	}
 
 	return userMsg;
 }
 
+/** One CodeWhisperer tool result per tool call, keyed by the toolUseId it answers. */
+function convertToolResult(msg: ToolResultMessage): WireToolResult {
+	const text = (msg.content ?? [])
+		.map(block => (block.type === "text" ? block.text : block.type === "image" ? "[image omitted]" : ""))
+		.filter(part => part.length > 0)
+		.join("\n");
+	return {
+		toolUseId: msg.toolCallId,
+		status: msg.isError ? "error" : "success",
+		content: [{ text }],
+	};
+}
+
 function extractTextContent(msg: Context["messages"][number]): string {
 	if (typeof msg.content === "string") return msg.content;
 	if (Array.isArray(msg.content)) {
@@ -573,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;