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

package/dist/cjs/index.cjs

@@ -1,17 +1,36 @@
 'use strict';
 
 var errors = require('@jaypie/errors');
-var Anthropic = require('@anthropic-ai/sdk');
 var v4 = require('zod/v4');
-var core = require('@jaypie/core');
+var kit = require('@jaypie/kit');
+var logger = require('@jaypie/logger');
 var RandomLib = require('random');
 var openai = require('openai');
 var zod = require('openai/helpers/zod');
 var aws = require('@jaypie/aws');
-var genai = require('@google/genai');
 var openmeteo = require('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: {
@@ -158,6 +177,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) {
@@ -185,6 +210,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) {
@@ -223,6 +257,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,
@@ -304,7 +347,7 @@ var LlmResponseStatus;
  * @returns LlmInputMessage
  */
 function formatOperateMessage(input, options) {
-    const content = options?.data ? core.placeholders(input, options.data) : input;
+    const content = options?.data ? kit.placeholders(input, options.data) : input;
     return {
         content,
         role: options?.role || exports.LlmMessageRole.User,
@@ -342,8 +385,8 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
-const getLogger$3 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
-const log$1 = getLogger$3();
+const getLogger$4 = () => logger.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+const log$1 = getLogger$4();
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
@@ -646,17 +689,18 @@ var ErrorCategory;
 //
 // Constants
 //
-const STRUCTURED_OUTPUT_TOOL_NAME$1 = "structured_output";
-const RETRYABLE_ERROR_TYPES$1 = [
-    Anthropic.APIConnectionError,
-    Anthropic.APIConnectionTimeoutError,
-    Anthropic.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 = [
-    Anthropic.AuthenticationError,
-    Anthropic.BadRequestError,
-    Anthropic.NotFoundError,
-    Anthropic.PermissionDeniedError,
+const NOT_RETRYABLE_ERROR_NAMES = [
+    "AuthenticationError",
+    "BadRequestError",
+    "NotFoundError",
+    "PermissionDeniedError",
 ];
 //
 //
@@ -711,7 +755,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",
             };
@@ -733,7 +777,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,
@@ -864,8 +908,9 @@ class AnthropicAdapter extends BaseProviderAdapter {
     // Error Classification
     //
     classifyError(error) {
+        const errorName = error?.constructor?.name;
         // Check for rate limit error
-        if (error instanceof Anthropic.RateLimitError) {
+        if (errorName === "RateLimitError") {
             return {
                 error,
                 category: ErrorCategory.RateLimit,
@@ -874,24 +919,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 {
@@ -912,13 +953,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;
@@ -943,10 +984,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
@@ -1060,7 +1101,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,
@@ -1261,7 +1302,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,
@@ -1325,7 +1366,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;
@@ -1334,7 +1375,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;
@@ -1764,8 +1805,411 @@ 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 v4.z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            jsonSchema = v4.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: exports.LlmMessageRole.Assistant,
+                type: exports.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 === exports.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 = core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const log = logger.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 function logToolMessage(message, context) {
     log.trace.var({ [context.name]: message });
 }
@@ -1831,7 +2275,7 @@ class Toolkit {
                     else if (typeof tool.message === "function") {
                         log.trace("[Toolkit] Tool provided function message");
                         log.trace("[Toolkit] Resolving message result");
-                        message = await core.resolveValue(tool.message(parsedArgs, { name }));
+                        message = await kit.resolveValue(tool.message(parsedArgs, { name }));
                     }
                     else {
                         log.warn("[Toolkit] Tool provided unknown message type");
@@ -1844,7 +2288,7 @@ class Toolkit {
                 }
                 if (typeof this.log === "function") {
                     log.trace("[Toolkit] Log tool call with custom logger");
-                    await core.resolveValue(this.log(message, context));
+                    await kit.resolveValue(this.log(message, context));
                 }
                 else {
                     log.trace("[Toolkit] Log tool call with default logger");
@@ -1857,7 +2301,7 @@ class Toolkit {
                 log.debug("[Toolkit] Continuing...");
             }
         }
-        return await core.resolveValue(tool.call(parsedArgs));
+        return await kit.resolveValue(tool.call(parsedArgs));
     }
     extend(tools, options = {}) {
         for (const tool of tools) {
@@ -1905,7 +2349,7 @@ class HookRunner {
      */
     async runBeforeModelRequest(hooks, context) {
         if (hooks?.beforeEachModelRequest) {
-            await core.resolveValue(hooks.beforeEachModelRequest(context));
+            await kit.resolveValue(hooks.beforeEachModelRequest(context));
         }
     }
     /**
@@ -1913,7 +2357,7 @@ class HookRunner {
      */
     async runAfterModelResponse(hooks, context) {
         if (hooks?.afterEachModelResponse) {
-            await core.resolveValue(hooks.afterEachModelResponse(context));
+            await kit.resolveValue(hooks.afterEachModelResponse(context));
         }
     }
     /**
@@ -1921,7 +2365,7 @@ class HookRunner {
      */
     async runBeforeTool(hooks, context) {
         if (hooks?.beforeEachTool) {
-            await core.resolveValue(hooks.beforeEachTool(context));
+            await kit.resolveValue(hooks.beforeEachTool(context));
         }
     }
     /**
@@ -1929,7 +2373,7 @@ class HookRunner {
      */
     async runAfterTool(hooks, context) {
         if (hooks?.afterEachTool) {
-            await core.resolveValue(hooks.afterEachTool(context));
+            await kit.resolveValue(hooks.afterEachTool(context));
         }
     }
     /**
@@ -1937,7 +2381,7 @@ class HookRunner {
      */
     async runOnToolError(hooks, context) {
         if (hooks?.onToolError) {
-            await core.resolveValue(hooks.onToolError(context));
+            await kit.resolveValue(hooks.onToolError(context));
         }
     }
     /**
@@ -1945,7 +2389,7 @@ class HookRunner {
      */
     async runOnRetryableError(hooks, context) {
         if (hooks?.onRetryableModelError) {
-            await core.resolveValue(hooks.onRetryableModelError(context));
+            await kit.resolveValue(hooks.onRetryableModelError(context));
         }
     }
     /**
@@ -1953,7 +2397,7 @@ class HookRunner {
      */
     async runOnUnrecoverableError(hooks, context) {
         if (hooks?.onUnrecoverableModelError) {
-            await core.resolveValue(hooks.onUnrecoverableModelError(context));
+            await kit.resolveValue(hooks.onUnrecoverableModelError(context));
         }
     }
 }
@@ -2019,7 +2463,7 @@ class InputProcessor {
         if (options.data &&
             (options.placeholders?.instructions === undefined ||
                 options.placeholders?.instructions)) {
-            return core.placeholders(options.instructions, options.data);
+            return kit.placeholders(options.instructions, options.data);
         }
         return options.instructions;
     }
@@ -2032,7 +2476,7 @@ class InputProcessor {
         }
         // Apply placeholders to system if data is provided and placeholders.system is not false
         if (options.data && options.placeholders?.system !== false) {
-            return core.placeholders(options.system, options.data);
+            return kit.placeholders(options.system, options.data);
         }
         return options.system;
     }
@@ -2316,7 +2760,7 @@ class RetryExecutor {
                     providerRequest: options.context.providerRequest,
                     error,
                 });
-                await core.sleep(delay);
+                await kit.sleep(delay);
                 attempt++;
             }
         }
@@ -2707,46 +3151,60 @@ 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 errors.ConfigurationError("@anthropic-ai/sdk is required but not installed. Run: npm install @anthropic-ai/sdk");
+    }
+}
 // Logger
-const getLogger$2 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const getLogger$3 = () => logger.log.lib({ lib: kit.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 aws.getEnvSecret("ANTHROPIC_API_KEY"));
     if (!resolvedApiKey) {
-        throw new core.ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
+        throw new errors.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 } = {}) {
+function formatSystemMessage$2(systemPrompt, { data, placeholders } = {}) {
     return placeholders?.system === false
         ? systemPrompt
-        : core.placeholders(systemPrompt, data);
+        : kit.placeholders(systemPrompt, data);
 }
-function formatUserMessage$2(message, { data, placeholders } = {}) {
+function formatUserMessage$3(message, { data, placeholders } = {}) {
     const content = placeholders?.message === false
         ? message
-        : core.placeholders(message, data);
+        : kit.placeholders(message, data);
     return {
         role: PROVIDER.ANTHROPIC.ROLE.USER,
         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;
 }
 // Basic text completion
 async function createTextCompletion$1(client, messages, model, systemMessage) {
-    core.log.trace("Using text output (unstructured)");
+    logger.log.trace("Using text output (unstructured)");
     const params = {
         model,
         messages,
@@ -2755,17 +3213,17 @@ async function createTextCompletion$1(client, messages, model, systemMessage) {
     // Add system instruction if provided
     if (systemMessage) {
         params.system = systemMessage;
-        core.log.trace(`System message: ${systemMessage.length} characters`);
+        logger.log.trace(`System message: ${systemMessage.length} characters`);
     }
     const response = await client.messages.create(params);
     const firstContent = response.content[0];
     const text = firstContent && "text" in firstContent ? firstContent.text : "";
-    core.log.trace(`Assistant reply: ${text.length} characters`);
+    logger.log.trace(`Assistant reply: ${text.length} characters`);
     return text;
 }
 // Structured output completion
 async function createStructuredCompletion$1(client, messages, model, responseSchema, systemMessage) {
-    core.log.trace("Using structured output");
+    logger.log.trace("Using structured output");
     // Get the JSON schema for the response
     const schema = responseSchema instanceof v4.z.ZodType
         ? responseSchema
@@ -2798,7 +3256,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
                 if (!schema.parse(result)) {
                     throw new Error(`JSON response from Anthropic does not match schema: ${responseText}`);
                 }
-                core.log.trace("Received structured response", { result });
+                logger.log.trace("Received structured response", { result });
                 return result;
             }
             catch {
@@ -2809,7 +3267,7 @@ async function createStructuredCompletion$1(client, messages, model, responseSch
         throw new Error("Failed to parse structured response from Anthropic");
     }
     catch (error) {
-        core.log.error("Error creating structured completion", { error });
+        logger.log.error("Error creating structured completion", { error });
         throw error;
     }
 }
@@ -2825,7 +3283,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;
@@ -2834,7 +3292,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() {
@@ -2851,12 +3309,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,
             });
@@ -2886,36 +3344,50 @@ 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 errors.ConfigurationError("@google/genai is required but not installed. Run: npm install @google/genai");
+    }
+}
 // Logger
-const getLogger$1 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const getLogger$2 = () => logger.log.lib({ lib: kit.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 aws.getEnvSecret("GEMINI_API_KEY"));
     if (!resolvedApiKey) {
-        throw new core.ConfigurationError("The application could not resolve the requested keys");
+        throw new errors.ConfigurationError("The application could not resolve the requested keys");
     }
-    const client = new genai.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 } = {}) {
+function formatUserMessage$2(message, { data, placeholders } = {}) {
     const content = placeholders?.message === false
         ? message
-        : core.placeholders(message, data);
+        : kit.placeholders(message, data);
     return {
         role: "user",
         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 };
@@ -2923,7 +3395,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;
@@ -2932,7 +3404,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() {
@@ -2948,7 +3420,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 = {};
@@ -3003,52 +3475,52 @@ class GeminiProvider {
 }
 
 // Logger
-const getLogger = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const getLogger$1 = () => logger.log.lib({ lib: kit.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 aws.getEnvSecret("OPENAI_API_KEY"));
     if (!resolvedApiKey) {
-        throw new core.ConfigurationError("The application could not resolve the requested keys");
+        throw new errors.ConfigurationError("The application could not resolve the requested keys");
     }
     const client = new openai.OpenAI({ apiKey: resolvedApiKey });
     logger.trace("Initialized OpenAI client");
     return client;
 }
-function formatSystemMessage(systemPrompt, { data, placeholders } = {}) {
+function formatSystemMessage$1(systemPrompt, { data, placeholders } = {}) {
     const content = placeholders?.system === false
         ? systemPrompt
-        : core.placeholders(systemPrompt, data);
+        : kit.placeholders(systemPrompt, data);
     return {
         role: "developer",
         content,
     };
 }
-function formatUserMessage(message, { data, placeholders } = {}) {
+function formatUserMessage$1(message, { data, placeholders } = {}) {
     const content = placeholders?.message === false
         ? message
-        : core.placeholders(message, data);
+        : kit.placeholders(message, data);
     return {
         role: "user",
         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 v4.z.ZodType
         ? responseSchema
@@ -3079,7 +3551,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,
@@ -3091,7 +3563,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;
@@ -3100,7 +3572,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() {
@@ -3116,7 +3588,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, {
@@ -3150,6 +3622,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 errors.ConfigurationError("@openrouter/sdk is required but not installed. Run: npm install @openrouter/sdk");
+    }
+}
+// Logger
+const getLogger = () => logger.log.lib({ lib: kit.JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient({ apiKey, } = {}) {
+    const logger = getLogger();
+    const resolvedApiKey = apiKey || (await aws.getEnvSecret("OPENROUTER_API_KEY"));
+    if (!resolvedApiKey) {
+        throw new errors.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 } = {}) {
+    const content = placeholders?.system === false
+        ? systemPrompt
+        : kit.placeholders(systemPrompt, data);
+    return {
+        role: "system",
+        content,
+    };
+}
+function formatUserMessage(message, { data, placeholders } = {}) {
+    const content = placeholders?.message === false
+        ? message
+        : kit.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;
@@ -3198,6 +3809,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 errors.ConfigurationError(`Unsupported provider: ${providerName}`);
         }
@@ -3533,6 +4148,7 @@ exports.GeminiProvider = GeminiProvider;
 exports.JaypieToolkit = JaypieToolkit;
 exports.LLM = constants;
 exports.Llm = Llm;
+exports.OpenRouterProvider = OpenRouterProvider;
 exports.Toolkit = Toolkit;
 exports.toolkit = toolkit;
 exports.tools = tools;