@openrouter/sdk 0.3.2 → 0.3.10

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/async-params.d.ts

@@ -0,0 +1,53 @@
+import type * as models from '../models/index.js';
+import type { StopWhen, Tool, TurnContext } from './tool-types.js';
+/**
+ * A field can be either a value of type T or a function that computes T
+ */
+export type FieldOrAsyncFunction<T> = T | ((context: TurnContext) => T | Promise<T>);
+/**
+ * Input type for callModel function
+ * Each field can independently be a static value or a function that computes the value
+ * Generic over TTools to enable proper type inference for stopWhen conditions
+ */
+export type CallModelInput<TTools extends readonly Tool[] = readonly Tool[]> = {
+    [K in keyof Omit<models.OpenResponsesRequest, 'stream' | 'tools'>]?: FieldOrAsyncFunction<models.OpenResponsesRequest[K]>;
+} & {
+    tools?: TTools;
+    stopWhen?: StopWhen<TTools>;
+};
+/**
+ * Resolved CallModelInput (all functions evaluated to values)
+ * This is the type after all async functions have been resolved to their values
+ */
+export type ResolvedCallModelInput = Omit<models.OpenResponsesRequest, 'stream' | 'tools'> & {
+    tools?: never;
+};
+/**
+ * Resolve all async functions in CallModelInput to their values
+ *
+ * @param input - Input with possible functions
+ * @param context - Turn context for function execution
+ * @returns Resolved input with all values (no functions)
+ *
+ * @example
+ * ```typescript
+ * const resolved = await resolveAsyncFunctions(
+ *   {
+ *     model: 'gpt-4',
+ *     temperature: (ctx) => ctx.numberOfTurns * 0.1,
+ *     input: 'Hello',
+ *   },
+ *   { numberOfTurns: 2, messageHistory: [] }
+ * );
+ * // resolved.temperature === 0.2
+ * ```
+ */
+export declare function resolveAsyncFunctions(input: CallModelInput, context: TurnContext): Promise<ResolvedCallModelInput>;
+/**
+ * Check if input has any async functions that need resolution
+ *
+ * @param input - Input to check
+ * @returns True if any field is a function
+ */
+export declare function hasAsyncFunctions(input: unknown): boolean;
+//# sourceMappingURL=async-params.d.ts.map

package/esm/lib/async-params.js

@@ -0,0 +1,76 @@
+/**
+ * Type guard to check if a value is a parameter function
+ * Parameter functions take TurnContext and return a value or promise
+ */
+function isParameterFunction(value) {
+    return typeof value === 'function';
+}
+/**
+ * Build a resolved request object from entries
+ * This validates the structure matches the expected ResolvedCallModelInput shape
+ */
+function buildResolvedRequest(entries) {
+    const obj = Object.fromEntries(entries);
+    return obj;
+}
+/**
+ * Resolve all async functions in CallModelInput to their values
+ *
+ * @param input - Input with possible functions
+ * @param context - Turn context for function execution
+ * @returns Resolved input with all values (no functions)
+ *
+ * @example
+ * ```typescript
+ * const resolved = await resolveAsyncFunctions(
+ *   {
+ *     model: 'gpt-4',
+ *     temperature: (ctx) => ctx.numberOfTurns * 0.1,
+ *     input: 'Hello',
+ *   },
+ *   { numberOfTurns: 2, messageHistory: [] }
+ * );
+ * // resolved.temperature === 0.2
+ * ```
+ */
+export async function resolveAsyncFunctions(input, context) {
+    // Build array of resolved entries
+    const resolvedEntries = [];
+    // Iterate over all keys in the input
+    for (const [key, value] of Object.entries(input)) {
+        // Skip stopWhen - it's handled separately in ModelResult
+        // Note: tools are already in API format at this point (converted in callModel()), so we include them
+        if (key === 'stopWhen') {
+            continue;
+        }
+        if (isParameterFunction(value)) {
+            try {
+                // Execute the function with context and store the result
+                const result = await Promise.resolve(value(context));
+                resolvedEntries.push([key, result]);
+            }
+            catch (error) {
+                // Wrap errors with context about which field failed
+                throw new Error(`Failed to resolve async function for field "${key}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            // Not a function, use as-is
+            resolvedEntries.push([key, value]);
+        }
+    }
+    return buildResolvedRequest(resolvedEntries);
+}
+/**
+ * Check if input has any async functions that need resolution
+ *
+ * @param input - Input to check
+ * @returns True if any field is a function
+ */
+export function hasAsyncFunctions(input) {
+    if (!input || typeof input !== 'object') {
+        return false;
+    }
+    return Object.values(input).some((value) => typeof value === 'function');
+}
+//# sourceMappingURL=async-params.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) {

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