@openrouter/sdk 0.2.6 → 0.2.11

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.2.6";
+    readonly sdkVersion: "0.2.11";
     readonly genVersion: "2.768.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.2.6 2.768.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.2.11 2.768.0 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.2.6",
+    sdkVersion: "0.2.11",
     genVersion: "2.768.0",
-    userAgent: "speakeasy-sdk/typescript 0.2.6 2.768.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.2.11 2.768.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

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

@@ -34,6 +34,10 @@ export declare class ResponseWrapper {
     private preliminaryResults;
     private allToolExecutionRounds;
     constructor(options: GetResponseOptions);
+    /**
+     * Type guard to check if a value is a non-streaming response
+     */
+    private isNonStreamingResponse;
     /**
      * Initialize the stream if not already started
      * This is idempotent - multiple calls will return the same promise
@@ -44,6 +48,14 @@ export declare class ResponseWrapper {
      * This is idempotent - multiple calls will return the same promise
      */
     private executeToolsIfNeeded;
+    /**
+     * Internal helper to get the message after tool execution
+     */
+    private getMessageInternal;
+    /**
+     * Internal helper to get the text after tool execution
+     */
+    private getTextInternal;
     /**
      * Get the completed message from the response.
      * This will consume the stream until completion, execute any tools, and extract the first message.

package/esm/lib/response-wrapper.js

@@ -29,6 +29,17 @@ export class ResponseWrapper {
         this.allToolExecutionRounds = [];
         this.options = options;
     }
+    /**
+     * Type guard to check if a value is a non-streaming response
+     */
+    isNonStreamingResponse(value) {
+        return (value !== null &&
+            typeof value === "object" &&
+            "id" in value &&
+            "object" in value &&
+            "output" in value &&
+            !("toReadableStream" in value));
+    }
     /**
      * Initialize the stream if not already started
      * This is idempotent - multiple calls will return the same promise
@@ -201,15 +212,46 @@ export class ResponseWrapper {
                     const stream = new ReusableReadableStream(value);
                     currentResponse = await consumeStreamForCompletion(stream);
                 }
-                else {
+                else if (this.isNonStreamingResponse(value)) {
                     currentResponse = value;
                 }
+                else {
+                    throw new Error("Unexpected response type from API");
+                }
                 currentRound++;
             }
+            // Validate the final response has required fields
+            if (!currentResponse || !currentResponse.id || !currentResponse.output) {
+                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) {
+                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
+     */
+    async getTextInternal() {
+        await this.executeToolsIfNeeded();
+        if (!this.finalResponse) {
+            throw new Error("Response not available");
+        }
+        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.
@@ -219,13 +261,7 @@ export class ResponseWrapper {
         if (this.messagePromise) {
             return this.messagePromise;
         }
-        this.messagePromise = (async () => {
-            await this.executeToolsIfNeeded();
-            if (!this.finalResponse) {
-                throw new Error('Response not available');
-            }
-            return extractMessageFromResponse(this.finalResponse);
-        })();
+        this.messagePromise = this.getMessageInternal();
         return this.messagePromise;
     }
     /**
@@ -236,13 +272,7 @@ export class ResponseWrapper {
         if (this.textPromise) {
             return this.textPromise;
         }
-        this.textPromise = (async () => {
-            await this.executeToolsIfNeeded();
-            if (!this.finalResponse) {
-                throw new Error('Response not available');
-            }
-            return extractTextFromResponse(this.finalResponse);
-        })();
+        this.textPromise = this.getTextInternal();
         return this.textPromise;
     }
     /**

package/esm/lib/tool-orchestrator.js

@@ -40,23 +40,21 @@ export async function executeToolLoop(sendRequest, initialInput, tools, apiTools
         if (!hasExecutableTools) {
             break;
         }
-        // Execute all tool calls
-        const roundResults = [];
-        for (const toolCall of toolCalls) {
+        // Execute all tool calls in parallel (parallel tool calling)
+        const toolCallPromises = toolCalls.map(async (toolCall) => {
             const tool = findToolByName(tools, toolCall.name);
             if (!tool) {
                 // Tool not found in definitions
-                roundResults.push({
+                return {
                     toolCallId: toolCall.id,
                     toolName: toolCall.name,
                     result: null,
                     error: new Error(`Tool "${toolCall.name}" not found in tool definitions`),
-                });
-                continue;
+                };
             }
             if (!hasExecuteFunction(tool)) {
-                // Tool has no execute function - skip
-                continue;
+                // Tool has no execute function - return null to filter out
+                return null;
             }
             // Build turn context
             const turnContext = {
@@ -64,9 +62,33 @@ export async function executeToolLoop(sendRequest, initialInput, tools, apiTools
                 messageHistory: conversationInput,
             };
             // Execute the tool
-            const result = await executeTool(tool, toolCall, turnContext, onPreliminaryResult);
-            roundResults.push(result);
-        }
+            return executeTool(tool, toolCall, turnContext, onPreliminaryResult);
+        });
+        // Wait for all tool executions to complete in parallel
+        const settledResults = await Promise.allSettled(toolCallPromises);
+        // Process settled results, handling both fulfilled and rejected promises
+        const roundResults = [];
+        settledResults.forEach((settled, i) => {
+            const toolCall = toolCalls[i];
+            if (!toolCall)
+                return;
+            if (settled.status === "fulfilled") {
+                if (settled.value !== null) {
+                    roundResults.push(settled.value);
+                }
+            }
+            else {
+                // Promise rejected - create error result
+                roundResults.push({
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    result: null,
+                    error: settled.reason instanceof Error
+                        ? settled.reason
+                        : new Error(String(settled.reason)),
+                });
+            }
+        });
         toolExecutionResults.push(...roundResults);
         // Build array input with all output from previous response plus tool results
         // The API expects continuation via previousResponseId, not by including outputs

package/esm/models/chatgenerationparams.d.ts

@@ -5,13 +5,145 @@ import { Message, Message$Outbound } from "./message.js";
 import { ReasoningSummaryVerbosity } from "./reasoningsummaryverbosity.js";
 import { ResponseFormatJSONSchema, ResponseFormatJSONSchema$Outbound } from "./responseformatjsonschema.js";
 import { ResponseFormatTextGrammar, ResponseFormatTextGrammar$Outbound } from "./responseformattextgrammar.js";
+import { Schema0, Schema0$Outbound } from "./schema0.js";
 import { ToolDefinitionJson, ToolDefinitionJson$Outbound } from "./tooldefinitionjson.js";
+export declare const ChatGenerationParamsDataCollection: {
+    readonly Deny: "deny";
+    readonly Allow: "allow";
+};
+export type ChatGenerationParamsDataCollection = OpenEnum<typeof ChatGenerationParamsDataCollection>;
+export declare const Quantizations: {
+    readonly Int4: "int4";
+    readonly Int8: "int8";
+    readonly Fp4: "fp4";
+    readonly Fp6: "fp6";
+    readonly Fp8: "fp8";
+    readonly Fp16: "fp16";
+    readonly Bf16: "bf16";
+    readonly Fp32: "fp32";
+    readonly Unknown: "unknown";
+};
+export type Quantizations = OpenEnum<typeof Quantizations>;
+export declare const Sort: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+};
+export type Sort = OpenEnum<typeof Sort>;
+/**
+ * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
+ */
+export type ChatGenerationParamsMaxPrice = {
+    prompt?: any | undefined;
+    completion?: any | undefined;
+    image?: any | undefined;
+    audio?: any | undefined;
+    request?: any | undefined;
+};
+export type ChatGenerationParamsProvider = {
+    /**
+     * Whether to allow backup providers to serve requests
+     *
+     * @remarks
+     * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
+     * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
+     */
+    allowFallbacks?: boolean | null | undefined;
+    /**
+     * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
+     */
+    requireParameters?: boolean | null | undefined;
+    /**
+     * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+     *
+     * @remarks
+     * - allow: (default) allow providers which store user data non-transiently and may train on it
+     *
+     * - deny: use only providers which do not collect user data.
+     */
+    dataCollection?: ChatGenerationParamsDataCollection | null | undefined;
+    zdr?: boolean | null | undefined;
+    enforceDistillableText?: boolean | null | undefined;
+    /**
+     * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
+     */
+    order?: Array<Schema0> | null | undefined;
+    /**
+     * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
+     */
+    only?: Array<Schema0> | null | undefined;
+    /**
+     * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
+     */
+    ignore?: Array<Schema0> | null | undefined;
+    /**
+     * A list of quantization levels to filter the provider by.
+     */
+    quantizations?: Array<Quantizations> | null | undefined;
+    /**
+     * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
+     */
+    sort?: Sort | null | undefined;
+    /**
+     * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
+     */
+    maxPrice?: ChatGenerationParamsMaxPrice | undefined;
+    /**
+     * The minimum throughput (in tokens per second) required for this request. Only providers serving the model with at least this throughput will be used.
+     */
+    minThroughput?: number | null | undefined;
+    /**
+     * The maximum latency (in seconds) allowed for this request. Only providers serving the model with better than this latency will be used.
+     */
+    maxLatency?: number | null | undefined;
+};
+export type ChatGenerationParamsPluginResponseHealing = {
+    id: "response-healing";
+    enabled?: boolean | undefined;
+};
+export declare const ChatGenerationParamsPdfEngine: {
+    readonly MistralOcr: "mistral-ocr";
+    readonly PdfText: "pdf-text";
+    readonly Native: "native";
+};
+export type ChatGenerationParamsPdfEngine = OpenEnum<typeof ChatGenerationParamsPdfEngine>;
+export type ChatGenerationParamsPdf = {
+    engine?: ChatGenerationParamsPdfEngine | undefined;
+};
+export type ChatGenerationParamsPluginFileParser = {
+    id: "file-parser";
+    enabled?: boolean | undefined;
+    maxFiles?: number | undefined;
+    pdf?: ChatGenerationParamsPdf | undefined;
+};
+export declare const ChatGenerationParamsEngine: {
+    readonly Native: "native";
+    readonly Exa: "exa";
+};
+export type ChatGenerationParamsEngine = OpenEnum<typeof ChatGenerationParamsEngine>;
+export type ChatGenerationParamsPluginWeb = {
+    id: "web";
+    enabled?: boolean | undefined;
+    maxResults?: number | undefined;
+    searchPrompt?: string | undefined;
+    engine?: ChatGenerationParamsEngine | undefined;
+};
+export type ChatGenerationParamsPluginModeration = {
+    id: "moderation";
+};
+export type ChatGenerationParamsPluginUnion = ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing;
+export declare const ChatGenerationParamsRoute: {
+    readonly Fallback: "fallback";
+    readonly Sort: "sort";
+};
+export type ChatGenerationParamsRoute = OpenEnum<typeof ChatGenerationParamsRoute>;
 export declare const Effort: {
     readonly None: "none";
     readonly Minimal: "minimal";
     readonly Low: "low";
     readonly Medium: "medium";
     readonly High: "high";
+    readonly Xhigh: "xhigh";
 };
 export type Effort = OpenEnum<typeof Effort>;
 export type Reasoning = {
@@ -29,7 +161,27 @@ export type ChatGenerationParamsResponseFormatText = {
 };
 export type ChatGenerationParamsResponseFormatUnion = ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatPython;
 export type ChatGenerationParamsStop = string | Array<string>;
+export type Debug = {
+    echoUpstreamBody?: boolean | undefined;
+};
 export type ChatGenerationParams = {
+    /**
+     * When multiple model providers are available, optionally indicate your routing preference.
+     */
+    provider?: ChatGenerationParamsProvider | null | undefined;
+    /**
+     * Plugins you want to enable for this request, including their settings.
+     */
+    plugins?: Array<ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing> | undefined;
+    /**
+     * Routing strategy for multiple models: "fallback" (default) uses secondary models as backups, "sort" sorts all endpoints together by routing criteria.
+     */
+    route?: ChatGenerationParamsRoute | null | undefined;
+    user?: string | undefined;
+    /**
+     * A unique identifier for grouping related requests (e.g., a conversation or agent workflow) for observability. If provided in both the request body and the x-session-id header, the body value takes precedence. Maximum of 128 characters.
+     */
+    sessionId?: string | undefined;
     messages: Array<Message>;
     model?: string | undefined;
     models?: Array<string> | undefined;
@@ -55,9 +207,99 @@ export type ChatGenerationParams = {
     toolChoice?: any | undefined;
     tools?: Array<ToolDefinitionJson> | undefined;
     topP?: number | null | undefined;
-    user?: string | undefined;
+    debug?: Debug | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsDataCollection$outboundSchema: z.ZodType<string, ChatGenerationParamsDataCollection>;
+/** @internal */
+export declare const Quantizations$outboundSchema: z.ZodType<string, Quantizations>;
+/** @internal */
+export declare const Sort$outboundSchema: z.ZodType<string, Sort>;
+/** @internal */
+export type ChatGenerationParamsMaxPrice$Outbound = {
+    prompt?: any | undefined;
+    completion?: any | undefined;
+    image?: any | undefined;
+    audio?: any | undefined;
+    request?: any | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsMaxPrice$outboundSchema: z.ZodType<ChatGenerationParamsMaxPrice$Outbound, ChatGenerationParamsMaxPrice>;
+export declare function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice: ChatGenerationParamsMaxPrice): string;
+/** @internal */
+export type ChatGenerationParamsProvider$Outbound = {
+    allow_fallbacks?: boolean | null | undefined;
+    require_parameters?: boolean | null | undefined;
+    data_collection?: string | null | undefined;
+    zdr?: boolean | null | undefined;
+    enforce_distillable_text?: boolean | null | undefined;
+    order?: Array<Schema0$Outbound> | null | undefined;
+    only?: Array<Schema0$Outbound> | null | undefined;
+    ignore?: Array<Schema0$Outbound> | null | undefined;
+    quantizations?: Array<string> | null | undefined;
+    sort?: string | null | undefined;
+    max_price?: ChatGenerationParamsMaxPrice$Outbound | undefined;
+    min_throughput?: number | null | undefined;
+    max_latency?: number | null | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsProvider$outboundSchema: z.ZodType<ChatGenerationParamsProvider$Outbound, ChatGenerationParamsProvider>;
+export declare function chatGenerationParamsProviderToJSON(chatGenerationParamsProvider: ChatGenerationParamsProvider): string;
+/** @internal */
+export type ChatGenerationParamsPluginResponseHealing$Outbound = {
+    id: "response-healing";
+    enabled?: boolean | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginResponseHealing$outboundSchema: z.ZodType<ChatGenerationParamsPluginResponseHealing$Outbound, ChatGenerationParamsPluginResponseHealing>;
+export declare function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationParamsPluginResponseHealing: ChatGenerationParamsPluginResponseHealing): string;
+/** @internal */
+export declare const ChatGenerationParamsPdfEngine$outboundSchema: z.ZodType<string, ChatGenerationParamsPdfEngine>;
+/** @internal */
+export type ChatGenerationParamsPdf$Outbound = {
+    engine?: string | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPdf$outboundSchema: z.ZodType<ChatGenerationParamsPdf$Outbound, ChatGenerationParamsPdf>;
+export declare function chatGenerationParamsPdfToJSON(chatGenerationParamsPdf: ChatGenerationParamsPdf): string;
+/** @internal */
+export type ChatGenerationParamsPluginFileParser$Outbound = {
+    id: "file-parser";
+    enabled?: boolean | undefined;
+    max_files?: number | undefined;
+    pdf?: ChatGenerationParamsPdf$Outbound | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginFileParser$outboundSchema: z.ZodType<ChatGenerationParamsPluginFileParser$Outbound, ChatGenerationParamsPluginFileParser>;
+export declare function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser: ChatGenerationParamsPluginFileParser): string;
+/** @internal */
+export declare const ChatGenerationParamsEngine$outboundSchema: z.ZodType<string, ChatGenerationParamsEngine>;
+/** @internal */
+export type ChatGenerationParamsPluginWeb$Outbound = {
+    id: "web";
+    enabled?: boolean | undefined;
+    max_results?: number | undefined;
+    search_prompt?: string | undefined;
+    engine?: string | undefined;
 };
 /** @internal */
+export declare const ChatGenerationParamsPluginWeb$outboundSchema: z.ZodType<ChatGenerationParamsPluginWeb$Outbound, ChatGenerationParamsPluginWeb>;
+export declare function chatGenerationParamsPluginWebToJSON(chatGenerationParamsPluginWeb: ChatGenerationParamsPluginWeb): string;
+/** @internal */
+export type ChatGenerationParamsPluginModeration$Outbound = {
+    id: "moderation";
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginModeration$outboundSchema: z.ZodType<ChatGenerationParamsPluginModeration$Outbound, ChatGenerationParamsPluginModeration>;
+export declare function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsPluginModeration: ChatGenerationParamsPluginModeration): string;
+/** @internal */
+export type ChatGenerationParamsPluginUnion$Outbound = ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound;
+/** @internal */
+export declare const ChatGenerationParamsPluginUnion$outboundSchema: z.ZodType<ChatGenerationParamsPluginUnion$Outbound, ChatGenerationParamsPluginUnion>;
+export declare function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPluginUnion: ChatGenerationParamsPluginUnion): string;
+/** @internal */
+export declare const ChatGenerationParamsRoute$outboundSchema: z.ZodType<string, ChatGenerationParamsRoute>;
+/** @internal */
 export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
 /** @internal */
 export type Reasoning$Outbound = {
@@ -99,7 +341,19 @@ export type ChatGenerationParamsStop$Outbound = string | Array<string>;
 export declare const ChatGenerationParamsStop$outboundSchema: z.ZodType<ChatGenerationParamsStop$Outbound, ChatGenerationParamsStop>;
 export declare function chatGenerationParamsStopToJSON(chatGenerationParamsStop: ChatGenerationParamsStop): string;
 /** @internal */
+export type Debug$Outbound = {
+    echo_upstream_body?: boolean | undefined;
+};
+/** @internal */
+export declare const Debug$outboundSchema: z.ZodType<Debug$Outbound, Debug>;
+export declare function debugToJSON(debug: Debug): string;
+/** @internal */
 export type ChatGenerationParams$Outbound = {
+    provider?: ChatGenerationParamsProvider$Outbound | null | undefined;
+    plugins?: Array<ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound> | undefined;
+    route?: string | null | undefined;
+    user?: string | undefined;
+    session_id?: string | undefined;
     messages: Array<Message$Outbound>;
     model?: string | undefined;
     models?: Array<string> | undefined;
@@ -125,7 +379,7 @@ export type ChatGenerationParams$Outbound = {
     tool_choice?: any | undefined;
     tools?: Array<ToolDefinitionJson$Outbound> | undefined;
     top_p?: number | null | undefined;
-    user?: string | undefined;
+    debug?: Debug$Outbound | undefined;
 };
 /** @internal */
 export declare const ChatGenerationParams$outboundSchema: z.ZodType<ChatGenerationParams$Outbound, ChatGenerationParams>;