@gajae-code/ai 0.11.0 → 0.11.2

package/src/providers/openai-chat-server.ts

@@ -14,6 +14,7 @@ import type {
 	ResolvedServiceTier,
 	StopReason,
 	TextContent,
+	ThinkingContent,
 	Tool,
 	ToolCall,
 	ToolResultMessage,
@@ -416,6 +417,29 @@ function buildUsage(message: AssistantMessage): Record<string, unknown> {
 	return usage;
 }
 
+function isResponsesFamilyApi(api: AssistantMessage["api"]): boolean {
+	return api === "openai-responses" || api === "openai-codex-responses";
+}
+
+function safeThinkingText(content: ThinkingContent, api: AssistantMessage["api"]): string | undefined {
+	if (isResponsesFamilyApi(api) && content.provenance === undefined) return undefined;
+	if (content.provenance === "raw") return undefined;
+	if (content.provenance === "mixed") return content.summaryText;
+	if (content.provenance === "summary") return content.summaryText ?? content.thinking;
+	return content.thinking;
+}
+
+function hasRawOrMixedThinking(partial: AssistantMessage, contentIndex: number): boolean {
+	const content = partial.content[contentIndex];
+	return content?.type === "thinking" && (content.provenance === "raw" || content.provenance === "mixed");
+}
+
+/** Responses-family reasoning is untrusted until output_item.done assigns provenance. */
+function hasUnfinalizedResponsesThinking(partial: AssistantMessage, contentIndex: number): boolean {
+	const content = partial.content[contentIndex];
+	return content?.type !== "thinking" || (isResponsesFamilyApi(partial.api) && content.provenance === undefined);
+}
+
 function flattenAssistant(message: AssistantMessage): {
 	text: string;
 	reasoning: string;
@@ -429,9 +453,11 @@ function flattenAssistant(message: AssistantMessage): {
 			case "text":
 				text += part.text;
 				break;
-			case "thinking":
-				reasoning += part.thinking;
+			case "thinking": {
+				const thinking = safeThinkingText(part, message.api);
+				if (thinking !== undefined) reasoning += thinking;
 				break;
+			}
 			case "redactedThinking":
 				// Opaque blob — surface verbatim on the reasoning channel so the
 				// concatenation round-trips through clients that just echo it.
@@ -521,6 +547,18 @@ export function encodeStream(
 			let nextToolIndex = 0;
 			let hasToolCalls = false;
 			let finishReason: string = "stop";
+			// contentIndexes that already streamed a reasoning summary delta, so a
+			// final-only reasoning_summary_end does not duplicate streamed summary text.
+			const summaryDeltaSeen = new Set<number>();
+			// Responses assigns reasoning provenance only at output_item.done. Keep its
+			// pre-classification bytes out of this public compatibility stream.
+			const pendingThinkingDeltas = new Map<number, string[]>();
+
+			const writeThinkingDelta = (thinking: string) => {
+				// DeepSeek-style / o-series reasoning channel. Clients that don't
+				// understand it ignore the unknown delta key.
+				if (thinking.length > 0) writeSse(controller, baseChunk({ reasoning_content: thinking }, null));
+			};
 
 			try {
 				// Initial role chunk.
@@ -534,14 +572,60 @@ export function encodeStream(
 							}
 							break;
 
-						case "thinking_delta":
-							// DeepSeek-style / o-series reasoning channel. Clients that don't
-							// understand it ignore the unknown delta key.
+						case "thinking_delta": {
+							if (hasRawOrMixedThinking(event.partial, event.contentIndex)) break;
+							if (hasUnfinalizedResponsesThinking(event.partial, event.contentIndex)) {
+								const deltas = pendingThinkingDeltas.get(event.contentIndex) ?? [];
+								deltas.push(event.delta);
+								pendingThinkingDeltas.set(event.contentIndex, deltas);
+								break;
+							}
+							writeThinkingDelta(event.delta);
+							break;
+						}
+						case "thinking_start":
+							if (
+								!hasRawOrMixedThinking(event.partial, event.contentIndex) &&
+								hasUnfinalizedResponsesThinking(event.partial, event.contentIndex)
+							) {
+								pendingThinkingDeltas.set(event.contentIndex, []);
+							}
+							break;
+						case "thinking_end": {
+							const pending = pendingThinkingDeltas.get(event.contentIndex);
+							pendingThinkingDeltas.delete(event.contentIndex);
+							if (
+								hasRawOrMixedThinking(event.partial, event.contentIndex) ||
+								hasUnfinalizedResponsesThinking(event.partial, event.contentIndex)
+							)
+								break;
+							if (pending) for (const delta of pending) writeThinkingDelta(delta);
+							break;
+						}
+						case "reasoning_summary_start":
+							// Chat format has no explicit reasoning open frame.
+							break;
+
+						case "reasoning_summary_delta":
+							// Provider-displayable summary reasoning surfaces on the same
+							// reasoning_content channel as raw thinking for this legacy format.
 							if (event.delta.length > 0) {
+								// Only a non-whitespace delta counts as a delivered summary; a bare
+								// separator ("\n\n") must not suppress a later final-only end content.
+								if (event.delta.trim().length > 0) summaryDeltaSeen.add(event.contentIndex);
 								writeSse(controller, baseChunk({ reasoning_content: event.delta }, null));
 							}
 							break;
 
+						case "reasoning_summary_end":
+							// Final-only summary: text arrives only on the end event with no prior
+							// deltas, so surface it now (skip when deltas already streamed to avoid
+							// duplicating the summary).
+							if (event.content.length > 0 && !summaryDeltaSeen.has(event.contentIndex)) {
+								writeSse(controller, baseChunk({ reasoning_content: event.content }, null));
+							}
+							break;
+
 						case "toolcall_start": {
 							hasToolCalls = true;
 							const idx = nextToolIndex++;
@@ -578,6 +662,7 @@ export function encodeStream(
 						}
 
 						case "done":
+							pendingThinkingDeltas.clear();
 							finishReason =
 								event.reason === "toolUse"
 									? "tool_calls"
@@ -593,6 +678,7 @@ export function encodeStream(
 							return;
 
 						case "error": {
+							pendingThinkingDeltas.clear();
 							const msg = event.error.errorMessage ?? "stream error";
 							writeSse(controller, { error: { message: msg, type: "upstream_error" } });
 							controller.close();
@@ -607,10 +693,12 @@ export function encodeStream(
 				}
 
 				// Stream ended without a terminal `done` (defensive). Close gracefully.
+				pendingThinkingDeltas.clear();
 				writeSse(controller, baseChunk({}, hasToolCalls ? "tool_calls" : "stop"));
 				controller.enqueue(encoder.encode("data: [DONE]\n\n"));
 				controller.close();
 			} catch (err) {
+				pendingThinkingDeltas.clear();
 				const msg = err instanceof Error ? err.message : String(err);
 				writeSse(controller, { error: { message: msg, type: "upstream_error" } });
 				controller.close();

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

@@ -113,9 +113,15 @@ const CODEX_NON_RETRYABLE_EVENT_CODES = new Set([
 	"invalid_request_error",
 	"invalid_schema",
 	"invalid_tool_schema",
+	// A poisoned-history rejection (`Request blocked (code=invalid_prompt)`) is a
+	// deterministic content fault, not a transient upstream failure: retrying the
+	// same request re-sends the same offending item and re-triggers the block, so
+	// classify it as explicitly non-retryable instead of relying on omission
+	// (the request-boundary sanitizer, not a provider retry, is the recovery path).
+	"invalid_prompt",
 ]);
 const CODEX_NON_RETRYABLE_EVENT_MESSAGE =
-	/invalid[_ -]function[_ -]parameters|invalid schema for function|invalid[_ -]tool[_ -]schema|schema must have type ["']?object["']?/i;
+	/invalid[_ -]function[_ -]parameters|invalid schema for function|invalid[_ -]tool[_ -]schema|schema must have type ["']?object["']?|request blocked[^\n]*invalid[_ -]prompt|code=invalid[_ -]prompt/i;
 const CODEX_RETRYABLE_EVENT_MESSAGE =
 	/processing your request|retry your request|temporar(?:y|ily)|overloaded|service.?unavailable|internal error|server error/i;
 const CODEX_PROVIDER_SESSION_STATE_KEY = "openai-codex-responses";
@@ -133,6 +139,7 @@ const CODEX_PROGRESS_EVENT_TYPES = new Set([
 	"response.reasoning_summary_part.added",
 	"response.reasoning_summary_text.delta",
 	"response.reasoning_summary_part.done",
+	"response.reasoning_text.delta",
 	"response.content_part.added",
 	"response.output_text.delta",
 	"response.refusal.delta",
@@ -155,8 +162,8 @@ function isCodexStreamProgressEvent(event: unknown): boolean {
 }
 type CodexTransport = "sse" | "websocket";
 type CodexEventItem = ResponseReasoningItem | ResponseOutputMessage | ResponseFunctionToolCall | ResponseCustomToolCall;
-type CodexOutputBlock = ThinkingContent | TextContent | (ToolCall & { partialJson: string });
-
+type CodexThinkingBlock = ThinkingContent & { summaryBuffer: string; rawBuffer: string; summaryStarted: boolean };
+type CodexOutputBlock = CodexThinkingBlock | TextContent | (ToolCall & { partialJson: string });
 export interface OpenAICodexWebSocketDebugStats {
 	fullContextRequests: number;
 	deltaRequests: number;
@@ -995,6 +1002,11 @@ function handleCodexStreamEvent(args: {
 		return firstTokenTime;
 	}
 
+	if (eventType === "response.reasoning_text.delta") {
+		handleReasoningTextDelta(runtime.currentItem, runtime.currentBlock, rawEvent, stream, output, blockIndex);
+		return firstTokenTime;
+	}
+
 	if (eventType === "response.content_part.added") {
 		handleContentPartAdded(runtime.currentItem, rawEvent);
 		return firstTokenTime;
@@ -1069,7 +1081,7 @@ function handleCodexStreamEvent(args: {
 
 function createOutputBlockForItem(item: CodexEventItem): CodexOutputBlock | null {
 	if (item.type === "reasoning") {
-		return { type: "thinking", thinking: "" };
+		return { type: "thinking", thinking: "", summaryBuffer: "", rawBuffer: "", summaryStarted: false };
 	}
 	if (item.type === "message") {
 		return { type: "text", text: "" };
@@ -1120,13 +1132,18 @@ function handleReasoningSummaryTextDelta(
 	blockIndex: () => number,
 ): void {
 	if (currentItem?.type !== "reasoning" || currentBlock?.type !== "thinking") return;
+	if (!currentBlock.summaryStarted) {
+		currentBlock.summaryStarted = true;
+		stream.push({ type: "reasoning_summary_start", contentIndex: blockIndex(), partial: output });
+	}
 	currentItem.summary = currentItem.summary || [];
 	const lastPart = currentItem.summary[currentItem.summary.length - 1];
 	if (!lastPart) return;
 	const delta = (rawEvent as { delta?: string }).delta || "";
 	currentBlock.thinking += delta;
+	currentBlock.summaryBuffer += delta;
 	lastPart.text += delta;
-	stream.push({ type: "thinking_delta", contentIndex: blockIndex(), delta, partial: output });
+	stream.push({ type: "reasoning_summary_delta", contentIndex: blockIndex(), delta, partial: output });
 }
 
 function handleReasoningSummaryPartDone(
@@ -1141,8 +1158,24 @@ function handleReasoningSummaryPartDone(
 	const lastPart = currentItem.summary[currentItem.summary.length - 1];
 	if (!lastPart) return;
 	currentBlock.thinking += "\n\n";
+	currentBlock.summaryBuffer += "\n\n";
 	lastPart.text += "\n\n";
-	stream.push({ type: "thinking_delta", contentIndex: blockIndex(), delta: "\n\n", partial: output });
+	stream.push({ type: "reasoning_summary_delta", contentIndex: blockIndex(), delta: "\n\n", partial: output });
+}
+
+function handleReasoningTextDelta(
+	currentItem: CodexEventItem | null,
+	currentBlock: CodexOutputBlock | null,
+	rawEvent: Record<string, unknown>,
+	stream: AssistantMessageEventStream,
+	output: AssistantMessage,
+	blockIndex: () => number,
+): void {
+	if (currentItem?.type !== "reasoning" || currentBlock?.type !== "thinking") return;
+	const delta = (rawEvent as { delta?: string }).delta || "";
+	currentBlock.thinking += delta;
+	currentBlock.rawBuffer += delta;
+	stream.push({ type: "thinking_delta", contentIndex: blockIndex(), delta, partial: output });
 }
 
 function handleContentPartAdded(currentItem: CodexEventItem | null, rawEvent: Record<string, unknown>): void {
@@ -1245,14 +1278,50 @@ function handleOutputItemDone(
 	runtime.nativeOutputItems.push(item as unknown as Record<string, unknown>);
 
 	if (item.type === "reasoning" && runtime.currentBlock?.type === "thinking") {
-		runtime.currentBlock.thinking = item.summary?.map(summary => summary.text).join("\n\n") || "";
-		runtime.currentBlock.thinkingSignature = JSON.stringify(item);
-		stream.push({
-			type: "thinking_end",
-			contentIndex: blockIndex(),
-			content: runtime.currentBlock.thinking,
-			partial: output,
-		});
+		const block = runtime.currentBlock;
+		// Prefer the streamed summary buffer only when it carries real text; a
+		// part.done before/without any summary_text delta leaves only separators, so
+		// fall back to the canonical item.summary from output_item.done (matches the
+		// shared Responses decoder).
+		const bufferSummary = block.summaryBuffer ?? "";
+		const itemSummary = item.summary?.map(summary => summary.text).join("\n\n") ?? "";
+		const summaryText = bufferSummary.trim() ? bufferSummary : itemSummary;
+		const rawText = block.rawBuffer;
+		const mutable = block as { provenance?: "summary" | "raw" | "mixed"; summaryText?: string; rawText?: string };
+		if (mutable.provenance === undefined) {
+			if (mutable.summaryText === undefined && summaryText) mutable.summaryText = summaryText;
+			if (mutable.rawText === undefined && rawText) mutable.rawText = rawText;
+			mutable.provenance = summaryText && rawText ? "mixed" : summaryText ? "summary" : rawText ? "raw" : undefined;
+		}
+		// Finalized display string must exclude raw CoT when a summary exists (parity
+		// with openai-responses-shared). Derive from STORED write-once provenance fields
+		// so a later/duplicate raw-only finalization cannot overwrite a summary/mixed
+		// block's safe display with raw CoT; raw-only stays raw.
+		{
+			const effSummary = mutable.summaryText ?? summaryText;
+			const effRaw = mutable.rawText ?? rawText;
+			block.thinking = mutable.provenance === "raw" ? effRaw : effSummary || effRaw;
+		}
+		block.thinkingSignature = JSON.stringify(item);
+		delete (block as { summaryBuffer?: string }).summaryBuffer;
+		delete (block as { rawBuffer?: string }).rawBuffer;
+		const wasSummaryStarted = block.summaryStarted;
+		delete (block as { summaryStarted?: boolean }).summaryStarted;
+		if (summaryText) {
+			// Emit a summary start first when none was streamed (part.added/done or
+			// canonical done-item summary with no summary_text delta), so consumers that
+			// open a summary on start don't receive an orphaned reasoning_summary_end.
+			if (!wasSummaryStarted) {
+				stream.push({ type: "reasoning_summary_start", contentIndex: blockIndex(), partial: output });
+			}
+			stream.push({
+				type: "reasoning_summary_end",
+				contentIndex: blockIndex(),
+				content: summaryText,
+				partial: output,
+			});
+		}
+		stream.push({ type: "thinking_end", contentIndex: blockIndex(), content: block.thinking, partial: output });
 		runtime.currentBlock = null;
 		return;
 	}
@@ -2650,8 +2719,11 @@ function normalizeInputMessageContent(
 	return convertResponsesInputContent(content, model.input.includes("image")) ?? [];
 }
 
-/** @internal Exported for tests. */
-export { convertMessages as convertCodexResponsesMessages };
+/** @internal Exported for tests. `classifyCodexFailureEventRetryable` is the retry classification of a Codex failure event. */
+export {
+	convertMessages as convertCodexResponsesMessages,
+	isRetryableCodexFailureEvent as classifyCodexFailureEventRetryable,
+};
 
 /**
  * Whether this OpenAI code backend-backend model should get the custom-tool grammar

package/src/providers/openai-responses-server.ts

@@ -95,12 +95,20 @@ let warnedReasoningSummaryLevel = false;
 
 // ─── inbound parser helpers ─────────────────────────────────────────────────
 
-function extractReasoningTextFromItem(item: OpenAIResponsesReasoningItem): string {
-	// Prefer `summary[]` — mirrors real OpenAI and the openai-responses provider
-	// which writes the surfaced reasoning summary into `summary[].text`.
-	const fromSummary = (item.summary ?? []).map(c => c.text).join("");
-	if (fromSummary) return fromSummary;
-	return (item.content ?? []).map(c => c.text).join("");
+function reasoningContentFromItem(
+	item: OpenAIResponsesReasoningItem,
+): Pick<ThinkingContent, "thinking" | "provenance" | "summaryText" | "rawText"> {
+	// `summary[]` is provider-displayable; `content[]` is raw reasoning. Keep
+	// these channels distinct so a Responses gateway round-trip cannot relabel
+	// raw CoT as a summary merely because summary text is absent.
+	const summaryText = (item.summary ?? []).map(part => part.text).join("");
+	const rawText = (item.content ?? []).map(part => part.text).join("");
+	if (summaryText && rawText) {
+		return { thinking: summaryText, provenance: "mixed", summaryText, rawText };
+	}
+	if (summaryText) return { thinking: summaryText, provenance: "summary", summaryText };
+	if (rawText) return { thinking: rawText, provenance: "raw", rawText };
+	return { thinking: "" };
 }
 
 type InputBlockUnion =
@@ -335,10 +343,10 @@ export function parseRequest(body: unknown, headers?: Headers): ParsedRequest {
 			}
 			if (effectiveType === "reasoning") {
 				const reasoning = item as OpenAIResponsesReasoningItem;
-				const text = extractReasoningTextFromItem(reasoning);
+				const content = reasoningContentFromItem(reasoning);
 				const thinking: ThinkingContent = {
 					type: "thinking",
-					thinking: text,
+					...content,
 					thinkingSignature: JSON.stringify(reasoning),
 					...(reasoning.id ? { itemId: reasoning.id } : {}),
 				};
@@ -538,6 +546,41 @@ function responseStatusForStopReason(message: AssistantMessage): ResponseStatus
 	return "completed";
 }
 
+/**
+ * Privacy boundary for the public Responses envelope: a reasoning item's
+ * `summary_text` must carry ONLY provider-displayable summary text, never raw
+ * chain-of-thought. A summary is published ONLY for blocks explicitly marked
+ * `provenance: "summary" | "mixed"` (the #2304 provenance path), sourced from
+ * `summaryText`. Raw-provenance AND unmarked blocks are omitted: unmarked
+ * `thinking` can be raw CoT from providers that stream unmarked reasoning (e.g.
+ * openai-completions / ollama) which the auth gateway re-encodes into the
+ * Responses wire format, so falling open to `part.thinking` would leak raw CoT.
+ */
+function envelopeSummaryText(part: ThinkingContent): string | undefined {
+	if (part.provenance === "summary" || part.provenance === "mixed") return part.summaryText;
+	return undefined;
+}
+
+function envelopeSummaryParts(part: ThinkingContent): Array<{ type: "summary_text"; text: string }> {
+	const text = envelopeSummaryText(part);
+	return text ? [{ type: "summary_text", text }] : [];
+}
+
+function normalizeSummaryParts(value: unknown): Array<{ type: "summary_text"; text: string }> {
+	// A serialized signature's `summary` is, by the Responses protocol, provider-
+	// displayable summary text (raw reasoning lives in content[]/encrypted_content,
+	// which is stripped). Coerce to the canonical shape, keeping only well-formed
+	// summary_text entries. This is NOT the unsafe `part.thinking` fallback.
+	if (!Array.isArray(value)) return [];
+	const out: Array<{ type: "summary_text"; text: string }> = [];
+	for (const entry of value) {
+		if (isObj(entry) && entry.type === "summary_text" && typeof entry.text === "string") {
+			out.push({ type: "summary_text", text: entry.text });
+		}
+	}
+	return out;
+}
+
 function buildReasoningItem(part: ThinkingContent): ReasoningOutputItem {
 	const baseId = part.itemId ?? makeReasoningId();
 	if (part.thinkingSignature) {
@@ -548,10 +591,15 @@ function buildReasoningItem(part: ThinkingContent): ReasoningOutputItem {
 				// Preserve any extra fields (encrypted_content, …) the original carried,
 				// but normalize the summary into the canonical `{type, text}[]` shape.
 				const merged: Record<string, unknown> = { ...sigParsed, type: "reasoning", id };
-				merged.summary = [{ type: "summary_text", text: part.thinking }];
-				// `content[]` is the encrypted/raw side-channel; leave whatever was
-				// already there. If absent, omit — real OpenAI only emits `content[]`
-				// when `include=['reasoning.encrypted_content']` is set.
+				merged.summary =
+					part.provenance === "summary" || part.provenance === "mixed"
+						? envelopeSummaryParts(part)
+						: normalizeSummaryParts(sigParsed.summary);
+				// Strip any `content[]` (raw `reasoning_text`) the serialized signature
+				// carried: raw chain-of-thought must never surface in the public final
+				// envelope (#2304 CoT boundary). Opaque top-level `encrypted_content`
+				// (when present) is a separate field and is preserved by the spread above.
+				delete merged.content;
 				return merged as ReasoningOutputItem;
 			}
 		} catch {
@@ -561,7 +609,7 @@ function buildReasoningItem(part: ThinkingContent): ReasoningOutputItem {
 	return {
 		type: "reasoning",
 		id: baseId,
-		summary: [{ type: "summary_text", text: part.thinking }],
+		summary: envelopeSummaryParts(part),
 	};
 }
 
@@ -701,7 +749,8 @@ interface OpenReasoning {
 	kind: "reasoning";
 	itemId: string;
 	outputIndex: number;
-	reasoningText: string;
+	summaryText: string;
+	summaryPartText: string;
 }
 interface OpenFunctionCall {
 	kind: "function_call";
@@ -781,16 +830,13 @@ export function encodeStream(
 					summary: [] as Array<{ type: "summary_text"; text: string }>,
 				};
 				emit("response.output_item.added", { output_index: outputIndex, item });
-				// Open the summary part. Real OpenAI streams summary text in the
-				// canonical `reasoning_summary_*` lifecycle; pi-ai's own decoder
-				// reads `summary[].text` from the eventual `output_item.done`.
-				emit("response.reasoning_summary_part.added", {
-					item_id: itemId,
-					output_index: outputIndex,
-					summary_index: 0,
-					part: { type: "summary_text", text: "" },
-				});
-				const next: OpenReasoning = { kind: "reasoning", itemId, outputIndex, reasoningText: "" };
+				const next: OpenReasoning = {
+					kind: "reasoning",
+					itemId,
+					outputIndex,
+					summaryText: "",
+					summaryPartText: "",
+				};
 				state.open = next;
 				return next;
 			};
@@ -856,18 +902,21 @@ export function encodeStream(
 						content: state.open.content,
 					});
 				} else if (state.open.kind === "reasoning") {
-					const summary = [{ type: "summary_text" as const, text: state.open.reasoningText ?? "" }];
-					const item = {
+					const summary = state.open.summaryText
+						? [{ type: "summary_text" as const, text: state.open.summaryText }]
+						: [];
+					// Final reasoning envelope carries the displayable summary ONLY. Raw
+					// chain-of-thought is streamed live via response.reasoning_text.delta
+					// (the internal raw channel) and is deliberately NOT persisted into the
+					// terminal item's content[] — the public final envelope must never carry
+					// raw CoT (#2304 CoT boundary).
+					const item: ReasoningOutputItem = {
 						type: "reasoning",
 						id: state.open.itemId,
 						summary,
 					};
 					emit("response.output_item.done", { output_index: state.open.outputIndex, item });
-					finishedItems.push({
-						type: "reasoning",
-						id: state.open.itemId,
-						summary,
-					});
+					finishedItems.push(item);
 				} else {
 					const text = state.open.argsText ?? "";
 					if (state.open.customWireName) {
@@ -1006,9 +1055,34 @@ export function encodeStream(
 							break;
 						}
 						case "thinking_delta": {
+							// Raw reasoning is private. The public Responses gateway emits only
+							// provider-displayable reasoning_summary_* events.
+							break;
+						}
+						case "thinking_end": {
+							if (state.open?.kind !== "reasoning") break;
+							// Raw reasoning is intentionally omitted from every public gateway
+							// frame. Only reasoning_summary_* events populate the terminal item.
+							closeOpen();
+							break;
+						}
+						case "reasoning_summary_start": {
 							if (state.open?.kind !== "reasoning") break;
 							const cur: OpenReasoning = state.open;
-							cur.reasoningText += ev.delta;
+							cur.summaryPartText = "";
+							emit("response.reasoning_summary_part.added", {
+								item_id: cur.itemId,
+								output_index: cur.outputIndex,
+								summary_index: 0,
+								part: { type: "summary_text", text: "" },
+							});
+							break;
+						}
+						case "reasoning_summary_delta": {
+							if (state.open?.kind !== "reasoning") break;
+							const cur: OpenReasoning = state.open;
+							cur.summaryPartText += ev.delta;
+							cur.summaryText += ev.delta;
 							emit("response.reasoning_summary_text.delta", {
 								item_id: cur.itemId,
 								output_index: cur.outputIndex,
@@ -1017,11 +1091,13 @@ export function encodeStream(
 							});
 							break;
 						}
-						case "thinking_end": {
+						case "reasoning_summary_end": {
 							if (state.open?.kind !== "reasoning") break;
 							const cur: OpenReasoning = state.open;
-							const text = ev.content ?? cur.reasoningText;
-							cur.reasoningText = text;
+							const text = ev.content ?? cur.summaryPartText;
+							// A separator-only accumulated summary (e.g. a part.done "\n\n" before any
+							// real text) is treated as empty so the real end content wins.
+							if (!cur.summaryText.trim()) cur.summaryText = text;
 							emit("response.reasoning_summary_text.done", {
 								item_id: cur.itemId,
 								output_index: cur.outputIndex,
@@ -1034,7 +1110,6 @@ export function encodeStream(
 								summary_index: 0,
 								part: { type: "summary_text", text },
 							});
-							closeOpen();
 							break;
 						}
 						case "toolcall_start": {