@jaypie/llm 1.1.23 → 1.1.25

package/dist/Llm.d.ts

@@ -1,20 +1,20 @@
 import { JsonObject } from "@jaypie/types";
 import { LlmProviderName } from "./constants.js";
-import { LlmProvider, LlmMessageOptions, LlmOperateOptions, LlmOptions, LlmOperateResponse } from "./types/LlmProvider.interface.js";
+import { LlmProvider, LlmHistory, LlmInputMessage, LlmMessageOptions, LlmOperateOptions, LlmOptions, LlmOperateResponse } from "./types/LlmProvider.interface.js";
 declare class Llm implements LlmProvider {
     private _provider;
     private _llm;
     private _options;
-    constructor(providerName?: LlmProviderName, options?: LlmOptions);
+    constructor(providerName?: LlmProviderName | string, options?: LlmOptions);
     private createProvider;
     send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
-    operate(message: string, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
+    operate(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
     static send(message: string, options?: LlmMessageOptions & {
         llm?: LlmProviderName;
         apiKey?: string;
         model?: string;
     }): Promise<string | JsonObject>;
-    static operate(message: string, options?: LlmOperateOptions & {
+    static operate(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions & {
         llm?: LlmProviderName;
         apiKey?: string;
         model?: string;

package/dist/constants.d.ts

@@ -1,16 +1,16 @@
 export declare const PROVIDER: {
     readonly ANTHROPIC: {
         readonly MODEL: {
-            readonly DEFAULT: "claude-sonnet-4-0";
-            readonly SMALL: "claude-3-5-haiku-latest";
+            readonly DEFAULT: "claude-opus-4-1";
+            readonly SMALL: "claude-sonnet-4-0";
             readonly TINY: "claude-3-5-haiku-latest";
-            readonly LARGE: "claude-opus-4-0";
-            readonly JUMBO: "claude-opus-4-0";
-            readonly CLAUDE_OPUS_4: "claude-opus-4-0";
+            readonly LARGE: "claude-opus-4-1";
+            readonly CLAUDE_OPUS_4: "claude-opus-4-1";
             readonly CLAUDE_SONNET_4: "claude-sonnet-4-0";
             readonly CLAUDE_3_HAIKU: "claude-3-5-haiku-latest";
             readonly CLAUDE_3_OPUS: "claude-3-opus-latest";
             readonly CLAUDE_3_SONNET: "claude-3-7-sonnet-latest";
+            readonly CLAUDE_OPUS_4_1: "claude-opus-4-1";
             readonly CLAUDE_OPUS_4_0: "claude-opus-4-0";
             readonly CLAUDE_SONNET_4_0: "claude-sonnet-4-0";
             readonly CLAUDE_3_7_SONNET: "claude-3-7-sonnet-latest\t";
@@ -20,6 +20,7 @@ export declare const PROVIDER: {
             readonly CLAUDE_OPUS_3: "claude-3-opus-latest";
             readonly CLAUDE_SONNET_3: "claude-3-7-sonnet-latest";
         };
+        readonly MODEL_MATCH_WORDS: readonly ["anthropic", "claude", "haiku", "opus", "sonnet"];
         readonly NAME: "anthropic";
         readonly PROMPT: {
             readonly AI: "\n\nAssistant:";
@@ -39,11 +40,13 @@ export declare const PROVIDER: {
     };
     readonly OPENAI: {
         readonly MODEL: {
-            readonly DEFAULT: "gpt-4.1";
-            readonly SMALL: "gpt-4.1-mini";
-            readonly LARGE: "o3";
-            readonly TINY: "gpt-4.1-nano";
-            readonly JUMBO: "o3-pro";
+            readonly DEFAULT: "gpt-5";
+            readonly SMALL: "gpt-5-mini";
+            readonly LARGE: "gpt-5";
+            readonly TINY: "gpt-5-nano";
+            readonly GPT_5: "gpt-5";
+            readonly GPT_5_MINI: "gpt-5-mini";
+            readonly GPT_5_NANO: "gpt-5-nano";
             readonly GPT_4_1: "gpt-4.1";
             readonly GPT_4_1_MINI: "gpt-4.1-mini";
             readonly GPT_4_1_NANO: "gpt-4.1-nano";
@@ -60,6 +63,7 @@ export declare const PROVIDER: {
             readonly O3_PRO: "o3-pro";
             readonly O4_MINI: "o4-mini";
         };
+        readonly MODEL_MATCH_WORDS: readonly ["openai", "gpt", RegExp];
         readonly NAME: "openai";
     };
 };
@@ -67,11 +71,13 @@ export type LlmProviderName = typeof PROVIDER.OPENAI.NAME | typeof PROVIDER.ANTH
 export declare const DEFAULT: {
     readonly PROVIDER: {
         readonly MODEL: {
-            readonly DEFAULT: "gpt-4.1";
-            readonly SMALL: "gpt-4.1-mini";
-            readonly LARGE: "o3";
-            readonly TINY: "gpt-4.1-nano";
-            readonly JUMBO: "o3-pro";
+            readonly DEFAULT: "gpt-5";
+            readonly SMALL: "gpt-5-mini";
+            readonly LARGE: "gpt-5";
+            readonly TINY: "gpt-5-nano";
+            readonly GPT_5: "gpt-5";
+            readonly GPT_5_MINI: "gpt-5-mini";
+            readonly GPT_5_NANO: "gpt-5-nano";
             readonly GPT_4_1: "gpt-4.1";
             readonly GPT_4_1_MINI: "gpt-4.1-mini";
             readonly GPT_4_1_NANO: "gpt-4.1-nano";
@@ -88,6 +94,7 @@ export declare const DEFAULT: {
             readonly O3_PRO: "o3-pro";
             readonly O4_MINI: "o4-mini";
         };
+        readonly MODEL_MATCH_WORDS: readonly ["openai", "gpt", RegExp];
         readonly NAME: "openai";
     };
 };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { default as Llm } from "./Llm.js";
 export * as LLM from "./constants.js";
-export type { LlmMessageOptions, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider, } from "./types/LlmProvider.interface.js";
+export type { LlmHistory, LlmInputContent, LlmInputContentFile, LlmInputContentImage, LlmInputContentText, LlmInputMessage, LlmMessageOptions, LlmOperateOptions, LlmOperateResponse, LlmOptions, LlmProvider, } from "./types/LlmProvider.interface.js";
+export { LlmMessageRole, LlmMessageType, } from "./types/LlmProvider.interface.js";
 export type { LlmTool } from "./types/LlmTool.interface.js";
-export { toolkit, Toolkit, tools } from "./tools/index.js";
+export { JaypieToolkit, toolkit, Toolkit, tools } from "./tools/index.js";

package/dist/index.js

@@ -14,18 +14,18 @@ const PROVIDER = {
         // https://docs.anthropic.com/en/docs/about-claude/models/overview
         MODEL: {
             // Jaypie Aliases
-            DEFAULT: "claude-sonnet-4-0",
-            SMALL: "claude-3-5-haiku-latest",
+            DEFAULT: "claude-opus-4-1",
+            SMALL: "claude-sonnet-4-0",
             TINY: "claude-3-5-haiku-latest",
-            LARGE: "claude-opus-4-0",
-            JUMBO: "claude-opus-4-0",
+            LARGE: "claude-opus-4-1",
             // Latests
-            CLAUDE_OPUS_4: "claude-opus-4-0",
+            CLAUDE_OPUS_4: "claude-opus-4-1",
             CLAUDE_SONNET_4: "claude-sonnet-4-0",
             CLAUDE_3_HAIKU: "claude-3-5-haiku-latest",
             CLAUDE_3_OPUS: "claude-3-opus-latest",
             CLAUDE_3_SONNET: "claude-3-7-sonnet-latest",
             // Specifics
+            CLAUDE_OPUS_4_1: "claude-opus-4-1",
             CLAUDE_OPUS_4_0: "claude-opus-4-0",
             CLAUDE_SONNET_4_0: "claude-sonnet-4-0",
             CLAUDE_3_7_SONNET: "claude-3-7-sonnet-latest	",
@@ -37,6 +37,13 @@ const PROVIDER = {
             CLAUDE_OPUS_3: "claude-3-opus-latest",
             CLAUDE_SONNET_3: "claude-3-7-sonnet-latest",
         },
+        MODEL_MATCH_WORDS: [
+            "anthropic",
+            "claude",
+            "haiku",
+            "opus",
+            "sonnet",
+        ],
         NAME: "anthropic",
         PROMPT: {
             AI: "\n\nAssistant:",
@@ -58,12 +65,14 @@ const PROVIDER = {
         // https://platform.openai.com/docs/models
         MODEL: {
             // Jaypie Aliases
-            DEFAULT: "gpt-4.1",
-            SMALL: "gpt-4.1-mini",
-            LARGE: "o3",
-            TINY: "gpt-4.1-nano",
-            JUMBO: "o3-pro",
+            DEFAULT: "gpt-5",
+            SMALL: "gpt-5-mini",
+            LARGE: "gpt-5",
+            TINY: "gpt-5-nano",
             // OpenAI Official
+            GPT_5: "gpt-5",
+            GPT_5_MINI: "gpt-5-mini",
+            GPT_5_NANO: "gpt-5-nano",
             GPT_4_1: "gpt-4.1",
             GPT_4_1_MINI: "gpt-4.1-mini",
             GPT_4_1_NANO: "gpt-4.1-nano",
@@ -80,6 +89,7 @@ const PROVIDER = {
             O3_PRO: "o3-pro",
             O4_MINI: "o4-mini",
         },
+        MODEL_MATCH_WORDS: ["openai", "gpt", /^o\d/],
         NAME: "openai",
     },
 };
@@ -94,6 +104,79 @@ var constants = /*#__PURE__*/Object.freeze({
     PROVIDER: PROVIDER
 });
 
+function determineModelProvider(input) {
+    if (!input) {
+        return {
+            model: DEFAULT.PROVIDER.MODEL.DEFAULT,
+            provider: DEFAULT.PROVIDER.NAME,
+        };
+    }
+    // Check if input is a provider name
+    if (input === PROVIDER.ANTHROPIC.NAME) {
+        return {
+            model: PROVIDER.ANTHROPIC.MODEL.DEFAULT,
+            provider: PROVIDER.ANTHROPIC.NAME,
+        };
+    }
+    if (input === PROVIDER.OPENAI.NAME) {
+        return {
+            model: PROVIDER.OPENAI.MODEL.DEFAULT,
+            provider: PROVIDER.OPENAI.NAME,
+        };
+    }
+    // Check if input matches an Anthropic model exactly
+    for (const [, modelValue] of Object.entries(PROVIDER.ANTHROPIC.MODEL)) {
+        if (input === modelValue) {
+            return {
+                model: input,
+                provider: PROVIDER.ANTHROPIC.NAME,
+            };
+        }
+    }
+    // Check if input matches an OpenAI model exactly
+    for (const [, modelValue] of Object.entries(PROVIDER.OPENAI.MODEL)) {
+        if (input === modelValue) {
+            return {
+                model: input,
+                provider: PROVIDER.OPENAI.NAME,
+            };
+        }
+    }
+    // Check Anthropic match words
+    const lowerInput = input.toLowerCase();
+    for (const matchWord of PROVIDER.ANTHROPIC.MODEL_MATCH_WORDS) {
+        if (lowerInput.includes(matchWord)) {
+            return {
+                model: input,
+                provider: PROVIDER.ANTHROPIC.NAME,
+            };
+        }
+    }
+    // Check OpenAI match words
+    for (const matchWord of PROVIDER.OPENAI.MODEL_MATCH_WORDS) {
+        if (typeof matchWord === "string") {
+            if (lowerInput.includes(matchWord)) {
+                return {
+                    model: input,
+                    provider: PROVIDER.OPENAI.NAME,
+                };
+            }
+        }
+        else if (matchWord instanceof RegExp) {
+            if (matchWord.test(input)) {
+                return {
+                    model: input,
+                    provider: PROVIDER.OPENAI.NAME,
+                };
+            }
+        }
+    }
+    // Default fallback if model not recognized
+    return {
+        model: input,
+    };
+}
+
 const DEFAULT_TOOL_TYPE = "function";
 const log$1 = log$2.lib({ lib: JAYPIE.LIB.LLM });
 function logToolMessage(message, context) {
@@ -644,6 +727,10 @@ function extractContentFromResponse(currentResponse, options) {
         if (output.type === LlmMessageType.FunctionCall) {
             return createFunctionCallContent(output);
         }
+        // Skip reasoning items when extracting content
+        if (output.type === "reasoning") {
+            continue;
+        }
     }
     return "";
 }
@@ -843,6 +930,7 @@ async function operate$1(input, options = {}, context = {
                     }));
                 }
                 // Use type assertion to handle the OpenAI SDK response type
+                log.trace.var({ "openai.responses.create": requestOptions });
                 const currentResponse = (await openai.responses.create(
                 // @ts-expect-error error claims missing non-required id, status
                 requestOptions));
@@ -878,12 +966,19 @@ async function operate$1(input, options = {}, context = {
                 }
                 // Check if we need to process function calls for multi-turn conversations
                 let hasFunctionCall = false;
+                const pendingReasoningItems = []; // Track reasoning items that need to be paired
                 try {
                     if (currentResponse.output && Array.isArray(currentResponse.output)) {
                         // New OpenAI API format with output array
                         for (const output of currentResponse.output) {
                             returnResponse.output.push(output);
                             returnResponse.history.push(output);
+                            // Handle reasoning items (GPT-5)
+                            if (output.type === "reasoning") {
+                                // Store reasoning items to be added with their paired function calls
+                                pendingReasoningItems.push(output);
+                                continue;
+                            }
                             if (output.type === LlmMessageType.FunctionCall) {
                                 hasFunctionCall = true;
                                 let toolkit;
@@ -940,6 +1035,13 @@ async function operate$1(input, options = {}, context = {
                                         }
                                         // Add model's function call and result
                                         if (Array.isArray(currentInput)) {
+                                            // Add any pending reasoning items before the function call
+                                            for (const reasoningItem of pendingReasoningItems) {
+                                                currentInput.push(reasoningItem);
+                                            }
+                                            // Clear the pending reasoning items after adding them
+                                            pendingReasoningItems.length = 0;
+                                            // Add the function call
                                             currentInput.push(output);
                                             // Add function call result
                                             const functionCallOutput = {
@@ -1651,9 +1753,38 @@ class AnthropicProvider {
 
 class Llm {
     constructor(providerName = DEFAULT.PROVIDER.NAME, options = {}) {
-        this._provider = providerName;
-        this._options = options;
-        this._llm = this.createProvider(providerName, options);
+        const { model } = options;
+        let finalProvider = providerName;
+        let finalModel = model;
+        if (model) {
+            const modelDetermined = determineModelProvider(model);
+            finalModel = modelDetermined.model;
+            if (modelDetermined.provider) {
+                finalProvider = modelDetermined.provider;
+            }
+        }
+        // Only determine provider from providerName if we don't have a provider from model
+        if (!model || !determineModelProvider(model).provider) {
+            const providerDetermined = determineModelProvider(providerName);
+            if (!providerDetermined.provider) {
+                throw new ConfigurationError(`Unable to determine provider from: ${providerName}`);
+            }
+            finalProvider = providerDetermined.provider;
+        }
+        // Handle conflicts: if both providerName and model specify different providers
+        if (model && providerName !== DEFAULT.PROVIDER.NAME) {
+            const modelDetermined = determineModelProvider(model);
+            const providerDetermined = determineModelProvider(providerName);
+            if (modelDetermined.provider &&
+                providerDetermined.provider &&
+                modelDetermined.provider !== providerDetermined.provider) {
+                // Model's provider conflicts with explicit provider, don't pass model
+                finalModel = undefined;
+            }
+        }
+        this._provider = finalProvider;
+        this._options = { ...options, model: finalModel };
+        this._llm = this.createProvider(finalProvider, this._options);
     }
     createProvider(providerName, options = {}) {
         const { apiKey, model } = options;
@@ -1665,27 +1796,43 @@ class Llm {
             case PROVIDER.ANTHROPIC.NAME:
                 return new AnthropicProvider(model || PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey });
             default:
-                throw new Error(`Unsupported provider: ${providerName}`);
+                throw new ConfigurationError(`Unsupported provider: ${providerName}`);
         }
     }
     async send(message, options) {
         return this._llm.send(message, options);
     }
-    async operate(message, options = {}) {
+    async operate(input, options = {}) {
         if (!this._llm.operate) {
             throw new NotImplementedError(`Provider ${this._provider} does not support operate method`);
         }
-        return this._llm.operate(message, options);
+        return this._llm.operate(input, options);
     }
     static async send(message, options) {
         const { llm, apiKey, model, ...messageOptions } = options || {};
         const instance = new Llm(llm, { apiKey, model });
         return instance.send(message, messageOptions);
     }
-    static async operate(message, options) {
+    static async operate(input, options) {
         const { llm, apiKey, model, ...operateOptions } = options || {};
-        const instance = new Llm(llm, { apiKey, model });
-        return instance.operate(message, operateOptions);
+        let finalLlm = llm;
+        let finalModel = model;
+        if (!llm && model) {
+            const determined = determineModelProvider(model);
+            if (determined.provider) {
+                finalLlm = determined.provider;
+            }
+        }
+        else if (llm && model) {
+            // When both llm and model are provided, check if they conflict
+            const determined = determineModelProvider(model);
+            if (determined.provider && determined.provider !== llm) {
+                // Don't pass the conflicting model to the constructor
+                finalModel = undefined;
+            }
+        }
+        const instance = new Llm(finalLlm, { apiKey, model: finalModel });
+        return instance.operate(input, operateOptions);
     }
 }
 
@@ -1957,7 +2104,16 @@ const weather = {
 };
 
 const tools = [random, roll, time, weather];
-const toolkit = new Toolkit(tools);
+class JaypieToolkit extends Toolkit {
+    constructor(tools, options) {
+        super(tools, options);
+        this.random = random;
+        this.roll = roll;
+        this.time = time;
+        this.weather = weather;
+    }
+}
+const toolkit = new JaypieToolkit(tools);
 
-export { constants as LLM, Llm, Toolkit, toolkit, tools };
+export { JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, Toolkit, toolkit, tools };
 //# sourceMappingURL=index.js.map