@openrouter/sdk 0.3.1 → 0.3.7

package/esm/lib/{response-wrapper.js → model-result.js}

@@ -1,26 +1,60 @@
-import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
-import { ReusableReadableStream } from './reusable-stream.js';
-import { buildMessageStream, buildToolCallStream, consumeStreamForCompletion, extractMessageFromResponse, extractReasoningDeltas, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from './stream-transformers.js';
-import { executeTool } from './tool-executor.js';
-import { hasExecuteFunction } from './tool-types.js';
+import { betaResponsesSend } from "../funcs/betaResponsesSend.js";
+import { ReusableReadableStream } from "./reusable-stream.js";
+import { buildResponsesMessageStream, buildToolCallStream, consumeStreamForCompletion, extractReasoningDeltas, extractResponsesMessageFromResponse, extractTextDeltas, extractTextFromResponse, extractToolCallsFromResponse, extractToolDeltas, } from "./stream-transformers.js";
+import { executeTool } from "./tool-executor.js";
+import { hasExecuteFunction } from "./tool-types.js";
+/**
+ * Type guard for stream event with toReadableStream method
+ */
+function isEventStream(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        "toReadableStream" in value &&
+        typeof value.toReadableStream ===
+            "function");
+}
+/**
+ * Type guard for response.output_text.delta events
+ */
+function isOutputTextDeltaEvent(event) {
+    return "type" in event && event.type === "response.output_text.delta";
+}
+/**
+ * Type guard for response.completed events
+ */
+function isResponseCompletedEvent(event) {
+    return "type" in event && event.type === "response.completed";
+}
+/**
+ * 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.
  *
  * Allows consuming the response in multiple ways:
- * - `await response.getMessage()` - Get the completed message
- * - `await response.getText()` - Get just the text
- * - `for await (const delta of response.getTextStream())` - Stream text deltas
- * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
- * - `for await (const event of response.getFullResponsesStream())` - Stream all response events
+ * - `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 event of result.getFullResponsesStream())` - Stream all response events
+ *
+ * For message format conversion, use the helper functions:
+ * - `toChatMessage(response)` for OpenAI chat format
+ * - `toClaudeMessage(response)` for Anthropic Claude format
  *
  * All consumption patterns can be used concurrently thanks to the underlying
  * ReusableReadableStream implementation.
  */
-export class ResponseWrapper {
+export class ModelResult {
     constructor(options) {
         this.reusableStream = null;
         this.streamPromise = null;
-        this.messagePromise = null;
         this.textPromise = null;
         this.initPromise = null;
         this.toolExecutionPromise = null;
@@ -78,14 +112,14 @@ export class ResponseWrapper {
         this.toolExecutionPromise = (async () => {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
+                throw new Error("Stream not initialized");
             }
             // Get the initial response
             const initialResponse = await consumeStreamForCompletion(this.reusableStream);
             // Check if we have tools and if auto-execution is enabled
             const shouldAutoExecute = this.options.tools &&
                 this.options.tools.length > 0 &&
-                initialResponse.output.some((item) => 'type' in item && item.type === 'function_call');
+                initialResponse.output.some((item) => hasTypeProperty(item) && item.type === "function_call");
             if (!shouldAutoExecute) {
                 // No tools to execute, use initial response
                 this.finalResponse = initialResponse;
@@ -121,12 +155,12 @@ export class ResponseWrapper {
                     break;
                 }
                 // Check if we should continue based on maxToolRounds
-                if (typeof maxToolRounds === 'number') {
+                if (typeof maxToolRounds === "number") {
                     if (currentRound >= maxToolRounds) {
                         break;
                     }
                 }
-                else if (typeof maxToolRounds === 'function') {
+                else if (typeof maxToolRounds === "function") {
                     // Function signature: (context: TurnContext) => boolean
                     const turnContext = {
                         numberOfTurns: currentRound + 1,
@@ -169,11 +203,12 @@ export class ResponseWrapper {
                     }
                     const result = await executeTool(tool, toolCall, turnContext);
                     // Store preliminary results
-                    if (result.preliminaryResults && result.preliminaryResults.length > 0) {
+                    if (result.preliminaryResults &&
+                        result.preliminaryResults.length > 0) {
                         this.preliminaryResults.set(toolCall.id, result.preliminaryResults);
                     }
                     toolResults.push({
-                        type: 'function_call_output',
+                        type: "function_call_output",
                         id: `output_${toolCall.id}`,
                         callId: toolCall.id,
                         output: result.error
@@ -188,9 +223,7 @@ export class ResponseWrapper {
                 const newInput = [
                     ...(Array.isArray(currentResponse.output)
                         ? currentResponse.output
-                        : [
-                            currentResponse.output,
-                        ]),
+                        : [currentResponse.output]),
                     ...toolResults,
                 ];
                 // Update current input for next iteration
@@ -207,7 +240,7 @@ export class ResponseWrapper {
                 }
                 // Handle the result - it might be a stream or a response
                 const value = newResult.value;
-                if (value && typeof value === 'object' && 'toReadableStream' in value) {
+                if (isEventStream(value)) {
                     // It's a stream, consume it
                     const stream = new ReusableReadableStream(value);
                     currentResponse = await consumeStreamForCompletion(stream);
@@ -225,23 +258,14 @@ export class ResponseWrapper {
                 throw new Error("Invalid final response: missing required fields");
             }
             // Ensure the response is in a completed state (has output content)
-            if (!Array.isArray(currentResponse.output) || currentResponse.output.length === 0) {
+            if (!Array.isArray(currentResponse.output) ||
+                currentResponse.output.length === 0) {
                 throw new Error("Invalid final response: empty or invalid output");
             }
             this.finalResponse = currentResponse;
         })();
         return this.toolExecutionPromise;
     }
-    /**
-     * Internal helper to get the message after tool execution
-     */
-    async getMessageInternal() {
-        await this.executeToolsIfNeeded();
-        if (!this.finalResponse) {
-            throw new Error("Response not available");
-        }
-        return extractMessageFromResponse(this.finalResponse);
-    }
     /**
      * Internal helper to get the text after tool execution
      */
@@ -252,18 +276,6 @@ export class ResponseWrapper {
         }
         return extractTextFromResponse(this.finalResponse);
     }
-    /**
-     * Get the completed message from the response.
-     * This will consume the stream until completion, execute any tools, and extract the first message.
-     * Returns an AssistantMessage in chat format.
-     */
-    getMessage() {
-        if (this.messagePromise) {
-            return this.messagePromise;
-        }
-        this.messagePromise = this.getMessageInternal();
-        return this.messagePromise;
-    }
     /**
      * Get just the text content from the response.
      * This will consume the stream until completion, execute any tools, and extract the text.
@@ -283,7 +295,7 @@ export class ResponseWrapper {
     async getResponse() {
         await this.executeToolsIfNeeded();
         if (!this.finalResponse) {
-            throw new Error('Response not available');
+            throw new Error("Response not available");
         }
         return this.finalResponse;
     }
@@ -296,7 +308,7 @@ export class ResponseWrapper {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
+                throw new Error("Stream not initialized");
             }
             const consumer = this.reusableStream.createConsumer();
             // Yield original events directly
@@ -309,7 +321,7 @@ export class ResponseWrapper {
             for (const [toolCallId, results] of this.preliminaryResults) {
                 for (const result of results) {
                     yield {
-                        type: 'tool.preliminary_result',
+                        type: "tool.preliminary_result",
                         toolCallId,
                         result,
                         timestamp: Date.now(),
@@ -326,28 +338,28 @@ export class ResponseWrapper {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
+                throw new Error("Stream not initialized");
             }
             yield* extractTextDeltas(this.reusableStream);
         }.call(this);
     }
     /**
-     * Stream incremental message updates as content is added.
+     * 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 ToolResponseMessages after tool execution completes.
-     * Returns AssistantMessage or ToolResponseMessage in chat format.
+     * Also yields OpenResponsesFunctionCallOutput after tool execution completes.
+     * Returns ResponsesOutputMessage or OpenResponsesFunctionCallOutput compatible with OpenAI Responses API format.
      */
     getNewMessagesStream() {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
+                throw new Error("Stream not initialized");
             }
-            // First yield assistant messages from the stream
-            yield* buildMessageStream(this.reusableStream);
+            // First yield messages from the stream in responses format
+            yield* buildResponsesMessageStream(this.reusableStream);
             // Execute tools if needed
             await this.executeToolsIfNeeded();
-            // Yield tool response messages for each executed tool
+            // Yield function call output for each executed tool
             for (const round of this.allToolExecutionRounds) {
                 for (const toolCall of round.toolCalls) {
                     // Find the tool to check if it was executed
@@ -360,20 +372,21 @@ export class ResponseWrapper {
                     const result = prelimResults && prelimResults.length > 0
                         ? prelimResults[prelimResults.length - 1] // Last result is the final output
                         : undefined;
-                    // Yield tool response message
+                    // Yield function call output in responses format
                     yield {
-                        role: 'tool',
-                        content: result !== undefined ? JSON.stringify(result) : '',
-                        toolCallId: toolCall.id,
+                        type: "function_call_output",
+                        id: `output_${toolCall.id}`,
+                        callId: toolCall.id,
+                        output: result !== undefined ? JSON.stringify(result) : "",
                     };
                 }
             }
-            // If tools were executed, yield the final assistant message (if there is one)
+            // If tools were executed, yield the final message (if there is one)
             if (this.finalResponse && this.allToolExecutionRounds.length > 0) {
                 // Check if the final response contains a message
-                const hasMessage = this.finalResponse.output.some((item) => 'type' in item && item.type === 'message');
+                const hasMessage = this.finalResponse.output.some((item) => hasTypeProperty(item) && item.type === "message");
                 if (hasMessage) {
-                    yield extractMessageFromResponse(this.finalResponse);
+                    yield extractResponsesMessageFromResponse(this.finalResponse);
                 }
             }
         }.call(this);
@@ -386,7 +399,7 @@ export class ResponseWrapper {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
+                throw new Error("Stream not initialized");
             }
             yield* extractReasoningDeltas(this.reusableStream);
         }.call(this);
@@ -401,12 +414,12 @@ export class ResponseWrapper {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
+                throw new Error("Stream not initialized");
             }
             // Yield tool deltas as structured events
             for await (const delta of extractToolDeltas(this.reusableStream)) {
                 yield {
-                    type: 'delta',
+                    type: "delta",
                     content: delta,
                 };
             }
@@ -416,7 +429,7 @@ export class ResponseWrapper {
             for (const [toolCallId, results] of this.preliminaryResults) {
                 for (const result of results) {
                     yield {
-                        type: 'preliminary_result',
+                        type: "preliminary_result",
                         toolCallId,
                         result,
                     };
@@ -438,27 +451,24 @@ export class ResponseWrapper {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
+                throw new Error("Stream not initialized");
             }
             const consumer = this.reusableStream.createConsumer();
             for await (const event of consumer) {
-                if (!('type' in event)) {
+                if (!("type" in event)) {
                     continue;
                 }
-                // Transform responses events to chat-like format
-                // This is a simplified transformation - you may need to adjust based on your needs
-                if (event.type === 'response.output_text.delta') {
-                    const deltaEvent = event;
+                // Transform responses events to chat-like format using type guards
+                if (isOutputTextDeltaEvent(event)) {
                     yield {
-                        type: 'content.delta',
-                        delta: deltaEvent.delta,
+                        type: "content.delta",
+                        delta: event.delta,
                     };
                 }
-                else if (event.type === 'response.completed') {
-                    const completedEvent = event;
+                else if (isResponseCompletedEvent(event)) {
                     yield {
-                        type: 'message.complete',
-                        response: completedEvent.response,
+                        type: "message.complete",
+                        response: event.response,
                     };
                 }
                 else {
@@ -475,7 +485,7 @@ export class ResponseWrapper {
             for (const [toolCallId, results] of this.preliminaryResults) {
                 for (const result of results) {
                     yield {
-                        type: 'tool.preliminary_result',
+                        type: "tool.preliminary_result",
                         toolCallId,
                         result,
                     };
@@ -492,7 +502,7 @@ export class ResponseWrapper {
     async getToolCalls() {
         await this.initStream();
         if (!this.reusableStream) {
-            throw new Error('Stream not initialized');
+            throw new Error("Stream not initialized");
         }
         const completedResponse = await consumeStreamForCompletion(this.reusableStream);
         return extractToolCallsFromResponse(completedResponse);
@@ -505,7 +515,7 @@ export class ResponseWrapper {
         return async function* () {
             await this.initStream();
             if (!this.reusableStream) {
-                throw new Error('Stream not initialized');
+                throw new Error("Stream not initialized");
             }
             yield* buildToolCallStream(this.reusableStream);
         }.call(this);
@@ -519,4 +529,4 @@ export class ResponseWrapper {
         }
     }
 }
-//# sourceMappingURL=response-wrapper.js.map
+//# sourceMappingURL=model-result.js.map

package/esm/lib/primitives.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 74859f750b28
  */
 class InvariantError extends Error {
     constructor(message) {

package/esm/lib/retries.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b24a69d15639
  */
 import { isConnectionError, isTimeoutError } from "./http.js";
 const defaultBackoff = {

package/esm/lib/schemas.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: deb4b531fae1
  */
 import * as z from "zod/v4";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";

package/esm/lib/sdks.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8a6d91f1218d
  */
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");

package/esm/lib/security.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0502afa7922e
  */
 import { env } from "./env.js";
 export var SecurityErrorCode;

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

@@ -13,6 +13,11 @@ export declare function extractReasoningDeltas(stream: ReusableReadableStream<mo
  * Extract tool call argument deltas from responses stream events
  */
 export declare function extractToolDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+/**
+ * Build incremental message updates from responses stream events
+ * Returns ResponsesOutputMessage (assistant/responses format)
+ */
+export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.ResponsesOutputMessage>;
 /**
  * Build incremental message updates from responses stream events
  * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage
@@ -23,9 +28,13 @@ export declare function buildMessageStream(stream: ReusableReadableStream<models
  */
 export declare function consumeStreamForCompletion(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): Promise<models.OpenResponsesNonStreamingResponse>;
 /**
- * Extract the first message from a completed response
+ * Extract the first message from a completed response (chat format)
  */
 export declare function extractMessageFromResponse(response: models.OpenResponsesNonStreamingResponse): models.AssistantMessage;
+/**
+ * Extract the first message from a completed response (responses format)
+ */
+export declare function extractResponsesMessageFromResponse(response: models.OpenResponsesNonStreamingResponse): models.ResponsesOutputMessage;
 /**
  * Extract text from a response, either from outputText or by concatenating message content
  */
@@ -44,4 +53,21 @@ export declare function buildToolCallStream(stream: ReusableReadableStream<model
  * Check if a response contains any tool calls
  */
 export declare function responseHasToolCalls(response: models.OpenResponsesNonStreamingResponse): boolean;
+/**
+ * Convert OpenResponsesNonStreamingResponse to ClaudeMessage format
+ * Compatible with the Anthropic SDK BetaMessage type
+ */
+export declare function convertToClaudeMessage(response: models.OpenResponsesNonStreamingResponse): models.ClaudeMessage;
+/**
+ * Extract unsupported content by original type
+ */
+export declare function extractUnsupportedContent(message: models.ClaudeMessage, originalType: string): models.UnsupportedContent[];
+/**
+ * Check if message has any unsupported content
+ */
+export declare function hasUnsupportedContent(message: models.ClaudeMessage): boolean;
+/**
+ * Get summary of unsupported content types
+ */
+export declare function getUnsupportedContentSummary(message: models.ClaudeMessage): Record<string, number>;
 //# sourceMappingURL=stream-transformers.d.ts.map