@openrouter/sdk 0.3.2 → 0.3.7

package/esm/lib/anthropic-compat.js

@@ -0,0 +1,204 @@
+import { OpenResponsesEasyInputMessageRoleUser, OpenResponsesEasyInputMessageRoleAssistant, } from "../models/openresponseseasyinputmessage.js";
+import { OpenResponsesInputMessageItemRoleUser, OpenResponsesInputMessageItemRoleSystem, } from "../models/openresponsesinputmessageitem.js";
+import { OpenResponsesFunctionCallOutputType } from "../models/openresponsesfunctioncalloutput.js";
+import { convertToClaudeMessage } from "./stream-transformers.js";
+/**
+ * Maps Claude role strings to OpenResponses role types
+ */
+function mapClaudeRole(role) {
+    if (role === "user") {
+        return OpenResponsesEasyInputMessageRoleUser.User;
+    }
+    return OpenResponsesEasyInputMessageRoleAssistant.Assistant;
+}
+/**
+ * Creates a properly typed OpenResponsesEasyInputMessage
+ */
+function createEasyInputMessage(role, content) {
+    return {
+        role: mapClaudeRole(role),
+        content,
+    };
+}
+/**
+ * Creates a properly typed OpenResponsesFunctionCallOutput
+ */
+function createFunctionCallOutput(callId, output) {
+    return {
+        type: OpenResponsesFunctionCallOutputType.FunctionCallOutput,
+        callId,
+        output,
+    };
+}
+/**
+ * Convert Anthropic Claude-style messages to OpenResponses input format.
+ *
+ * This function transforms ClaudeMessageParam[] (Anthropic SDK format) to
+ * OpenResponsesInput format that can be passed directly to callModel().
+ *
+ * @example
+ * ```typescript
+ * import { fromClaudeMessages } from '@openrouter/sdk';
+ *
+ * const claudeMessages = [
+ *   { role: "user", content: "Hello!" },
+ *   { role: "assistant", content: "Hi there!" },
+ * ];
+ *
+ * const response = openrouter.callModel({
+ *   model: "anthropic/claude-3-sonnet",
+ *   input: fromClaudeMessages(claudeMessages),
+ * });
+ * ```
+ */
+export function fromClaudeMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+        const { role, content } = msg;
+        if (typeof content === "string") {
+            result.push(createEasyInputMessage(role, content));
+            continue;
+        }
+        const contentItems = [];
+        let hasStructuredContent = false;
+        for (const block of content) {
+            switch (block.type) {
+                case 'text': {
+                    const textBlock = block;
+                    contentItems.push({
+                        type: 'input_text',
+                        text: textBlock.text,
+                    });
+                    // Note: cache_control is lost in conversion (OpenRouter doesn't support it)
+                    break;
+                }
+                case 'image': {
+                    const imageBlock = block;
+                    hasStructuredContent = true;
+                    // Convert Claude image source to OpenRouter format
+                    if (imageBlock.source.type === 'url') {
+                        contentItems.push({
+                            type: 'input_image',
+                            detail: 'auto',
+                            imageUrl: imageBlock.source.url,
+                        });
+                    }
+                    else if (imageBlock.source.type === 'base64') {
+                        // Base64 images: OpenRouter expects a URL, so we use data URI
+                        const dataUri = `data:${imageBlock.source.media_type};base64,${imageBlock.source.data}`;
+                        contentItems.push({
+                            type: 'input_image',
+                            detail: 'auto',
+                            imageUrl: dataUri,
+                        });
+                    }
+                    break;
+                }
+                case 'tool_use': {
+                    const toolUseBlock = block;
+                    // Map to OpenResponsesFunctionToolCall
+                    result.push({
+                        type: 'function_call',
+                        callId: toolUseBlock.id,
+                        name: toolUseBlock.name,
+                        arguments: JSON.stringify(toolUseBlock.input),
+                        id: toolUseBlock.id,
+                        status: 'completed', // Tool use in conversation history is already completed
+                    });
+                    break;
+                }
+                case 'tool_result': {
+                    const toolResultBlock = block;
+                    let toolOutput = '';
+                    if (typeof toolResultBlock.content === 'string') {
+                        toolOutput = toolResultBlock.content;
+                    }
+                    else {
+                        // Extract text and handle images separately
+                        const textParts = [];
+                        const imageParts = [];
+                        for (const part of toolResultBlock.content) {
+                            if (part.type === 'text') {
+                                textParts.push(part.text);
+                            }
+                            else if (part.type === 'image') {
+                                imageParts.push(part);
+                            }
+                        }
+                        toolOutput = textParts.join('');
+                        // Map images to image_generation_call items
+                        for (const imagePart of imageParts) {
+                            const imageUrl = imagePart.source.type === 'url'
+                                ? imagePart.source.url
+                                : `data:${imagePart.source.media_type};base64,${imagePart.source.data}`;
+                            result.push({
+                                type: 'image_generation_call',
+                                id: `${toolResultBlock.tool_use_id}-image-${imageParts.indexOf(imagePart)}`,
+                                result: imageUrl,
+                                status: 'completed',
+                            });
+                        }
+                    }
+                    // Add the function call output for the text portion
+                    if (toolOutput || typeof toolResultBlock.content === 'string') {
+                        result.push(createFunctionCallOutput(toolResultBlock.tool_use_id, toolOutput));
+                    }
+                    break;
+                }
+                default: {
+                    const _exhaustiveCheck = block;
+                    throw new Error(`Unhandled content block type: ${_exhaustiveCheck.type}`);
+                }
+            }
+        }
+        // Use structured format if we have images, otherwise use simple format
+        if (contentItems.length > 0) {
+            if (hasStructuredContent) {
+                // Use OpenResponsesInputMessageItem for messages with images
+                const messageRole = role === 'user'
+                    ? OpenResponsesInputMessageItemRoleUser.User
+                    : role === 'assistant'
+                        ? OpenResponsesInputMessageItemRoleSystem.System // Assistant messages treated as system in this context
+                        : OpenResponsesInputMessageItemRoleSystem.System;
+                result.push({
+                    type: 'message',
+                    role: messageRole,
+                    content: contentItems,
+                });
+            }
+            else {
+                // Use simple format for text-only messages
+                const textContent = contentItems
+                    .filter((item) => item.type === 'input_text')
+                    .map(item => item.text)
+                    .join('');
+                if (textContent) {
+                    result.push(createEasyInputMessage(role, textContent));
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Convert an OpenResponses response to Anthropic Claude message format.
+ *
+ * This function transforms OpenResponsesNonStreamingResponse to ClaudeMessage
+ * (Anthropic SDK format) for compatibility with code expecting Claude responses.
+ *
+ * @example
+ * ```typescript
+ * import { toClaudeMessage } from '@openrouter/sdk';
+ *
+ * const response = await openrouter.callModel({
+ *   model: "anthropic/claude-3-sonnet",
+ *   input: "Hello!",
+ * });
+ *
+ * const openResponsesResult = await response.getResponse();
+ * const claudeMessage = toClaudeMessage(openResponsesResult);
+ * // claudeMessage is now compatible with Anthropic SDK types
+ * ```
+ */
+export const toClaudeMessage = convertToClaudeMessage;
+//# sourceMappingURL=anthropic-compat.js.map

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

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

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

@@ -0,0 +1,479 @@
+import { describe, expect, it } from "vitest";
+import { fromClaudeMessages, toClaudeMessage } from "./anthropic-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("fromClaudeMessages", () => {
+    describe("basic message conversion", () => {
+        it("converts user message with string content", () => {
+            const claudeMessages = [
+                { role: "user", content: "Hello, how are you?" },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            expect(result).toEqual([
+                { role: "user", content: "Hello, how are you?" },
+            ]);
+        });
+        it("converts assistant message with string content", () => {
+            const claudeMessages = [
+                { role: "assistant", content: "I am doing well, thank you!" },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            expect(result).toEqual([
+                { role: "assistant", content: "I am doing well, thank you!" },
+            ]);
+        });
+        it("converts multiple messages in conversation", () => {
+            const claudeMessages = [
+                { role: "user", content: "Hi" },
+                { role: "assistant", content: "Hello!" },
+                { role: "user", content: "How are you?" },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            expect(result).toEqual([
+                { role: "user", content: "Hi" },
+                { role: "assistant", content: "Hello!" },
+                { role: "user", content: "How are you?" },
+            ]);
+        });
+    });
+    describe("text block content conversion", () => {
+        it("converts user message with text block array", () => {
+            const claudeMessages = [
+                {
+                    role: "user",
+                    content: [{ type: "text", text: "Hello from text block" }],
+                },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            expect(result).toEqual([
+                { role: "user", content: "Hello from text block" },
+            ]);
+        });
+        it("combines multiple text blocks into single content string", () => {
+            const claudeMessages = [
+                {
+                    role: "user",
+                    content: [
+                        { type: "text", text: "First part. " },
+                        { type: "text", text: "Second part." },
+                    ],
+                },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            expect(result).toEqual([
+                { role: "user", content: "First part. Second part." },
+            ]);
+        });
+    });
+    describe("tool_result block conversion", () => {
+        it("converts tool_result with string content to function_call_output", () => {
+            const claudeMessages = [
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: "tool_123",
+                            content: "Tool execution result",
+                        },
+                    ],
+                },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            expect(result).toEqual([
+                {
+                    type: "function_call_output",
+                    callId: "tool_123",
+                    output: "Tool execution result",
+                },
+            ]);
+        });
+        it("converts tool_result with text block array to function_call_output", () => {
+            const claudeMessages = [
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: "tool_456",
+                            content: [
+                                { type: "text", text: "Result part 1. " },
+                                { type: "text", text: "Result part 2." },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            expect(result).toEqual([
+                {
+                    type: "function_call_output",
+                    callId: "tool_456",
+                    output: "Result part 1. Result part 2.",
+                },
+            ]);
+        });
+        it("handles mixed text and tool_result blocks", () => {
+            const claudeMessages = [
+                {
+                    role: "user",
+                    content: [
+                        { type: "text", text: "Here is some context. " },
+                        {
+                            type: "tool_result",
+                            tool_use_id: "tool_789",
+                            content: "Tool output",
+                        },
+                        { type: "text", text: "And some more text." },
+                    ],
+                },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            // Should produce both the text message and the function_call_output
+            expect(result).toEqual([
+                {
+                    type: "function_call_output",
+                    callId: "tool_789",
+                    output: "Tool output",
+                },
+                { role: "user", content: "Here is some context. And some more text." },
+            ]);
+        });
+    });
+    describe("tool_use blocks (should be skipped)", () => {
+        it("skips tool_use blocks as they are output from assistant", () => {
+            const claudeMessages = [
+                {
+                    role: "assistant",
+                    content: [
+                        { type: "text", text: "Let me help you with that." },
+                        {
+                            type: "tool_use",
+                            id: "tool_abc",
+                            name: "get_weather",
+                            input: { location: "SF" },
+                        },
+                    ],
+                },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            // Only the text should be captured, tool_use is from previous response
+            expect(result).toEqual([
+                { role: "assistant", content: "Let me help you with that." },
+            ]);
+        });
+    });
+    describe("image blocks (should be skipped)", () => {
+        it("skips image blocks", () => {
+            const claudeMessages = [
+                {
+                    role: "user",
+                    content: [
+                        { type: "text", text: "Look at this image:" },
+                        {
+                            type: "image",
+                            source: {
+                                type: "base64",
+                                media_type: "image/png",
+                                data: "base64data...",
+                            },
+                        },
+                    ],
+                },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            // Only the text should be captured
+            expect(result).toEqual([
+                { role: "user", content: "Look at this image:" },
+            ]);
+        });
+    });
+    describe("empty and edge cases", () => {
+        it("handles empty messages array", () => {
+            const result = fromClaudeMessages([]);
+            expect(result).toEqual([]);
+        });
+        it("handles message with empty string content", () => {
+            const claudeMessages = [
+                { role: "user", content: "" },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            expect(result).toEqual([{ role: "user", content: "" }]);
+        });
+        it("handles message with empty content array", () => {
+            const claudeMessages = [
+                { role: "user", content: [] },
+            ];
+            const result = fromClaudeMessages(claudeMessages);
+            // Should produce empty array since no text and no tool_results
+            expect(result).toEqual([]);
+        });
+    });
+});
+describe("toClaudeMessage", () => {
+    describe("basic message conversion", () => {
+        it("converts response with text output to ClaudeMessage", () => {
+            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 = toClaudeMessage(response);
+            expect(result).toEqual({
+                id: "resp_123",
+                type: "message",
+                role: "assistant",
+                model: "openai/gpt-4",
+                content: [
+                    {
+                        type: "text",
+                        text: "Hello! How can I help you?",
+                    },
+                ],
+                stop_reason: "end_turn",
+                stop_sequence: null,
+                usage: {
+                    input_tokens: 10,
+                    output_tokens: 20,
+                    cache_creation_input_tokens: 0,
+                    cache_read_input_tokens: 0,
+                },
+            });
+        });
+    });
+    describe("function call conversion", () => {
+        it("converts function_call output to tool_use block", () => {
+            const response = createMockResponse({
+                id: "resp_456",
+                output: [
+                    {
+                        type: "function_call",
+                        callId: "call_abc",
+                        name: "get_weather",
+                        arguments: '{"location":"San Francisco"}',
+                        id: "fc_1",
+                        status: "completed",
+                    },
+                ],
+                usage: {
+                    inputTokens: 15,
+                    outputTokens: 25,
+                    totalTokens: 40,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            const result = toClaudeMessage(response);
+            expect(result.content).toEqual([
+                {
+                    type: "tool_use",
+                    id: "call_abc",
+                    name: "get_weather",
+                    input: { location: "San Francisco" },
+                },
+            ]);
+            expect(result.stop_reason).toBe("tool_use");
+        });
+    });
+    describe("reasoning conversion", () => {
+        it("converts reasoning output to thinking block", () => {
+            const response = createMockResponse({
+                id: "resp_789",
+                model: "openai/o1",
+                output: [
+                    {
+                        type: "reasoning",
+                        id: "reason_1",
+                        summary: [
+                            {
+                                type: "summary_text",
+                                text: "I need to think about this carefully...",
+                            },
+                        ],
+                    },
+                    {
+                        id: "msg_2",
+                        type: "message",
+                        role: "assistant",
+                        status: "completed",
+                        content: [
+                            {
+                                type: "output_text",
+                                text: "Here is my answer.",
+                                annotations: [],
+                            },
+                        ],
+                    },
+                ],
+                usage: {
+                    inputTokens: 20,
+                    outputTokens: 100,
+                    totalTokens: 120,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            const result = toClaudeMessage(response);
+            expect(result.content).toEqual([
+                {
+                    type: "thinking",
+                    thinking: "I need to think about this carefully...",
+                    signature: "",
+                },
+                {
+                    type: "text",
+                    text: "Here is my answer.",
+                },
+            ]);
+        });
+    });
+    describe("stop reason mapping", () => {
+        it("maps completed status to end_turn", () => {
+            const response = createMockResponse({
+                id: "resp_1",
+                output: [
+                    {
+                        id: "msg_1",
+                        type: "message",
+                        role: "assistant",
+                        status: "completed",
+                        content: [{ type: "output_text", text: "Done", annotations: [] }],
+                    },
+                ],
+                usage: {
+                    inputTokens: 5,
+                    outputTokens: 5,
+                    totalTokens: 10,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            const result = toClaudeMessage(response);
+            expect(result.stop_reason).toBe("end_turn");
+        });
+        it("maps incomplete with max_output_tokens to max_tokens", () => {
+            const response = createMockResponse({
+                id: "resp_2",
+                status: "incomplete",
+                incompleteDetails: { reason: "max_output_tokens" },
+                output: [
+                    {
+                        id: "msg_1",
+                        type: "message",
+                        role: "assistant",
+                        status: "incomplete",
+                        content: [
+                            { type: "output_text", text: "Partial...", annotations: [] },
+                        ],
+                    },
+                ],
+                usage: {
+                    inputTokens: 5,
+                    outputTokens: 100,
+                    totalTokens: 105,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            const result = toClaudeMessage(response);
+            expect(result.stop_reason).toBe("max_tokens");
+        });
+        it("maps response with function calls to tool_use", () => {
+            const response = createMockResponse({
+                id: "resp_3",
+                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 },
+                },
+            });
+            const result = toClaudeMessage(response);
+            expect(result.stop_reason).toBe("tool_use");
+        });
+    });
+    describe("usage mapping", () => {
+        it("maps usage with cached tokens", () => {
+            const response = createMockResponse({
+                id: "resp_1",
+                output: [
+                    {
+                        id: "msg_1",
+                        type: "message",
+                        role: "assistant",
+                        status: "completed",
+                        content: [{ type: "output_text", text: "OK", annotations: [] }],
+                    },
+                ],
+                usage: {
+                    inputTokens: 100,
+                    outputTokens: 50,
+                    totalTokens: 150,
+                    inputTokensDetails: {
+                        cachedTokens: 80,
+                    },
+                    outputTokensDetails: { reasoningTokens: 0 },
+                },
+            });
+            const result = toClaudeMessage(response);
+            expect(result.usage).toEqual({
+                input_tokens: 100,
+                output_tokens: 50,
+                cache_creation_input_tokens: 80,
+                cache_read_input_tokens: 0,
+            });
+        });
+    });
+});
+//# sourceMappingURL=anthropic-compat.test.js.map

package/esm/lib/base64.js

@@ -1,5 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 598522066688
  */
 import * as z from "zod/v4";
 export function bytesToBase64(u8arr) {