@openrouter/sdk 0.3.15 → 0.4.0

package/esm/funcs/modelsListForUser.d.ts

@@ -10,7 +10,10 @@ import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 /**
- * List models filtered by user provider preferences
+ * List models filtered by user provider preferences, privacy settings, and guardrails
+ *
+ * @remarks
+ * List models filtered by user provider preferences, [privacy settings](https://openrouter.ai/docs/guides/privacy/logging), and [guardrails](https://openrouter.ai/docs/guides/features/guardrails). If requesting through `eu.openrouter.ai/api/v1/...` the results will be filtered to models that satisfy [EU in-region routing](https://openrouter.ai/docs/guides/privacy/logging#enterprise-eu-in-region-routing).
  */
-export declare function modelsListForUser(client: OpenRouterCore, security: operations.ListModelsUserSecurity, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function modelsListForUser(client: OpenRouterCore, security: operations.ListModelsUserSecurity, options?: RequestOptions): APIPromise<Result<models.ModelsListResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=modelsListForUser.d.ts.map

package/esm/funcs/modelsListForUser.js

@@ -10,7 +10,10 @@ import * as errors from "../models/errors/index.js";
 import * as models from "../models/index.js";
 import { APIPromise } from "../types/async.js";
 /**
- * List models filtered by user provider preferences
+ * List models filtered by user provider preferences, privacy settings, and guardrails
+ *
+ * @remarks
+ * List models filtered by user provider preferences, [privacy settings](https://openrouter.ai/docs/guides/privacy/logging), and [guardrails](https://openrouter.ai/docs/guides/features/guardrails). If requesting through `eu.openrouter.ai/api/v1/...` the results will be filtered to models that satisfy [EU in-region routing](https://openrouter.ai/docs/guides/privacy/logging#enterprise-eu-in-region-routing).
  */
 export function modelsListForUser(client, security, options) {
     return new APIPromise($do(client, security, options));
@@ -54,7 +57,7 @@ async function $do(client, security, options) {
     const req = requestRes.value;
     const doResult = await client._do(req, {
         context,
-        errorCodes: ["401", "4XX", "500", "5XX"],
+        errorCodes: ["401", "404", "4XX", "500", "5XX"],
         retryConfig: context.retryConfig,
         retryCodes: context.retryCodes,
     });
@@ -65,7 +68,7 @@ async function $do(client, security, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.ModelsListResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/index.d.ts

@@ -1,6 +1,6 @@
 export type { CallModelInput, CallModelInputWithState, FieldOrAsyncFunction, ResolvedCallModelInput, } from './lib/async-params.js';
 export type { Fetcher, HTTPClientOptions } from './lib/http.js';
-export type { ChatStreamEvent, ConversationState, ConversationStatus, ResponseStreamEvent as EnhancedResponseStreamEvent, HasApprovalTools, InferToolEvent, InferToolEventsUnion, InferToolInput, InferToolOutput, ManualTool, NextTurnParamsContext, NextTurnParamsFunctions, ParsedToolCall, PartialResponse, StateAccessor, StepResult, StopCondition, StopWhen, Tool, ToolApprovalCheck, ToolExecutionResult, ToolExecutionResultUnion, ToolHasApproval, ToolPreliminaryResultEvent, ToolStreamEvent, ToolWithExecute, ToolWithGenerator, TurnContext, TypedToolCall, TypedToolCallUnion, UnsentToolResult, Warning, } from './lib/tool-types.js';
+export type { ChatStreamEvent, ConversationState, ConversationStatus, ResponseStreamEvent as EnhancedResponseStreamEvent, HasApprovalTools, InferToolEvent, InferToolEventsUnion, InferToolInput, InferToolOutput, InferToolOutputsUnion, ManualTool, NextTurnParamsContext, NextTurnParamsFunctions, ParsedToolCall, PartialResponse, StateAccessor, StepResult, StopCondition, StopWhen, Tool, ToolApprovalCheck, ToolExecutionResult, ToolExecutionResultUnion, ToolHasApproval, ToolPreliminaryResultEvent, ToolResultEvent, ToolStreamEvent, ToolWithExecute, ToolWithGenerator, TurnContext, TypedToolCall, TypedToolCallUnion, UnsentToolResult, Warning, } from './lib/tool-types.js';
 export type { BuildTurnContextOptions } from './lib/turn-context.js';
 export type { ClaudeBase64ImageSource, ClaudeCacheControl, ClaudeCitationCharLocation, ClaudeCitationContentBlockLocation, ClaudeCitationPageLocation, ClaudeCitationSearchResultLocation, ClaudeCitationWebSearchResultLocation, ClaudeContentBlock, ClaudeContentBlockParam, ClaudeImageBlockParam, ClaudeMessage, ClaudeMessageParam, ClaudeRedactedThinkingBlock, ClaudeServerToolUseBlock, ClaudeStopReason, ClaudeTextBlock, ClaudeTextBlockParam, ClaudeTextCitation, ClaudeThinkingBlock, ClaudeToolResultBlockParam, ClaudeToolUseBlock, ClaudeToolUseBlockParam, ClaudeURLImageSource, ClaudeUsage, } from './models/claude-message.js';
 export { fromClaudeMessages, toClaudeMessage } from './lib/anthropic-compat.js';
@@ -14,8 +14,9 @@ export { HTTPClient } from './lib/http.js';
 export { applyNextTurnParamsToRequest, buildNextTurnParamsContext, executeNextTurnParamsFunctions, } from './lib/next-turn-params.js';
 export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed, stepCountIs, } from './lib/stop-conditions.js';
 export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent, } from './lib/stream-transformers.js';
+export type { StreamableOutputItem } from './lib/stream-transformers.js';
 export { tool } from './lib/tool.js';
-export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
+export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, isToolResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
 export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';
 export { appendToMessages, createInitialState, createRejectedResult, createUnsentResult, generateConversationId, partitionToolCalls, toolRequiresApproval, updateState, } from './lib/conversation-state.js';
 export { ToolEventBroadcaster } from './lib/tool-event-broadcaster.js';

package/esm/index.js

@@ -18,7 +18,7 @@ export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed
 export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent, } from './lib/stream-transformers.js';
 // Tool creation helpers
 export { tool } from './lib/tool.js';
-export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
+export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, isToolResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
 // Turn context helpers
 export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';
 // Conversation state helpers

package/esm/lib/config.d.ts

@@ -45,8 +45,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.3.15";
+    readonly sdkVersion: "0.4.0";
     readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.15 2.788.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.4.0 2.788.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.3.15",
+    sdkVersion: "0.4.0",
     genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.3.15 2.788.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.4.0 2.788.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/model-result.d.ts

@@ -2,7 +2,8 @@ import type { OpenRouterCore } from '../core.js';
 import type * as models from '../models/index.js';
 import type { CallModelInput } from './async-params.js';
 import type { RequestOptions } from './sdks.js';
-import type { ConversationState, ResponseStreamEvent, InferToolEventsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
+import type { ConversationState, ResponseStreamEvent, InferToolEventsUnion, InferToolOutputsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
+import { type StreamableOutputItem } from './stream-transformers.js';
 export interface GetResponseOptions<TTools extends readonly Tool[]> {
     request: CallModelInput<TTools>;
     client: OpenRouterCore;
@@ -57,6 +58,7 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     /**
      * Get or create the tool event broadcaster (lazy initialization).
      * Ensures only one broadcaster exists for the lifetime of this ModelResult.
+     * Broadcasts both preliminary results and final tool results.
      */
     private ensureBroadcaster;
     /**
@@ -139,6 +141,7 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     /**
      * Execute all tools in a single round.
      * Runs each tool call sequentially and collects results for API submission.
+     * Emits tool.result events after each tool execution completes.
      *
      * @param toolCalls - The tool calls to execute
      * @param turnContext - The current turn context
@@ -234,15 +237,34 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     /**
      * Stream all response events as they arrive.
      * Multiple consumers can iterate over this stream concurrently.
-     * Preliminary tool results are streamed in REAL-TIME as generator tools yield.
+     * Preliminary tool results and tool results are streamed in REAL-TIME as generator tools yield.
      */
-    getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>>>;
+    getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>, InferToolOutputsUnion<TTools>>>;
     /**
      * Stream only text deltas as they arrive.
      * This filters the full event stream to only yield text content.
      */
     getTextStream(): AsyncIterableIterator<string>;
     /**
+     * Stream all output items cumulatively as they arrive.
+     * Items are emitted with the same ID but progressively updated content as streaming progresses.
+     * Also yields tool results (function_call_output) after tool execution completes.
+     *
+     * Item types include:
+     * - message: Assistant text responses (emitted cumulatively as text streams)
+     * - function_call: Tool calls (emitted cumulatively as arguments stream)
+     * - reasoning: Model reasoning (emitted cumulatively as thinking streams)
+     * - web_search_call: Web search operations
+     * - file_search_call: File search operations
+     * - image_generation_call: Image generation operations
+     * - function_call_output: Results from executed tools
+     */
+    getItemsStream(): AsyncIterableIterator<StreamableOutputItem>;
+    /**
+     * @deprecated Use `getItemsStream()` instead. This method only streams messages,
+     * while `getItemsStream()` streams all output item types (messages, function_calls,
+     * reasoning, etc.) with cumulative updates.
+     *
      * Stream incremental message updates as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
      * Also yields OpenResponsesFunctionCallOutput after tool execution completes.

package/esm/lib/model-result.js

@@ -3,11 +3,12 @@ import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
 import { hasAsyncFunctions, resolveAsyncFunctions, } from './async-params.js';
 import { appendToMessages, createInitialState, createRejectedResult, createUnsentResult, extractTextFromResponse as extractTextFromResponseState, partitionToolCalls, unsentResultsToAPIFormat, updateState, } from './conversation-state.js';
 import { ReusableReadableStream } from './reusable-stream.js';
-import { buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
+import { buildItemsStream, buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
 import { executeTool } from './tool-executor.js';
 import { executeNextTurnParamsFunctions, applyNextTurnParamsToRequest } from './next-turn-params.js';
 import { hasExecuteFunction } from './tool-types.js';
 import { isStopConditionMet, stepCountIs } from './stop-conditions.js';
+import { isOutputMessage, isFunctionCallOutputItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, hasTypeProperty, } from './stream-type-guards.js';
 /**
  * Default maximum number of tool execution steps if no stopWhen is specified.
  * This prevents infinite loops in tool execution.
@@ -30,15 +31,6 @@ function isEventStream(value) {
     const maybeStream = value;
     return typeof maybeStream.toReadableStream === 'function';
 }
-/**
- * Type guard for output items with a type property
- */
-function hasTypeProperty(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        typeof item.type === 'string');
-}
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
  *
@@ -93,6 +85,7 @@ export class ModelResult {
     /**
      * Get or create the tool event broadcaster (lazy initialization).
      * Ensures only one broadcaster exists for the lifetime of this ModelResult.
+     * Broadcasts both preliminary results and final tool results.
      */
     ensureBroadcaster() {
         if (!this.toolEventBroadcaster) {
@@ -300,6 +293,7 @@ export class ModelResult {
     /**
      * Execute all tools in a single round.
      * Runs each tool call sequentially and collects results for API submission.
+     * Emits tool.result events after each tool execution completes.
      *
      * @param toolCalls - The tool calls to execute
      * @param turnContext - The current turn context
@@ -311,17 +305,33 @@ export class ModelResult {
             const tool = this.options.tools?.find((t) => t.function.name === toolCall.name);
             if (!tool || !hasExecuteFunction(tool))
                 continue;
+            // Track preliminary results for this specific tool call
+            const preliminaryResultsForCall = [];
             // Create callback for real-time preliminary results
             const onPreliminaryResult = this.toolEventBroadcaster
                 ? (callId, resultValue) => {
+                    // Track preliminary results for the tool.result event
+                    const typedResult = resultValue;
+                    preliminaryResultsForCall.push(typedResult);
+                    // Emit preliminary result event
                     this.toolEventBroadcaster?.push({
                         type: 'preliminary_result',
                         toolCallId: callId,
-                        result: resultValue,
+                        result: typedResult,
                     });
                 }
                 : undefined;
             const result = await executeTool(tool, toolCall, turnContext, onPreliminaryResult);
+            // Emit tool.result event with final result and any preliminary results
+            if (this.toolEventBroadcaster) {
+                const toolResultEvent = {
+                    type: 'tool_result',
+                    toolCallId: toolCall.id,
+                    result: (result.error ? { error: result.error.message } : result.result),
+                    ...(preliminaryResultsForCall.length > 0 && { preliminaryResults: preliminaryResultsForCall }),
+                };
+                this.toolEventBroadcaster.push(toolResultEvent);
+            }
             toolResults.push({
                 type: 'function_call_output',
                 id: `output_${toolCall.id}`,
@@ -799,7 +809,7 @@ export class ModelResult {
     /**
      * Stream all response events as they arrive.
      * Multiple consumers can iterate over this stream concurrently.
-     * Preliminary tool results are streamed in REAL-TIME as generator tools yield.
+     * Preliminary tool results and tool results are streamed in REAL-TIME as generator tools yield.
      */
     getFullResponsesStream() {
         return async function* () {
@@ -819,14 +829,25 @@ export class ModelResult {
             for await (const event of consumer) {
                 yield event;
             }
-            // Yield tool preliminary results as they arrive (real-time!)
+            // Yield tool events as they arrive (real-time!)
             for await (const event of toolEventConsumer) {
-                yield {
-                    type: 'tool.preliminary_result',
-                    toolCallId: event.toolCallId,
-                    result: event.result,
-                    timestamp: Date.now(),
-                };
+                if (event.type === 'preliminary_result') {
+                    yield {
+                        type: 'tool.preliminary_result',
+                        toolCallId: event.toolCallId,
+                        result: event.result,
+                        timestamp: Date.now(),
+                    };
+                }
+                else if (event.type === 'tool_result') {
+                    yield {
+                        type: 'tool.result',
+                        toolCallId: event.toolCallId,
+                        result: event.result,
+                        timestamp: Date.now(),
+                        ...(event.preliminaryResults && { preliminaryResults: event.preliminaryResults }),
+                    };
+                }
             }
             // Ensure execution completed (handles errors)
             await executionPromise;
@@ -846,6 +867,55 @@ export class ModelResult {
         }.call(this);
     }
     /**
+     * Stream all output items cumulatively as they arrive.
+     * Items are emitted with the same ID but progressively updated content as streaming progresses.
+     * Also yields tool results (function_call_output) after tool execution completes.
+     *
+     * Item types include:
+     * - message: Assistant text responses (emitted cumulatively as text streams)
+     * - function_call: Tool calls (emitted cumulatively as arguments stream)
+     * - reasoning: Model reasoning (emitted cumulatively as thinking streams)
+     * - web_search_call: Web search operations
+     * - file_search_call: File search operations
+     * - image_generation_call: Image generation operations
+     * - function_call_output: Results from executed tools
+     */
+    getItemsStream() {
+        return async function* () {
+            await this.initStream();
+            if (!this.reusableStream) {
+                throw new Error('Stream not initialized');
+            }
+            // Stream all items from the API response cumulatively
+            yield* buildItemsStream(this.reusableStream);
+            // Execute tools if needed
+            await this.executeToolsIfNeeded();
+            // Yield function call outputs for each executed tool
+            for (const round of this.allToolExecutionRounds) {
+                for (const toolResult of round.toolResults) {
+                    yield toolResult;
+                }
+            }
+            // If tools were executed, yield all items from the final response
+            if (this.finalResponse && this.allToolExecutionRounds.length > 0) {
+                for (const item of this.finalResponse.output) {
+                    if (isOutputMessage(item) ||
+                        isFunctionCallOutputItem(item) ||
+                        isReasoningOutputItem(item) ||
+                        isWebSearchCallOutputItem(item) ||
+                        isFileSearchCallOutputItem(item) ||
+                        isImageGenerationCallOutputItem(item)) {
+                        yield item;
+                    }
+                }
+            }
+        }.call(this);
+    }
+    /**
+     * @deprecated Use `getItemsStream()` instead. This method only streams messages,
+     * while `getItemsStream()` streams all output item types (messages, function_calls,
+     * reasoning, etc.) with cumulative updates.
+     *
      * Stream incremental message updates as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
      * Also yields OpenResponsesFunctionCallOutput after tool execution completes.
@@ -916,9 +986,11 @@ export class ModelResult {
                     content: delta,
                 };
             }
-            // Yield tool events as they arrive (real-time!)
+            // Yield only preliminary_result events (filter out tool_result events)
             for await (const event of toolEventConsumer) {
-                yield event;
+                if (event.type === 'preliminary_result') {
+                    yield event;
+                }
             }
             // Ensure execution completed (handles errors)
             await executionPromise;

package/esm/lib/stream-transformers.d.ts

@@ -18,6 +18,18 @@ export declare function extractToolDeltas(stream: ReusableReadableStream<models.
  * Returns ResponsesOutputMessage (assistant/responses format)
  */
 export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.ResponsesOutputMessage>;
+/**
+ * Output item types that can be streamed from a response.
+ * This is the union of all item types that appear in response output,
+ * plus function_call_output for tool results.
+ */
+export type StreamableOutputItem = models.ResponsesOutputMessage | models.ResponsesOutputItemFunctionCall | models.ResponsesOutputItemReasoning | models.ResponsesWebSearchCallOutput | models.ResponsesOutputItemFileSearchCall | models.ResponsesImageGenerationCall | models.OpenResponsesFunctionCallOutput;
+/**
+ * Build incremental output item updates from responses stream events.
+ * Yields all item types cumulatively - same item may be emitted multiple times
+ * with the same ID but progressively updated content as streaming progresses.
+ */
+export declare function buildItemsStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<StreamableOutputItem>;
 /**
  * Build incremental message updates from responses stream events
  * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage

package/esm/lib/stream-transformers.js

@@ -127,6 +127,212 @@ export async function* buildResponsesMessageStream(stream) {
         }
     }
 }
+/**
+ * Handle output_item.added event - Initialize tracking for new items
+ */
+function handleOutputItemAdded(event, itemsInProgress) {
+    if (!isOutputItemAddedEvent(event) || !event.item) {
+        return undefined;
+    }
+    const item = event.item;
+    if (isOutputMessage(item)) {
+        itemsInProgress.set(item.id, {
+            type: 'message',
+            id: item.id,
+            textContent: '',
+        });
+        return {
+            id: item.id,
+            type: 'message',
+            role: 'assistant',
+            status: 'in_progress',
+            content: [],
+        };
+    }
+    if (isFunctionCallOutputItem(item)) {
+        // Use item.id if available (matches itemId in delta events), fall back to callId
+        const itemKey = item.id ?? item.callId;
+        itemsInProgress.set(itemKey, {
+            type: 'function_call',
+            id: itemKey,
+            name: item.name,
+            callId: item.callId,
+            argumentsAccumulated: '',
+        });
+        return {
+            type: 'function_call',
+            id: item.id,
+            callId: item.callId,
+            name: item.name,
+            arguments: '',
+            status: 'in_progress',
+        };
+    }
+    if (isReasoningOutputItem(item)) {
+        itemsInProgress.set(item.id, {
+            type: 'reasoning',
+            id: item.id,
+            reasoningContent: '',
+        });
+        return {
+            type: 'reasoning',
+            id: item.id,
+            status: 'in_progress',
+            summary: [],
+        };
+    }
+    if (isWebSearchCallOutputItem(item)) {
+        return item;
+    }
+    if (isFileSearchCallOutputItem(item)) {
+        return item;
+    }
+    if (isImageGenerationCallOutputItem(item)) {
+        return item;
+    }
+    return undefined;
+}
+/**
+ * Handle text delta event for messages
+ */
+function handleTextDelta(event, itemsInProgress) {
+    if (!isOutputTextDeltaEvent(event) || !event.delta) {
+        return undefined;
+    }
+    const item = itemsInProgress.get(event.itemId);
+    if (item?.type === 'message') {
+        item.textContent += event.delta;
+        return {
+            id: item.id,
+            type: 'message',
+            role: 'assistant',
+            status: 'in_progress',
+            content: [
+                {
+                    type: 'output_text',
+                    text: item.textContent,
+                    annotations: [],
+                },
+            ],
+        };
+    }
+    return undefined;
+}
+/**
+ * Handle function call argument delta event
+ */
+function handleFunctionCallDelta(event, itemsInProgress) {
+    if (!isFunctionCallArgumentsDeltaEvent(event) || !event.delta) {
+        return undefined;
+    }
+    const item = itemsInProgress.get(event.itemId);
+    if (item?.type === 'function_call') {
+        item.argumentsAccumulated += event.delta;
+        return {
+            type: 'function_call',
+            // Include id if it differs from callId (means API provided an id)
+            id: item.id !== item.callId ? item.id : undefined,
+            callId: item.callId,
+            name: item.name,
+            arguments: item.argumentsAccumulated,
+            status: 'in_progress',
+        };
+    }
+    return undefined;
+}
+/**
+ * Handle reasoning text delta event
+ */
+function handleReasoningDelta(event, itemsInProgress) {
+    if (!isReasoningDeltaEvent(event) || !event.delta) {
+        return undefined;
+    }
+    const item = itemsInProgress.get(event.itemId);
+    if (item?.type === 'reasoning') {
+        item.reasoningContent += event.delta;
+        return {
+            type: 'reasoning',
+            id: item.id,
+            status: 'in_progress',
+            summary: [
+                {
+                    type: 'summary_text',
+                    text: item.reasoningContent,
+                },
+            ],
+        };
+    }
+    return undefined;
+}
+/**
+ * Handle output_item.done event - Yield final complete item
+ */
+function handleOutputItemDone(event, itemsInProgress) {
+    if (!isOutputItemDoneEvent(event) || !event.item) {
+        return undefined;
+    }
+    const item = event.item;
+    if (isOutputMessage(item)) {
+        itemsInProgress.delete(item.id);
+        return item;
+    }
+    if (isFunctionCallOutputItem(item)) {
+        // Use item.id if available (matches itemId in delta events), fall back to callId
+        itemsInProgress.delete(item.id ?? item.callId);
+        return item;
+    }
+    if (isReasoningOutputItem(item)) {
+        itemsInProgress.delete(item.id);
+        return item;
+    }
+    if (isWebSearchCallOutputItem(item)) {
+        return item;
+    }
+    if (isFileSearchCallOutputItem(item)) {
+        return item;
+    }
+    if (isImageGenerationCallOutputItem(item)) {
+        return item;
+    }
+    return undefined;
+}
+const itemsStreamHandlers = {
+    'response.output_item.added': handleOutputItemAdded,
+    'response.output_text.delta': handleTextDelta,
+    'response.function_call_arguments.delta': handleFunctionCallDelta,
+    'response.reasoning_text.delta': handleReasoningDelta,
+    'response.output_item.done': handleOutputItemDone,
+};
+const streamTerminationEvents = new Set([
+    'response.completed',
+    'response.failed',
+    'response.incomplete',
+]);
+//#endregion
+/**
+ * Build incremental output item updates from responses stream events.
+ * Yields all item types cumulatively - same item may be emitted multiple times
+ * with the same ID but progressively updated content as streaming progresses.
+ */
+export async function* buildItemsStream(stream) {
+    const consumer = stream.createConsumer();
+    const itemsInProgress = new Map();
+    for await (const event of consumer) {
+        if (!('type' in event)) {
+            continue;
+        }
+        if (streamTerminationEvents.has(event.type)) {
+            return;
+        }
+        const handler = itemsStreamHandlers[event.type];
+        if (handler) {
+            const result = handler(event, itemsInProgress);
+            if (result) {
+                yield result;
+            }
+        }
+    }
+}
 /**
  * Build incremental message updates from responses stream events
  * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage