@sayknow-cli/ai 0.2.3 → 0.2.5

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

@@ -27,7 +27,7 @@ import {
 	iterateWithIdleTimeout,
 } from "../utils/idle-iterator";
 import { resolveRetryBudget } from "../utils/retry-budget";
-import { sanitizeSchemaForOpenAIResponses, toolWireSchema } from "../utils/schema";
+import { flattenToolRootCombinators, sanitizeSchemaForOpenAIResponses, toolWireSchema } from "../utils/schema";
 import { wrapFetchForSseDebug } from "../utils/sse-debug";
 import { mapToOpenAIResponsesToolChoice } from "../utils/tool-choice";
 import {
@@ -373,7 +373,7 @@ function convertTools(tools: Tool[]): OpenAITool[] {
 		type: "function",
 		name: tool.name,
 		description: tool.description || "",
-		parameters: sanitizeSchemaForOpenAIResponses(toolWireSchema(tool)),
+		parameters: sanitizeSchemaForOpenAIResponses(flattenToolRootCombinators(toolWireSchema(tool))),
 		strict: false,
 	}));
 }

package/src/providers/cursor.ts

@@ -29,7 +29,7 @@ import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { parseStreamingJson } from "../utils/json-parse";
 import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";
-import { toolWireSchema } from "../utils/schema/wire";
+import { flattenToolRootCombinators, toolWireSchema } from "../utils/schema";
 import { COMPOSER_EDIT_DISCIPLINE_PROMPT, isComposerHarnessModel } from "./composer-discipline";
 import type { McpToolDefinition } from "./cursor/gen/agent_pb";
 import {
@@ -2183,7 +2183,7 @@ function buildMcpToolDefinitions(tools: Tool[] | undefined): McpToolDefinition[]
 	}
 
 	return advertisedTools.map(tool => {
-		const jsonSchema = toolWireSchema(tool);
+		const jsonSchema = flattenToolRootCombinators(toolWireSchema(tool));
 		const schemaValue: JsonValue =
 			jsonSchema && typeof jsonSchema === "object"
 				? (jsonSchema as JsonValue)

package/src/providers/ollama.ts

@@ -19,7 +19,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream";
 import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
 import { parseStreamingJson } from "../utils/json-parse";
 import { resolveRetryBudget } from "../utils/retry-budget";
-import { toolWireSchema } from "../utils/schema/wire";
+import { flattenToolRootCombinators, toolWireSchema } from "../utils/schema";
 import {
 	isForcedToolChoiceUnsupportedError,
 	markToolChoiceIncapability,
@@ -253,7 +253,7 @@ function convertTools(tools: Tool[] | undefined): OllamaFunctionTool[] | undefin
 		function: {
 			name: tool.name,
 			description: tool.description,
-			parameters: toolWireSchema(tool),
+			parameters: flattenToolRootCombinators(toolWireSchema(tool)),
 		},
 	}));
 }

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

@@ -50,7 +50,13 @@ import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-ins
 import { getOpenAIStreamIdleTimeoutMs, iterateWithIdleTimeout } from "../utils/idle-iterator";
 import { parseStreamingJson } from "../utils/json-parse";
 import { resolveRetryBudget } from "../utils/retry-budget";
-import { adaptSchemaForStrict, NO_STRICT, sanitizeSchemaForOpenAIResponses, toolWireSchema } from "../utils/schema";
+import {
+	adaptSchemaForStrict,
+	flattenToolRootCombinators,
+	NO_STRICT,
+	sanitizeSchemaForOpenAIResponses,
+	toolWireSchema,
+} from "../utils/schema";
 import {
 	isForcedToolChoiceUnsupportedError,
 	markToolChoiceIncapability,
@@ -98,6 +104,14 @@ const CODEX_WEBSOCKET_RETRY_BUDGET = CODEX_MAX_RETRIES;
 const CODEX_WEBSOCKET_TRANSPORT_ERROR_PREFIX = "Codex websocket transport error";
 const CODEX_PREVIOUS_RESPONSE_STALE_CODES = new Set(["previous_response_not_found", "codex_previous_response_stale"]);
 const CODEX_RETRYABLE_EVENT_CODES = new Set(["model_error", "server_error", "internal_error"]);
+const CODEX_NON_RETRYABLE_EVENT_CODES = new Set([
+	"invalid_function_parameters",
+	"invalid_request_error",
+	"invalid_schema",
+	"invalid_tool_schema",
+]);
+const CODEX_NON_RETRYABLE_EVENT_MESSAGE =
+	/invalid[_ -]function[_ -]parameters|invalid schema for function|invalid[_ -]tool[_ -]schema|schema must have type ["']?object["']?/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";
@@ -2658,7 +2672,7 @@ export function convertOpenAICodexResponsesTools(
 			};
 		}
 		const strict = !!(!NO_STRICT && tool.strict);
-		const baseParameters = sanitizeSchemaForOpenAIResponses(toolWireSchema(tool));
+		const baseParameters = sanitizeSchemaForOpenAIResponses(flattenToolRootCombinators(toolWireSchema(tool)));
 		const { schema: parameters, strict: effectiveStrict } = adaptSchemaForStrict(baseParameters, strict);
 		return {
 			type: "function",
@@ -2703,11 +2717,17 @@ class CodexProviderStreamError extends Error {
 }
 
 function isRetryableCodexFailureEvent(rawEvent: Record<string, unknown>): boolean {
-	const code = getCodexEventErrorCode(rawEvent);
-	if (code && CODEX_RETRYABLE_EVENT_CODES.has(code.toLowerCase())) {
+	const code = getCodexEventErrorCode(rawEvent).toLowerCase();
+	const message = getCodexEventErrorMessage(rawEvent);
+	if (
+		(code && CODEX_NON_RETRYABLE_EVENT_CODES.has(code)) ||
+		(!!message && CODEX_NON_RETRYABLE_EVENT_MESSAGE.test(message))
+	) {
+		return false;
+	}
+	if (code && CODEX_RETRYABLE_EVENT_CODES.has(code)) {
 		return true;
 	}
-	const message = getCodexEventErrorMessage(rawEvent);
 	return !!message && CODEX_RETRYABLE_EVENT_MESSAGE.test(message);
 }
 

package/src/providers/openai-completions-compat.ts

@@ -189,6 +189,7 @@ export function detectOpenAICompat(model: Model<"openai-completions">, resolvedB
 	return {
 		supportsStore: !isNonStandard,
 		supportsDeveloperRole: !isNonStandard,
+		sendSessionHeaders: false,
 		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
 		supportsReasoningEffort: !isGrok && !isZai,
 		reasoningEffortMap,
@@ -254,6 +255,7 @@ export function resolveOpenAICompat(
 	return {
 		supportsStore: model.compat.supportsStore ?? detected.supportsStore,
 		supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
+		sendSessionHeaders: model.compat.sendSessionHeaders ?? detected.sendSessionHeaders,
 		supportsMultipleSystemMessages:
 			model.compat.supportsMultipleSystemMessages ?? detected.supportsMultipleSystemMessages,
 		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,

package/src/providers/openai-completions.ts

@@ -57,7 +57,7 @@ import { getKimiCommonHeaders } from "../utils/oauth/kimi";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { callWithCopilotModelRetry } from "../utils/retry";
 import { resolveRetryBudget } from "../utils/retry-budget";
-import { adaptSchemaForStrict, NO_STRICT, toolWireSchema } from "../utils/schema";
+import { adaptSchemaForStrict, flattenToolRootCombinators, NO_STRICT, toolWireSchema } from "../utils/schema";
 import { wrapFetchForSseDebug } from "../utils/sse-debug";
 import { type HealedToolCall, modelMayLeakKimiToolCalls, ToolCallHealer } from "../utils/tool-call-healing";
 import { isForcedToolChoice, mapToOpenAICompletionsToolChoice } from "../utils/tool-choice";
@@ -453,6 +453,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				options?.streamFirstEventTimeoutMs,
 				options?.authCredentialType,
 				options?.requestMaxRetries,
+				options?.sessionId,
 			);
 			const premiumRequestsTotal = copilotPremiumRequests;
 			getCapturedErrorResponse = captureErrorResponse;
@@ -943,6 +944,7 @@ async function createClient(
 	streamFirstEventTimeoutOverride?: number,
 	authCredentialType?: OpenAICompletionsOptions["authCredentialType"],
 	requestMaxRetries?: number,
+	sessionId?: string,
 ): Promise<{
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
@@ -981,6 +983,14 @@ async function createClient(
 		headers["X-OpenRouter-Cache-TTL"] = "3600";
 	}
 	Object.assign(headers, extraHeaders);
+	if (sessionId && resolveOpenAICompat(model).sendSessionHeaders) {
+		// Forward the agent session id as vendor-neutral session-identity headers so
+		// OpenAI-compatible proxies/relays can do session-affinity routing and reuse a
+		// server-side prompt cache. Opt-in via `compat.sendSessionHeaders`; never
+		// overwrite a header the caller already set (model.headers / requestTransform).
+		headers.session_id ??= sessionId;
+		headers["x-session-id"] ??= sessionId;
+	}
 	if (model.provider === "kimi-code") {
 		headers = { ...getKimiCommonHeaders(), ...headers };
 	}
@@ -1832,7 +1842,7 @@ function convertTools(
 ): BuiltOpenAICompletionTools {
 	const adaptedTools = tools.map(tool => {
 		const strict = !NO_STRICT && compat.supportsStrictMode !== false && tool.strict !== false;
-		const baseParameters = toolWireSchema(tool);
+		const baseParameters = flattenToolRootCombinators(toolWireSchema(tool));
 		const adapted = adaptSchemaForStrict(baseParameters, strict);
 		return {
 			tool,

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

@@ -370,15 +370,66 @@ export async function processResponsesStream<TApi extends Api>(
 	model: Model<TApi>,
 	options?: ProcessResponsesStreamOptions,
 ): Promise<void> {
-	let currentItem:
-		| ResponseReasoningItem
-		| ResponseOutputMessage
-		| ResponseFunctionToolCall
-		| ResponseCustomToolCall
-		| null = null;
-	let currentBlock: ThinkingContent | TextContent | (ToolCall & { partialJson: string }) | null = null;
-	const blocks = output.content;
-	const blockIndex = () => blocks.length - 1;
+	type StreamItem = ResponseReasoningItem | ResponseOutputMessage | ResponseFunctionToolCall | ResponseCustomToolCall;
+	type StreamBlock = ThinkingContent | TextContent | (ToolCall & { partialJson: string });
+	interface ItemEntry {
+		item: StreamItem;
+		block: StreamBlock;
+		blockContentIndex: number;
+	}
+	// Per-item argument buffer keyed on stable item identity. Multiple tool-call
+	// items can stream interleaved argument deltas in one response, so a single
+	// most-recent slot would mis-attribute deltas to the wrong item.
+	const items = new Map<string, ItemEntry>();
+	let lastKey: string | null = null;
+	const idKey = (id: string) => `id:${id}`;
+	const idxKey = (n: number) => `idx:${n}`;
+	const hasIndex = (n: number | undefined): n is number => typeof n === "number" && Number.isFinite(n);
+	const resolveEntry = (
+		itemId: string | undefined,
+		outputIndex: number | undefined,
+		// Fallback to the most-recently-added entry (`lastKey`) when the event
+		// cannot be resolved by identity:
+		//  - "never": tool ghost events with an explicit but unmatched key are ignored.
+		//  - "no-key": only when BOTH item_id and a finite output_index are absent —
+		//    the legacy single continuation-style tool delta/done shape.
+		//  - "always": continuation-style non-tool events (reasoning/text), which may
+		//    legitimately omit identity and target the open block.
+		fallback: "never" | "no-key" | "always",
+	): ItemEntry | undefined => {
+		if (itemId) {
+			const byId = items.get(idKey(itemId));
+			if (byId) return byId;
+		}
+		if (hasIndex(outputIndex)) {
+			const byIdx = items.get(idxKey(outputIndex));
+			if (byIdx) return byIdx;
+		}
+		const hasExplicitKey = !!itemId || hasIndex(outputIndex);
+		const allowLastKey = fallback === "always" || (fallback === "no-key" && !hasExplicitKey);
+		if (allowLastKey && lastKey) return items.get(lastKey);
+		return undefined;
+	};
+	const registerEntry = (item: StreamItem, block: StreamBlock, outputIndex: number | undefined): ItemEntry => {
+		output.content.push(block);
+		const entry: ItemEntry = { item, block, blockContentIndex: output.content.length - 1 };
+		// Primary key prefers the stable item id; if the wire omits it, fall back to
+		// the positional index. A synthetic key keeps the entry addressable as lastKey
+		// for continuation-style non-tool events even when neither is present.
+		const key = item.id ? idKey(item.id) : hasIndex(outputIndex) ? idxKey(outputIndex) : `seq:${items.size}`;
+		items.set(key, entry);
+		if (item.id && hasIndex(outputIndex)) items.set(idxKey(outputIndex), entry);
+		lastKey = key;
+		return entry;
+	};
+	const dropEntry = (itemId: string | undefined, outputIndex: number | undefined): void => {
+		const key = itemId ? idKey(itemId) : hasIndex(outputIndex) ? idxKey(outputIndex) : null;
+		if (key) {
+			items.delete(key);
+			if (lastKey === key) lastKey = null;
+		}
+		if (itemId && hasIndex(outputIndex)) items.delete(idxKey(outputIndex));
+	};
 	let sawFirstToken = false;
 
 	for await (const event of openaiStream) {
@@ -390,30 +441,27 @@ export async function processResponsesStream<TApi extends Api>(
 				options?.onFirstToken?.();
 			}
 			const item = event.item;
+			const outputIndex = event.output_index;
 			if (item.type === "reasoning") {
-				currentItem = item;
-				currentBlock = { type: "thinking", thinking: "", itemId: item.id };
-				output.content.push(currentBlock);
-				stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+				const block: ThinkingContent = { type: "thinking", thinking: "", itemId: item.id };
+				const entry = registerEntry(item, block, outputIndex);
+				stream.push({ type: "thinking_start", contentIndex: entry.blockContentIndex, partial: output });
 			} else if (item.type === "message") {
-				currentItem = item;
-				currentBlock = { type: "text", text: "" };
-				output.content.push(currentBlock);
-				stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+				const block: TextContent = { type: "text", text: "" };
+				const entry = registerEntry(item, block, outputIndex);
+				stream.push({ type: "text_start", contentIndex: entry.blockContentIndex, partial: output });
 			} else if (item.type === "function_call") {
-				currentItem = item;
-				currentBlock = {
+				const block: ToolCall & { partialJson: string } = {
 					type: "toolCall",
 					id: encodeResponsesToolCallId(item.call_id, item.id),
 					name: item.name,
 					arguments: {},
 					partialJson: item.arguments || "",
 				};
-				output.content.push(currentBlock);
-				stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+				const entry = registerEntry(item, block, outputIndex);
+				stream.push({ type: "toolcall_start", contentIndex: entry.blockContentIndex, partial: output });
 			} else if (item.type === "custom_tool_call") {
-				currentItem = item;
-				currentBlock = {
+				const block: ToolCall & { partialJson: string } = {
 					type: "toolCall",
 					id: encodeResponsesToolCallId(item.call_id, item.id),
 					// Preserve the raw wire name (e.g. `apply_patch`). The agent-loop
@@ -427,39 +475,42 @@ export async function processResponsesStream<TApi extends Api>(
 					// accumulation buffer so later code that inspects the field still works.
 					partialJson: item.input ?? "",
 				};
-				output.content.push(currentBlock);
-				stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+				const entry = registerEntry(item, block, outputIndex);
+				stream.push({ type: "toolcall_start", contentIndex: entry.blockContentIndex, partial: output });
 			}
 		} else if (event.type === "response.reasoning_summary_part.added") {
-			if (currentItem?.type === "reasoning") {
-				currentItem.summary = currentItem.summary || [];
-				currentItem.summary.push(event.part);
+			const entry = resolveEntry(event.item_id, event.output_index, "always");
+			if (entry?.item.type === "reasoning") {
+				entry.item.summary = entry.item.summary || [];
+				entry.item.summary.push(event.part);
 			}
 		} else if (event.type === "response.reasoning_summary_text.delta") {
-			if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-				currentItem.summary = currentItem.summary || [];
-				const lastPart = currentItem.summary[currentItem.summary.length - 1];
+			const entry = resolveEntry(event.item_id, event.output_index, "always");
+			if (entry?.item.type === "reasoning" && entry.block.type === "thinking") {
+				entry.item.summary = entry.item.summary || [];
+				const lastPart = entry.item.summary[entry.item.summary.length - 1];
 				if (lastPart) {
-					currentBlock.thinking += event.delta;
+					entry.block.thinking += event.delta;
 					lastPart.text += event.delta;
 					stream.push({
 						type: "thinking_delta",
-						contentIndex: blockIndex(),
+						contentIndex: entry.blockContentIndex,
 						delta: event.delta,
 						partial: output,
 					});
 				}
 			}
 		} else if (event.type === "response.reasoning_summary_part.done") {
-			if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-				currentItem.summary = currentItem.summary || [];
-				const lastPart = currentItem.summary[currentItem.summary.length - 1];
+			const entry = resolveEntry(event.item_id, event.output_index, "always");
+			if (entry?.item.type === "reasoning" && entry.block.type === "thinking") {
+				entry.item.summary = entry.item.summary || [];
+				const lastPart = entry.item.summary[entry.item.summary.length - 1];
 				if (lastPart) {
-					currentBlock.thinking += "\n\n";
+					entry.block.thinking += "\n\n";
 					lastPart.text += "\n\n";
 					stream.push({
 						type: "thinking_delta",
-						contentIndex: blockIndex(),
+						contentIndex: entry.blockContentIndex,
 						delta: "\n\n",
 						partial: output,
 					});
@@ -468,85 +519,94 @@ export async function processResponsesStream<TApi extends Api>(
 		} else if (event.type === "response.reasoning_text.delta") {
 			// Raw reasoning text delta from local providers that stream thinking
 			// directly rather than via the OpenAI summary tracking protocol.
-			if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
-				currentBlock.thinking += event.delta;
+			const entry = resolveEntry(event.item_id, event.output_index, "always");
+			if (entry?.item.type === "reasoning" && entry.block.type === "thinking") {
+				entry.block.thinking += event.delta;
 				stream.push({
 					type: "thinking_delta",
-					contentIndex: blockIndex(),
+					contentIndex: entry.blockContentIndex,
 					delta: event.delta,
 					partial: output,
 				});
 			}
 		} else if (event.type === "response.content_part.added") {
-			if (currentItem?.type === "message") {
-				currentItem.content = currentItem.content || [];
+			const entry = resolveEntry(event.item_id, event.output_index, "always");
+			if (entry?.item.type === "message") {
+				entry.item.content = entry.item.content || [];
 				if (event.part.type === "output_text" || event.part.type === "refusal") {
-					currentItem.content.push(event.part);
+					entry.item.content.push(event.part);
 				}
 			}
 		} else if (event.type === "response.output_text.delta") {
-			if (currentItem?.type === "message" && currentBlock?.type === "text") {
-				const lastPart = currentItem.content?.[currentItem.content.length - 1];
+			const entry = resolveEntry(event.item_id, event.output_index, "always");
+			if (entry?.item.type === "message" && entry.block.type === "text") {
+				const lastPart = entry.item.content?.[entry.item.content.length - 1];
 				if (lastPart?.type === "output_text") {
-					currentBlock.text += event.delta;
+					entry.block.text += event.delta;
 					lastPart.text += event.delta;
 					stream.push({
 						type: "text_delta",
-						contentIndex: blockIndex(),
+						contentIndex: entry.blockContentIndex,
 						delta: event.delta,
 						partial: output,
 					});
 				}
 			}
 		} else if (event.type === "response.refusal.delta") {
-			if (currentItem?.type === "message" && currentBlock?.type === "text") {
-				const lastPart = currentItem.content?.[currentItem.content.length - 1];
+			const entry = resolveEntry(event.item_id, event.output_index, "always");
+			if (entry?.item.type === "message" && entry.block.type === "text") {
+				const lastPart = entry.item.content?.[entry.item.content.length - 1];
 				if (lastPart?.type === "refusal") {
-					currentBlock.text += event.delta;
+					entry.block.text += event.delta;
 					lastPart.refusal += event.delta;
 					stream.push({
 						type: "text_delta",
-						contentIndex: blockIndex(),
+						contentIndex: entry.blockContentIndex,
 						delta: event.delta,
 						partial: output,
 					});
 				}
 			}
 		} else if (event.type === "response.function_call_arguments.delta") {
-			if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-				currentBlock.partialJson += event.delta;
-				currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
+			const entry = resolveEntry(event.item_id, event.output_index, "no-key");
+			if (entry?.item.type === "function_call" && entry.block.type === "toolCall") {
+				entry.block.partialJson += event.delta;
+				entry.block.arguments = parseStreamingJson(entry.block.partialJson);
 				stream.push({
 					type: "toolcall_delta",
-					contentIndex: blockIndex(),
+					contentIndex: entry.blockContentIndex,
 					delta: event.delta,
 					partial: output,
 				});
 			}
 		} else if (event.type === "response.function_call_arguments.done") {
-			if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
-				currentBlock.partialJson = event.arguments;
-				currentBlock.arguments = parseStreamingJson(currentBlock.partialJson);
+			const entry = resolveEntry(event.item_id, event.output_index, "no-key");
+			if (entry?.item.type === "function_call" && entry.block.type === "toolCall") {
+				entry.block.partialJson = event.arguments;
+				entry.block.arguments = parseStreamingJson(entry.block.partialJson);
 			}
 		} else if (event.type === "response.custom_tool_call_input.delta") {
-			if (currentItem?.type === "custom_tool_call" && currentBlock?.type === "toolCall") {
-				currentBlock.partialJson += event.delta;
-				currentBlock.arguments = { input: currentBlock.partialJson };
+			const entry = resolveEntry(event.item_id, event.output_index, "no-key");
+			if (entry?.item.type === "custom_tool_call" && entry.block.type === "toolCall") {
+				entry.block.partialJson += event.delta;
+				entry.block.arguments = { input: entry.block.partialJson };
 				stream.push({
 					type: "toolcall_delta",
-					contentIndex: blockIndex(),
+					contentIndex: entry.blockContentIndex,
 					delta: event.delta,
 					partial: output,
 				});
 			}
 		} else if (event.type === "response.custom_tool_call_input.done") {
-			if (currentItem?.type === "custom_tool_call" && currentBlock?.type === "toolCall") {
-				currentBlock.partialJson = event.input;
-				currentBlock.arguments = { input: event.input };
+			const entry = resolveEntry(event.item_id, event.output_index, "no-key");
+			if (entry?.item.type === "custom_tool_call" && entry.block.type === "toolCall") {
+				entry.block.partialJson = event.input;
+				entry.block.arguments = { input: event.input };
 			}
 		} else if (event.type === "response.output_item.done") {
 			const item = structuredCloneJSON(event.item);
 			options?.onOutputItemDone?.(item);
+			const entry = resolveEntry(item.id, event.output_index, "never");
 			if (item.type === "reasoning") {
 				const thinking =
 					item.summary?.length > 0
@@ -554,13 +614,17 @@ export async function processResponsesStream<TApi extends Api>(
 						: item.content?.[0]?.type === "reasoning_text"
 							? (item.content[0].text ?? "")
 							: "";
-				const reasoningBlock = output.content.find(
-					b => b.type === "thinking" && (b as ThinkingContent).itemId === item.id,
-				) as ThinkingContent | undefined;
+				const reasoningBlock =
+					entry?.block.type === "thinking"
+						? entry.block
+						: (output.content.find(b => b.type === "thinking" && (b as ThinkingContent).itemId === item.id) as
+								| ThinkingContent
+								| undefined);
 				if (reasoningBlock) {
 					reasoningBlock.thinking = thinking;
 					reasoningBlock.thinkingSignature = JSON.stringify(item);
-					const reasoningBlockIndex = output.content.indexOf(reasoningBlock);
+					const reasoningBlockIndex =
+						entry?.block === reasoningBlock ? entry.blockContentIndex : output.content.indexOf(reasoningBlock);
 					stream.push({
 						type: "thinking_end",
 						contentIndex: reasoningBlockIndex,
@@ -568,23 +632,27 @@ export async function processResponsesStream<TApi extends Api>(
 						partial: output,
 					});
 				}
-				if ((currentBlock as ThinkingContent | null)?.itemId === item.id) currentBlock = null;
-			} else if (item.type === "message" && currentBlock?.type === "text") {
-				currentBlock.text = item.content
+				dropEntry(item.id, event.output_index);
+			} else if (item.type === "message" && entry?.block.type === "text") {
+				const block = entry.block;
+				block.text = item.content
 					.map(part => (part.type === "output_text" ? (part.text ?? "") : (part.refusal ?? "")))
 					.join("");
-				currentBlock.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
+				block.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
 				stream.push({
 					type: "text_end",
-					contentIndex: blockIndex(),
-					content: currentBlock.text,
+					contentIndex: entry.blockContentIndex,
+					content: block.text,
 					partial: output,
 				});
-				currentBlock = null;
+				dropEntry(item.id, event.output_index);
 			} else if (item.type === "function_call") {
+				// Finalize onto the same block object stored in output.content, reading
+				// the matching entry's buffered partialJson first and only then the done
+				// item's arguments — never an adjacent item's buffer.
 				const args =
-					currentBlock?.type === "toolCall" && currentBlock.partialJson
-						? parseStreamingJson(currentBlock.partialJson)
+					entry?.block.type === "toolCall" && entry.block.partialJson
+						? parseStreamingJson(entry.block.partialJson)
 						: parseStreamingJson(item.arguments || "{}");
 				const toolCall: ToolCall = {
 					type: "toolCall",
@@ -592,12 +660,18 @@ export async function processResponsesStream<TApi extends Api>(
 					name: item.name,
 					arguments: args,
 				};
-				currentBlock = null;
-				stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+				if (entry?.block.type === "toolCall") {
+					entry.block.id = toolCall.id;
+					entry.block.name = toolCall.name;
+					entry.block.arguments = args;
+				}
+				const contentIndex = entry?.blockContentIndex ?? output.content.length - 1;
+				dropEntry(item.id, event.output_index);
+				stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
 			} else if (item.type === "custom_tool_call") {
 				const rawInput =
-					currentBlock?.type === "toolCall" && currentBlock.partialJson
-						? currentBlock.partialJson
+					entry?.block.type === "toolCall" && entry.block.partialJson
+						? entry.block.partialJson
 						: (item.input ?? "");
 				const toolCall: ToolCall = {
 					type: "toolCall",
@@ -606,8 +680,14 @@ export async function processResponsesStream<TApi extends Api>(
 					arguments: { input: rawInput },
 					customWireName: item.name,
 				};
-				currentBlock = null;
-				stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+				if (entry?.block.type === "toolCall") {
+					entry.block.id = toolCall.id;
+					entry.block.name = toolCall.name;
+					entry.block.arguments = { input: rawInput };
+				}
+				const contentIndex = entry?.blockContentIndex ?? output.content.length - 1;
+				dropEntry(item.id, event.output_index);
+				stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
 			}
 		} else if (event.type === "response.completed") {
 			const response = event.response;

package/src/providers/openai-responses.ts

@@ -50,7 +50,13 @@ import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { callWithCopilotModelRetry } from "../utils/retry";
 import { resolveRetryBudget } from "../utils/retry-budget";
-import { adaptSchemaForStrict, NO_STRICT, sanitizeSchemaForOpenAIResponses, toolWireSchema } from "../utils/schema";
+import {
+	adaptSchemaForStrict,
+	flattenToolRootCombinators,
+	NO_STRICT,
+	sanitizeSchemaForOpenAIResponses,
+	toolWireSchema,
+} from "../utils/schema";
 import { wrapFetchForSseDebug } from "../utils/sse-debug";
 import { mapToOpenAIResponsesToolChoice, type OpenAIResponsesToolChoice } from "../utils/tool-choice";
 import {
@@ -724,7 +730,7 @@ export function convertTools(tools: Tool[], strictMode: boolean, model: Model<"o
 			} as unknown as OpenAITool;
 		}
 		const strict = !NO_STRICT && strictMode && tool.strict !== false;
-		const baseParameters = toolWireSchema(tool);
+		const baseParameters = flattenToolRootCombinators(toolWireSchema(tool));
 		const responseParameters = sanitizeSchemaForOpenAIResponses(baseParameters);
 		const { schema: parameters, strict: effectiveStrict } = adaptSchemaForStrict(responseParameters, strict);
 		return {

package/src/types.ts

@@ -742,6 +742,17 @@ export interface OpenAICompat extends ToolChoiceCompat {
 	supportsStore?: boolean;
 	/** Whether the provider supports the `developer` role (vs `system`). Default: auto-detected from URL. */
 	supportsDeveloperRole?: boolean;
+	/**
+	 * Whether to forward the agent session id as vendor-neutral session-identity
+	 * headers (`session_id`, `x-session-id`) on every chat-completions request.
+	 * Off by default. Opt in for OpenAI-compatible proxies/relays that route on
+	 * session affinity or reuse a server-side prompt cache keyed by session.
+	 * First-party OpenAI does not need this (it has its own gated injection in
+	 * the openai-responses provider). Headers are only added when a non-empty
+	 * session id is available and are never allowed to overwrite a header the
+	 * caller already set via `headers`/`requestTransform`.
+	 */
+	sendSessionHeaders?: boolean;
 	/**
 	 * Whether the provider's chat-completions endpoint accepts multiple
 	 * leading `system`/`developer` messages. When false, ordered system

package/src/utils/schema/index.ts

@@ -7,6 +7,7 @@ export * from "./fields";
 export * from "./json-schema-validator";
 export * from "./meta-validator";
 export * from "./normalize";
+export * from "./root-combinator";
 export * from "./spill";
 export * from "./types";
 export * from "./wire";