@openrouter/sdk 0.1.25 → 0.2.6

package/esm/lib/response-wrapper.js

@@ -1,8 +1,8 @@
-import { betaResponsesSend } from "../funcs/betaResponsesSend.js";
-import { ReusableReadableStream } from "./reusable-stream.js";
-import { extractTextDeltas, extractReasoningDeltas, extractToolDeltas, buildMessageStream, consumeStreamForCompletion, extractMessageFromResponse, extractTextFromResponse, extractToolCallsFromResponse, buildToolCallStream, } from "./stream-transformers.js";
-import { hasExecuteFunction, } from "./tool-types.js";
-import { executeTool, } from "./tool-executor.js";
+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';
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
  *
@@ -39,7 +39,10 @@ export class ResponseWrapper {
         }
         this.initPromise = (async () => {
             // Force stream mode
-            const request = { ...this.options.request, stream: true };
+            const request = {
+                ...this.options.request,
+                stream: true,
+            };
             // Create the stream promise
             this.streamPromise = betaResponsesSend(this.options.client, request, this.options.options).then((result) => {
                 if (!result.ok) {
@@ -64,14 +67,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) => 'type' in item && item.type === 'function_call');
             if (!shouldAutoExecute) {
                 // No tools to execute, use initial response
                 this.finalResponse = initialResponse;
@@ -107,18 +110,22 @@ 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,
                         messageHistory: currentInput,
-                        ...(this.options.request.model && { model: this.options.request.model }),
-                        ...(this.options.request.models && { models: this.options.request.models }),
+                        ...(this.options.request.model && {
+                            model: this.options.request.model,
+                        }),
+                        ...(this.options.request.models && {
+                            models: this.options.request.models,
+                        }),
                     };
                     const shouldContinue = maxToolRounds(turnContext);
                     if (!shouldContinue) {
@@ -135,8 +142,12 @@ export class ResponseWrapper {
                 const turnContext = {
                     numberOfTurns: currentRound + 1, // 1-indexed
                     messageHistory: currentInput,
-                    ...(this.options.request.model && { model: this.options.request.model }),
-                    ...(this.options.request.models && { models: this.options.request.models }),
+                    ...(this.options.request.model && {
+                        model: this.options.request.model,
+                    }),
+                    ...(this.options.request.models && {
+                        models: this.options.request.models,
+                    }),
                 };
                 // Execute all tool calls
                 const toolResults = [];
@@ -151,18 +162,24 @@ export class ResponseWrapper {
                         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
-                            ? JSON.stringify({ error: result.error.message })
+                            ? JSON.stringify({
+                                error: result.error.message,
+                            })
                             : JSON.stringify(result.result),
                     });
                 }
                 // Build new input with tool results
                 // For the Responses API, we need to include the tool results in the input
                 const newInput = [
-                    ...(Array.isArray(currentResponse.output) ? currentResponse.output : [currentResponse.output]),
+                    ...(Array.isArray(currentResponse.output)
+                        ? currentResponse.output
+                        : [
+                            currentResponse.output,
+                        ]),
                     ...toolResults,
                 ];
                 // Update current input for next iteration
@@ -179,7 +196,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 (value && typeof value === 'object' && 'toReadableStream' in value) {
                     // It's a stream, consume it
                     const stream = new ReusableReadableStream(value);
                     currentResponse = await consumeStreamForCompletion(stream);
@@ -205,7 +222,7 @@ export class ResponseWrapper {
         this.messagePromise = (async () => {
             await this.executeToolsIfNeeded();
             if (!this.finalResponse) {
-                throw new Error("Response not available");
+                throw new Error('Response not available');
             }
             return extractMessageFromResponse(this.finalResponse);
         })();
@@ -222,7 +239,7 @@ export class ResponseWrapper {
         this.textPromise = (async () => {
             await this.executeToolsIfNeeded();
             if (!this.finalResponse) {
-                throw new Error("Response not available");
+                throw new Error('Response not available');
             }
             return extractTextFromResponse(this.finalResponse);
         })();
@@ -236,7 +253,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;
     }
@@ -246,10 +263,10 @@ export class ResponseWrapper {
      * Includes preliminary tool result events after tool execution.
      */
     getFullResponsesStream() {
-        return (async function* () {
+        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
@@ -262,27 +279,27 @@ 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(),
                     };
                 }
             }
-        }.call(this));
+        }.call(this);
     }
     /**
      * Stream only text deltas as they arrive.
      * This filters the full event stream to only yield text content.
      */
     getTextStream() {
-        return (async function* () {
+        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));
+        }.call(this);
     }
     /**
      * Stream incremental message updates as content is added.
@@ -291,10 +308,10 @@ export class ResponseWrapper {
      * Returns AssistantMessage or ToolResponseMessage in chat format.
      */
     getNewMessagesStream() {
-        return (async function* () {
+        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);
@@ -315,8 +332,8 @@ export class ResponseWrapper {
                         : undefined;
                     // Yield tool response message
                     yield {
-                        role: "tool",
-                        content: result !== undefined ? JSON.stringify(result) : "",
+                        role: 'tool',
+                        content: result !== undefined ? JSON.stringify(result) : '',
                         toolCallId: toolCall.id,
                     };
                 }
@@ -324,25 +341,25 @@ export class ResponseWrapper {
             // If tools were executed, yield the final assistant 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) => 'type' in item && item.type === 'message');
                 if (hasMessage) {
                     yield extractMessageFromResponse(this.finalResponse);
                 }
             }
-        }.call(this));
+        }.call(this);
     }
     /**
      * Stream only reasoning deltas as they arrive.
      * This filters the full event stream to only yield reasoning content.
      */
     getReasoningStream() {
-        return (async function* () {
+        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));
+        }.call(this);
     }
     /**
      * Stream tool call argument deltas and preliminary results.
@@ -351,14 +368,17 @@ export class ResponseWrapper {
      * - Preliminary results as { type: "preliminary_result", toolCallId, result }
      */
     getToolStream() {
-        return (async function* () {
+        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", content: delta };
+                yield {
+                    type: 'delta',
+                    content: delta,
+                };
             }
             // After stream completes, check if tools were executed and emit preliminary results
             await this.executeToolsIfNeeded();
@@ -366,13 +386,13 @@ export class ResponseWrapper {
             for (const [toolCallId, results] of this.preliminaryResults) {
                 for (const result of results) {
                     yield {
-                        type: "preliminary_result",
+                        type: 'preliminary_result',
                         toolCallId,
                         result,
                     };
                 }
             }
-        }.call(this));
+        }.call(this);
     }
     /**
      * Stream events in chat format (compatibility layer).
@@ -385,28 +405,29 @@ export class ResponseWrapper {
      * this may not be a perfect mapping.
      */
     getFullChatStream() {
-        return (async function* () {
+        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") {
+                if (event.type === 'response.output_text.delta') {
                     const deltaEvent = event;
                     yield {
-                        type: "content.delta",
+                        type: 'content.delta',
                         delta: deltaEvent.delta,
                     };
                 }
-                else if (event.type === "response.completed") {
+                else if (event.type === 'response.completed') {
                     const completedEvent = event;
                     yield {
-                        type: "message.complete",
+                        type: 'message.complete',
                         response: completedEvent.response,
                     };
                 }
@@ -424,13 +445,13 @@ 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,
                     };
                 }
             }
-        }.call(this));
+        }.call(this);
     }
     /**
      * Get all tool calls from the completed response (before auto-execution).
@@ -441,7 +462,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);
@@ -451,13 +472,13 @@ export class ResponseWrapper {
      * Each iteration yields a complete tool call with parsed arguments.
      */
     getToolCallsStream() {
-        return (async function* () {
+        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));
+        }.call(this);
     }
     /**
      * Cancel the underlying stream and all consumers

package/esm/lib/reusable-stream.js

@@ -41,22 +41,34 @@ export class ReusableReadableStream {
             async next() {
                 const consumer = self.consumers.get(consumerId);
                 if (!consumer) {
-                    return { done: true, value: undefined };
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
                 }
                 if (consumer.cancelled) {
-                    return { done: true, value: undefined };
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
                 }
                 // If we have buffered data at this position, return it
                 if (consumer.position < self.buffer.length) {
                     const value = self.buffer[consumer.position];
                     consumer.position++;
                     // Note: We don't clean up buffer to allow sequential/reusable access
-                    return { done: false, value };
+                    return {
+                        done: false,
+                        value,
+                    };
                 }
                 // If source is complete and we've read everything, we're done
                 if (self.sourceComplete) {
                     self.consumers.delete(consumerId);
-                    return { done: true, value: undefined };
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
                 }
                 // If source had an error, propagate it
                 if (self.sourceError) {
@@ -66,7 +78,10 @@ export class ReusableReadableStream {
                 // Wait for more data - but check conditions after setting up the promise
                 // to avoid race condition where source completes between check and wait
                 const waitPromise = new Promise((resolve, reject) => {
-                    consumer.waitingPromise = { resolve, reject };
+                    consumer.waitingPromise = {
+                        resolve,
+                        reject,
+                    };
                 });
                 // Double-check conditions after setting up promise to handle race
                 if (self.sourceComplete || self.sourceError || consumer.position < self.buffer.length) {
@@ -86,7 +101,10 @@ export class ReusableReadableStream {
                     consumer.cancelled = true;
                     self.consumers.delete(consumerId);
                 }
-                return { done: true, value: undefined };
+                return {
+                    done: true,
+                    value: undefined,
+                };
             },
             async throw(e) {
                 const consumer = self.consumers.get(consumerId);
@@ -105,8 +123,9 @@ export class ReusableReadableStream {
      * Start pumping data from the source stream into the buffer
      */
     startPump() {
-        if (this.pumpStarted)
+        if (this.pumpStarted) {
             return;
+        }
         this.pumpStarted = true;
         this.sourceReader = this.sourceStream.getReader();
         void (async () => {

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

@@ -1,6 +1,6 @@
-import * as models from "../models/index.js";
-import { ReusableReadableStream } from "./reusable-stream.js";
-import { ParsedToolCall } from "./tool-types.js";
+import type * as models from '../models/index.js';
+import type { ReusableReadableStream } from './reusable-stream.js';
+import type { ParsedToolCall } from './tool-types.js';
 /**
  * Extract text deltas from responses stream events
  */