@gajae-code/ai 0.18.10 → 0.18.12

package/src/providers/kiro-api-key.ts

@@ -444,6 +444,7 @@ type KiroStreamEvent =
 	| { type: "toolUseInput"; data: { input: string } }
 	| { type: "toolUseStop"; data: { stop: boolean } }
 	| { type: "usage"; data: { inputTokens?: number; outputTokens?: number } }
+	| { type: "completion"; data: { stopReason: "COMPLETED" | "TOOL_USE" } }
 	| {
 			type: "refusal";
 			data: { stopReason?: string; stopDetails?: { refusal?: { category?: string; explanation?: string } } };
@@ -482,6 +483,188 @@ function findJsonEnd(text: string, start: number): number {
 	return -1;
 }
 
+type JsonPrefixResult = "complete" | "incomplete" | "invalid";
+
+/** Return whether an unfinished object is still a valid JSON prefix. */
+function isValidJsonPrefix(text: string): boolean {
+	let position = 0;
+	const maxDepth = 128;
+
+	function skipWhitespace(): void {
+		while (position < text.length) {
+			const char = text[position];
+			if (char !== " " && char !== "\t" && char !== "\n" && char !== "\r") break;
+			position++;
+		}
+	}
+
+	function isDigit(char: string | undefined): boolean {
+		return char !== undefined && char >= "0" && char <= "9";
+	}
+
+	function isHexDigit(char: string | undefined): boolean {
+		return (
+			char !== undefined &&
+			((char >= "0" && char <= "9") || (char >= "a" && char <= "f") || (char >= "A" && char <= "F"))
+		);
+	}
+
+	function parseString(): JsonPrefixResult {
+		if (text[position] !== '"') return "invalid";
+		position++;
+		while (position < text.length) {
+			const char = text[position];
+			if (char === '"') {
+				position++;
+				return "complete";
+			}
+			if (char === "\\") {
+				position++;
+				if (position >= text.length) return "incomplete";
+				const escaped = text[position];
+				if (escaped === "u") {
+					position++;
+					for (let i = 0; i < 4; i++) {
+						if (position >= text.length) return "incomplete";
+						if (!isHexDigit(text[position])) return "invalid";
+						position++;
+					}
+					continue;
+				}
+				if (escaped !== '"' && escaped !== "\\" && escaped !== "/" && !"bfnrt".includes(escaped ?? "")) {
+					return "invalid";
+				}
+				position++;
+				continue;
+			}
+			if (char !== undefined && char.charCodeAt(0) < 0x20) return "invalid";
+			position++;
+		}
+		return "incomplete";
+	}
+
+	function parseLiteral(literal: string): JsonPrefixResult {
+		for (const char of literal) {
+			if (position >= text.length) return "incomplete";
+			if (text[position] !== char) return "invalid";
+			position++;
+		}
+		return "complete";
+	}
+
+	function parseNumber(): JsonPrefixResult {
+		if (text[position] === "-") {
+			position++;
+			if (position >= text.length) return "incomplete";
+		}
+
+		if (text[position] === "0") {
+			position++;
+			if (isDigit(text[position])) return "invalid";
+		} else if (isDigit(text[position]) && text[position] !== "0") {
+			while (isDigit(text[position])) position++;
+		} else {
+			return "invalid";
+		}
+
+		if (text[position] === ".") {
+			position++;
+			if (position >= text.length) return "incomplete";
+			if (!isDigit(text[position])) return "invalid";
+			while (isDigit(text[position])) position++;
+		}
+
+		if (text[position] === "e" || text[position] === "E") {
+			position++;
+			if (position >= text.length) return "incomplete";
+			if (text[position] === "+" || text[position] === "-") position++;
+			if (position >= text.length) return "incomplete";
+			if (!isDigit(text[position])) return "invalid";
+			while (isDigit(text[position])) position++;
+		}
+		return "complete";
+	}
+
+	function parseValue(depth: number): JsonPrefixResult {
+		if (depth > maxDepth) return "incomplete";
+		skipWhitespace();
+		if (position >= text.length) return "incomplete";
+
+		const char = text[position];
+		if (char === "{") return parseObject(depth);
+		if (char === "[") return parseArray(depth);
+		if (char === '"') return parseString();
+		if (char === "t") return parseLiteral("true");
+		if (char === "f") return parseLiteral("false");
+		if (char === "n") return parseLiteral("null");
+		if (char === "-" || isDigit(char)) return parseNumber();
+		return "invalid";
+	}
+
+	function parseObject(depth: number): JsonPrefixResult {
+		if (depth > maxDepth) return "incomplete";
+		if (text[position] !== "{") return "invalid";
+		position++;
+		skipWhitespace();
+		if (position >= text.length) return "incomplete";
+		if (text[position] === "}") {
+			position++;
+			return "complete";
+		}
+
+		while (position < text.length) {
+			const key = parseString();
+			if (key !== "complete") return key;
+			skipWhitespace();
+			if (position >= text.length) return "incomplete";
+			if (text[position] !== ":") return "invalid";
+			position++;
+
+			const value = parseValue(depth + 1);
+			if (value !== "complete") return value;
+			skipWhitespace();
+			if (position >= text.length) return "incomplete";
+			if (text[position] === "}") {
+				position++;
+				return "complete";
+			}
+			if (text[position] !== ",") return "invalid";
+			position++;
+			skipWhitespace();
+		}
+		return "incomplete";
+	}
+
+	function parseArray(depth: number): JsonPrefixResult {
+		if (depth > maxDepth) return "incomplete";
+		if (text[position] !== "[") return "invalid";
+		position++;
+		skipWhitespace();
+		if (position >= text.length) return "incomplete";
+		if (text[position] === "]") {
+			position++;
+			return "complete";
+		}
+
+		while (position < text.length) {
+			const value = parseValue(depth + 1);
+			if (value !== "complete") return value;
+			skipWhitespace();
+			if (position >= text.length) return "incomplete";
+			if (text[position] === "]") {
+				position++;
+				return "complete";
+			}
+			if (text[position] !== ",") return "invalid";
+			position++;
+			skipWhitespace();
+		}
+		return "incomplete";
+	}
+
+	return parseObject(0) !== "invalid";
+}
+
 export function parseKiroApiEvents(buffer: string): { events: KiroStreamEvent[]; remaining: string } {
 	const events: KiroStreamEvent[] = [];
 	let pos = 0;
@@ -497,8 +680,14 @@ export function parseKiroApiEvents(buffer: string): { events: KiroStreamEvent[];
 		const end = findJsonEnd(buffer, start);
 		if (end < 0) {
 			// Unclosed brace at 'start'. Could be incomplete JSON waiting for more data, or junk/corruption.
-			// Resync by looking for valid JSON objects within MAX_RESCAN_DISTANCE that parse successfully.
 			const strayBraceEnd = Math.min(start + MAX_RESCAN_DISTANCE, buffer.length);
+			const incompleteCandidate = buffer.slice(start, strayBraceEnd);
+			if (isValidJsonPrefix(incompleteCandidate)) {
+				// Preserve valid incomplete envelopes; a complete nested child is not evidence that the
+				// outer frame is junk until its own JSON prefix is syntactically impossible.
+				return { events, remaining: incompleteCandidate };
+			}
+			// The prefix is syntactically impossible. Resync only after establishing invalid framing.
 			let resyncPos = start + 1;
 			let found = false;
 			while (resyncPos < strayBraceEnd) {
@@ -525,7 +714,7 @@ export function parseKiroApiEvents(buffer: string): { events: KiroStreamEvent[];
 			if (!found) {
 				// No valid JSON found within MAX_RESCAN_DISTANCE. Retain the stray brace and data up to the cap
 				// for the next parse call. Enforce the MAX_RESCAN_DISTANCE cap to prevent unbounded buffering.
-				return { events, remaining: buffer.slice(start, start + MAX_RESCAN_DISTANCE) };
+				return { events, remaining: buffer.slice(start, strayBraceEnd) };
 			}
 			// Loop will continue with the resynced pos
 			continue;
@@ -567,12 +756,14 @@ export function parseKiroApiEvents(buffer: string): { events: KiroStreamEvent[];
 
 			// Check for refusal after usage so that usage is processed first and recorded before refusal terminates
 			// This check is now order-independent: stopDetails can appear at any position in the JSON object
+			// Also handle detail-free CONTENT_FILTERED as a refusal (no stopDetails.refusal needed)
 			if (
-				typeof parsed.stopDetails === "object" &&
-				parsed.stopDetails !== null &&
-				(parsed.stopDetails as Record<string, unknown>).refusal
+				(typeof parsed.stopDetails === "object" &&
+					parsed.stopDetails !== null &&
+					(parsed.stopDetails as Record<string, unknown>).refusal) ||
+				parsed.stopReason === "CONTENT_FILTERED"
 			) {
-				// Emit refusal event if stopDetails contains actual refusal data
+				// Emit refusal event if stopDetails contains actual refusal data or stopReason is CONTENT_FILTERED
 				events.push({
 					type: "refusal",
 					data: {
@@ -580,7 +771,6 @@ export function parseKiroApiEvents(buffer: string): { events: KiroStreamEvent[];
 						stopDetails: parsed.stopDetails as { refusal?: { category?: string; explanation?: string } },
 					},
 				});
-				// Normal terminal metadata (stopReason: "COMPLETED", etc.) without refusal data is ignored
 			} else if (parsed.error || parsed.Error) {
 				events.push({
 					type: "error",
@@ -589,6 +779,14 @@ export function parseKiroApiEvents(buffer: string): { events: KiroStreamEvent[];
 						message: (parsed.message || parsed.Message) as string | undefined,
 					},
 				});
+			} else if (parsed.stopReason === "COMPLETED" || parsed.stopReason === "TOOL_USE") {
+				// Only accepted successful terminal reasons confirm buffered text.
+				events.push({
+					type: "completion",
+					data: {
+						stopReason: parsed.stopReason,
+					},
+				});
 			}
 		} catch {
 			// JSON parsing failed for a balanced frame: could be a junk wrapper like '{junk{...}}'
@@ -801,12 +999,42 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 			timestamp: Date.now(),
 		};
 		const blocks = output.content as Block[];
+		const snapshotOutput = (): AssistantMessage => ({
+			...output,
+			content: output.content.map(block => ({ ...block })),
+			usage: { ...output.usage, cost: { ...output.usage.cost } },
+		});
 
 		// Variables for streaming tool calls (initialized before try block so they're accessible in catch)
 		let currentTool: { id: string; name: string; input: string } | undefined;
 		let toolComplete = false; // Track whether the current tool has been completed (has stop flag)
-		let toolcallIndex: number | undefined;
 		const pendingToolCalls: Array<{ input: string; toolCall: ToolCall; index: number }> = [];
+		// Successful metadata fences later generation but text remains quarantined until clean EOF.
+		let completionSeen = false;
+		let completionStopReason: "COMPLETED" | "TOOL_USE" | undefined;
+		let textIndex: number | undefined; // Track text block index (accessible in catch)
+		let textContentConfirmed = false; // Track whether clean EOF committed text to blocks (accessible in catch)
+		let textStartDeferred = false; // Track if text_start is deferred (accessible in catch)
+		let pendingTextContent = ""; // Text buffer (accessible in catch)
+		const pendingTextEvents: Array<{ type: "start" | "delta" | "end"; delta?: string; content?: string }> = []; // Deferred text events (accessible in catch)
+		const removeUnconfirmedTextBlock = () => {
+			if (textContentConfirmed || textIndex === undefined) return;
+
+			const removedIndex = textIndex;
+			blocks.splice(removedIndex, 1);
+			for (let i = removedIndex; i < blocks.length; i++) {
+				const block = blocks[i] as Block;
+				if (block && typeof block === "object" && "index" in block) {
+					block.index = i;
+				}
+			}
+			for (const pending of pendingToolCalls) {
+				if (pending.index > removedIndex) pending.index--;
+			}
+			textIndex = undefined;
+			pendingTextContent = "";
+			pendingTextEvents.length = 0;
+		};
 
 		try {
 			// Use validated identity snapshot from trust check if available (no second read of getters),
@@ -873,13 +1101,14 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 			}
 			if (!response.body) throw new Error("Kiro API key response has no body");
 
-			stream.push({ type: "start", partial: output });
+			stream.push({ type: "start", partial: snapshotOutput() });
 			const reader = response.body.getReader();
 			const decoder = new TextDecoder();
 			let buffer = "";
 			let lastContent = "";
 			let thinkingIndex: number | undefined;
-			let textIndex: number | undefined;
+			// Note: textIndex, textContentConfirmed, textStartDeferred, pendingTextContent, pendingTextEvents
+			// are declared before the try block so they're accessible in the catch block
 
 			// Add tool to blocks without emitting events (deferred until stream end)
 			const addToolToBlocks = () => {
@@ -899,9 +1128,6 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 				};
 				const index = blocks.length;
 				blocks.push({ ...toolCall, index });
-				if (toolcallIndex === undefined) {
-					toolcallIndex = index;
-				}
 				const toolArgs =
 					typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
 						? (parsed as Record<string, unknown>)
@@ -938,8 +1164,6 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 				toolComplete = false; // Reset tool completion flag
 			};
 
-			let textStartDeferred = false; // Track if text_start has been deferred pending thinking
-
 			const appendText = (delta: string) => {
 				// Set firstTokenTime on first real (non-thinking) text delta
 				if (!firstTokenEmitted) {
@@ -951,51 +1175,70 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 				}
 				if (textIndex === undefined) {
 					textIndex = blocks.length;
+					// Create block with empty text (content will be added only after confirmation)
 					blocks.push({ type: "text", text: "", index: textIndex });
-					// Defer text_start emission if thinking might come before text.
-					// thinkingAccumulated is non-empty means we've seen thinking in this or prior content events.
-					// We don't know yet if more thinking will come, so defer text_start until stream end.
-					if (thinkingAccumulated.length === 0) {
-						// No thinking yet; safe to emit text_start now
-						stream.push({ type: "text_start", contentIndex: textIndex, partial: output });
-					} else {
-						// Thinking exists; defer text_start until we know thinking position
-						textStartDeferred = true;
-					}
-				}
-				const block = blocks[textIndex] as TextContent;
-				block.text += delta;
-				// Only emit text_delta if text_start was already emitted
-				if (!textStartDeferred) {
-					stream.push({ type: "text_delta", contentIndex: textIndex, delta, partial: output });
+					// ALWAYS defer text_start until clean EOF. Terminal metadata may be followed
+					// by a refusal in a later read, so it cannot safely publish text by itself.
+					textStartDeferred = true;
 				}
+				// Buffer text content separately (don't add to blocks yet)
+				pendingTextContent += delta;
+				// Don't emit text_delta yet; defer until stream end or terminal metadata is received.
+				// Queue delta for later emission when confirmed.
+				pendingTextEvents.push({ type: "delta", delta });
+			};
+
+			// Commit pending text to blocks only at clean EOF, when a later refusal is ruled out.
+			const commitPendingText = () => {
+				if (textContentConfirmed || pendingTextContent.length === 0) return; // Already committed or no text
+				textContentConfirmed = true;
+				// Note: we don't populate block.text here to avoid it appearing in previously emitted events
+				// The text will be populated after text_start is emitted in emitDeferredTextEvents
 			};
 
 			// Emit deferred text events if text_start was not yet sent
 			const emitDeferredTextEvents = () => {
 				if (textStartDeferred && textIndex !== undefined && textIndex < blocks.length) {
 					const block = blocks[textIndex];
-					if (block && block.type === "text") {
-						stream.push({ type: "text_start", contentIndex: textIndex, partial: output });
-						if (block.text.length > 0) {
-							stream.push({
-								type: "text_delta",
-								contentIndex: textIndex,
-								delta: block.text,
-								partial: output,
-							});
+					// Only emit text events if we have pending text content and it's been confirmed
+					if (block && block.type === "text" && pendingTextContent.length > 0 && textContentConfirmed) {
+						// Emit text_start WITHOUT populating block.text yet
+						// This ensures previously emitted events (like start) see the block as empty
+						stream.push({ type: "text_start", contentIndex: textIndex, partial: snapshotOutput() });
+						// Emit all pending text_delta events WITHOUT populating block.text yet
+						// (The text will be populated later when text_end is emitted or at EOF)
+						for (const evt of pendingTextEvents) {
+							if (evt.type === "delta" && evt.delta) {
+								stream.push({
+									type: "text_delta",
+									contentIndex: textIndex,
+									delta: evt.delta,
+									partial: snapshotOutput(),
+								});
+							}
 						}
-						textStartDeferred = false;
 					}
+					textStartDeferred = false;
 				}
 			};
 
 			// Emit text_end if text block was opened
 			const closeTextBlock = () => {
-				if (textIndex !== undefined) {
+				if (textIndex !== undefined && textContentConfirmed) {
 					const block = blocks[textIndex] as TextContent;
-					stream.push({ type: "text_end", contentIndex: textIndex, content: block.text, partial: output });
+					// Ensure text is populated before emitting text_end
+					if (block.text.length === 0 && pendingTextContent.length > 0) {
+						block.text = pendingTextContent;
+					}
+					stream.push({
+						type: "text_end",
+						contentIndex: textIndex,
+						content: block.text,
+						partial: snapshotOutput(),
+					});
 					textIndex = undefined;
+					pendingTextContent = "";
+					pendingTextEvents.length = 0;
 				}
 			};
 
@@ -1063,7 +1306,6 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 						}
 						// Update state tracking variables for shifted blocks
 						if (textIndex !== undefined) textIndex += 1;
-						if (toolcallIndex !== undefined) toolcallIndex += 1;
 						// Update indices in pending tool calls since all blocks shifted by 1
 						for (const pending of pendingToolCalls) {
 							pending.index += 1;
@@ -1098,6 +1340,21 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 				const hasTerminalEvent = events.some(e => e.type === "refusal");
 
 				for (const event of events) {
+					const isActiveToolContinuation =
+						currentTool !== undefined &&
+						completionStopReason === "TOOL_USE" &&
+						!toolComplete &&
+						(event.type === "toolUseInput" ||
+							event.type === "toolUseStop" ||
+							(event.type === "toolUse" && event.data.toolUseId === currentTool.id));
+					if (
+						completionSeen &&
+						(event.type === "content" ||
+							((event.type === "toolUse" || event.type === "toolUseInput" || event.type === "toolUseStop") &&
+								!isActiveToolContinuation))
+					) {
+						continue;
+					}
 					if (event.type === "content") {
 						if (!hasTerminalEvent) {
 							if (event.data === lastContent) continue;
@@ -1110,7 +1367,12 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 								firstTokenEmitted = true;
 								firstTokenTime = Date.now();
 							}
-							if (currentTool && currentTool.id !== event.data.toolUseId) addToolToBlocks();
+							if (currentTool && currentTool.id !== event.data.toolUseId) {
+								// Only emit previous tool if it was completed
+								if (toolComplete) addToolToBlocks();
+								currentTool = undefined; // Clear the incomplete tool
+								toolComplete = false; // Reset for new tool
+							}
 							if (!currentTool) {
 								currentTool = { id: event.data.toolUseId, name: event.data.name, input: event.data.input };
 								toolComplete = false; // New tool starts as incomplete
@@ -1128,26 +1390,34 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 							firstTokenTime = Date.now();
 						}
 						currentTool.input += event.data.input;
-					} else if (event.type === "toolUseStop" && event.data.stop) {
+					} else if (event.type === "toolUseStop" && event.data.stop && !hasTerminalEvent) {
 						toolComplete = true; // Mark tool as complete when toolUseStop is received
 						addToolToBlocks();
 					} else if (event.type === "usage") {
 						if (event.data.inputTokens !== undefined) output.usage.input = event.data.inputTokens;
 						if (event.data.outputTokens !== undefined) output.usage.output = event.data.outputTokens;
 						output.usage.totalTokens = output.usage.input + output.usage.output;
+					} else if (event.type === "completion" && !hasTerminalEvent) {
+						// Successful terminal metadata fences later generation. Keep text quarantined
+						// until clean EOF so a later refusal cannot depend on HTTP chunk boundaries.
+						completionSeen = true;
+						completionStopReason = event.data.stopReason;
 					} else if (event.type === "refusal") {
 						const refusalData = event.data as {
 							stopReason?: string;
 							stopDetails?: { refusal?: { category?: string; explanation?: string } };
 						};
-						if (refusalData.stopDetails?.refusal) {
-							// Handle refusal: clear blocks and emit error (don't emit any text/tool that came before)
+						if (refusalData.stopDetails?.refusal || refusalData.stopReason === "CONTENT_FILTERED") {
+							// Handle refusal: clear pending content and emit error (don't emit any text/tool that came before)
 							consumeContent(""); // Flush any pending thinking
 							clearPendingToolCalls(); // DROP any pending tool call without emitting events
+							// Clear pending text (it was never committed to blocks, so it's safe to discard)
+							pendingTextContent = "";
+							pendingTextEvents.length = 0;
 
-							const refusal = refusalData.stopDetails.refusal;
-							const category = refusal.category;
-							const explanation = refusal.explanation?.trim();
+							const refusal = refusalData.stopDetails?.refusal;
+							const category = refusal?.category;
+							const explanation = refusal?.explanation?.trim();
 							const label = category ? `Kiro refused the request (${category})` : "Kiro refused the request";
 
 							output.stopReason = "error";
@@ -1181,27 +1451,34 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 							stream.end();
 							return;
 						}
-					} else if (event.type === "error") {
-						// On ordinary errors, flush pending COMPLETED tool events before the error terminal
-						// (refusals drop them, incomplete tools must not be emitted)
-						// Only emit the tool if it was explicitly completed (has stop flag)
+					} else if (event.type === "error" && !hasTerminalEvent) {
+						// An ordinary error is not clean EOF, so keep quarantined text private.
+
+						// Preserve only tools that were explicitly completed (have a stop flag).
 						if (toolComplete) addToolToBlocks();
+						removeUnconfirmedTextBlock();
 						emitPendingToolCalls();
 
-						// Preserve any already-accumulated text in the error context
-						const accumulatedText = blocks
-							.filter((b): b is TextContent => b.type === "text")
-							.map(b => b.text)
-							.join("");
 						const errorMsg = sanitizeKiroError(`${event.data.error}: ${event.data.message ?? ""}`, apiKey);
-						const fullErrorMsg = accumulatedText ? `${errorMsg}\n\nPartial output: ${accumulatedText}` : errorMsg;
-						throw new Error(fullErrorMsg);
+						throw new Error(errorMsg);
 					}
 				}
 			}
 
-			// Stream is done - add any pending tool, emit accumulated thinking, then deferred text, then close text block
-			addToolToBlocks();
+			// Check for incomplete JSON frame in leftover buffer at EOF
+			if (buffer.trim().length > 0) {
+				// Non-whitespace content remains in buffer
+				const openBraceIdx = buffer.indexOf("{");
+				if (openBraceIdx >= 0 && findJsonEnd(buffer, openBraceIdx) < 0) {
+					// Incomplete JSON frame at EOF (opening brace with no matching close)
+					throw new Error(`Kiro API key stream truncated: incomplete JSON frame at EOF`);
+				}
+			}
+
+			// Clean EOF rules out a later refusal, so pending text can now be published.
+			commitPendingText();
+			// Emit tool only if explicitly completed (has stop flag); incomplete tools are discarded at EOF
+			if (currentTool && toolComplete) addToolToBlocks();
 			emitThinking();
 			emitDeferredTextEvents();
 			// Now emit all tool call events in order (safe since no refusal occurred)
@@ -1237,10 +1514,44 @@ export const streamKiroApiKey: StreamFunction<"kiro-codewhisperer-stream"> = (
 			stream.push({ type: "done", reason: output.stopReason as "stop" | "toolUse", message: output });
 			stream.end();
 		} catch (error) {
-			// On ordinary errors (including reader.read() throws), emit only COMPLETED tool events
-			// before the error terminal (same semantics as the ordinary-error flush in the event loop).
-			// Incomplete currentTool is NOT finalized/emitted (only completed tools in pendingToolCalls flush).
-			// Refusals drop them via clearPendingToolCalls, but ordinary errors preserve content consistency.
+			// On ordinary errors (including reader.read() throws):
+			// - Emit COMPLETED tool events (same semantics as in the event processing loop)
+			// - Emit text only if clean EOF already confirmed it
+			// - Incomplete currentTool is NOT finalized/emitted (only completed tools in pendingToolCalls flush).
+			// - Unconfirmed text is suppressed (terminal metadata alone does not rule out a later refusal)
+
+			if (textContentConfirmed && textIndex !== undefined && textIndex < blocks.length) {
+				const block = blocks[textIndex];
+				if (block && block.type === "text") {
+					if (textStartDeferred && pendingTextContent.length > 0) {
+						stream.push({ type: "text_start", contentIndex: textIndex, partial: snapshotOutput() });
+						// Emit all pending text_delta events
+						for (const evt of pendingTextEvents) {
+							if (evt.type === "delta" && evt.delta) {
+								stream.push({
+									type: "text_delta",
+									contentIndex: textIndex,
+									delta: evt.delta,
+									partial: snapshotOutput(),
+								});
+							}
+						}
+					}
+					if (block.text.length === 0 && pendingTextContent.length > 0) block.text = pendingTextContent;
+					stream.push({
+						type: "text_end",
+						contentIndex: textIndex,
+						content: block.text,
+						partial: snapshotOutput(),
+					});
+				}
+				textIndex = undefined;
+				pendingTextContent = "";
+				pendingTextEvents.length = 0;
+				textStartDeferred = false;
+			}
+
+			removeUnconfirmedTextBlock();
 
 			// Emit all pending tool call events (inline of emitPendingToolCalls logic)
 			for (const { input, toolCall, index } of pendingToolCalls) {