@jaypie/llm 1.1.30-rc.0 → 1.2.0-rc.0

package/dist/esm/index.js

@@ -1,15 +1,34 @@
 import { ConfigurationError, BadGatewayError, TooManyRequestsError, NotImplementedError } from '@jaypie/errors';
-import Anthropic, { RateLimitError, APIConnectionError, APIConnectionTimeoutError, InternalServerError, AuthenticationError, BadRequestError, NotFoundError, PermissionDeniedError } from '@anthropic-ai/sdk';
 import { z } from 'zod/v4';
-import { placeholders, log as log$2, JAYPIE, resolveValue, sleep, ConfigurationError as ConfigurationError$1 } from '@jaypie/core';
+import { placeholders, JAYPIE, resolveValue, sleep } from '@jaypie/kit';
+import { log as log$2 } from '@jaypie/logger';
 import RandomLib from 'random';
-import { RateLimitError as RateLimitError$1, APIConnectionError as APIConnectionError$1, APIConnectionTimeoutError as APIConnectionTimeoutError$1, InternalServerError as InternalServerError$1, APIUserAbortError, AuthenticationError as AuthenticationError$1, BadRequestError as BadRequestError$1, ConflictError, NotFoundError as NotFoundError$1, PermissionDeniedError as PermissionDeniedError$1, UnprocessableEntityError, OpenAI } from 'openai';
+import { RateLimitError, APIConnectionError, APIConnectionTimeoutError, InternalServerError, APIUserAbortError, AuthenticationError, BadRequestError, ConflictError, NotFoundError, PermissionDeniedError, UnprocessableEntityError, OpenAI } from 'openai';
 import { zodResponseFormat } from 'openai/helpers/zod';
 import { getEnvSecret } from '@jaypie/aws';
-import { GoogleGenAI } from '@google/genai';
 import { fetchWeatherApi } from 'openmeteo';
 
 const PROVIDER = {
+    OPENROUTER: {
+        // https://openrouter.ai/models
+        // OpenRouter provides access to hundreds of models from various providers
+        // The model format is: provider/model-name (e.g., "openai/gpt-4", "anthropic/claude-3-opus")
+        MODEL: {
+            // Default uses env var OPENROUTER_MODEL if set, otherwise a reasonable default
+            DEFAULT: "openai/gpt-4o",
+            SMALL: "openai/gpt-4o-mini",
+            LARGE: "anthropic/claude-3-opus",
+            TINY: "openai/gpt-4o-mini",
+        },
+        MODEL_MATCH_WORDS: ["openrouter"],
+        NAME: "openrouter",
+        ROLE: {
+            ASSISTANT: "assistant",
+            SYSTEM: "system",
+            TOOL: "tool",
+            USER: "user",
+        },
+    },
     GEMINI: {
         // https://ai.google.dev/gemini-api/docs/models
         MODEL: {
@@ -156,6 +175,12 @@ function determineModelProvider(input) {
             provider: PROVIDER.OPENAI.NAME,
         };
     }
+    if (input === PROVIDER.OPENROUTER.NAME) {
+        return {
+            model: PROVIDER.OPENROUTER.MODEL.DEFAULT,
+            provider: PROVIDER.OPENROUTER.NAME,
+        };
+    }
     // Check if input matches an Anthropic model exactly
     for (const [, modelValue] of Object.entries(PROVIDER.ANTHROPIC.MODEL)) {
         if (input === modelValue) {
@@ -183,6 +208,15 @@ function determineModelProvider(input) {
             };
         }
     }
+    // Check if input matches an OpenRouter model exactly
+    for (const [, modelValue] of Object.entries(PROVIDER.OPENROUTER.MODEL)) {
+        if (input === modelValue) {
+            return {
+                model: input,
+                provider: PROVIDER.OPENROUTER.NAME,
+            };
+        }
+    }
     // Check Anthropic match words
     const lowerInput = input.toLowerCase();
     for (const matchWord of PROVIDER.ANTHROPIC.MODEL_MATCH_WORDS) {
@@ -221,6 +255,15 @@ function determineModelProvider(input) {
             }
         }
     }
+    // Check OpenRouter match words
+    for (const matchWord of PROVIDER.OPENROUTER.MODEL_MATCH_WORDS) {
+        if (lowerInput.includes(matchWord)) {
+            return {
+                model: input,
+                provider: PROVIDER.OPENROUTER.NAME,
+            };
+        }
+    }
     // Default fallback if model not recognized
     return {
         model: input,
@@ -340,8 +383,8 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
-const getLogger$3 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
-const log$1 = getLogger$3();
+const getLogger$4 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const log$1 = getLogger$4();
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
@@ -644,17 +687,18 @@ var ErrorCategory;
 //
 // Constants
 //
-const STRUCTURED_OUTPUT_TOOL_NAME$1 = "structured_output";
-const RETRYABLE_ERROR_TYPES$1 = [
-    APIConnectionError,
-    APIConnectionTimeoutError,
-    InternalServerError,
+const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
+// Error names for classification (using string names since SDK is optional)
+const RETRYABLE_ERROR_NAMES = [
+    "APIConnectionError",
+    "APIConnectionTimeoutError",
+    "InternalServerError",
 ];
-const NOT_RETRYABLE_ERROR_TYPES$1 = [
-    AuthenticationError,
-    BadRequestError,
-    NotFoundError,
-    PermissionDeniedError,
+const NOT_RETRYABLE_ERROR_NAMES = [
+    "AuthenticationError",
+    "BadRequestError",
+    "NotFoundError",
+    "PermissionDeniedError",
 ];
 //
 //
@@ -709,7 +753,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 type: "custom",
             }));
             // Determine tool choice based on whether structured output is requested
-            const hasStructuredOutput = request.tools.some((t) => t.name === STRUCTURED_OUTPUT_TOOL_NAME$1);
+            const hasStructuredOutput = request.tools.some((t) => t.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
             anthropicRequest.tool_choice = {
                 type: hasStructuredOutput ? "any" : "auto",
             };
@@ -731,7 +775,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         // Add structured output tool if schema is provided
         if (outputSchema) {
             tools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME$1,
+                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
                 description: "Output a structured JSON object, " +
                     "use this before your final response to give structured outputs to the user",
                 parameters: outputSchema,
@@ -862,8 +906,9 @@ class AnthropicAdapter extends BaseProviderAdapter {
     // Error Classification
     //
     classifyError(error) {
+        const errorName = error?.constructor?.name;
         // Check for rate limit error
-        if (error instanceof RateLimitError) {
+        if (errorName === "RateLimitError") {
             return {
                 error,
                 category: ErrorCategory.RateLimit,
@@ -872,24 +917,20 @@ class AnthropicAdapter extends BaseProviderAdapter {
             };
         }
         // Check for retryable errors
-        for (const ErrorType of RETRYABLE_ERROR_TYPES$1) {
-            if (error instanceof ErrorType) {
-                return {
-                    error,
-                    category: ErrorCategory.Retryable,
-                    shouldRetry: true,
-                };
-            }
+        if (RETRYABLE_ERROR_NAMES.includes(errorName)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
         }
         // Check for non-retryable errors
-        for (const ErrorType of NOT_RETRYABLE_ERROR_TYPES$1) {
-            if (error instanceof ErrorType) {
-                return {
-                    error,
-                    category: ErrorCategory.Unrecoverable,
-                    shouldRetry: false,
-                };
-            }
+        if (NOT_RETRYABLE_ERROR_NAMES.includes(errorName)) {
+            return {
+                error,
+                category: ErrorCategory.Unrecoverable,
+                shouldRetry: false,
+            };
         }
         // Unknown error - treat as potentially retryable
         return {
@@ -910,13 +951,13 @@ class AnthropicAdapter extends BaseProviderAdapter {
         // Check if the last content block is a tool_use with structured_output
         const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
         return (lastBlock?.type === "tool_use" &&
-            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$1);
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
     }
     extractStructuredOutput(response) {
         const anthropicResponse = response;
         const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
         if (lastBlock?.type === "tool_use" &&
-            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$1) {
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2) {
             return lastBlock.input;
         }
         return undefined;
@@ -941,10 +982,10 @@ const anthropicAdapter = new AnthropicAdapter();
 //
 // Constants
 //
-const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
+const STRUCTURED_OUTPUT_TOOL_NAME$1 = "structured_output";
 // Gemini uses HTTP status codes for error classification
 // Documented at: https://ai.google.dev/api/rest/v1beta/Status
-const RETRYABLE_STATUS_CODES = [
+const RETRYABLE_STATUS_CODES$1 = [
     408, // Request Timeout
     429, // Too Many Requests (Rate Limit)
     500, // Internal Server Error
@@ -1058,7 +1099,7 @@ class GeminiAdapter extends BaseProviderAdapter {
         // Add structured output tool if schema is provided
         if (outputSchema) {
             tools.push({
-                name: STRUCTURED_OUTPUT_TOOL_NAME,
+                name: STRUCTURED_OUTPUT_TOOL_NAME$1,
                 description: "Output a structured JSON object, " +
                     "use this before your final response to give structured outputs to the user",
                 parameters: outputSchema,
@@ -1259,7 +1300,7 @@ class GeminiAdapter extends BaseProviderAdapter {
         }
         // Check for retryable errors
         if (typeof statusCode === "number" &&
-            RETRYABLE_STATUS_CODES.includes(statusCode)) {
+            RETRYABLE_STATUS_CODES$1.includes(statusCode)) {
             return {
                 error,
                 category: ErrorCategory.Retryable,
@@ -1323,7 +1364,7 @@ class GeminiAdapter extends BaseProviderAdapter {
         }
         // Check if the last part is a function call with structured_output
         const lastPart = candidate.content.parts[candidate.content.parts.length - 1];
-        return lastPart?.functionCall?.name === STRUCTURED_OUTPUT_TOOL_NAME;
+        return lastPart?.functionCall?.name === STRUCTURED_OUTPUT_TOOL_NAME$1;
     }
     extractStructuredOutput(response) {
         const geminiResponse = response;
@@ -1332,7 +1373,7 @@ class GeminiAdapter extends BaseProviderAdapter {
             return undefined;
         }
         const lastPart = candidate.content.parts[candidate.content.parts.length - 1];
-        if (lastPart?.functionCall?.name === STRUCTURED_OUTPUT_TOOL_NAME) {
+        if (lastPart?.functionCall?.name === STRUCTURED_OUTPUT_TOOL_NAME$1) {
             return lastPart.functionCall.args;
         }
         return undefined;
@@ -1458,18 +1499,18 @@ const geminiAdapter = new GeminiAdapter();
 // Constants
 //
 const RETRYABLE_ERROR_TYPES = [
-    APIConnectionError$1,
-    APIConnectionTimeoutError$1,
-    InternalServerError$1,
+    APIConnectionError,
+    APIConnectionTimeoutError,
+    InternalServerError,
 ];
 const NOT_RETRYABLE_ERROR_TYPES = [
     APIUserAbortError,
-    AuthenticationError$1,
-    BadRequestError$1,
+    AuthenticationError,
+    BadRequestError,
     ConflictError,
-    NotFoundError$1,
-    PermissionDeniedError$1,
-    RateLimitError$1,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
     UnprocessableEntityError,
 ];
 //
@@ -1668,7 +1709,7 @@ class OpenAiAdapter extends BaseProviderAdapter {
     //
     classifyError(error) {
         // Check for rate limit error
-        if (error instanceof RateLimitError$1) {
+        if (error instanceof RateLimitError) {
             return {
                 error,
                 category: ErrorCategory.RateLimit,
@@ -1762,6 +1803,409 @@ class OpenAiAdapter extends BaseProviderAdapter {
 // Export singleton instance
 const openAiAdapter = new OpenAiAdapter();
 
+//
+//
+// Constants
+//
+const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
+// OpenRouter SDK error types based on HTTP status codes
+const RETRYABLE_STATUS_CODES = [408, 500, 502, 503, 524, 529];
+const RATE_LIMIT_STATUS_CODE = 429;
+//
+//
+// Main
+//
+/**
+ * OpenRouterAdapter implements the ProviderAdapter interface for OpenRouter's API.
+ * OpenRouter provides a unified API to access hundreds of AI models through OpenAI-compatible endpoints.
+ * It handles request building, response parsing, and error classification
+ * specific to OpenRouter's Chat Completions API.
+ */
+class OpenRouterAdapter extends BaseProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = PROVIDER.OPENROUTER.NAME;
+        this.defaultModel = PROVIDER.OPENROUTER.MODEL.DEFAULT;
+    }
+    //
+    // Request Building
+    //
+    buildRequest(request) {
+        // Convert messages to OpenRouter format (OpenAI-compatible)
+        const messages = this.convertMessagesToOpenRouter(request.messages, request.system);
+        // Append instructions to last message if provided
+        if (request.instructions && messages.length > 0) {
+            const lastMsg = messages[messages.length - 1];
+            if (lastMsg.content && typeof lastMsg.content === "string") {
+                lastMsg.content = lastMsg.content + "\n\n" + request.instructions;
+            }
+        }
+        const openRouterRequest = {
+            model: request.model || this.defaultModel,
+            messages,
+        };
+        if (request.user) {
+            openRouterRequest.user = request.user;
+        }
+        if (request.tools && request.tools.length > 0) {
+            openRouterRequest.tools = request.tools.map((tool) => ({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters,
+                },
+            }));
+            // Determine tool choice based on whether structured output is requested
+            const hasStructuredOutput = request.tools.some((t) => t.name === STRUCTURED_OUTPUT_TOOL_NAME);
+            openRouterRequest.tool_choice = hasStructuredOutput ? "required" : "auto";
+        }
+        if (request.providerOptions) {
+            Object.assign(openRouterRequest, request.providerOptions);
+        }
+        return openRouterRequest;
+    }
+    formatTools(toolkit, outputSchema) {
+        const tools = toolkit.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        }));
+        // Add structured output tool if schema is provided
+        // (OpenRouter doesn't have native structured output like OpenAI, so use tool approach)
+        if (outputSchema) {
+            tools.push({
+                name: STRUCTURED_OUTPUT_TOOL_NAME,
+                description: "REQUIRED: You MUST call this tool to provide your final response. " +
+                    "After gathering all necessary information (including results from other tools), " +
+                    "call this tool with the structured data to complete the request.",
+                parameters: outputSchema,
+            });
+        }
+        return tools;
+    }
+    formatOutputSchema(schema) {
+        let jsonSchema;
+        // Check if schema is already a JsonObject with type "json_schema"
+        if (typeof schema === "object" &&
+            schema !== null &&
+            !Array.isArray(schema) &&
+            schema.type === "json_schema") {
+            jsonSchema = structuredClone(schema);
+            jsonSchema.type = "object"; // Normalize type
+        }
+        else {
+            // Convert NaturalSchema to JSON schema through Zod
+            const zodSchema = schema instanceof z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            jsonSchema = z.toJSONSchema(zodSchema);
+        }
+        // Remove $schema property (can cause issues with some providers)
+        if (jsonSchema.$schema) {
+            delete jsonSchema.$schema;
+        }
+        return jsonSchema;
+    }
+    //
+    // API Execution
+    //
+    async executeRequest(client, request) {
+        const openRouter = client;
+        const openRouterRequest = request;
+        const response = await openRouter.chat.send({
+            model: openRouterRequest.model,
+            messages: openRouterRequest.messages,
+            tools: openRouterRequest.tools,
+            toolChoice: openRouterRequest.tool_choice,
+            user: openRouterRequest.user,
+        });
+        return response;
+    }
+    //
+    // Response Parsing
+    //
+    parseResponse(response, _options) {
+        const openRouterResponse = response;
+        const choice = openRouterResponse.choices[0];
+        const content = this.extractContent(openRouterResponse);
+        const hasToolCalls = this.hasToolCalls(openRouterResponse);
+        // SDK returns camelCase (finishReason), but support snake_case as fallback
+        const stopReason = choice?.finishReason ?? choice?.finish_reason ?? undefined;
+        return {
+            content,
+            hasToolCalls,
+            stopReason,
+            usage: this.extractUsage(openRouterResponse, openRouterResponse.model),
+            raw: openRouterResponse,
+        };
+    }
+    extractToolCalls(response) {
+        const openRouterResponse = response;
+        const toolCalls = [];
+        const choice = openRouterResponse.choices[0];
+        // SDK returns camelCase (toolCalls)
+        if (!choice?.message?.toolCalls) {
+            return toolCalls;
+        }
+        for (const toolCall of choice.message.toolCalls) {
+            toolCalls.push({
+                callId: toolCall.id,
+                name: toolCall.function.name,
+                arguments: toolCall.function.arguments,
+                raw: toolCall,
+            });
+        }
+        return toolCalls;
+    }
+    extractUsage(response, model) {
+        const openRouterResponse = response;
+        if (!openRouterResponse.usage) {
+            return {
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                total: 0,
+                provider: this.name,
+                model,
+            };
+        }
+        // SDK returns camelCase, but support snake_case as fallback
+        const usage = openRouterResponse.usage;
+        return {
+            input: usage.promptTokens || usage.prompt_tokens || 0,
+            output: usage.completionTokens || usage.completion_tokens || 0,
+            reasoning: 0, // OpenRouter doesn't expose reasoning tokens in standard format
+            total: usage.totalTokens || usage.total_tokens || 0,
+            provider: this.name,
+            model,
+        };
+    }
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        return {
+            role: "tool",
+            toolCallId: toolCall.callId,
+            content: result.output,
+        };
+    }
+    appendToolResult(request, toolCall, result) {
+        const openRouterRequest = request;
+        const toolCallRaw = toolCall.raw;
+        // Add assistant message with the tool call (SDK uses camelCase)
+        openRouterRequest.messages.push({
+            role: "assistant",
+            content: null,
+            toolCalls: [toolCallRaw],
+        });
+        // Add tool result message
+        openRouterRequest.messages.push(this.formatToolResult(toolCall, result));
+        return openRouterRequest;
+    }
+    //
+    // History Management
+    //
+    responseToHistoryItems(response) {
+        const openRouterResponse = response;
+        const historyItems = [];
+        const choice = openRouterResponse.choices[0];
+        if (!choice?.message) {
+            return historyItems;
+        }
+        // Check if this is a tool use response (SDK returns camelCase)
+        if (choice.message.toolCalls && choice.message.toolCalls.length > 0) {
+            // Don't add to history yet - will be added after tool execution
+            return historyItems;
+        }
+        // Extract text content for non-tool responses
+        if (choice.message.content) {
+            historyItems.push({
+                content: choice.message.content,
+                role: LlmMessageRole.Assistant,
+                type: LlmMessageType.Message,
+            });
+        }
+        return historyItems;
+    }
+    //
+    // Error Classification
+    //
+    classifyError(error) {
+        // Check if error has a status code (HTTP error)
+        const errorWithStatus = error;
+        const statusCode = errorWithStatus.status || errorWithStatus.statusCode;
+        if (statusCode) {
+            // Rate limit error
+            if (statusCode === RATE_LIMIT_STATUS_CODE) {
+                return {
+                    error,
+                    category: ErrorCategory.RateLimit,
+                    shouldRetry: false,
+                    suggestedDelayMs: 60000,
+                };
+            }
+            // Retryable errors (server errors, timeouts, etc.)
+            if (RETRYABLE_STATUS_CODES.includes(statusCode)) {
+                return {
+                    error,
+                    category: ErrorCategory.Retryable,
+                    shouldRetry: true,
+                };
+            }
+            // Client errors (4xx except 429) are unrecoverable
+            if (statusCode >= 400 && statusCode < 500) {
+                return {
+                    error,
+                    category: ErrorCategory.Unrecoverable,
+                    shouldRetry: false,
+                };
+            }
+        }
+        // Check error message for rate limit indicators
+        const errorMessage = error instanceof Error ? error.message.toLowerCase() : "";
+        if (errorMessage.includes("rate limit") ||
+            errorMessage.includes("too many requests")) {
+            return {
+                error,
+                category: ErrorCategory.RateLimit,
+                shouldRetry: false,
+                suggestedDelayMs: 60000,
+            };
+        }
+        // Unknown error - treat as potentially retryable
+        return {
+            error,
+            category: ErrorCategory.Unknown,
+            shouldRetry: true,
+        };
+    }
+    //
+    // Provider-Specific Features
+    //
+    isComplete(response) {
+        const openRouterResponse = response;
+        const choice = openRouterResponse.choices[0];
+        // Complete if no tool calls (SDK returns camelCase)
+        if (!choice?.message?.toolCalls?.length) {
+            return true;
+        }
+        return false;
+    }
+    hasStructuredOutput(response) {
+        const openRouterResponse = response;
+        const choice = openRouterResponse.choices[0];
+        // SDK returns camelCase (toolCalls)
+        if (!choice?.message?.toolCalls?.length) {
+            return false;
+        }
+        // Check if the last tool call is structured_output
+        const lastToolCall = choice.message.toolCalls[choice.message.toolCalls.length - 1];
+        return lastToolCall?.function?.name === STRUCTURED_OUTPUT_TOOL_NAME;
+    }
+    extractStructuredOutput(response) {
+        const openRouterResponse = response;
+        const choice = openRouterResponse.choices[0];
+        // SDK returns camelCase (toolCalls)
+        if (!choice?.message?.toolCalls?.length) {
+            return undefined;
+        }
+        const lastToolCall = choice.message.toolCalls[choice.message.toolCalls.length - 1];
+        if (lastToolCall?.function?.name === STRUCTURED_OUTPUT_TOOL_NAME) {
+            try {
+                return JSON.parse(lastToolCall.function.arguments);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    //
+    // Private Helpers
+    //
+    hasToolCalls(response) {
+        const choice = response.choices[0];
+        // SDK returns camelCase (toolCalls)
+        return (choice?.message?.toolCalls?.length ?? 0) > 0;
+    }
+    extractContent(response) {
+        // Check for structured output first
+        if (this.hasStructuredOutput(response)) {
+            return this.extractStructuredOutput(response);
+        }
+        const choice = response.choices[0];
+        return choice?.message?.content ?? undefined;
+    }
+    convertMessagesToOpenRouter(messages, system) {
+        const openRouterMessages = [];
+        // Add system message if provided
+        if (system) {
+            openRouterMessages.push({
+                role: "system",
+                content: system,
+            });
+        }
+        for (const msg of messages) {
+            const message = msg;
+            // Handle different message types
+            if (message.role === "system") {
+                openRouterMessages.push({
+                    role: "system",
+                    content: message.content,
+                });
+            }
+            else if (message.role === "user") {
+                openRouterMessages.push({
+                    role: "user",
+                    content: message.content,
+                });
+            }
+            else if (message.role === "assistant") {
+                const assistantMsg = {
+                    role: "assistant",
+                    content: message.content || null,
+                };
+                // Include toolCalls if present (check both camelCase and snake_case for compatibility)
+                if (message.toolCalls) {
+                    assistantMsg.toolCalls = message.toolCalls;
+                }
+                else if (message.tool_calls) {
+                    assistantMsg.toolCalls = message.tool_calls;
+                }
+                openRouterMessages.push(assistantMsg);
+            }
+            else if (message.role === "tool") {
+                openRouterMessages.push({
+                    role: "tool",
+                    toolCallId: message.toolCallId || message.tool_call_id,
+                    content: message.content,
+                });
+            }
+            else if (message.type === LlmMessageType.Message) {
+                // Handle internal message format
+                const role = message.role?.toLowerCase();
+                if (role === "assistant") {
+                    openRouterMessages.push({
+                        role: "assistant",
+                        content: message.content,
+                    });
+                }
+                else {
+                    openRouterMessages.push({
+                        role: "user",
+                        content: message.content,
+                    });
+                }
+            }
+        }
+        return openRouterMessages;
+    }
+}
+// Export singleton instance
+const openRouterAdapter = new OpenRouterAdapter();
+
 const DEFAULT_TOOL_TYPE = "function";
 const log = log$2.lib({ lib: JAYPIE.LIB.LLM });
 function logToolMessage(message, context) {
@@ -2705,26 +3149,40 @@ function createOperateLoop(config) {
     return new OperateLoop(config);
 }
 
+// SDK loader with caching
+let cachedSdk$2 = null;
+async function loadSdk$2() {
+    if (cachedSdk$2)
+        return cachedSdk$2;
+    try {
+        cachedSdk$2 = await import('@anthropic-ai/sdk');
+        return cachedSdk$2;
+    }
+    catch {
+        throw new ConfigurationError("@anthropic-ai/sdk is required but not installed. Run: npm install @anthropic-ai/sdk");
+    }
+}
 // Logger
-const getLogger$2 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$3 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$2({ apiKey, } = {}) {
-    const logger = getLogger$2();
+async function initializeClient$3({ apiKey, } = {}) {
+    const logger = getLogger$3();
     const resolvedApiKey = apiKey || (await getEnvSecret("ANTHROPIC_API_KEY"));
     if (!resolvedApiKey) {
-        throw new ConfigurationError$1("The application could not resolve the required API key: ANTHROPIC_API_KEY");
+        throw new ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
     }
-    const client = new Anthropic({ apiKey: resolvedApiKey });
+    const sdk = await loadSdk$2();
+    const client = new sdk.default({ apiKey: resolvedApiKey });
     logger.trace("Initialized Anthropic client");
     return client;
 }
 // Message formatting functions
-function formatSystemMessage$1(systemPrompt, { data, placeholders: placeholders$1 } = {}) {
+function formatSystemMessage$2(systemPrompt, { data, placeholders: placeholders$1 } = {}) {
     return placeholders$1?.system === false
         ? systemPrompt
         : placeholders(systemPrompt, data);
 }
-function formatUserMessage$2(message, { data, placeholders: placeholders$1 } = {}) {
+function formatUserMessage$3(message, { data, placeholders: placeholders$1 } = {}) {
     const content = placeholders$1?.message === false
         ? message
         : placeholders(message, data);
@@ -2733,11 +3191,11 @@ function formatUserMessage$2(message, { data, placeholders: placeholders$1 } = {
         content,
     };
 }
-function prepareMessages$2(message, { data, placeholders } = {}) {
-    const logger = getLogger$2();
+function prepareMessages$3(message, { data, placeholders } = {}) {
+    const logger = getLogger$3();
     const messages = [];
     // Add user message (necessary for all requests)
-    const userMessage = formatUserMessage$2(message, { data, placeholders });
+    const userMessage = formatUserMessage$3(message, { data, placeholders });
     messages.push(userMessage);
     logger.trace(`User message: ${userMessage.content.length} characters`);
     return messages;
@@ -2823,7 +3281,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
 // Main class implementation
 class AnthropicProvider {
     constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$2();
+        this.log = getLogger$3();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -2832,7 +3290,7 @@ class AnthropicProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$2({ apiKey: this.apiKey });
+        this._client = await initializeClient$3({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -2849,12 +3307,12 @@ class AnthropicProvider {
     // Main send method
     async send(message, options) {
         const client = await this.getClient();
-        const messages = prepareMessages$2(message, options || {});
+        const messages = prepareMessages$3(message, options || {});
         const modelToUse = options?.model || this.model;
         // Process system message if provided
         let systemMessage;
         if (options?.system) {
-            systemMessage = formatSystemMessage$1(options.system, {
+            systemMessage = formatSystemMessage$2(options.system, {
                 data: options.data,
                 placeholders: options.placeholders,
             });
@@ -2884,20 +3342,34 @@ class AnthropicProvider {
     }
 }
 
+// SDK loader with caching
+let cachedSdk$1 = null;
+async function loadSdk$1() {
+    if (cachedSdk$1)
+        return cachedSdk$1;
+    try {
+        cachedSdk$1 = await import('@google/genai');
+        return cachedSdk$1;
+    }
+    catch {
+        throw new ConfigurationError("@google/genai is required but not installed. Run: npm install @google/genai");
+    }
+}
 // Logger
-const getLogger$1 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$2 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient$1({ apiKey, } = {}) {
-    const logger = getLogger$1();
+async function initializeClient$2({ apiKey, } = {}) {
+    const logger = getLogger$2();
     const resolvedApiKey = apiKey || (await getEnvSecret("GEMINI_API_KEY"));
     if (!resolvedApiKey) {
-        throw new ConfigurationError$1("The application could not resolve the requested keys");
+        throw new ConfigurationError("The application could not resolve the requested keys");
     }
-    const client = new GoogleGenAI({ apiKey: resolvedApiKey });
+    const sdk = await loadSdk$1();
+    const client = new sdk.GoogleGenAI({ apiKey: resolvedApiKey });
     logger.trace("Initialized Gemini client");
     return client;
 }
-function formatUserMessage$1(message, { data, placeholders: placeholders$1 } = {}) {
+function formatUserMessage$2(message, { data, placeholders: placeholders$1 } = {}) {
     const content = placeholders$1?.message === false
         ? message
         : placeholders(message, data);
@@ -2906,14 +3378,14 @@ function formatUserMessage$1(message, { data, placeholders: placeholders$1 } = {
         content,
     };
 }
-function prepareMessages$1(message, { data, placeholders } = {}) {
-    const logger = getLogger$1();
+function prepareMessages$2(message, { data, placeholders } = {}) {
+    const logger = getLogger$2();
     const messages = [];
     let systemInstruction;
     // Note: Gemini handles system prompts differently via systemInstruction config
     // This function is kept for compatibility but system prompts should be passed
     // via the systemInstruction parameter in generateContent
-    const userMessage = formatUserMessage$1(message, { data, placeholders });
+    const userMessage = formatUserMessage$2(message, { data, placeholders });
     messages.push(userMessage);
     logger.trace(`User message: ${userMessage.content?.length} characters`);
     return { messages, systemInstruction };
@@ -2921,7 +3393,7 @@ function prepareMessages$1(message, { data, placeholders } = {}) {
 
 class GeminiProvider {
     constructor(model = PROVIDER.GEMINI.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$1();
+        this.log = getLogger$2();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -2930,7 +3402,7 @@ class GeminiProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient$1({ apiKey: this.apiKey });
+        this._client = await initializeClient$2({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -2946,7 +3418,7 @@ class GeminiProvider {
     }
     async send(message, options) {
         const client = await this.getClient();
-        const { messages } = prepareMessages$1(message, options);
+        const { messages } = prepareMessages$2(message, options);
         const modelToUse = options?.model || this.model;
         // Build the request config
         const config = {};
@@ -3001,19 +3473,19 @@ class GeminiProvider {
 }
 
 // Logger
-const getLogger = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+const getLogger$1 = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient({ apiKey, } = {}) {
-    const logger = getLogger();
+async function initializeClient$1({ apiKey, } = {}) {
+    const logger = getLogger$1();
     const resolvedApiKey = apiKey || (await getEnvSecret("OPENAI_API_KEY"));
     if (!resolvedApiKey) {
-        throw new ConfigurationError$1("The application could not resolve the requested keys");
+        throw new ConfigurationError("The application could not resolve the requested keys");
     }
     const client = new OpenAI({ apiKey: resolvedApiKey });
     logger.trace("Initialized OpenAI client");
     return client;
 }
-function formatSystemMessage(systemPrompt, { data, placeholders: placeholders$1 } = {}) {
+function formatSystemMessage$1(systemPrompt, { data, placeholders: placeholders$1 } = {}) {
     const content = placeholders$1?.system === false
         ? systemPrompt
         : placeholders(systemPrompt, data);
@@ -3022,7 +3494,7 @@ function formatSystemMessage(systemPrompt, { data, placeholders: placeholders$1
         content,
     };
 }
-function formatUserMessage(message, { data, placeholders: placeholders$1 } = {}) {
+function formatUserMessage$1(message, { data, placeholders: placeholders$1 } = {}) {
     const content = placeholders$1?.message === false
         ? message
         : placeholders(message, data);
@@ -3031,22 +3503,22 @@ function formatUserMessage(message, { data, placeholders: placeholders$1 } = {})
         content,
     };
 }
-function prepareMessages(message, { system, data, placeholders } = {}) {
-    const logger = getLogger();
+function prepareMessages$1(message, { system, data, placeholders } = {}) {
+    const logger = getLogger$1();
     const messages = [];
     if (system) {
-        const systemMessage = formatSystemMessage(system, { data, placeholders });
+        const systemMessage = formatSystemMessage$1(system, { data, placeholders });
         messages.push(systemMessage);
         logger.trace(`System message: ${systemMessage.content?.length} characters`);
     }
-    const userMessage = formatUserMessage(message, { data, placeholders });
+    const userMessage = formatUserMessage$1(message, { data, placeholders });
     messages.push(userMessage);
     logger.trace(`User message: ${userMessage.content?.length} characters`);
     return messages;
 }
 // Completion requests
 async function createStructuredCompletion(client, { messages, responseSchema, model, }) {
-    const logger = getLogger();
+    const logger = getLogger$1();
     logger.trace("Using structured output");
     const zodSchema = responseSchema instanceof z.ZodType
         ? responseSchema
@@ -3077,7 +3549,7 @@ async function createStructuredCompletion(client, { messages, responseSchema, mo
     return completion.choices[0].message.parsed;
 }
 async function createTextCompletion(client, { messages, model, }) {
-    const logger = getLogger();
+    const logger = getLogger$1();
     logger.trace("Using text output (unstructured)");
     const completion = await client.chat.completions.create({
         messages,
@@ -3089,7 +3561,7 @@ async function createTextCompletion(client, { messages, model, }) {
 
 class OpenAiProvider {
     constructor(model = PROVIDER.OPENAI.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger();
+        this.log = getLogger$1();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -3098,7 +3570,7 @@ class OpenAiProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient({ apiKey: this.apiKey });
+        this._client = await initializeClient$1({ apiKey: this.apiKey });
         return this._client;
     }
     async getOperateLoop() {
@@ -3114,7 +3586,7 @@ class OpenAiProvider {
     }
     async send(message, options) {
         const client = await this.getClient();
-        const messages = prepareMessages(message, options || {});
+        const messages = prepareMessages$1(message, options || {});
         const modelToUse = options?.model || this.model;
         if (options?.response) {
             return createStructuredCompletion(client, {
@@ -3148,6 +3620,145 @@ class OpenAiProvider {
     }
 }
 
+// SDK loader with caching
+let cachedSdk = null;
+async function loadSdk() {
+    if (cachedSdk)
+        return cachedSdk;
+    try {
+        cachedSdk = await import('@openrouter/sdk');
+        return cachedSdk;
+    }
+    catch {
+        throw new ConfigurationError("@openrouter/sdk is required but not installed. Run: npm install @openrouter/sdk");
+    }
+}
+// Logger
+const getLogger = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient({ apiKey, } = {}) {
+    const logger = getLogger();
+    const resolvedApiKey = apiKey || (await getEnvSecret("OPENROUTER_API_KEY"));
+    if (!resolvedApiKey) {
+        throw new ConfigurationError("The application could not resolve the requested keys");
+    }
+    const sdk = await loadSdk();
+    const client = new sdk.OpenRouter({ apiKey: resolvedApiKey });
+    logger.trace("Initialized OpenRouter client");
+    return client;
+}
+// Get default model from environment or constants
+function getDefaultModel() {
+    return process.env.OPENROUTER_MODEL || PROVIDER.OPENROUTER.MODEL.DEFAULT;
+}
+function formatSystemMessage(systemPrompt, { data, placeholders: placeholders$1 } = {}) {
+    const content = placeholders$1?.system === false
+        ? systemPrompt
+        : placeholders(systemPrompt, data);
+    return {
+        role: "system",
+        content,
+    };
+}
+function formatUserMessage(message, { data, placeholders: placeholders$1 } = {}) {
+    const content = placeholders$1?.message === false
+        ? message
+        : placeholders(message, data);
+    return {
+        role: "user",
+        content,
+    };
+}
+function prepareMessages(message, { system, data, placeholders } = {}) {
+    const logger = getLogger();
+    const messages = [];
+    if (system) {
+        const systemMessage = formatSystemMessage(system, { data, placeholders });
+        messages.push(systemMessage);
+        logger.trace(`System message: ${systemMessage.content?.length} characters`);
+    }
+    const userMessage = formatUserMessage(message, { data, placeholders });
+    messages.push(userMessage);
+    logger.trace(`User message: ${userMessage.content?.length} characters`);
+    return messages;
+}
+
+class OpenRouterProvider {
+    constructor(model = getDefaultModel(), { apiKey } = {}) {
+        this.log = getLogger();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient({ apiKey: this.apiKey });
+        return this._client;
+    }
+    async getOperateLoop() {
+        if (this._operateLoop) {
+            return this._operateLoop;
+        }
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({
+            adapter: openRouterAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
+    async send(message, options) {
+        const client = await this.getClient();
+        const messages = prepareMessages(message, options);
+        const modelToUse = options?.model || this.model;
+        // Build the request
+        const response = await client.chat.send({
+            model: modelToUse,
+            messages: messages,
+        });
+        const rawContent = response.choices?.[0]?.message?.content;
+        // Extract text content - content could be string or array of content items
+        const content = typeof rawContent === "string"
+            ? rawContent
+            : Array.isArray(rawContent)
+                ? rawContent
+                    .filter((item) => item.type === "text")
+                    .map((item) => item.text)
+                    .join("")
+                : "";
+        this.log.trace(`Assistant reply: ${content?.length || 0} characters`);
+        // If structured output was requested, try to parse the response
+        if (options?.response && content) {
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                return content || "";
+            }
+        }
+        return content || "";
+    }
+    async operate(input, options = {}) {
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        if (this.conversationHistory.length > 0) {
+            // If options.history exists, merge with instance history, otherwise use instance history
+            mergedOptions.history = options.history
+                ? [...this.conversationHistory, ...options.history]
+                : [...this.conversationHistory];
+        }
+        // Execute operate loop
+        const response = await operateLoop.execute(input, mergedOptions);
+        // Update conversation history with the new history from the response
+        if (response.history && response.history.length > 0) {
+            this.conversationHistory = response.history;
+        }
+        return response;
+    }
+}
+
 class Llm {
     constructor(providerName = DEFAULT.PROVIDER.NAME, options = {}) {
         const { model } = options;
@@ -3196,6 +3807,10 @@ class Llm {
                 return new OpenAiProvider(model || PROVIDER.OPENAI.MODEL.DEFAULT, {
                     apiKey,
                 });
+            case PROVIDER.OPENROUTER.NAME:
+                return new OpenRouterProvider(model || PROVIDER.OPENROUTER.MODEL.DEFAULT, {
+                    apiKey,
+                });
             default:
                 throw new ConfigurationError(`Unsupported provider: ${providerName}`);
         }
@@ -3527,5 +4142,5 @@ const toolkit = new JaypieToolkit(tools);
     [LlmMessageRole.Developer]: "user",
 });
 
-export { GeminiProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, Toolkit, toolkit, tools };
+export { GeminiProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, OpenRouterProvider, Toolkit, toolkit, tools };
 //# sourceMappingURL=index.js.map