@openrouter/sdk 0.1.18 → 0.1.23

package/esm/funcs/callModel.d.ts

@@ -0,0 +1,77 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { ResponseWrapper } from "../lib/response-wrapper.js";
+import * as models from "../models/index.js";
+import { EnhancedTool, MaxToolRounds } from "../lib/tool-types.js";
+/**
+ * Get a response with multiple consumption patterns
+ *
+ * @remarks
+ * Creates a response using the OpenResponses API in streaming mode and returns
+ * a wrapper that allows consuming the response in multiple ways:
+ *
+ * - `await response.getMessage()` - Get the completed message (tools auto-executed)
+ * - `await response.getText()` - Get just the text content (tools auto-executed)
+ * - `for await (const delta of response.getTextStream())` - Stream text deltas
+ * - `for await (const delta of response.getReasoningStream())` - Stream reasoning deltas
+ * - `for await (const event of response.getToolStream())` - Stream tool events (incl. preliminary results)
+ * - `for await (const toolCall of response.getToolCallsStream())` - Stream structured tool calls
+ * - `await response.getToolCalls()` - Get all tool calls from completed response
+ * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const event of response.getFullResponsesStream())` - Stream all events (incl. tool preliminary)
+ * - `for await (const event of response.getFullChatStream())` - Stream in chat format (incl. tool preliminary)
+ *
+ * All consumption patterns can be used concurrently on the same response.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * // Simple text extraction
+ * const response = openrouter.callModel({
+ *   model: "openai/gpt-4",
+ *   input: "Hello!"
+ * });
+ * const text = await response.getText();
+ * console.log(text);
+ *
+ * // With tools (automatic execution)
+ * const response = openrouter.callModel({
+ *   model: "openai/gpt-4",
+ *   input: "What's the weather in SF?",
+ *   tools: [{
+ *     type: "function",
+ *     function: {
+ *       name: "get_weather",
+ *       description: "Get current weather",
+ *       inputSchema: z.object({
+ *         location: z.string()
+ *       }),
+ *       outputSchema: z.object({
+ *         temperature: z.number(),
+ *         description: z.string()
+ *       }),
+ *       execute: async (params) => {
+ *         return { temperature: 72, description: "Sunny" };
+ *       }
+ *     }
+ *   }],
+ *   maxToolRounds: 5, // or function: (context: TurnContext) => boolean
+ * });
+ * const message = await response.getMessage(); // Tools auto-executed!
+ *
+ * // Stream with preliminary results
+ * for await (const event of response.getFullChatStream()) {
+ *   if (event.type === "content.delta") {
+ *     process.stdout.write(event.delta);
+ *   } else if (event.type === "tool.preliminary_result") {
+ *     console.log("Tool progress:", event.result);
+ *   }
+ * }
+ * ```
+ */
+export declare function callModel(client: OpenRouterCore, request: Omit<models.OpenResponsesRequest, "stream" | "tools"> & {
+    tools?: EnhancedTool[] | models.OpenResponsesRequest["tools"];
+    maxToolRounds?: MaxToolRounds;
+}, options?: RequestOptions): ResponseWrapper;
+//# sourceMappingURL=callModel.d.ts.map

package/esm/funcs/callModel.js

@@ -0,0 +1,100 @@
+import { ResponseWrapper } from "../lib/response-wrapper.js";
+import { convertEnhancedToolsToAPIFormat } from "../lib/tool-executor.js";
+/**
+ * Get a response with multiple consumption patterns
+ *
+ * @remarks
+ * Creates a response using the OpenResponses API in streaming mode and returns
+ * a wrapper that allows consuming the response in multiple ways:
+ *
+ * - `await response.getMessage()` - Get the completed message (tools auto-executed)
+ * - `await response.getText()` - Get just the text content (tools auto-executed)
+ * - `for await (const delta of response.getTextStream())` - Stream text deltas
+ * - `for await (const delta of response.getReasoningStream())` - Stream reasoning deltas
+ * - `for await (const event of response.getToolStream())` - Stream tool events (incl. preliminary results)
+ * - `for await (const toolCall of response.getToolCallsStream())` - Stream structured tool calls
+ * - `await response.getToolCalls()` - Get all tool calls from completed response
+ * - `for await (const msg of response.getNewMessagesStream())` - Stream incremental message updates
+ * - `for await (const event of response.getFullResponsesStream())` - Stream all events (incl. tool preliminary)
+ * - `for await (const event of response.getFullChatStream())` - Stream in chat format (incl. tool preliminary)
+ *
+ * All consumption patterns can be used concurrently on the same response.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * // Simple text extraction
+ * const response = openrouter.callModel({
+ *   model: "openai/gpt-4",
+ *   input: "Hello!"
+ * });
+ * const text = await response.getText();
+ * console.log(text);
+ *
+ * // With tools (automatic execution)
+ * const response = openrouter.callModel({
+ *   model: "openai/gpt-4",
+ *   input: "What's the weather in SF?",
+ *   tools: [{
+ *     type: "function",
+ *     function: {
+ *       name: "get_weather",
+ *       description: "Get current weather",
+ *       inputSchema: z.object({
+ *         location: z.string()
+ *       }),
+ *       outputSchema: z.object({
+ *         temperature: z.number(),
+ *         description: z.string()
+ *       }),
+ *       execute: async (params) => {
+ *         return { temperature: 72, description: "Sunny" };
+ *       }
+ *     }
+ *   }],
+ *   maxToolRounds: 5, // or function: (context: TurnContext) => boolean
+ * });
+ * const message = await response.getMessage(); // Tools auto-executed!
+ *
+ * // Stream with preliminary results
+ * for await (const event of response.getFullChatStream()) {
+ *   if (event.type === "content.delta") {
+ *     process.stdout.write(event.delta);
+ *   } else if (event.type === "tool.preliminary_result") {
+ *     console.log("Tool progress:", event.result);
+ *   }
+ * }
+ * ```
+ */
+export function callModel(client, request, options) {
+    const { tools, maxToolRounds, ...apiRequest } = request;
+    // Separate enhanced tools from API tools
+    let isEnhancedTools = false;
+    if (tools && tools.length > 0) {
+        const firstTool = tools[0];
+        isEnhancedTools = "function" in firstTool && firstTool.function && "inputSchema" in firstTool.function;
+    }
+    const enhancedTools = isEnhancedTools ? tools : undefined;
+    // Convert enhanced tools to API format if provided, otherwise use tools as-is
+    const apiTools = enhancedTools ? convertEnhancedToolsToAPIFormat(enhancedTools) : tools;
+    // Build the request with converted tools
+    const finalRequest = {
+        ...apiRequest,
+        ...(apiTools && { tools: apiTools }),
+    };
+    const wrapperOptions = {
+        client,
+        request: finalRequest,
+        options: options ?? {},
+    };
+    // Only pass enhanced tools to wrapper (needed for auto-execution)
+    if (enhancedTools) {
+        wrapperOptions.tools = enhancedTools;
+    }
+    if (maxToolRounds !== undefined) {
+        wrapperOptions.maxToolRounds = maxToolRounds;
+    }
+    return new ResponseWrapper(wrapperOptions);
+}
+//# sourceMappingURL=callModel.js.map

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.1.18";
+    readonly sdkVersion: "0.1.23";
     readonly genVersion: "2.755.9";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.18 2.755.9 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.1.23 2.755.9 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

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

package/esm/lib/response-wrapper.d.ts

@@ -0,0 +1,116 @@
+import { OpenRouterCore } from "../core.js";
+import { RequestOptions } from "./sdks.js";
+import * as models from "../models/index.js";
+import { EnhancedTool, ParsedToolCall, MaxToolRounds, EnhancedResponseStreamEvent, ToolStreamEvent, ChatStreamEvent } from "./tool-types.js";
+export interface GetResponseOptions {
+    request: models.OpenResponsesRequest;
+    client: OpenRouterCore;
+    options?: RequestOptions;
+    tools?: EnhancedTool[];
+    maxToolRounds?: MaxToolRounds;
+}
+/**
+ * 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
+ *
+ * All consumption patterns can be used concurrently thanks to the underlying
+ * ReusableReadableStream implementation.
+ */
+export declare class ResponseWrapper {
+    private reusableStream;
+    private streamPromise;
+    private messagePromise;
+    private textPromise;
+    private options;
+    private initPromise;
+    private toolExecutionPromise;
+    private finalResponse;
+    private preliminaryResults;
+    private allToolExecutionRounds;
+    constructor(options: GetResponseOptions);
+    /**
+     * Initialize the stream if not already started
+     * This is idempotent - multiple calls will return the same promise
+     */
+    private initStream;
+    /**
+     * Execute tools automatically if they are provided and have execute functions
+     * This is idempotent - multiple calls will return the same promise
+     */
+    private executeToolsIfNeeded;
+    /**
+     * 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(): Promise<models.AssistantMessage>;
+    /**
+     * Get just the text content from the response.
+     * This will consume the stream until completion, execute any tools, and extract the text.
+     */
+    getText(): Promise<string>;
+    /**
+     * Stream all response events as they arrive.
+     * Multiple consumers can iterate over this stream concurrently.
+     * Includes preliminary tool result events after tool execution.
+     */
+    getFullResponsesStream(): AsyncIterableIterator<EnhancedResponseStreamEvent>;
+    /**
+     * Stream only text deltas as they arrive.
+     * This filters the full event stream to only yield text content.
+     */
+    getTextStream(): AsyncIterableIterator<string>;
+    /**
+     * Stream incremental message updates as content is added.
+     * 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.
+     */
+    getNewMessagesStream(): AsyncIterableIterator<models.AssistantMessage | models.ToolResponseMessage>;
+    /**
+     * Stream only reasoning deltas as they arrive.
+     * This filters the full event stream to only yield reasoning content.
+     */
+    getReasoningStream(): AsyncIterableIterator<string>;
+    /**
+     * Stream tool call argument deltas and preliminary results.
+     * This filters the full event stream to yield:
+     * - Tool call argument deltas as { type: "delta", content: string }
+     * - Preliminary results as { type: "preliminary_result", toolCallId, result }
+     */
+    getToolStream(): AsyncIterableIterator<ToolStreamEvent>;
+    /**
+     * Stream events in chat format (compatibility layer).
+     * Note: This transforms responses API events into a chat-like format.
+     * Includes preliminary tool result events after tool execution.
+     *
+     * @remarks
+     * This is a compatibility method that attempts to transform the responses API
+     * stream into a format similar to the chat API. Due to differences in the APIs,
+     * this may not be a perfect mapping.
+     */
+    getFullChatStream(): AsyncIterableIterator<ChatStreamEvent>;
+    /**
+     * Get all tool calls from the completed response (before auto-execution).
+     * Note: If tools have execute functions, they will be automatically executed
+     * and this will return the tool calls from the initial response.
+     * Returns structured tool calls with parsed arguments.
+     */
+    getToolCalls(): Promise<ParsedToolCall[]>;
+    /**
+     * Stream structured tool call objects as they're completed.
+     * Each iteration yields a complete tool call with parsed arguments.
+     */
+    getToolCallsStream(): AsyncIterableIterator<ParsedToolCall>;
+    /**
+     * Cancel the underlying stream and all consumers
+     */
+    cancel(): Promise<void>;
+}
+//# sourceMappingURL=response-wrapper.d.ts.map