@jaypie/llm 1.1.22 → 1.1.24

package/dist/index.js

@@ -2,19 +2,40 @@ import { ConfigurationError, BadGatewayError, TooManyRequestsError, NotImplement
 import { log as log$2, JAYPIE, resolveValue, placeholders, sleep, ConfigurationError as ConfigurationError$1 } from '@jaypie/core';
 import { OpenAI, APIUserAbortError, AuthenticationError, BadRequestError, ConflictError, NotFoundError, PermissionDeniedError, RateLimitError, UnprocessableEntityError, APIConnectionError, APIConnectionTimeoutError, InternalServerError } from 'openai';
 import { zodResponseFormat } from 'openai/helpers/zod';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 import RandomLib from 'random';
 import { getEnvSecret } from '@jaypie/aws';
-import Anthropic from '@anthropic-ai/sdk';
+import Anthropic$1, { Anthropic } from '@anthropic-ai/sdk';
+import ZSchema from 'z-schema';
 import { fetchWeatherApi } from 'openmeteo';
 
 const PROVIDER = {
     ANTHROPIC: {
+        // https://docs.anthropic.com/en/docs/about-claude/models/overview
         MODEL: {
+            // Jaypie Aliases
+            DEFAULT: "claude-opus-4-1",
+            SMALL: "claude-sonnet-4-0",
+            TINY: "claude-3-5-haiku-latest",
+            LARGE: "claude-opus-4-1",
+            // Latests
+            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-5-sonnet-latest",
-            DEFAULT: "claude-3-5-sonnet-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	",
+            CLAUDE_3_5_SONNET: "claude-3-5-sonnet-latest",
+            CLAUDE_3_5_HAIKU: "claude-3-5-haiku-latest",
+            // _Note: Claude reversed the order of model name and version in 4_
+            // Backward compatibility
+            CLAUDE_HAIKU_3: "claude-3-5-haiku-latest",
+            CLAUDE_OPUS_3: "claude-3-opus-latest",
+            CLAUDE_SONNET_3: "claude-3-7-sonnet-latest",
         },
         NAME: "anthropic",
         PROMPT: {
@@ -34,8 +55,20 @@ const PROVIDER = {
         },
     },
     OPENAI: {
+        // https://platform.openai.com/docs/models
         MODEL: {
-            DEFAULT: "gpt-4o",
+            // Jaypie Aliases
+            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",
             GPT_4: "gpt-4",
             GPT_4_O_MINI: "gpt-4o-mini",
             GPT_4_O: "gpt-4o",
@@ -45,6 +78,9 @@ const PROVIDER = {
             O1_PRO: "o1-pro",
             O3_MINI: "o3-mini",
             O3_MINI_HIGH: "o3-mini-high",
+            O3: "o3",
+            O3_PRO: "o3-pro",
+            O4_MINI: "o4-mini",
         },
         NAME: "openai",
     },
@@ -610,6 +646,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 "";
 }
@@ -668,11 +708,26 @@ function createRequestOptions(input, options = {}) {
                 ? options.format
                 : naturalZodSchema(options.format);
             const responseFormat = zodResponseFormat(zodSchema, "response");
+            const jsonSchema = z.toJSONSchema(zodSchema);
+            // Temporary hack because of OpenAI requires additional_properties to be false on all objects
+            const checks = [jsonSchema];
+            while (checks.length > 0) {
+                const current = checks[0];
+                if (current.type == "object") {
+                    current.additionalProperties = false;
+                }
+                Object.keys(current).forEach((key) => {
+                    if (typeof current[key] == "object") {
+                        checks.push(current[key]);
+                    }
+                });
+                checks.shift();
+            }
             // Set up structured output format in the format expected by the test
             requestOptions.text = {
                 format: {
                     name: responseFormat.json_schema.name,
-                    schema: responseFormat.json_schema.schema,
+                    schema: jsonSchema, // Replace this with responseFormat.json_schema.schema once OpenAI supports Zod v4
                     strict: responseFormat.json_schema.strict,
                     type: responseFormat.type,
                 },
@@ -701,7 +756,7 @@ function createRequestOptions(input, options = {}) {
 //
 // Main
 //
-async function operate(input, options = {}, context = {
+async function operate$1(input, options = {}, context = {
     client: new OpenAI(),
 }) {
     //
@@ -829,12 +884,19 @@ async function operate(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;
@@ -891,6 +953,13 @@ async function operate(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 = {
@@ -1080,21 +1149,38 @@ function prepareMessages$1(message, { system, data, placeholders } = {}) {
     return messages;
 }
 // Completion requests
-async function createStructuredCompletion(client, { messages, responseSchema, model, }) {
+async function createStructuredCompletion$1(client, { messages, responseSchema, model, }) {
     const logger = getLogger$1();
     logger.trace("Using structured output");
     const zodSchema = responseSchema instanceof z.ZodType
         ? responseSchema
         : naturalZodSchema(responseSchema);
+    const responseFormat = zodResponseFormat(zodSchema, "response");
+    const jsonSchema = z.toJSONSchema(zodSchema);
+    // Temporary hack because OpenAI requires additional_properties to be false on all objects
+    const checks = [jsonSchema];
+    while (checks.length > 0) {
+        const current = checks[0];
+        if (current.type == "object") {
+            current.additionalProperties = false;
+        }
+        Object.keys(current).forEach((key) => {
+            if (typeof current[key] == "object") {
+                checks.push(current[key]);
+            }
+        });
+        checks.shift();
+    }
+    responseFormat.json_schema.schema = jsonSchema;
     const completion = await client.beta.chat.completions.parse({
         messages,
         model,
-        response_format: zodResponseFormat(zodSchema, "response"),
+        response_format: responseFormat,
     });
     logger.var({ assistantReply: completion.choices[0].message.parsed });
     return completion.choices[0].message.parsed;
 }
-async function createTextCompletion(client, { messages, model, }) {
+async function createTextCompletion$1(client, { messages, model, }) {
     const logger = getLogger$1();
     logger.trace("Using text output (unstructured)");
     const completion = await client.chat.completions.create({
@@ -1124,13 +1210,13 @@ class OpenAiProvider {
         const messages = prepareMessages$1(message, options || {});
         const modelToUse = options?.model || this.model;
         if (options?.response) {
-            return createStructuredCompletion(client, {
+            return createStructuredCompletion$1(client, {
                 messages,
                 responseSchema: options.response,
                 model: modelToUse,
             });
         }
-        return createTextCompletion(client, {
+        return createTextCompletion$1(client, {
             messages,
             model: modelToUse,
         });
@@ -1147,7 +1233,7 @@ class OpenAiProvider {
                 : [...this.conversationHistory];
         }
         // Call operate with the updated options
-        const response = await operate(input, mergedOptions, { client });
+        const response = await operate$1(input, mergedOptions, { client });
         // Update conversation history with the new history from the response
         if (response.history && response.history.length > 0) {
             this.conversationHistory = response.history;
@@ -1156,6 +1242,267 @@ class OpenAiProvider {
     }
 }
 
+// Handle placeholder logic
+// Convert string input to array format if needed
+// Apply placeholders to fields if data is provided and placeholders.* is undefined or true
+function handleInputAndPlaceholders(input, options) {
+    let history = formatOperateInput(input);
+    let llmInstructions;
+    let systemPrompt;
+    if (options?.data &&
+        (options.placeholders?.input === undefined || options.placeholders?.input)) {
+        history = formatOperateInput(input, {
+            data: options?.data,
+        });
+    }
+    if (options?.instructions) {
+        llmInstructions =
+            options.data && options.placeholders?.instructions !== false
+                ? placeholders(options.instructions, options.data)
+                : options.instructions;
+    }
+    if (options?.system) {
+        systemPrompt =
+            options.data && options.placeholders?.system !== false
+                ? placeholders(options.system, options.data)
+                : options.system;
+    }
+    return { history, systemPrompt, llmInstructions };
+}
+function updateUsage(usage, totalUsage) {
+    totalUsage.input += usage.input_tokens;
+    totalUsage.output += usage.output_tokens;
+    totalUsage.reasoning += usage.prompt_tokens;
+    totalUsage.total += usage.input_tokens + usage.output_tokens;
+}
+function handleMaxTurns(maxTurns, history, inputMessages, response, totalUsage) {
+    const error = new TooManyRequestsError();
+    const detail = `Model requested function call but exceeded ${maxTurns} turns`;
+    log.warn(detail);
+    return {
+        //model: model,
+        //provider: PROVIDER.ANTHROPIC,
+        error: {
+            detail,
+            status: error.status,
+            title: error.title,
+        },
+        history,
+        output: inputMessages.slice(-1),
+        responses: response.content,
+        status: LlmResponseStatus.Incomplete,
+        usage: [totalUsage],
+    };
+}
+function handleOutputSchema(format) {
+    let schema;
+    if (format) {
+        // Check if format is a JsonObject with type "json_schema"
+        if (typeof format === "object" &&
+            format !== null &&
+            !Array.isArray(format) &&
+            format.type === "json_schema") {
+            // Direct pass-through for JsonObject with type "json_schema"
+            schema = structuredClone(format);
+            schema.type = "object"; // Validator does not recognise "json_schema" as a type
+        }
+        else {
+            // Convert NaturalSchema to JSON schema through Zod
+            const zodSchema = format instanceof z.ZodType
+                ? format
+                : naturalZodSchema(format);
+            schema = z.toJSONSchema(zodSchema);
+        }
+        if (schema.$schema) {
+            delete schema.$schema; // Hack to fix issue with validator
+        }
+        return schema;
+    }
+}
+// Register tools and process them to work with Anthropic
+function bundleTools(tools, explain, schema) {
+    let toolkit;
+    let processedTools = [];
+    if (tools instanceof Toolkit) {
+        toolkit = tools;
+    }
+    else if (Array.isArray(tools)) {
+        toolkit = new Toolkit(tools, { explain });
+    }
+    if (toolkit) {
+        toolkit.tools.forEach((tool) => {
+            processedTools.push({
+                ...tool,
+                input_schema: {
+                    ...tool.parameters,
+                    type: "object",
+                },
+                type: "custom",
+            });
+            delete processedTools[processedTools.length - 1].parameters;
+        });
+    }
+    if (schema) {
+        processedTools.push({
+            name: "structured_output",
+            description: "Output a structured JSON object, " +
+                "use this before your final response to give structured outputs to the user",
+            input_schema: schema,
+            type: "custom",
+        });
+    }
+    return { processedTools, toolkit };
+}
+// Handles individual tool calls. Returns true for break, false for continue.
+async function callTool(inputMessages, response, hooks, toolkit) {
+    inputMessages.push({
+        role: PROVIDER.ANTHROPIC.ROLE.ASSISTANT,
+        content: response.content,
+    });
+    // Get the tool use
+    const toolUse = response.content[response.content.length - 1];
+    // If the tool use is structured output (magic tool), break
+    if (toolUse.name === "structured_output") {
+        return true;
+    }
+    if (hooks?.beforeEachTool) {
+        await hooks.beforeEachTool({
+            toolName: toolUse.name,
+            args: JSON.stringify(toolUse.input),
+        });
+    }
+    let result;
+    try {
+        result = await toolkit?.call({
+            name: toolUse.name,
+            arguments: JSON.stringify(toolUse.input),
+        });
+    }
+    catch (error) {
+        if (hooks?.onToolError) {
+            await hooks.onToolError({
+                error: error,
+                toolName: toolUse.name,
+                args: JSON.stringify(toolUse.input),
+            });
+        }
+        throw error;
+    }
+    if (hooks?.afterEachTool) {
+        await hooks.afterEachTool({
+            result,
+            toolName: toolUse.name,
+            args: JSON.stringify(toolUse.input),
+        });
+    }
+    inputMessages.push({
+        role: PROVIDER.ANTHROPIC.ROLE.USER,
+        content: [
+            {
+                type: "tool_result",
+                content: JSON.stringify(result),
+                tool_use_id: toolUse.id,
+            },
+        ],
+    });
+    return false;
+}
+//
+//
+// Main
+//
+async function operate(input, options = {}, context = {
+    client: new Anthropic(),
+}) {
+    // Set model
+    const model = options?.model || PROVIDER.ANTHROPIC.MODEL.DEFAULT;
+    let schema = handleOutputSchema(options.format);
+    let { processedTools, toolkit } = bundleTools(options.tools, options.explain, schema);
+    let { history, systemPrompt, llmInstructions } = handleInputAndPlaceholders(input, options);
+    // If history is provided, merge it with the input
+    if (options.history) {
+        history = [...options.history, ...history];
+    }
+    // Avoid Anthropic error by removing type property
+    const inputMessages = structuredClone(history);
+    inputMessages.forEach((message) => {
+        delete message.type;
+    });
+    // Add instruction to the input message
+    if (llmInstructions) {
+        inputMessages[inputMessages.length - 1].content += "\n\n" + llmInstructions;
+    }
+    // Setup usage tracking
+    let totalUsage = {
+        input: 0,
+        output: 0,
+        reasoning: 0,
+        total: 0,
+    };
+    // Determine max turns from options
+    const maxTurns = maxTurnsFromOptions(options);
+    const enableMultipleTurns = maxTurns > 1;
+    let currentTurn = 0;
+    let response;
+    while (true) {
+        // Loop for tool use
+        response = await context.client.messages.create({
+            model: model,
+            system: systemPrompt,
+            messages: inputMessages,
+            max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
+            stream: false,
+            tools: processedTools,
+            tool_choice: processedTools.length > 0
+                ? { type: schema ? "any" : "auto" }
+                : undefined,
+            ...options?.providerOptions,
+        });
+        // Update usage
+        updateUsage(response.usage, totalUsage);
+        // If the response is not a tool use, break
+        if (response.stop_reason !== "tool_use") {
+            break;
+        }
+        const breakLoop = await callTool(inputMessages, response, options.hooks, toolkit);
+        if (breakLoop) {
+            break;
+        }
+        // Handle turn limit
+        if (!enableMultipleTurns || currentTurn >= maxTurns) {
+            return handleMaxTurns(maxTurns, history, inputMessages, response, totalUsage);
+        }
+        currentTurn++;
+    }
+    let jsonResult;
+    if (schema) {
+        const validator = new ZSchema({});
+        jsonResult = response.content[response.content.length - 1].input;
+        if (!validator.validate(jsonResult, schema)) {
+            throw new Error("Model returned invalid JSON");
+        }
+    }
+    history.push({
+        content: schema
+            ? JSON.stringify(jsonResult)
+            : response.content[0].text,
+        role: PROVIDER.ANTHROPIC.ROLE.ASSISTANT,
+        type: LlmMessageType.Message,
+    });
+    return {
+        //model: model,
+        //provider: PROVIDER.ANTHROPIC,
+        content: schema
+            ? jsonResult
+            : response.content[0].text,
+        responses: [response],
+        output: history.slice(-1),
+        history,
+        status: LlmResponseStatus.Completed,
+        usage: [totalUsage],
+    };
+}
+
 // Logger
 const getLogger = () => log$2.lib({ lib: JAYPIE.LIB.LLM });
 // Client initialization
@@ -1165,7 +1512,7 @@ async function initializeClient({ apiKey, } = {}) {
     if (!resolvedApiKey) {
         throw new ConfigurationError$1("The application could not resolve the required API key: ANTHROPIC_API_KEY");
     }
-    const client = new Anthropic({ apiKey: resolvedApiKey });
+    const client = new Anthropic$1({ apiKey: resolvedApiKey });
     logger.trace("Initialized Anthropic client");
     return client;
 }
@@ -1193,6 +1540,72 @@ function prepareMessages(message, { data, placeholders } = {}) {
     logger.trace(`User message: ${userMessage.content.length} characters`);
     return messages;
 }
+// Basic text completion
+async function createTextCompletion(client, messages, model, systemMessage) {
+    log$2.trace("Using text output (unstructured)");
+    const params = {
+        model,
+        messages,
+        max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
+    };
+    // Add system instruction if provided
+    if (systemMessage) {
+        params.system = systemMessage;
+        log$2.trace(`System message: ${systemMessage.length} characters`);
+    }
+    const response = await client.messages.create(params);
+    log$2.trace(`Assistant reply: ${response.content[0]?.text?.length || 0} characters`);
+    return response.content[0]?.text || "";
+}
+// Structured output completion
+async function createStructuredCompletion(client, messages, model, responseSchema, systemMessage) {
+    log$2.trace("Using structured output");
+    // Get the JSON schema for the response
+    const schema = responseSchema instanceof z.ZodType
+        ? responseSchema
+        : naturalZodSchema(responseSchema);
+    // Set system message with JSON instructions
+    const defaultSystemPrompt = "You will be responding with structured JSON data. " +
+        "Format your entire response as a valid JSON object with the following structure: " +
+        JSON.stringify(z.toJSONSchema(schema));
+    const systemPrompt = systemMessage || defaultSystemPrompt;
+    try {
+        // Use standard Anthropic API to get response
+        const params = {
+            model,
+            messages,
+            max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
+            system: systemPrompt,
+        };
+        const response = await client.messages.create(params);
+        // Extract text from response
+        const responseText = response.content[0]?.text || "";
+        // Find JSON in response
+        const jsonMatch = responseText.match(/```json\s*([\s\S]*?)\s*```/) ||
+            responseText.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            try {
+                // Parse the JSON response
+                const jsonStr = jsonMatch[1] || jsonMatch[0];
+                const result = JSON.parse(jsonStr);
+                if (!schema.parse(result)) {
+                    throw new Error(`JSON response from Anthropic does not match schema: ${responseText}`);
+                }
+                log$2.trace("Received structured response", { result });
+                return result;
+            }
+            catch {
+                throw new Error(`Failed to parse JSON response from Anthropic: ${responseText}`);
+            }
+        }
+        // If we can't extract JSON
+        throw new Error("Failed to parse structured response from Anthropic");
+    }
+    catch (error) {
+        log$2.error("Error creating structured completion", { error });
+        throw error;
+    }
+}
 
 // Maps Jaypie roles to Anthropic roles
 ({
@@ -1217,89 +1630,6 @@ class AnthropicProvider {
         this._client = await initializeClient({ apiKey: this.apiKey });
         return this._client;
     }
-    // Basic text completion
-    async createTextCompletion(client, messages, model, systemMessage) {
-        this.log.trace("Using text output (unstructured)");
-        const params = {
-            model,
-            messages,
-            max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
-        };
-        // Add system instruction if provided
-        if (systemMessage) {
-            params.system = systemMessage;
-            this.log.trace(`System message: ${systemMessage.length} characters`);
-        }
-        const response = await client.messages.create(params);
-        this.log.trace(`Assistant reply: ${response.content[0]?.text?.length || 0} characters`);
-        return response.content[0]?.text || "";
-    }
-    // Structured output completion
-    async createStructuredCompletion(client, messages, model, responseSchema, systemMessage) {
-        this.log.trace("Using structured output");
-        // Get the JSON schema for the response
-        const schema = responseSchema instanceof z.ZodType
-            ? responseSchema
-            : naturalZodSchema(responseSchema);
-        // Set system message with JSON instructions
-        const defaultSystemPrompt = "You will be responding with structured JSON data. " +
-            "Format your entire response as a valid JSON object with the following structure: " +
-            (responseSchema instanceof z.ZodType
-                ? JSON.stringify(this.simplifyZodSchema(schema))
-                : JSON.stringify(responseSchema));
-        const systemPrompt = systemMessage || defaultSystemPrompt;
-        try {
-            // Use standard Anthropic API to get response
-            const params = {
-                model,
-                messages,
-                max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
-                system: systemPrompt,
-            };
-            const response = await client.messages.create(params);
-            // Extract text from response
-            const responseText = response.content[0]?.text || "";
-            // Find JSON in response
-            const jsonMatch = responseText.match(/```json\s*([\s\S]*?)\s*```/) ||
-                responseText.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                try {
-                    // Parse the JSON response
-                    const jsonStr = jsonMatch[1] || jsonMatch[0];
-                    const result = JSON.parse(jsonStr);
-                    this.log.trace("Received structured response", { result });
-                    return result;
-                }
-                catch {
-                    throw new Error(`Failed to parse JSON response from Anthropic: ${responseText}`);
-                }
-            }
-            // If we can't extract JSON
-            throw new Error("Failed to parse structured response from Anthropic");
-        }
-        catch (error) {
-            this.log.error("Error creating structured completion", { error });
-            throw error;
-        }
-    }
-    // Helper method to simplify Zod schema to a plain object for system prompt
-    simplifyZodSchema(schema) {
-        try {
-            const zodSchema = schema;
-            if (typeof zodSchema._def?.shape === "object") {
-                const result = {};
-                Object.keys(zodSchema._def.shape || {}).forEach((key) => {
-                    result[key] = "string";
-                });
-                return result;
-            }
-            return { result: "string" };
-        }
-        catch (error) {
-            this.log.error(`Error simplifying schema: ${error}`);
-            return { result: "string" };
-        }
-    }
     // Main send method
     async send(message, options) {
         const client = await this.getClient();
@@ -1314,17 +1644,28 @@ class AnthropicProvider {
             });
         }
         if (options?.response) {
-            const schema = options.response instanceof z.ZodType
-                ? options.response
-                : naturalZodSchema(options.response);
-            return this.createStructuredCompletion(client, messages, modelToUse, schema, systemMessage);
+            return createStructuredCompletion(client, messages, modelToUse, options.response, systemMessage);
         }
-        return this.createTextCompletion(client, messages, modelToUse, systemMessage);
+        return createTextCompletion(client, messages, modelToUse, systemMessage);
     }
-    // Placeholder for operate method - will be implemented in a future task
-    // This will be properly implemented in the "Tool Calling Implementation" task
-    async operate(input, _options = {}) {
-        throw new Error("The operate method is not yet implemented for AnthropicProvider");
+    async operate(input, options = {}) {
+        const client = await this.getClient();
+        options.model = options?.model || this.model;
+        // Create a merged history including both the tracked history and any explicitly provided history
+        const mergedOptions = { ...options };
+        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];
+        }
+        // Call operate with the updated options
+        const response = await operate(input, mergedOptions, { client });
+        // Update conversation history with the new history from the response
+        if (response.history && response.history.length > 0) {
+            this.conversationHistory = response.history;
+        }
+        return response;
     }
 }
 
@@ -1636,7 +1977,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, Toolkit, toolkit, tools };
 //# sourceMappingURL=index.js.map