@jaypie/llm 1.1.30 → 1.2.0-rc.0

package/dist/cjs/index.cjs

@@ -1,15 +1,13 @@
 '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 sdk = require('@openrouter/sdk');
 var openmeteo = require('openmeteo');
 
 const PROVIDER = {
@@ -349,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,
@@ -387,7 +385,7 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
-const getLogger$4 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const getLogger$4 = () => logger.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 const log$1 = getLogger$4();
 
 // Turn policy constants
@@ -692,16 +690,17 @@ var ErrorCategory;
 // Constants
 //
 const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
-const RETRYABLE_ERROR_TYPES$1 = [
-    Anthropic.APIConnectionError,
-    Anthropic.APIConnectionTimeoutError,
-    Anthropic.InternalServerError,
+// 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",
 ];
 //
 //
@@ -909,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,
@@ -919,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 {
@@ -2213,7 +2209,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
 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 });
 }
@@ -2279,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");
@@ -2292,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");
@@ -2305,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) {
@@ -2353,7 +2349,7 @@ class HookRunner {
      */
     async runBeforeModelRequest(hooks, context) {
         if (hooks?.beforeEachModelRequest) {
-            await core.resolveValue(hooks.beforeEachModelRequest(context));
+            await kit.resolveValue(hooks.beforeEachModelRequest(context));
         }
     }
     /**
@@ -2361,7 +2357,7 @@ class HookRunner {
      */
     async runAfterModelResponse(hooks, context) {
         if (hooks?.afterEachModelResponse) {
-            await core.resolveValue(hooks.afterEachModelResponse(context));
+            await kit.resolveValue(hooks.afterEachModelResponse(context));
         }
     }
     /**
@@ -2369,7 +2365,7 @@ class HookRunner {
      */
     async runBeforeTool(hooks, context) {
         if (hooks?.beforeEachTool) {
-            await core.resolveValue(hooks.beforeEachTool(context));
+            await kit.resolveValue(hooks.beforeEachTool(context));
         }
     }
     /**
@@ -2377,7 +2373,7 @@ class HookRunner {
      */
     async runAfterTool(hooks, context) {
         if (hooks?.afterEachTool) {
-            await core.resolveValue(hooks.afterEachTool(context));
+            await kit.resolveValue(hooks.afterEachTool(context));
         }
     }
     /**
@@ -2385,7 +2381,7 @@ class HookRunner {
      */
     async runOnToolError(hooks, context) {
         if (hooks?.onToolError) {
-            await core.resolveValue(hooks.onToolError(context));
+            await kit.resolveValue(hooks.onToolError(context));
         }
     }
     /**
@@ -2393,7 +2389,7 @@ class HookRunner {
      */
     async runOnRetryableError(hooks, context) {
         if (hooks?.onRetryableModelError) {
-            await core.resolveValue(hooks.onRetryableModelError(context));
+            await kit.resolveValue(hooks.onRetryableModelError(context));
         }
     }
     /**
@@ -2401,7 +2397,7 @@ class HookRunner {
      */
     async runOnUnrecoverableError(hooks, context) {
         if (hooks?.onUnrecoverableModelError) {
-            await core.resolveValue(hooks.onUnrecoverableModelError(context));
+            await kit.resolveValue(hooks.onUnrecoverableModelError(context));
         }
     }
 }
@@ -2467,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;
     }
@@ -2480,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;
     }
@@ -2764,7 +2760,7 @@ class RetryExecutor {
                     providerRequest: options.context.providerRequest,
                     error,
                 });
-                await core.sleep(delay);
+                await kit.sleep(delay);
                 attempt++;
             }
         }
@@ -3155,16 +3151,30 @@ 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$3 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const getLogger$3 = () => logger.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
 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;
 }
@@ -3172,12 +3182,12 @@ async function initializeClient$3({ apiKey, } = {}) {
 function formatSystemMessage$2(systemPrompt, { data, placeholders } = {}) {
     return placeholders?.system === false
         ? systemPrompt
-        : core.placeholders(systemPrompt, data);
+        : kit.placeholders(systemPrompt, data);
 }
 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,
@@ -3194,7 +3204,7 @@ function prepareMessages$3(message, { data, placeholders } = {}) {
 }
 // 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,
@@ -3203,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
@@ -3246,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 {
@@ -3257,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;
     }
 }
@@ -3334,23 +3344,37 @@ 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$2 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const getLogger$2 = () => logger.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
 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$2(message, { data, placeholders } = {}) {
     const content = placeholders?.message === false
         ? message
-        : core.placeholders(message, data);
+        : kit.placeholders(message, data);
     return {
         role: "user",
         content,
@@ -3451,13 +3475,13 @@ class GeminiProvider {
 }
 
 // Logger
-const getLogger$1 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const getLogger$1 = () => logger.log.lib({ lib: kit.JAYPIE.LIB.LLM });
 // Client initialization
 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");
@@ -3466,7 +3490,7 @@ async function initializeClient$1({ apiKey, } = {}) {
 function formatSystemMessage$1(systemPrompt, { data, placeholders } = {}) {
     const content = placeholders?.system === false
         ? systemPrompt
-        : core.placeholders(systemPrompt, data);
+        : kit.placeholders(systemPrompt, data);
     return {
         role: "developer",
         content,
@@ -3475,7 +3499,7 @@ function formatSystemMessage$1(systemPrompt, { 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,
@@ -3598,15 +3622,29 @@ 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 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+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 core.ConfigurationError("The application could not resolve the requested keys");
+        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;
@@ -3618,7 +3656,7 @@ function getDefaultModel() {
 function formatSystemMessage(systemPrompt, { data, placeholders } = {}) {
     const content = placeholders?.system === false
         ? systemPrompt
-        : core.placeholders(systemPrompt, data);
+        : kit.placeholders(systemPrompt, data);
     return {
         role: "system",
         content,
@@ -3627,7 +3665,7 @@ function formatSystemMessage(systemPrompt, { data, placeholders } = {}) {
 function formatUserMessage(message, { data, placeholders } = {}) {
     const content = placeholders?.message === false
         ? message
-        : core.placeholders(message, data);
+        : kit.placeholders(message, data);
     return {
         role: "user",
         content,