@openrouter/sdk 0.2.6 → 0.2.9

package/esm/funcs/embeddingsGenerate.js

@@ -29,7 +29,7 @@ async function $do(client, request, options) {
     const path = pathToFunc("/embeddings")();
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
-        Accept: "application/json;q=1, text/event-stream;q=0",
+        Accept: "application/json",
     }));
     const secConfig = await extractSecurity(client._options.apiKey);
     const securityInput = secConfig == null ? {} : { apiKey: secConfig };
@@ -86,9 +86,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.CreateEmbeddingsResponse$inboundSchema), M.text(200, operations.CreateEmbeddingsResponse$inboundSchema, {
-        ctype: "text/event-stream",
-    }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors.PaymentRequiredResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.jsonErr(524, errors.EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors.ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, operations.CreateEmbeddingsResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(402, errors.PaymentRequiredResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.jsonErr(524, errors.EdgeNetworkTimeoutResponseError$inboundSchema), M.jsonErr(529, errors.ProviderOverloadedResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

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.9";
     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.9 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.9",
     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.9 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

@@ -29,6 +29,9 @@ 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 = {
     messages: Array<Message>;
     model?: string | undefined;
@@ -56,6 +59,7 @@ export type ChatGenerationParams = {
     tools?: Array<ToolDefinitionJson> | undefined;
     topP?: number | null | undefined;
     user?: string | undefined;
+    debug?: Debug | undefined;
 };
 /** @internal */
 export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
@@ -99,6 +103,13 @@ 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 = {
     messages: Array<Message$Outbound>;
     model?: string | undefined;
@@ -126,6 +137,7 @@ export type ChatGenerationParams$Outbound = {
     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>;

package/esm/models/chatgenerationparams.js

@@ -66,6 +66,17 @@ export function chatGenerationParamsStopToJSON(chatGenerationParamsStop) {
     return JSON.stringify(ChatGenerationParamsStop$outboundSchema.parse(chatGenerationParamsStop));
 }
 /** @internal */
+export const Debug$outboundSchema = z.object({
+    echoUpstreamBody: z.boolean().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        echoUpstreamBody: "echo_upstream_body",
+    });
+});
+export function debugToJSON(debug) {
+    return JSON.stringify(Debug$outboundSchema.parse(debug));
+}
+/** @internal */
 export const ChatGenerationParams$outboundSchema = z.object({
     messages: z.array(Message$outboundSchema),
     model: z.string().optional(),
@@ -95,6 +106,7 @@ export const ChatGenerationParams$outboundSchema = z.object({
     tools: z.array(ToolDefinitionJson$outboundSchema).optional(),
     topP: z.nullable(z.number()).optional(),
     user: z.string().optional(),
+    debug: z.lazy(() => Debug$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         frequencyPenalty: "frequency_penalty",

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -1,30 +1,15 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ChatMessageContentItemAudioFormat: {
-    readonly Wav: "wav";
-    readonly Mp3: "mp3";
-    readonly Flac: "flac";
-    readonly M4a: "m4a";
-    readonly Ogg: "ogg";
-    readonly Pcm16: "pcm16";
-    readonly Pcm24: "pcm24";
-};
-export type ChatMessageContentItemAudioFormat = OpenEnum<typeof ChatMessageContentItemAudioFormat>;
 export type ChatMessageContentItemAudioInputAudio = {
     data: string;
-    format: ChatMessageContentItemAudioFormat;
+    format: string;
 };
 export type ChatMessageContentItemAudio = {
     type: "input_audio";
     inputAudio: ChatMessageContentItemAudioInputAudio;
 };
 /** @internal */
-export declare const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, unknown>;
-/** @internal */
-export declare const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodType<string, ChatMessageContentItemAudioFormat>;
-/** @internal */
 export declare const ChatMessageContentItemAudioInputAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio, unknown>;
 /** @internal */
 export type ChatMessageContentItemAudioInputAudio$Outbound = {

package/esm/models/chatmessagecontentitemaudio.js

@@ -4,29 +4,15 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-export const ChatMessageContentItemAudioFormat = {
-    Wav: "wav",
-    Mp3: "mp3",
-    Flac: "flac",
-    M4a: "m4a",
-    Ogg: "ogg",
-    Pcm16: "pcm16",
-    Pcm24: "pcm24",
-};
-/** @internal */
-export const ChatMessageContentItemAudioFormat$inboundSchema = openEnums.inboundSchema(ChatMessageContentItemAudioFormat);
-/** @internal */
-export const ChatMessageContentItemAudioFormat$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemAudioFormat);
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$inboundSchema = z.object({
     data: z.string(),
-    format: ChatMessageContentItemAudioFormat$inboundSchema,
+    format: z.string(),
 });
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$outboundSchema = z.object({
     data: z.string(),
-    format: ChatMessageContentItemAudioFormat$outboundSchema,
+    format: z.string(),
 });
 export function chatMessageContentItemAudioInputAudioToJSON(chatMessageContentItemAudioInputAudio) {
     return JSON.stringify(ChatMessageContentItemAudioInputAudio$outboundSchema.parse(chatMessageContentItemAudioInputAudio));

package/esm/models/operations/createembeddings.d.ts

@@ -138,14 +138,13 @@ export type Usage = {
 /**
  * Embedding response
  */
-export type CreateEmbeddingsResponseBody = {
+export type CreateEmbeddingsResponse = {
     id?: string | undefined;
     object: ObjectT;
     data: Array<CreateEmbeddingsData>;
     model: string;
     usage?: Usage | undefined;
 };
-export type CreateEmbeddingsResponse = CreateEmbeddingsResponseBody | string;
 /** @internal */
 export type ImageUrl$Outbound = {
     url: string;
@@ -258,9 +257,6 @@ export declare function createEmbeddingsDataFromJSON(jsonString: string): SafePa
 export declare const Usage$inboundSchema: z.ZodType<Usage, unknown>;
 export declare function usageFromJSON(jsonString: string): SafeParseResult<Usage, SDKValidationError>;
 /** @internal */
-export declare const CreateEmbeddingsResponseBody$inboundSchema: z.ZodType<CreateEmbeddingsResponseBody, unknown>;
-export declare function createEmbeddingsResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateEmbeddingsResponseBody, SDKValidationError>;
-/** @internal */
 export declare const CreateEmbeddingsResponse$inboundSchema: z.ZodType<CreateEmbeddingsResponse, unknown>;
 export declare function createEmbeddingsResponseFromJSON(jsonString: string): SafeParseResult<CreateEmbeddingsResponse, SDKValidationError>;
 //# sourceMappingURL=createembeddings.d.ts.map

package/esm/models/operations/createembeddings.js

@@ -196,21 +196,13 @@ export function usageFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Usage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Usage' from JSON`);
 }
 /** @internal */
-export const CreateEmbeddingsResponseBody$inboundSchema = z.object({
+export const CreateEmbeddingsResponse$inboundSchema = z.object({
     id: z.string().optional(),
     object: ObjectT$inboundSchema,
     data: z.array(z.lazy(() => CreateEmbeddingsData$inboundSchema)),
     model: z.string(),
     usage: z.lazy(() => Usage$inboundSchema).optional(),
 });
-export function createEmbeddingsResponseBodyFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => CreateEmbeddingsResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateEmbeddingsResponseBody' from JSON`);
-}
-/** @internal */
-export const CreateEmbeddingsResponse$inboundSchema = z.union([
-    z.lazy(() => CreateEmbeddingsResponseBody$inboundSchema),
-    z.string(),
-]);
 export function createEmbeddingsResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => CreateEmbeddingsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateEmbeddingsResponse' from JSON`);
 }

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "0.2.6",
+  "version": "0.2.9",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.2.6",
+  "version": "0.2.9",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 300+ language models through a unified API.",
   "keywords": [