@openrouter/sdk 0.3.1 → 0.3.7

package/esm/lib/chat-compat.d.ts

@@ -0,0 +1,46 @@
+import type * as models from "../models/index.js";
+import { extractMessageFromResponse } from "./stream-transformers.js";
+/**
+ * Convert OpenAI chat-style messages to OpenResponses input format.
+ *
+ * This function transforms Message[] (OpenAI chat format) to OpenResponsesInput
+ * format that can be passed directly to callModel().
+ *
+ * @example
+ * ```typescript
+ * import { fromChatMessages } from '@openrouter/sdk';
+ *
+ * const chatMessages = [
+ *   { role: "system", content: "You are a helpful assistant." },
+ *   { role: "user", content: "Hello!" },
+ * ];
+ *
+ * const response = openrouter.callModel({
+ *   model: "openai/gpt-4",
+ *   input: fromChatMessages(chatMessages),
+ * });
+ * ```
+ */
+export declare function fromChatMessages(messages: models.Message[]): models.OpenResponsesInput;
+/**
+ * Convert an OpenResponses response to OpenAI chat message format.
+ *
+ * This function transforms OpenResponsesNonStreamingResponse to AssistantMessage
+ * (OpenAI chat format) for compatibility with code expecting chat responses.
+ *
+ * @example
+ * ```typescript
+ * import { toChatMessage } from '@openrouter/sdk';
+ *
+ * const response = await openrouter.callModel({
+ *   model: "openai/gpt-4",
+ *   input: "Hello!",
+ * });
+ *
+ * const openResponsesResult = await response.getResponse();
+ * const chatMessage = toChatMessage(openResponsesResult);
+ * // chatMessage is now { role: "assistant", content: "..." }
+ * ```
+ */
+export declare const toChatMessage: typeof extractMessageFromResponse;
+//# sourceMappingURL=chat-compat.d.ts.map

package/esm/lib/chat-compat.js

@@ -0,0 +1,108 @@
+import { OpenResponsesEasyInputMessageRoleUser, OpenResponsesEasyInputMessageRoleSystem, OpenResponsesEasyInputMessageRoleAssistant, OpenResponsesEasyInputMessageRoleDeveloper, } from "../models/openresponseseasyinputmessage.js";
+import { OpenResponsesFunctionCallOutputType } from "../models/openresponsesfunctioncalloutput.js";
+import { extractMessageFromResponse } from "./stream-transformers.js";
+/**
+ * Type guard for ToolResponseMessage
+ */
+function isToolResponseMessage(msg) {
+    return msg.role === "tool";
+}
+/**
+ * Type guard for AssistantMessage
+ */
+function isAssistantMessage(msg) {
+    return msg.role === "assistant";
+}
+/**
+ * Maps chat role strings to OpenResponses role types
+ */
+function mapChatRole(role) {
+    switch (role) {
+        case "user":
+            return OpenResponsesEasyInputMessageRoleUser.User;
+        case "system":
+            return OpenResponsesEasyInputMessageRoleSystem.System;
+        case "assistant":
+            return OpenResponsesEasyInputMessageRoleAssistant.Assistant;
+        case "developer":
+            return OpenResponsesEasyInputMessageRoleDeveloper.Developer;
+    }
+}
+/**
+ * Convert message content to a string representation.
+ * Handles string, null, undefined, and object content types.
+ */
+function contentToString(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (content === null || content === undefined) {
+        return "";
+    }
+    return JSON.stringify(content);
+}
+/**
+ * Convert OpenAI chat-style messages to OpenResponses input format.
+ *
+ * This function transforms Message[] (OpenAI chat format) to OpenResponsesInput
+ * format that can be passed directly to callModel().
+ *
+ * @example
+ * ```typescript
+ * import { fromChatMessages } from '@openrouter/sdk';
+ *
+ * const chatMessages = [
+ *   { role: "system", content: "You are a helpful assistant." },
+ *   { role: "user", content: "Hello!" },
+ * ];
+ *
+ * const response = openrouter.callModel({
+ *   model: "openai/gpt-4",
+ *   input: fromChatMessages(chatMessages),
+ * });
+ * ```
+ */
+export function fromChatMessages(messages) {
+    return messages.map((msg) => {
+        if (isToolResponseMessage(msg)) {
+            return {
+                type: OpenResponsesFunctionCallOutputType.FunctionCallOutput,
+                callId: msg.toolCallId,
+                output: contentToString(msg.content),
+            };
+        }
+        if (isAssistantMessage(msg)) {
+            return {
+                role: mapChatRole("assistant"),
+                content: contentToString(msg.content),
+            };
+        }
+        // System, user, developer messages
+        return {
+            role: mapChatRole(msg.role),
+            content: contentToString(msg.content),
+        };
+    });
+}
+/**
+ * Convert an OpenResponses response to OpenAI chat message format.
+ *
+ * This function transforms OpenResponsesNonStreamingResponse to AssistantMessage
+ * (OpenAI chat format) for compatibility with code expecting chat responses.
+ *
+ * @example
+ * ```typescript
+ * import { toChatMessage } from '@openrouter/sdk';
+ *
+ * const response = await openrouter.callModel({
+ *   model: "openai/gpt-4",
+ *   input: "Hello!",
+ * });
+ *
+ * const openResponsesResult = await response.getResponse();
+ * const chatMessage = toChatMessage(openResponsesResult);
+ * // chatMessage is now { role: "assistant", content: "..." }
+ * ```
+ */
+export const toChatMessage = extractMessageFromResponse;
+//# sourceMappingURL=chat-compat.js.map

package/esm/lib/chat-compat.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=chat-compat.test.d.ts.map

package/esm/lib/chat-compat.test.js

@@ -0,0 +1,282 @@
+import { describe, expect, it } from "vitest";
+import { fromChatMessages, toChatMessage } from "./chat-compat.js";
+/**
+ * Creates a properly typed mock OpenResponsesNonStreamingResponse for testing.
+ * This factory provides all required fields with sensible defaults.
+ */
+function createMockResponse(overrides) {
+    return {
+        id: "resp_test",
+        object: "response",
+        createdAt: Date.now(),
+        model: "openai/gpt-4",
+        status: "completed",
+        error: null,
+        incompleteDetails: null,
+        temperature: null,
+        topP: null,
+        metadata: null,
+        tools: [],
+        toolChoice: "auto",
+        parallelToolCalls: false,
+        ...overrides,
+    };
+}
+describe("fromChatMessages", () => {
+    describe("basic message conversion", () => {
+        it("converts user message with string content", () => {
+            const messages = [
+                { role: "user", content: "Hello, how are you?" },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                { role: "user", content: "Hello, how are you?" },
+            ]);
+        });
+        it("converts assistant message with string content", () => {
+            const messages = [
+                { role: "assistant", content: "I am doing well, thank you!" },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                { role: "assistant", content: "I am doing well, thank you!" },
+            ]);
+        });
+        it("converts system message with string content", () => {
+            const messages = [
+                { role: "system", content: "You are a helpful assistant." },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                { role: "system", content: "You are a helpful assistant." },
+            ]);
+        });
+        it("converts developer message with string content", () => {
+            const messages = [
+                { role: "developer", content: "Developer instructions here." },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                { role: "developer", content: "Developer instructions here." },
+            ]);
+        });
+        it("converts multiple messages in conversation", () => {
+            const messages = [
+                { role: "system", content: "You are helpful." },
+                { role: "user", content: "Hi" },
+                { role: "assistant", content: "Hello!" },
+                { role: "user", content: "How are you?" },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                { role: "system", content: "You are helpful." },
+                { role: "user", content: "Hi" },
+                { role: "assistant", content: "Hello!" },
+                { role: "user", content: "How are you?" },
+            ]);
+        });
+    });
+    describe("tool response message conversion", () => {
+        it("converts tool message to function_call_output", () => {
+            const messages = [
+                {
+                    role: "tool",
+                    content: "The weather is sunny and 72F",
+                    toolCallId: "call_abc123",
+                },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                {
+                    type: "function_call_output",
+                    callId: "call_abc123",
+                    output: "The weather is sunny and 72F",
+                },
+            ]);
+        });
+        it("converts tool message with object content by stringifying", () => {
+            const messages = [
+                {
+                    role: "tool",
+                    content: [{ type: "text", text: "Structured response" }],
+                    toolCallId: "call_def456",
+                },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                {
+                    type: "function_call_output",
+                    callId: "call_def456",
+                    output: JSON.stringify([{ type: "text", text: "Structured response" }]),
+                },
+            ]);
+        });
+    });
+    describe("content array handling", () => {
+        it("stringifies array content for user messages", () => {
+            const messages = [
+                {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello from array" }],
+                },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                {
+                    role: "user",
+                    content: JSON.stringify([{ type: "text", text: "Hello from array" }]),
+                },
+            ]);
+        });
+        it("stringifies array content for assistant messages", () => {
+            const messages = [
+                {
+                    role: "assistant",
+                    content: [{ type: "text", text: "Response in array" }],
+                },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([
+                {
+                    role: "assistant",
+                    content: JSON.stringify([{ type: "text", text: "Response in array" }]),
+                },
+            ]);
+        });
+    });
+    describe("null and empty content handling", () => {
+        it("handles null content in assistant message", () => {
+            const messages = [
+                { role: "assistant", content: null },
+            ];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([{ role: "assistant", content: "" }]);
+        });
+        it("handles empty string content", () => {
+            const messages = [{ role: "user", content: "" }];
+            const result = fromChatMessages(messages);
+            expect(result).toEqual([{ role: "user", content: "" }]);
+        });
+        it("handles empty messages array", () => {
+            const result = fromChatMessages([]);
+            expect(result).toEqual([]);
+        });
+    });
+});
+describe("toChatMessage", () => {
+    describe("basic message conversion", () => {
+        it("converts response with text output to AssistantMessage", () => {
+            const response = createMockResponse({
+                id: "resp_123",
+                output: [
+                    {
+                        id: "msg_1",
+                        type: "message",
+                        role: "assistant",
+                        status: "completed",
+                        content: [
+                            {
+                                type: "output_text",
+                                text: "Hello! How can I help you?",
+                                annotations: [],
+                            },
+                        ],
+                    },
+                ],
+                usage: {
+                    inputTokens: 10,
+                    outputTokens: 20,
+                    totalTokens: 30,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            const result = toChatMessage(response);
+            expect(result).toEqual({
+                role: "assistant",
+                content: "Hello! How can I help you?",
+            });
+        });
+        it("combines multiple text parts into single content string", () => {
+            const response = createMockResponse({
+                id: "resp_456",
+                output: [
+                    {
+                        id: "msg_1",
+                        type: "message",
+                        role: "assistant",
+                        status: "completed",
+                        content: [
+                            { type: "output_text", text: "Part 1. ", annotations: [] },
+                            { type: "output_text", text: "Part 2.", annotations: [] },
+                        ],
+                    },
+                ],
+                usage: {
+                    inputTokens: 5,
+                    outputTokens: 10,
+                    totalTokens: 15,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            const result = toChatMessage(response);
+            expect(result).toEqual({
+                role: "assistant",
+                content: "Part 1. Part 2.",
+            });
+        });
+        it("returns null content when message has no text", () => {
+            const response = createMockResponse({
+                id: "resp_789",
+                output: [
+                    {
+                        id: "msg_1",
+                        type: "message",
+                        role: "assistant",
+                        status: "completed",
+                        content: [],
+                    },
+                ],
+                usage: {
+                    inputTokens: 5,
+                    outputTokens: 0,
+                    totalTokens: 5,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            const result = toChatMessage(response);
+            expect(result).toEqual({
+                role: "assistant",
+                content: null,
+            });
+        });
+    });
+    describe("error handling", () => {
+        it("throws error when no message found in output", () => {
+            const response = createMockResponse({
+                id: "resp_err",
+                output: [
+                    {
+                        type: "function_call",
+                        callId: "call_1",
+                        name: "test_tool",
+                        arguments: "{}",
+                        id: "fc_1",
+                        status: "completed",
+                    },
+                ],
+                usage: {
+                    inputTokens: 5,
+                    outputTokens: 10,
+                    totalTokens: 15,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            expect(() => toChatMessage(response)).toThrow("No message found in response output");
+        });
+    });
+});
+//# sourceMappingURL=chat-compat.test.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.3.1";
-    readonly genVersion: "2.768.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.1 2.768.0 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.3.7";
+    readonly genVersion: "2.788.4";
+    readonly userAgent: "speakeasy-sdk/typescript 0.3.7 2.788.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 320761608fb3
  */
 import { pathToFunc } from "./url.js";
 /**
@@ -25,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.3.1",
-    genVersion: "2.768.0",
-    userAgent: "speakeasy-sdk/typescript 0.3.1 2.768.0 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.3.7",
+    genVersion: "2.788.4",
+    userAgent: "speakeasy-sdk/typescript 0.3.7 2.788.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/dlv.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b1988214835a
  */
 /*
 MIT License

package/esm/lib/encodings.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3bd8ead98afd
  */
 import { bytesToBase64 } from "./base64.js";
 import { isPlainObject } from "./is-plain-object.js";

package/esm/lib/env.js

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

package/esm/lib/event-streams.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3f731f808a79
  */
 export class EventStream extends ReadableStream {
     constructor(responseBody, parse) {
@@ -20,7 +21,7 @@ export class EventStream extends ReadableStream {
                         const message = buffer.slice(0, match.index);
                         buffer = buffer.slice(match.index + match.length);
                         const item = parseMessage(message, parse);
-                        if (item?.value)
+                        if (item && !item.done)
                             return downstream.enqueue(item.value);
                         if (item?.done) {
                             await upstream.cancel("done");

package/esm/lib/files.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e5efa54fcb95
  */
 /**
  * Consumes a stream and returns a concatenated array buffer. Useful in

package/esm/lib/http.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 63a80782d37e
  */
 const DEFAULT_FETCHER = (input, init) => {
     // If input is a Request and init is undefined, Bun will discard the method,

package/esm/lib/is-plain-object.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b9862591096a
  */
 /*
 MIT License

package/esm/lib/logger.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7ee7741a02bf
  */
 export {};
 //# sourceMappingURL=logger.js.map

package/esm/lib/matchers.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d54b2253b719
  */
 import { OpenRouterDefaultError } from "../models/errors/openrouterdefaulterror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";

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

@@ -1,7 +1,7 @@
-import type { OpenRouterCore } from '../core.js';
-import type * as models from '../models/index.js';
-import type { RequestOptions } from './sdks.js';
-import type { ChatStreamEvent, EnhancedResponseStreamEvent, Tool, MaxToolRounds, ParsedToolCall, ToolStreamEvent } from './tool-types.js';
+import type { OpenRouterCore } from "../core.js";
+import type * as models from "../models/index.js";
+import type { RequestOptions } from "./sdks.js";
+import type { ChatStreamEvent, EnhancedResponseStreamEvent, Tool, MaxToolRounds, ParsedToolCall, ToolStreamEvent } from "./tool-types.js";
 export interface GetResponseOptions {
     request: models.OpenResponsesRequest;
     client: OpenRouterCore;
@@ -13,19 +13,22 @@ export interface GetResponseOptions {
  * 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 declare class ResponseWrapper {
+export declare class ModelResult {
     private reusableStream;
     private streamPromise;
-    private messagePromise;
     private textPromise;
     private options;
     private initPromise;
@@ -48,20 +51,10 @@ 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.
-     * 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.
@@ -85,12 +78,12 @@ export declare class ResponseWrapper {
      */
     getTextStream(): AsyncIterableIterator<string>;
     /**
-     * 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(): AsyncIterableIterator<models.AssistantMessage | models.ToolResponseMessage>;
+    getNewMessagesStream(): AsyncIterableIterator<models.ResponsesOutputMessage | models.OpenResponsesFunctionCallOutput>;
     /**
      * Stream only reasoning deltas as they arrive.
      * This filters the full event stream to only yield reasoning content.
@@ -131,4 +124,4 @@ export declare class ResponseWrapper {
      */
     cancel(): Promise<void>;
 }
-//# sourceMappingURL=response-wrapper.d.ts.map
+//# sourceMappingURL=model-result.d.ts.map