@openrouter/sdk 0.3.2 → 0.3.10

package/esm/lib/chat-compat.js

@@ -0,0 +1,112 @@
+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;
+        default: {
+            const exhaustiveCheck = role;
+            throw new Error(`Unhandled role type: ${exhaustiveCheck}`);
+        }
+    }
+}
+/**
+ * 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/claude-constants.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Claude-specific content block types
+ * Used for detecting Claude message format
+ */
+export declare const ClaudeContentBlockType: {
+    readonly Text: "text";
+    readonly Image: "image";
+    readonly ToolUse: "tool_use";
+    readonly ToolResult: "tool_result";
+};
+export type ClaudeContentBlockType = (typeof ClaudeContentBlockType)[keyof typeof ClaudeContentBlockType];
+/**
+ * Message roles that are NOT supported in Claude format
+ * Used for distinguishing Claude vs OpenAI format
+ */
+export declare const NonClaudeMessageRole: {
+    readonly System: "system";
+    readonly Developer: "developer";
+    readonly Tool: "tool";
+};
+export type NonClaudeMessageRole = (typeof NonClaudeMessageRole)[keyof typeof NonClaudeMessageRole];
+//# sourceMappingURL=claude-constants.d.ts.map

package/esm/lib/claude-constants.js

@@ -0,0 +1,20 @@
+/**
+ * Claude-specific content block types
+ * Used for detecting Claude message format
+ */
+export const ClaudeContentBlockType = {
+    Text: "text",
+    Image: "image",
+    ToolUse: "tool_use",
+    ToolResult: "tool_result",
+};
+/**
+ * Message roles that are NOT supported in Claude format
+ * Used for distinguishing Claude vs OpenAI format
+ */
+export const NonClaudeMessageRole = {
+    System: "system",
+    Developer: "developer",
+    Tool: "tool",
+};
+//# sourceMappingURL=claude-constants.js.map

package/esm/lib/claude-type-guards.d.ts

@@ -0,0 +1,10 @@
+import type * as models from "../models/index.js";
+/**
+ * Check if input is in Claude message format
+ * Uses structural analysis to detect Claude-specific patterns
+ *
+ * @param input - Input to check
+ * @returns True if input appears to be Claude format
+ */
+export declare function isClaudeStyleMessages(input: unknown): input is models.ClaudeMessageParam[];
+//# sourceMappingURL=claude-type-guards.d.ts.map

package/esm/lib/claude-type-guards.js

@@ -0,0 +1,70 @@
+import { ClaudeContentBlockType, NonClaudeMessageRole, } from "./claude-constants.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonClaudeRole(role) {
+    return (role === NonClaudeMessageRole.System ||
+        role === NonClaudeMessageRole.Developer ||
+        role === NonClaudeMessageRole.Tool);
+}
+function isClaudeToolResultBlock(block) {
+    if (!isRecord(block))
+        return false;
+    return block["type"] === ClaudeContentBlockType.ToolResult;
+}
+function isClaudeImageBlockWithSource(block) {
+    if (!isRecord(block))
+        return false;
+    return (block["type"] === ClaudeContentBlockType.Image &&
+        "source" in block &&
+        isRecord(block["source"]));
+}
+function isClaudeToolUseBlockWithId(block) {
+    if (!isRecord(block))
+        return false;
+    return (block["type"] === ClaudeContentBlockType.ToolUse &&
+        "id" in block &&
+        typeof block["id"] === "string");
+}
+function hasClaudeSpecificBlocks(content) {
+    for (const block of content) {
+        if (isClaudeToolResultBlock(block))
+            return true;
+        if (isClaudeImageBlockWithSource(block))
+            return true;
+        if (isClaudeToolUseBlockWithId(block))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if input is in Claude message format
+ * Uses structural analysis to detect Claude-specific patterns
+ *
+ * @param input - Input to check
+ * @returns True if input appears to be Claude format
+ */
+export function isClaudeStyleMessages(input) {
+    if (!Array.isArray(input) || input.length === 0) {
+        return false;
+    }
+    for (const msg of input) {
+        if (!isRecord(msg))
+            continue;
+        if (!("role" in msg))
+            continue;
+        if ("type" in msg)
+            continue; // Claude messages don't have top-level "type"
+        // If we find a non-Claude role, it's not Claude format
+        if (isNonClaudeRole(msg["role"])) {
+            return false;
+        }
+        // If we find Claude-specific content blocks, it's Claude format
+        const content = msg["content"];
+        if (Array.isArray(content) && hasClaudeSpecificBlocks(content)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=claude-type-guards.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.2";
+    readonly sdkVersion: "0.3.9";
     readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.2 2.788.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.3.9 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.2",
+    sdkVersion: "0.3.9",
     genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.3.2 2.788.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.3.9 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) {

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";