@openrouter/sdk 0.10.2 → 0.11.2

package/esm/lib/files.js

@@ -71,4 +71,22 @@ export function getContentTypeFromFileName(fileName) {
     };
     return mimeTypes[ext] || null;
 }
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+export function bytesToBlob(content, contentType) {
+    if (content instanceof Uint8Array) {
+        return new Blob([new Uint8Array(content)], { type: contentType });
+    }
+    return new Blob([content], { type: contentType });
+}
 //# sourceMappingURL=files.js.map

package/esm/lib/matchers.js

@@ -122,7 +122,6 @@ export function match(...matchers) {
                 raw = body;
                 break;
             default:
-                encoding;
                 throw new Error(`Unsupported response type: ${encoding}`);
         }
         if (matcher.enc === "fail") {

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

@@ -27,7 +27,7 @@ export interface GetResponseOptions<TTools extends readonly Tool[], TShared exte
     /** Callback invoked at the start of each tool execution turn */
     onTurnStart?: (context: TurnContext) => void | Promise<void>;
     /** Callback invoked at the end of each tool execution turn */
-    onTurnEnd?: (context: TurnContext, response: models.OpenResponsesNonStreamingResponse) => void | Promise<void>;
+    onTurnEnd?: (context: TurnContext, response: models.OpenResponsesResult) => void | Promise<void>;
 }
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
@@ -36,7 +36,7 @@ export interface GetResponseOptions<TTools extends readonly Tool[], TShared exte
  * - `await result.getText()` - Get just the text
  * - `await result.getResponse()` - Get the full response object
  * - `for await (const delta of result.getTextStream())` - Stream text deltas
- * - `for await (const msg of result.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of result.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of result.getFullResponsesStream())` - Stream all response events
  *
  * For message format conversion, use the helper functions:
@@ -203,11 +203,6 @@ export declare class ModelResult<TTools extends readonly Tool[], TShared extends
     /**
      * Make a follow-up API request with tool results.
      * Uses streaming and pipes events through the turn broadcaster when available.
-     *
-     * @param currentResponse - The response that contained tool calls
-     * @param toolResults - The results from executing those tools
-     * @param turnNumber - The turn number for this follow-up request
-     * @returns The new response from the API
      */
     private makeFollowupRequest;
     /**
@@ -270,9 +265,9 @@ export declare class ModelResult<TTools extends readonly Tool[], TShared extends
     /**
      * Get the complete response object including usage information.
      * This will consume the stream until completion and execute any tools.
-     * Returns the full OpenResponsesNonStreamingResponse with usage data (inputTokens, outputTokens, cachedTokens, etc.)
+     * Returns the full OpenResponsesResult with usage data (inputTokens, outputTokens, cachedTokens, etc.)
      */
-    getResponse(): Promise<models.OpenResponsesNonStreamingResponse>;
+    getResponse(): Promise<models.OpenResponsesResult>;
     /**
      * Stream all response events as they arrive across all turns.
      * Multiple consumers can iterate over this stream concurrently.
@@ -305,13 +300,13 @@ export declare class ModelResult<TTools extends readonly Tool[], TShared extends
      * 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.
+     * Stream cumulative message snapshots as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
-     * Also yields function_call items and OpenResponsesFunctionCallOutput after tool execution completes.
-     * Returns ResponsesOutputMessage, ResponsesOutputItemFunctionCall, or OpenResponsesFunctionCallOutput
+     * Also yields function_call items and FunctionCallOutputItem after tool execution completes.
+     * Returns OutputMessage, OutputFunctionCallItem, or FunctionCallOutputItem
      * compatible with OpenAI Responses API format.
      */
-    getNewMessagesStream(): AsyncIterableIterator<models.ResponsesOutputMessage | models.OpenResponsesFunctionCallOutput | models.ResponsesOutputItemFunctionCall>;
+    getNewMessagesStream(): AsyncIterableIterator<models.OutputMessage | models.FunctionCallOutputItem | models.OutputFunctionCallItem>;
     /**
      * Stream only reasoning deltas as they arrive from all turns.
      * This filters the full event stream to only yield reasoning content,

package/esm/lib/model-result.js

@@ -4,12 +4,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 { buildItemsStream, buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
+import { buildItemsStream, buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, itemsStreamHandlers, streamTerminationEvents, } 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 { hasExecuteFunction, isToolCallOutputEvent } from './tool-types.js';
 import { isStopConditionMet, stepCountIs } from './stop-conditions.js';
-import { isOutputMessage, isFunctionCallItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, isResponseCompletedEvent, isResponseFailedEvent, isResponseIncompleteEvent, isOutputTextDeltaEvent, isReasoningDeltaEvent, hasTypeProperty, } from './stream-type-guards.js';
+import { isFunctionCallItem, isResponseCompletedEvent, isResponseFailedEvent, isResponseIncompleteEvent, isOutputTextDeltaEvent, isReasoningDeltaEvent, 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.
@@ -39,7 +39,7 @@ function isEventStream(value) {
  * - `await result.getText()` - Get just the text
  * - `await result.getResponse()` - Get the full response object
  * - `for await (const delta of result.getTextStream())` - Stream text deltas
- * - `for await (const msg of result.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const msg of result.getNewMessagesStream())` - Stream cumulative message snapshots
  * - `for await (const event of result.getFullResponsesStream())` - Stream all response events
  *
  * For message format conversion, use the helper functions:
@@ -503,11 +503,17 @@ export class ModelResult {
                     ? settled.reason.message
                     : String(settled.reason);
                 this.broadcastToolResult(originalToolCall.id, { error: errorMessage });
-                toolResults.push({
+                const rejectedOutput = {
                     type: 'function_call_output',
                     id: `output_${originalToolCall.id}`,
                     callId: originalToolCall.id,
                     output: JSON.stringify({ error: errorMessage }),
+                };
+                toolResults.push(rejectedOutput);
+                this.turnBroadcaster?.push({
+                    type: 'tool.call_output',
+                    output: rejectedOutput,
+                    timestamp: Date.now(),
                 });
                 continue;
             }
@@ -516,19 +522,30 @@ export class ModelResult {
                 continue;
             if (value.type === 'parse_error') {
                 toolResults.push(value.output);
+                this.turnBroadcaster?.push({
+                    type: 'tool.call_output',
+                    output: value.output,
+                    timestamp: Date.now(),
+                });
                 continue;
             }
             const toolResult = (value.result.error
                 ? { error: value.result.error.message }
                 : value.result.result);
             this.broadcastToolResult(value.toolCall.id, toolResult, value.preliminaryResultsForCall.length > 0 ? value.preliminaryResultsForCall : undefined);
-            toolResults.push({
+            const executedOutput = {
                 type: 'function_call_output',
                 id: `output_${value.toolCall.id}`,
                 callId: value.toolCall.id,
                 output: value.result.error
                     ? JSON.stringify({ error: value.result.error.message })
                     : JSON.stringify(value.result.result),
+            };
+            toolResults.push(executedOutput);
+            this.turnBroadcaster?.push({
+                type: 'tool.call_output',
+                output: executedOutput,
+                timestamp: Date.now(),
             });
         }
         return toolResults;
@@ -570,14 +587,8 @@ export class ModelResult {
     /**
      * Make a follow-up API request with tool results.
      * Uses streaming and pipes events through the turn broadcaster when available.
-     *
-     * @param currentResponse - The response that contained tool calls
-     * @param toolResults - The results from executing those tools
-     * @param turnNumber - The turn number for this follow-up request
-     * @returns The new response from the API
      */
     async makeFollowupRequest(currentResponse, toolResults, turnNumber) {
-        // Build new input preserving original conversation + tool results
         const originalInput = this.resolvedRequest?.input;
         const normalizedOriginalInput = Array.isArray(originalInput)
             ? originalInput
@@ -603,7 +614,7 @@ export class ModelResult {
             ...this.resolvedRequest,
             stream: true,
         };
-        const newResult = await betaResponsesSend(this.options.client, { openResponsesRequest: newRequest }, this.options.options);
+        const newResult = await betaResponsesSend(this.options.client, { responsesRequest: newRequest }, this.options.options);
         if (!newResult.ok) {
             throw newResult.error;
         }
@@ -768,7 +779,7 @@ export class ModelResult {
             // Force stream mode for initial request
             const request = this.resolvedRequest;
             // Make the API request
-            const apiResult = await betaResponsesSend(this.options.client, { openResponsesRequest: request }, this.options.options);
+            const apiResult = await betaResponsesSend(this.options.client, { responsesRequest: request }, this.options.options);
             if (!apiResult.ok) {
                 throw apiResult.error;
             }
@@ -892,7 +903,7 @@ export class ModelResult {
         };
         this.resolvedRequest = request;
         // Make the API request
-        const apiResult = await betaResponsesSend(this.options.client, { openResponsesRequest: request }, this.options.options);
+        const apiResult = await betaResponsesSend(this.options.client, { responsesRequest: request }, this.options.options);
         if (!apiResult.ok) {
             throw apiResult.error;
         }
@@ -1021,7 +1032,7 @@ export class ModelResult {
     /**
      * Get the complete response object including usage information.
      * This will consume the stream until completion and execute any tools.
-     * Returns the full OpenResponsesNonStreamingResponse with usage data (inputTokens, outputTokens, cachedTokens, etc.)
+     * Returns the full OpenResponsesResult with usage data (inputTokens, outputTokens, cachedTokens, etc.)
      */
     async getResponse() {
         await this.executeToolsIfNeeded();
@@ -1103,39 +1114,43 @@ export class ModelResult {
             if (!this.reusableStream && !this.finalResponse) {
                 throw new Error('Stream not initialized');
             }
-            // Stream all items from the API response cumulatively
-            if (this.reusableStream) {
-                yield* buildItemsStream(this.reusableStream);
+            // No tools — stream single turn directly (no broadcaster needed)
+            if (!this.options.tools?.length) {
+                if (this.reusableStream) {
+                    yield* buildItemsStream(this.reusableStream);
+                }
+                return;
             }
-            // Execute tools if needed
-            await this.executeToolsIfNeeded();
-            // Yield function calls and outputs for each tool round
-            for (const round of this.allToolExecutionRounds) {
-                // Round 0's function_calls already yielded via buildItemsStream
-                if (round.round > 0) {
-                    for (const item of round.response.output) {
-                        if (isFunctionCallItem(item)) {
-                            yield item;
-                        }
-                    }
+            // Use turnBroadcaster (same pattern as getTextStream/getFullResponsesStream).
+            // executeToolsIfNeeded() drives tool execution in the background while we
+            // passively consume events from the broadcaster in real-time.
+            const { consumer, executionPromise } = this.startTurnBroadcasterExecution();
+            const itemsInProgress = new Map();
+            for await (const event of consumer) {
+                // Tool call outputs → yield directly as function_call_output items
+                if (isToolCallOutputEvent(event)) {
+                    yield event.output;
+                    continue;
                 }
-                for (const toolResult of round.toolResults) {
-                    yield toolResult;
+                // Stream termination → reset items map for next turn
+                if ('type' in event && streamTerminationEvents.has(event.type)) {
+                    itemsInProgress.clear();
                 }
-            }
-            // 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) ||
-                        isFunctionCallItem(item) ||
-                        isReasoningOutputItem(item) ||
-                        isWebSearchCallOutputItem(item) ||
-                        isFileSearchCallOutputItem(item) ||
-                        isImageGenerationCallOutputItem(item)) {
-                        yield item;
+                // API stream events → dispatch through item handlers
+                // Cast is necessary: TypeScript cannot narrow a union via Record key lookup,
+                // but `event.type in itemsStreamHandlers` guarantees the event is an
+                // StreamEvents whose type matches a handler key.
+                if ('type' in event && event.type in itemsStreamHandlers) {
+                    const handler = itemsStreamHandlers[event.type];
+                    if (handler) {
+                        const result = handler(event, itemsInProgress);
+                        if (result) {
+                            yield result;
+                        }
                     }
                 }
             }
+            await executionPromise;
         }.call(this);
     }
     /**
@@ -1143,10 +1158,10 @@ export class ModelResult {
      * 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.
+     * Stream cumulative message snapshots as content is added in responses format.
      * Each iteration yields an updated version of the message with new content.
-     * Also yields function_call items and OpenResponsesFunctionCallOutput after tool execution completes.
-     * Returns ResponsesOutputMessage, ResponsesOutputItemFunctionCall, or OpenResponsesFunctionCallOutput
+     * Also yields function_call items and FunctionCallOutputItem after tool execution completes.
+     * Returns OutputMessage, OutputFunctionCallItem, or FunctionCallOutputItem
      * compatible with OpenAI Responses API format.
      */
     getNewMessagesStream() {

package/esm/lib/next-turn-params.d.ts

@@ -4,10 +4,10 @@ import type { NextTurnParamsContext, ParsedToolCall, Tool } from './tool-types.j
  * Build a NextTurnParamsContext from the current request
  * Extracts relevant fields that can be modified by nextTurnParams functions
  *
- * @param request - The current OpenResponsesRequest
+ * @param request - The current ResponsesRequest
  * @returns Context object with current parameter values
  */
-export declare function buildNextTurnParamsContext(request: models.OpenResponsesRequest): NextTurnParamsContext;
+export declare function buildNextTurnParamsContext(request: models.ResponsesRequest): NextTurnParamsContext;
 /**
  * Execute nextTurnParams functions for all called tools
  * Composes functions when multiple tools modify the same parameter
@@ -17,7 +17,7 @@ export declare function buildNextTurnParamsContext(request: models.OpenResponses
  * @param currentRequest - The current request
  * @returns Object with computed parameter values
  */
-export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: models.OpenResponsesRequest): Promise<Partial<NextTurnParamsContext>>;
+export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: models.ResponsesRequest): Promise<Partial<NextTurnParamsContext>>;
 /**
  * Apply computed nextTurnParams to the current request
  * Returns a new request object with updated parameters
@@ -26,5 +26,5 @@ export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall
  * @param computedParams - Computed parameter values from nextTurnParams functions
  * @returns New request with updated parameters
  */
-export declare function applyNextTurnParamsToRequest(request: models.OpenResponsesRequest, computedParams: Partial<NextTurnParamsContext>): models.OpenResponsesRequest;
+export declare function applyNextTurnParamsToRequest(request: models.ResponsesRequest, computedParams: Partial<NextTurnParamsContext>): models.ResponsesRequest;
 //# sourceMappingURL=next-turn-params.d.ts.map

package/esm/lib/next-turn-params.js

@@ -8,7 +8,7 @@ function isRecord(value) {
  * Build a NextTurnParamsContext from the current request
  * Extracts relevant fields that can be modified by nextTurnParams functions
  *
- * @param request - The current OpenResponsesRequest
+ * @param request - The current ResponsesRequest
  * @returns Context object with current parameter values
  */
 export function buildNextTurnParamsContext(request) {

package/esm/lib/sdks.js

@@ -67,12 +67,16 @@ export class ClientSDK {
         if (!base) {
             return ERR(new InvalidRequestError("No base URL provided for operation"));
         }
-        const reqURL = new URL(base);
-        const inputURL = new URL(path, reqURL);
+        const baseURL = new URL(base);
+        let reqURL;
         if (path) {
-            reqURL.pathname += reqURL.pathname.endsWith("/") ? "" : "/";
-            reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
+            baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
+            reqURL = new URL(path, baseURL);
         }
+        else {
+            reqURL = baseURL;
+        }
+        reqURL.hash = "";
         let finalQuery = query || "";
         const secQuery = [];
         for (const [k, v] of Object.entries(security?.queryParams || {})) {
@@ -186,8 +190,8 @@ export class ClientSDK {
     }
 }
 _ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap();
-const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
-const jsonlLikeContentTypeRE = /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
+const jsonLikeContentTypeRE = /^(application|text)\/([^+]+\+)*json.*/;
+const jsonlLikeContentTypeRE = /^(application|text)\/([^+]+\+)*(jsonl|x-ndjson)\b.*/;
 async function logRequest(logger, req) {
     if (!logger) {
         return;

package/esm/lib/security.d.ts

@@ -77,7 +77,7 @@ type SecurityInputCustom = {
 };
 export type SecurityInput = SecurityInputBasic | SecurityInputBearer | SecurityInputAPIKey | SecurityInputOAuth2 | SecurityInputOAuth2ClientCredentials | SecurityInputOAuth2PasswordCredentials | SecurityInputOIDC | SecurityInputCustom;
 export declare function resolveSecurity(...options: SecurityInput[][]): SecurityState | null;
-export declare function resolveGlobalSecurity(security: Partial<models.Security> | null | undefined): SecurityState | null;
+export declare function resolveGlobalSecurity(security: Partial<models.Security> | null | undefined, allowedFields?: number[]): SecurityState | null;
 export declare function extractSecurity<T extends string | Record<string, unknown>>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined>;
 export {};
 //# sourceMappingURL=security.d.ts.map

package/esm/lib/security.js

@@ -96,8 +96,7 @@ export function resolveSecurity(...options) {
                 applyBearer(state, spec);
                 break;
             default:
-                spec;
-                throw SecurityError.unrecognizedType(type);
+                throw SecurityError.unrecognizedType((spec, type));
         }
     });
     return state;
@@ -120,14 +119,25 @@ function applyBearer(state, spec) {
         state.headers[spec.fieldName] = value;
     }
 }
-export function resolveGlobalSecurity(security) {
-    return resolveSecurity([
-        {
-            fieldName: "Authorization",
-            type: "http:bearer",
-            value: security?.apiKey ?? env().OPENROUTER_API_KEY,
-        },
-    ]);
+export function resolveGlobalSecurity(security, allowedFields) {
+    let inputs = [
+        [
+            {
+                fieldName: "Authorization",
+                type: "http:bearer",
+                value: security?.apiKey ?? env().OPENROUTER_API_KEY,
+            },
+        ],
+    ];
+    if (allowedFields) {
+        inputs = allowedFields.map((i) => {
+            if (i < 0 || i >= inputs.length) {
+                throw new RangeError(`invalid allowedFields index ${i}`);
+            }
+            return inputs[i];
+        });
+    }
+    return resolveSecurity(...inputs);
 }
 export async function extractSecurity(sec) {
     if (sec == null) {

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

@@ -5,72 +5,94 @@ import type { ParsedToolCall, Tool } from './tool-types.js';
 /**
  * Extract text deltas from responses stream events
  */
-export declare function extractTextDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractTextDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Extract reasoning deltas from responses stream events
  */
-export declare function extractReasoningDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractReasoningDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Extract tool call argument deltas from responses stream events
  */
-export declare function extractToolDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractToolDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Build incremental message updates from responses stream events
- * Returns ResponsesOutputMessage (assistant/responses format)
+ * Returns OutputMessage (assistant/responses format)
  */
-export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.ResponsesOutputMessage>;
+export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<models.OutputMessage>;
 /**
  * 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;
+export type StreamableOutputItem = models.OutputMessage | models.OutputFunctionCallItem | models.OutputReasoningItem | models.OutputWebSearchCallItem | models.OutputFileSearchCallItem | models.OutputImageGenerationCallItem | models.FunctionCallOutputItem;
+/**
+ * Discriminated union for tracking items in progress.
+ * Each variant has only the fields relevant to that item type.
+ */
+export type ItemInProgress = {
+    type: 'message';
+    id: string;
+    textContent: string;
+} | {
+    type: 'function_call';
+    id: string;
+    name: string;
+    callId: string;
+    argumentsAccumulated: string;
+} | {
+    type: 'reasoning';
+    id: string;
+    reasoningContent: string;
+};
+type ItemsStreamHandler = (event: models.StreamEvents, itemsInProgress: Map<string, ItemInProgress>) => StreamableOutputItem | undefined;
+export declare const itemsStreamHandlers: Record<string, ItemsStreamHandler>;
+export declare const streamTerminationEvents: Set<string>;
 /**
  * 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>;
+export declare function buildItemsStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<StreamableOutputItem>;
 /**
  * Build incremental message updates from responses stream events
- * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage
+ * Returns ChatAssistantMessage (chat format) instead of OutputMessage
  */
-export declare function buildMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.AssistantMessage>;
+export declare function buildMessageStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<models.ChatAssistantMessage>;
 /**
  * Consume stream until completion and return the complete response
  */
-export declare function consumeStreamForCompletion(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): Promise<models.OpenResponsesNonStreamingResponse>;
+export declare function consumeStreamForCompletion(stream: ReusableReadableStream<models.StreamEvents>): Promise<models.OpenResponsesResult>;
 /**
  * Extract the first message from a completed response (chat format)
  */
-export declare function extractMessageFromResponse(response: models.OpenResponsesNonStreamingResponse): models.AssistantMessage;
+export declare function extractMessageFromResponse(response: models.OpenResponsesResult): models.ChatAssistantMessage;
 /**
  * Extract the first message from a completed response (responses format)
  */
-export declare function extractResponsesMessageFromResponse(response: models.OpenResponsesNonStreamingResponse): models.ResponsesOutputMessage;
+export declare function extractResponsesMessageFromResponse(response: models.OpenResponsesResult): models.OutputMessage;
 /**
  * Extract text from a response, either from outputText or by concatenating message content
  */
-export declare function extractTextFromResponse(response: models.OpenResponsesNonStreamingResponse): string;
+export declare function extractTextFromResponse(response: models.OpenResponsesResult): string;
 /**
  * Extract all tool calls from a completed response
  * Returns parsed tool calls with arguments as objects (not JSON strings)
  */
-export declare function extractToolCallsFromResponse(response: models.OpenResponsesNonStreamingResponse): ParsedToolCall<Tool>[];
+export declare function extractToolCallsFromResponse(response: models.OpenResponsesResult): ParsedToolCall<Tool>[];
 /**
  * Build incremental tool call updates from responses stream events
  * Yields structured tool call objects as they're built from deltas
  */
-export declare function buildToolCallStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<ParsedToolCall<Tool>>;
+export declare function buildToolCallStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<ParsedToolCall<Tool>>;
 /**
  * Check if a response contains any tool calls
  */
-export declare function responseHasToolCalls(response: models.OpenResponsesNonStreamingResponse): boolean;
+export declare function responseHasToolCalls(response: models.OpenResponsesResult): boolean;
 /**
- * Convert OpenResponsesNonStreamingResponse to ClaudeMessage format
+ * Convert OpenResponsesResult to ClaudeMessage format
  * Compatible with the Anthropic SDK BetaMessage type
  */
-export declare function convertToClaudeMessage(response: models.OpenResponsesNonStreamingResponse): ClaudeMessage;
+export declare function convertToClaudeMessage(response: models.OpenResponsesResult): ClaudeMessage;
 /**
  * Extract unsupported content by original type
  */
@@ -83,4 +105,5 @@ export declare function hasUnsupportedContent(message: ClaudeMessage): boolean;
  * Get summary of unsupported content types
  */
 export declare function getUnsupportedContentSummary(message: ClaudeMessage): Record<string, number>;
+export {};
 //# sourceMappingURL=stream-transformers.d.ts.map

package/esm/lib/stream-transformers.js

@@ -101,12 +101,12 @@ async function* buildMessageStreamCore(stream) {
 }
 /**
  * Build incremental message updates from responses stream events
- * Returns ResponsesOutputMessage (assistant/responses format)
+ * Returns OutputMessage (assistant/responses format)
  */
 export async function* buildResponsesMessageStream(stream) {
     for await (const update of buildMessageStreamCore(stream)) {
         if (update.type === 'delta' && update.text !== undefined && update.messageId !== undefined) {
-            // Yield incremental update in ResponsesOutputMessage format
+            // Yield incremental update in OutputMessage format
             yield {
                 id: update.messageId,
                 type: 'message',
@@ -296,14 +296,14 @@ function handleOutputItemDone(event, itemsInProgress) {
     }
     return undefined;
 }
-const itemsStreamHandlers = {
+export 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([
+export const streamTerminationEvents = new Set([
     'response.completed',
     'response.failed',
     'response.incomplete',
@@ -335,7 +335,7 @@ export async function* buildItemsStream(stream) {
 }
 /**
  * Build incremental message updates from responses stream events
- * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage
+ * Returns ChatAssistantMessage (chat format) instead of OutputMessage
  */
 export async function* buildMessageStream(stream) {
     for await (const update of buildMessageStreamCore(stream)) {
@@ -376,7 +376,7 @@ export async function consumeStreamForCompletion(stream) {
     throw new Error('Stream ended without completion event');
 }
 /**
- * Convert ResponsesOutputMessage to AssistantMessage (chat format)
+ * Convert OutputMessage to ChatAssistantMessage (chat format)
  */
 function convertToAssistantMessage(outputMessage) {
     // Extract text content
@@ -423,9 +423,9 @@ export function extractTextFromResponse(response) {
         // No message in response (e.g., only function calls)
         return '';
     }
-    // Otherwise, extract from the first message (convert to AssistantMessage which has string content)
+    // Otherwise, extract from the first message (convert to ChatAssistantMessage which has string content)
     const message = extractMessageFromResponse(response);
-    // AssistantMessage.content is string | Array | null | undefined
+    // ChatAssistantMessage.content is string | Array | null | undefined
     if (typeof message.content === 'string') {
         return message.content;
     }
@@ -644,7 +644,7 @@ function mapStopReason(response) {
     return 'end_turn';
 }
 /**
- * Convert OpenResponsesNonStreamingResponse to ClaudeMessage format
+ * Convert OpenResponsesResult to ClaudeMessage format
  * Compatible with the Anthropic SDK BetaMessage type
  */
 export function convertToClaudeMessage(response) {