@jaypie/llm 1.1.25 → 1.1.27

package/dist/cjs/index.cjs

@@ -0,0 +1,2128 @@
+'use strict';
+
+var errors = require('@jaypie/errors');
+var core = require('@jaypie/core');
+var openai = require('openai');
+var zod = require('openai/helpers/zod');
+var v4 = require('zod/v4');
+var RandomLib = require('random');
+var aws = require('@jaypie/aws');
+var Anthropic = require('@anthropic-ai/sdk');
+var ZSchema = require('z-schema');
+var openmeteo = require('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-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",
+        },
+        MODEL_MATCH_WORDS: [
+            "anthropic",
+            "claude",
+            "haiku",
+            "opus",
+            "sonnet",
+        ],
+        NAME: "anthropic",
+        PROMPT: {
+            AI: "\n\nAssistant:",
+            HUMAN: "\n\nHuman:",
+        },
+        ROLE: {
+            ASSISTANT: "assistant",
+            SYSTEM: "system",
+            USER: "user",
+        },
+        MAX_TOKENS: {
+            DEFAULT: 4096,
+        },
+        TOOLS: {
+            SCHEMA_VERSION: "v2",
+        },
+    },
+    OPENAI: {
+        // https://platform.openai.com/docs/models
+        MODEL: {
+            // 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",
+            GPT_4_5: "gpt-4.5-preview",
+            O1: "o1",
+            O1_MINI: "o1-mini",
+            O1_PRO: "o1-pro",
+            O3_MINI: "o3-mini",
+            O3_MINI_HIGH: "o3-mini-high",
+            O3: "o3",
+            O3_PRO: "o3-pro",
+            O4_MINI: "o4-mini",
+        },
+        MODEL_MATCH_WORDS: ["openai", "gpt", /^o\d/],
+        NAME: "openai",
+    },
+};
+// Last: Defaults
+const DEFAULT = {
+    PROVIDER: PROVIDER.OPENAI,
+};
+
+var constants = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DEFAULT: DEFAULT,
+    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 = core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+function logToolMessage(message, context) {
+    log$1.trace.var({ [context.name]: message });
+}
+class Toolkit {
+    constructor(tools, options) {
+        this._tools = tools;
+        this._options = options || {};
+        this.explain = this._options.explain ? true : false;
+        this.log = this._options.log !== undefined ? this._options.log : true;
+    }
+    get tools() {
+        return this._tools.map((tool) => {
+            const toolCopy = { ...tool };
+            delete toolCopy.call;
+            delete toolCopy.message;
+            if (this.explain && toolCopy.parameters?.type === "object") {
+                if (toolCopy.parameters?.properties) {
+                    if (!toolCopy.parameters.properties.__Explanation) {
+                        toolCopy.parameters.properties.__Explanation = {
+                            type: "string",
+                            description: `Clearly state why the tool is being called and what larger question it helps answer. For example, "I am checking the location API because the user asked for nearby pizza and I need coordinates to proceed"`,
+                        };
+                    }
+                }
+            }
+            // Set default type if not provided
+            if (!toolCopy.type) {
+                toolCopy.type = DEFAULT_TOOL_TYPE;
+            }
+            return toolCopy;
+        });
+    }
+    async call({ name, arguments: args }) {
+        const tool = this._tools.find((t) => t.name === name);
+        if (!tool) {
+            throw new Error(`Tool '${name}' not found`);
+        }
+        let parsedArgs;
+        try {
+            parsedArgs = JSON.parse(args);
+            if (this.explain) {
+                delete parsedArgs.__Explanation;
+            }
+        }
+        catch {
+            parsedArgs = args;
+        }
+        if (this.log !== false) {
+            try {
+                const context = {
+                    name,
+                    args: parsedArgs,
+                };
+                let message;
+                if (this.explain) {
+                    context.explanation = parsedArgs.__Explanation;
+                }
+                if (tool.message) {
+                    if (typeof tool.message === "string") {
+                        log$1.trace("[Toolkit] Tool provided string message");
+                        message = tool.message;
+                    }
+                    else if (typeof tool.message === "function") {
+                        log$1.trace("[Toolkit] Tool provided function message");
+                        log$1.trace("[Toolkit] Resolving message result");
+                        message = await core.resolveValue(tool.message(parsedArgs, { name }));
+                    }
+                    else {
+                        log$1.warn("[Toolkit] Tool provided unknown message type");
+                        message = String(tool.message);
+                    }
+                }
+                else {
+                    log$1.trace("[Toolkit] Log tool call with default message");
+                    message = `${tool.name}:${JSON.stringify(parsedArgs)}`;
+                }
+                if (typeof this.log === "function") {
+                    log$1.trace("[Toolkit] Log tool call with custom logger");
+                    await core.resolveValue(this.log(message, context));
+                }
+                else {
+                    log$1.trace("[Toolkit] Log tool call with default logger");
+                    logToolMessage(message, context);
+                }
+            }
+            catch (error) {
+                log$1.error("[Toolkit] Caught error during logToolCall");
+                log$1.var({ error });
+                log$1.debug("[Toolkit] Continuing...");
+            }
+        }
+        return await core.resolveValue(tool.call(parsedArgs));
+    }
+    extend(tools, options = {}) {
+        for (const tool of tools) {
+            const existingIndex = this._tools.findIndex((t) => t.name === tool.name);
+            if (existingIndex !== -1) {
+                if (options.replace === false) {
+                    continue;
+                }
+                if (options.warn !== false) {
+                    if (typeof this.log === "function") {
+                        this.log(`[Toolkit] Tool '${tool.name}' already exists, replacing with new tool`, { name: tool.name, args: {} });
+                    }
+                    else if (this.log) {
+                        log$1.warn(`[Toolkit] Tool '${tool.name}' already exists, replacing with new tool`);
+                    }
+                }
+                this._tools[existingIndex] = tool;
+            }
+            else {
+                this._tools.push(tool);
+            }
+        }
+        if (Object.prototype.hasOwnProperty.call(options, "log")) {
+            this.log = options.log;
+        }
+        if (Object.prototype.hasOwnProperty.call(options, "explain")) {
+            this.explain = options.explain;
+        }
+        return this;
+    }
+}
+
+// Enums
+exports.LlmMessageRole = void 0;
+(function (LlmMessageRole) {
+    LlmMessageRole["Assistant"] = "assistant";
+    LlmMessageRole["Developer"] = "developer";
+    LlmMessageRole["System"] = "system";
+    LlmMessageRole["User"] = "user";
+})(exports.LlmMessageRole || (exports.LlmMessageRole = {}));
+exports.LlmMessageType = void 0;
+(function (LlmMessageType) {
+    LlmMessageType["FunctionCall"] = "function_call";
+    LlmMessageType["FunctionCallOutput"] = "function_call_output";
+    LlmMessageType["InputFile"] = "input_file";
+    LlmMessageType["InputImage"] = "input_image";
+    LlmMessageType["InputText"] = "input_text";
+    LlmMessageType["ItemReference"] = "item_reference";
+    LlmMessageType["Message"] = "message";
+    LlmMessageType["OutputText"] = "output_text";
+    LlmMessageType["Refusal"] = "refusal";
+})(exports.LlmMessageType || (exports.LlmMessageType = {}));
+var LlmResponseStatus;
+(function (LlmResponseStatus) {
+    LlmResponseStatus["Completed"] = "completed";
+    LlmResponseStatus["Incomplete"] = "incomplete";
+    LlmResponseStatus["InProgress"] = "in_progress";
+})(LlmResponseStatus || (LlmResponseStatus = {}));
+
+/**
+ * Converts a string to a standardized LlmInputMessage
+ * @param input - String to format
+ * @param options - Optional configuration
+ * @param options.data - Data to use for placeholder substitution
+ * @param options.role - Role to use for the message (defaults to User)
+ * @returns LlmInputMessage
+ */
+function formatOperateMessage(input, options) {
+    const content = options?.data ? core.placeholders(input, options.data) : input;
+    return {
+        content,
+        role: options?.role || exports.LlmMessageRole.User,
+        type: exports.LlmMessageType.Message,
+    };
+}
+
+/**
+ * Converts various input types to a standardized LlmHistory format
+ * @param input - String, LlmInputMessage, or LlmHistory to format
+ * @param options - Optional configuration
+ * @param options.data - Data to use for placeholder substitution
+ * @param options.role - Role to use when converting a string to LlmInputMessage (defaults to User)
+ * @returns Standardized LlmHistory array
+ */
+function formatOperateInput(input, options) {
+    // If input is already LlmHistory, return it
+    if (Array.isArray(input)) {
+        return input;
+    }
+    // If input is a string, convert it to LlmInputMessage
+    if (typeof input === "string") {
+        return [formatOperateMessage(input, options)];
+    }
+    // If input is LlmInputMessage, apply placeholders if data is provided
+    if (options?.data && typeof input.content === "string") {
+        return [
+            formatOperateMessage(input.content, {
+                data: options.data,
+                role: input.role || options?.role,
+            }),
+        ];
+    }
+    // Otherwise, just wrap the input in an array
+    return [input];
+}
+
+const getLogger$2 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const log = getLogger$2();
+
+// Turn policy constants
+const MAX_TURNS_ABSOLUTE_LIMIT = 72;
+const MAX_TURNS_DEFAULT_LIMIT = 12;
+/**
+ * Determines the maximum number of turns based on the provided options
+ *
+ * @param options - The LLM operate options
+ * @returns The maximum number of turns
+ */
+function maxTurnsFromOptions(options) {
+    // Default to single turn (1) when turns are disabled
+    // Handle the turns parameter
+    if (options.turns === undefined) {
+        // Default to default limit when undefined
+        return MAX_TURNS_DEFAULT_LIMIT;
+    }
+    else if (options.turns === true) {
+        // Explicitly set to true
+        return MAX_TURNS_DEFAULT_LIMIT;
+    }
+    else if (typeof options.turns === "number") {
+        if (options.turns > 0) {
+            // Positive number - use that limit (capped at absolute limit)
+            return Math.min(options.turns, MAX_TURNS_ABSOLUTE_LIMIT);
+        }
+        else if (options.turns < 0) {
+            // Negative number - use default limit
+            return MAX_TURNS_DEFAULT_LIMIT;
+        }
+        // If turns is 0, return 1 (disabled)
+        return 1;
+    }
+    // All other values (false, null, etc.) will return 1 (disabled)
+    return 1;
+}
+
+function naturalZodSchema(definition) {
+    if (Array.isArray(definition)) {
+        if (definition.length === 0) {
+            // Handle empty array - accept any[]
+            return v4.z.array(v4.z.any());
+        }
+        else if (definition.length === 1) {
+            // Handle array types
+            const itemType = definition[0];
+            switch (itemType) {
+                case String:
+                    return v4.z.array(v4.z.string());
+                case Number:
+                    return v4.z.array(v4.z.number());
+                case Boolean:
+                    return v4.z.array(v4.z.boolean());
+                default:
+                    if (typeof itemType === "object") {
+                        // Handle array of objects
+                        return v4.z.array(naturalZodSchema(itemType));
+                    }
+                    // Handle enum arrays
+                    return v4.z.enum(definition);
+            }
+        }
+        else {
+            // Handle enum arrays
+            return v4.z.enum(definition);
+        }
+    }
+    else if (definition && typeof definition === "object") {
+        if (Object.keys(definition).length === 0) {
+            // Handle empty object - accept any key-value pairs
+            return v4.z.record(v4.z.string(), v4.z.any());
+        }
+        else {
+            // Handle object with properties
+            const schemaShape = {};
+            for (const [key, value] of Object.entries(definition)) {
+                schemaShape[key] = naturalZodSchema(value);
+            }
+            return v4.z.object(schemaShape);
+        }
+    }
+    else {
+        switch (definition) {
+            case String:
+                return v4.z.string();
+            case Number:
+                return v4.z.number();
+            case Boolean:
+                return v4.z.boolean();
+            case Object:
+                return v4.z.record(v4.z.string(), v4.z.any());
+            case Array:
+                return v4.z.array(v4.z.any());
+            default:
+                throw new Error(`Unsupported type: ${definition}`);
+        }
+    }
+}
+
+//
+// Constants
+//
+const DEFAULT_MIN = 0;
+const DEFAULT_MAX = 1;
+//
+// Helper Functions
+//
+/**
+ * Clamps a number between optional minimum and maximum values
+ * @param num - The number to clamp
+ * @param min - Optional minimum value
+ * @param max - Optional maximum value
+ * @returns The clamped number
+ */
+const clamp = (num, min, max) => {
+    let result = num;
+    if (typeof min === "number")
+        result = Math.max(result, min);
+    if (typeof max === "number")
+        result = Math.min(result, max);
+    return result;
+};
+/**
+ * Validates that min is not greater than max
+ * @param min - Optional minimum value
+ * @param max - Optional maximum value
+ * @throws {ConfigurationError} If min is greater than max
+ */
+const validateBounds = (min, max) => {
+    if (typeof min === "number" && typeof max === "number" && min > max) {
+        throw new errors.ConfigurationError(`Invalid bounds: min (${min}) cannot be greater than max (${max})`);
+    }
+};
+//
+// Main
+//
+/**
+ * Creates a random number generator with optional seeding
+ *
+ * @param defaultSeed - Seed string for the default RNG
+ * @returns A function that generates random numbers based on provided options
+ *
+ * @example
+ * const rng = random("default-seed");
+ *
+ * // Generate a random float between 0 and 1
+ * const basic = rng();
+ *
+ * // Generate an integer between 1 and 10
+ * const integer = rng({ min: 1, max: 10, integer: true });
+ *
+ * // Generate from normal distribution
+ * const normal = rng({ mean: 50, stddev: 10 });
+ *
+ * // Use consistent seeding
+ * const seeded = rng({ seed: "my-seed" });
+ */
+function random$1(defaultSeed) {
+    // Initialize default seeded RNG
+    const defaultRng = RandomLib.clone(defaultSeed);
+    // Store per-seed RNGs
+    const seedMap = new Map();
+    const rngFn = ({ min, max: providedMax, mean, stddev, integer = false, start = 0, seed, precision, currency = false, } = {}) => {
+        // Select the appropriate RNG based on seed
+        const rng = seed
+            ? seedMap.get(seed) ||
+                (() => {
+                    const newRng = RandomLib.clone(seed);
+                    seedMap.set(seed, newRng);
+                    return newRng;
+                })()
+            : defaultRng;
+        // If only min is set, set max to min*2, but keep track of whether max was provided
+        let max = providedMax;
+        if (typeof min === "number" && typeof max !== "number") {
+            max = min * 2;
+        }
+        validateBounds(min, max);
+        // Determine effective precision based on parameters
+        const getEffectivePrecision = () => {
+            if (integer)
+                return 0;
+            const precisions = [];
+            if (typeof precision === "number" && precision >= 0) {
+                precisions.push(precision);
+            }
+            if (currency) {
+                precisions.push(2);
+            }
+            // Return the lowest precision if any are set, undefined otherwise
+            return precisions.length > 0 ? Math.min(...precisions) : undefined;
+        };
+        // Helper function to apply precision
+        const applyPrecision = (value) => {
+            const effectivePrecision = getEffectivePrecision();
+            if (typeof effectivePrecision === "number") {
+                const factor = Math.pow(10, effectivePrecision);
+                return Math.round(value * factor) / factor;
+            }
+            return value;
+        };
+        // Use normal distribution if both mean and stddev are provided
+        if (typeof mean === "number" && typeof stddev === "number") {
+            const normalDist = rng.normal(mean, stddev);
+            const value = normalDist();
+            // Only clamp if min/max are defined
+            const clampedValue = clamp(value, min, providedMax);
+            // Switch to uniform distribution only if both bounds were explicitly provided and exceeded
+            if (typeof min === "number" &&
+                typeof providedMax === "number" &&
+                clampedValue !== value) {
+                const baseValue = integer ? rng.int(min, max) : rng.float(min, max);
+                return applyPrecision(start + baseValue);
+            }
+            return applyPrecision(start + (integer ? Math.round(clampedValue) : clampedValue));
+        }
+        // For uniform distribution, use defaults if min/max are undefined
+        const uniformMin = typeof min === "number" ? min : DEFAULT_MIN;
+        const uniformMax = typeof max === "number" ? max : DEFAULT_MAX;
+        const baseValue = integer
+            ? rng.int(uniformMin, uniformMax)
+            : rng.float(uniformMin, uniformMax);
+        return applyPrecision(start + baseValue);
+    };
+    return rngFn;
+}
+
+/**
+ * Helper function to safely call a function that might throw
+ * @param fn Function to call safely
+ */
+function callSafely(fn) {
+    try {
+        fn();
+    }
+    catch {
+        // Silently catch any errors from the function
+    }
+}
+/**
+ * Attempts to parse a value as a number. Returns the original input if parsing fails or results in NaN.
+ * @param input - The value to attempt to parse as a number
+ * @param options - Optional configuration
+ * @param options.defaultValue - Default value to return if parsing fails or results in NaN
+ * @param options.warnFunction - Function to call with warning message if parsing fails or results in NaN
+ * @returns The parsed number, defaultValue (if specified and parsing fails), or the original input
+ */
+function tryParseNumber(input, options) {
+    if (input === null || input === undefined) {
+        return input;
+    }
+    try {
+        const parsed = Number(input);
+        if (Number.isNaN(parsed)) {
+            if (options?.warnFunction) {
+                const warningMessage = `Failed to parse "${String(input)}" as number`;
+                callSafely(() => options.warnFunction(warningMessage));
+            }
+            return typeof options?.defaultValue === "number"
+                ? options.defaultValue
+                : input;
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (options?.warnFunction) {
+            let errorMessage = "";
+            if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            const warningMessage = `Error parsing "${String(input)}" as number${errorMessage ? "; " + errorMessage : ""}`;
+            callSafely(() => options.warnFunction(warningMessage));
+        }
+        return typeof options?.defaultValue === "number"
+            ? options.defaultValue
+            : input;
+    }
+}
+
+//
+//
+// Constants
+//
+const MAX_RETRIES_ABSOLUTE_LIMIT = 72;
+const MAX_RETRIES_DEFAULT_LIMIT = 6;
+// Retry policy constants
+const INITIAL_RETRY_DELAY_MS = 1000; // 1 second
+const MAX_RETRY_DELAY_MS = 32000; // 32 seconds
+const RETRY_BACKOFF_FACTOR = 2; // Exponential backoff multiplier
+const RETRYABLE_ERRORS = [
+    openai.APIConnectionError,
+    openai.APIConnectionTimeoutError,
+    openai.InternalServerError,
+];
+const NOT_RETRYABLE_ERRORS = [
+    openai.APIUserAbortError,
+    openai.AuthenticationError,
+    openai.BadRequestError,
+    openai.ConflictError,
+    openai.NotFoundError,
+    openai.PermissionDeniedError,
+    openai.RateLimitError,
+    openai.UnprocessableEntityError,
+];
+const ERROR = {
+    BAD_FUNCTION_CALL: "Bad Function Call",
+};
+//
+//
+// Helpers
+//
+/**
+ * Creates content string for function calls
+ */
+function createFunctionCallContent(output) {
+    return `${exports.LlmMessageType.FunctionCall}:${output.name}${output.arguments}#${output.call_id}`;
+}
+/**
+ * Extracts content from OpenAI response output array
+ */
+function extractContentFromResponse(currentResponse, options) {
+    if (!currentResponse.output || !Array.isArray(currentResponse.output)) {
+        return "";
+    }
+    for (const output of currentResponse.output) {
+        if (output.type === exports.LlmMessageType.Message) {
+            if (output.content?.[0] &&
+                output.content[0].type === exports.LlmMessageType.OutputText) {
+                const rawContent = output.content[0].text;
+                // If format is provided, try to parse the content as JSON
+                if (options?.format && typeof rawContent === "string") {
+                    try {
+                        const parsedContent = JSON.parse(rawContent);
+                        return parsedContent;
+                    }
+                    catch (error) {
+                        // If parsing fails, keep the original string content
+                        log.debug("Failed to parse formatted response as JSON");
+                        log.var({ error });
+                        return rawContent;
+                    }
+                }
+                return rawContent;
+            }
+        }
+        if (output.type === exports.LlmMessageType.FunctionCall) {
+            return createFunctionCallContent(output);
+        }
+        // Skip reasoning items when extracting content
+        if (output.type === "reasoning") {
+            continue;
+        }
+    }
+    return "";
+}
+/**
+ * Creates the request options for the OpenAI API call
+ *
+ * @param input - The formatted input messages
+ * @param options - The LLM operation options
+ * @returns The request options for the OpenAI API
+ */
+function createRequestOptions(input, options = {}) {
+    const requestOptions = {
+        model: options?.model || PROVIDER.OPENAI.MODEL.DEFAULT,
+        input,
+    };
+    // Add user if provided
+    if (options?.user) {
+        requestOptions.user = options.user;
+    }
+    // Add any provider-specific options
+    if (options?.providerOptions) {
+        Object.assign(requestOptions, options.providerOptions);
+    }
+    // Handle instructions or system message
+    if (options?.instructions) {
+        // Apply placeholders to instructions if data is provided and placeholders.instructions is undefined or true
+        requestOptions.instructions =
+            options.data &&
+                (options.placeholders?.instructions === undefined ||
+                    options.placeholders?.instructions)
+                ? core.placeholders(options.instructions, options.data)
+                : options.instructions;
+    }
+    // Handle developer message as system message
+    // @ts-expect-error Testing invalid option
+    if (options?.developer) {
+        log.warn("Developer message provided but not supported. Using as system message.");
+        // @ts-expect-error Testing invalid option
+        requestOptions.system = options.developer;
+    }
+    // Handle structured output format
+    if (options?.format) {
+        // Check if format is a JsonObject with type "json_schema"
+        if (typeof options.format === "object" &&
+            options.format !== null &&
+            !Array.isArray(options.format) &&
+            options.format.type === "json_schema") {
+            // Direct pass-through for JsonObject with type "json_schema"
+            requestOptions.text = {
+                format: options.format,
+            };
+        }
+        else {
+            // Convert NaturalSchema to Zod schema if needed
+            const zodSchema = options.format instanceof v4.z.ZodType
+                ? options.format
+                : naturalZodSchema(options.format);
+            const responseFormat = zod.zodResponseFormat(zodSchema, "response");
+            const jsonSchema = v4.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" && current[key] !== null) {
+                        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: jsonSchema, // Replace this with responseFormat.json_schema.schema once OpenAI supports Zod v4
+                    strict: responseFormat.json_schema.strict,
+                    type: responseFormat.type,
+                },
+            };
+        }
+    }
+    // Handle tools - either as LlmTool[] or Toolkit
+    if (options.tools) {
+        let toolkit;
+        if (options.tools instanceof Toolkit) {
+            // If toolkit is already provided, use it directly
+            toolkit = options.tools;
+        }
+        else if (Array.isArray(options.tools) && options.tools.length > 0) {
+            // If array of tools provided, create toolkit from them
+            const explain = options?.explain ?? false;
+            toolkit = new Toolkit(options.tools, { explain });
+        }
+        if (toolkit) {
+            requestOptions.tools = toolkit.tools;
+        }
+    }
+    return requestOptions;
+}
+//
+//
+// Main
+//
+async function operate$1(input, options = {}, context = {
+    client: new openai.OpenAI(),
+}) {
+    //
+    //
+    // Setup
+    //
+    const openai = context.client;
+    if (!context.maxRetries) {
+        context.maxRetries = MAX_RETRIES_DEFAULT_LIMIT;
+    }
+    let retryCount = 0;
+    let retryDelay = INITIAL_RETRY_DELAY_MS;
+    const maxRetries = Math.min(context.maxRetries, MAX_RETRIES_ABSOLUTE_LIMIT);
+    const returnResponse = {
+        history: [],
+        model: options?.model || PROVIDER.OPENAI.MODEL.DEFAULT,
+        output: [],
+        provider: PROVIDER.OPENAI.NAME,
+        responses: [],
+        status: LlmResponseStatus.InProgress,
+        usage: [], // Initialize as empty array, will add entry for each response
+    };
+    // Convert string input to array format with placeholders if needed
+    let currentInput = formatOperateInput(input);
+    if (options?.data &&
+        (options.placeholders?.input === undefined || options.placeholders?.input)) {
+        currentInput = formatOperateInput(input, {
+            data: options?.data,
+        });
+    }
+    // If history is provided, merge it with currentInput
+    if (options.history) {
+        currentInput = [...options.history, ...currentInput];
+    }
+    // If system message is provided, add it to the beginning of the input
+    if (options?.system) {
+        const systemMessage = options.data && options.placeholders?.system !== false
+            ? core.placeholders(options.system, options.data)
+            : options.system;
+        // Create system message
+        const systemInputMessage = {
+            content: systemMessage,
+            role: exports.LlmMessageRole.System,
+            type: exports.LlmMessageType.Message,
+        };
+        // Check if history starts with an identical system message
+        const firstMessage = currentInput[0];
+        const isIdenticalSystemMessage = firstMessage?.type === exports.LlmMessageType.Message &&
+            firstMessage?.role === exports.LlmMessageRole.System &&
+            firstMessage?.content === systemMessage;
+        // Only prepend if not identical
+        if (!isIdenticalSystemMessage) {
+            // Remove any existing system message from the beginning
+            if (currentInput[0]?.type === exports.LlmMessageType.Message &&
+                currentInput[0]?.role === exports.LlmMessageRole.System) {
+                currentInput = currentInput.slice(1);
+            }
+            currentInput = [systemInputMessage, ...currentInput];
+        }
+    }
+    // Initialize history with currentInput
+    returnResponse.history = [...currentInput];
+    // Determine max turns from options
+    const maxTurns = maxTurnsFromOptions(options);
+    const enableMultipleTurns = maxTurns > 1;
+    let currentTurn = 0;
+    // Build request options outside the retry loop
+    const requestOptions = createRequestOptions(currentInput, options);
+    // OpenAI Multi-turn Loop
+    while (currentTurn < maxTurns) {
+        currentTurn++;
+        retryCount = 0;
+        retryDelay = INITIAL_RETRY_DELAY_MS;
+        // OpenAI Retry Loop
+        while (true) {
+            try {
+                // Log appropriate message based on turn number
+                if (currentTurn > 1) {
+                    log.trace(`[operate] Calling OpenAI Responses API - ${currentTurn}`);
+                }
+                else {
+                    log.trace("[operate] Calling OpenAI Responses API");
+                }
+                // Execute beforeEachModelRequest hook if defined
+                if (options.hooks?.beforeEachModelRequest) {
+                    await core.resolveValue(options.hooks.beforeEachModelRequest({
+                        input,
+                        options,
+                        providerRequest: requestOptions,
+                    }));
+                }
+                // 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));
+                if (retryCount > 0) {
+                    log.debug(`OpenAI API call succeeded after ${retryCount} retries`);
+                }
+                // Add the response to the responses array
+                returnResponse.responses.push(currentResponse);
+                // Add a new usage entry for each response instead of accumulating
+                if (currentResponse.usage) {
+                    // Create new usage item for this response
+                    returnResponse.usage.push({
+                        input: currentResponse.usage.input_tokens || 0,
+                        output: currentResponse.usage.output_tokens || 0,
+                        total: currentResponse.usage.total_tokens || 0,
+                        reasoning: currentResponse.usage.output_tokens_details?.reasoning_tokens ||
+                            0,
+                        provider: PROVIDER.OPENAI.NAME,
+                        model: options?.model || PROVIDER.OPENAI.MODEL.DEFAULT,
+                    });
+                }
+                // Execute afterEachModelResponse hook immediately after usage processing
+                if (options.hooks?.afterEachModelResponse) {
+                    const extractedContent = extractContentFromResponse(currentResponse, options);
+                    await core.resolveValue(options.hooks.afterEachModelResponse({
+                        input,
+                        options,
+                        providerRequest: requestOptions,
+                        providerResponse: currentResponse,
+                        content: extractedContent || "",
+                        usage: returnResponse.usage,
+                    }));
+                }
+                // 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 === exports.LlmMessageType.FunctionCall) {
+                                hasFunctionCall = true;
+                                let toolkit;
+                                // Initialize toolkit for multi-turn function calling
+                                if (options.tools) {
+                                    if (options.tools instanceof Toolkit) {
+                                        // If toolkit is already provided, use it directly
+                                        toolkit = options.tools;
+                                    }
+                                    else if (Array.isArray(options.tools) &&
+                                        options.tools.length > 0) {
+                                        // If array of tools provided, create toolkit from them
+                                        const explain = options?.explain ?? false;
+                                        toolkit = new Toolkit(options.tools, { explain });
+                                    }
+                                }
+                                if (toolkit && enableMultipleTurns) {
+                                    try {
+                                        // Call the tool and ensure the result is resolved if it's a Promise
+                                        log.trace(`[operate] Calling tool - ${output.name}`);
+                                        // Content will be set by extractContentFromResponse call later
+                                        // Execute beforeEachTool hook if defined
+                                        if (options.hooks?.beforeEachTool) {
+                                            await core.resolveValue(options.hooks.beforeEachTool({
+                                                toolName: output.name,
+                                                args: output.arguments,
+                                            }));
+                                        }
+                                        let result;
+                                        try {
+                                            result = await toolkit.call({
+                                                name: output.name,
+                                                arguments: output.arguments,
+                                            });
+                                            // Execute afterEachTool hook if defined
+                                            if (options.hooks?.afterEachTool) {
+                                                await core.resolveValue(options.hooks.afterEachTool({
+                                                    result,
+                                                    toolName: output.name,
+                                                    args: output.arguments,
+                                                }));
+                                            }
+                                        }
+                                        catch (error) {
+                                            // Execute onToolError hook if defined
+                                            if (options.hooks?.onToolError) {
+                                                await core.resolveValue(options.hooks.onToolError({
+                                                    error: error,
+                                                    toolName: output.name,
+                                                    args: output.arguments,
+                                                }));
+                                            }
+                                            throw error;
+                                        }
+                                        // 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 = {
+                                                call_id: output.call_id,
+                                                output: JSON.stringify(result),
+                                                type: exports.LlmMessageType.FunctionCallOutput,
+                                            };
+                                            currentInput.push(functionCallOutput);
+                                            returnResponse.output.push(functionCallOutput);
+                                            returnResponse.history.push(functionCallOutput);
+                                            // Content will be set by extractContentFromResponse call later
+                                        }
+                                    }
+                                    catch (error) {
+                                        // TODO: but I do need to tell the model that something went wrong, right?
+                                        const jaypieError = new errors.BadGatewayError();
+                                        const detail = [
+                                            `Error executing function call ${output.name}.`,
+                                            error.message,
+                                        ].join("\n");
+                                        returnResponse.error = {
+                                            detail,
+                                            status: jaypieError.status,
+                                            title: ERROR.BAD_FUNCTION_CALL,
+                                        };
+                                        log.error(`Error executing function call ${output.name}`);
+                                        log.var({ error });
+                                        // We don't add error messages to allResponses here as we want to keep the original response objects
+                                    }
+                                }
+                                else if (!toolkit) {
+                                    log.warn("Model requested function call but no toolkit available");
+                                }
+                            }
+                            // Content processing is now handled by extractContentFromResponse function
+                        }
+                    }
+                }
+                catch (error) {
+                    // If there's an error processing the response, log it but don't fail
+                    // This helps with test mocks that might not have the expected structure
+                    log.warn("Error processing response for function calls");
+                    log.var({ error });
+                }
+                // Set content using the shared extraction function
+                returnResponse.content = extractContentFromResponse(currentResponse, options);
+                // If there's no function call or we can't take another turn, exit the loop
+                if (!hasFunctionCall || !enableMultipleTurns) {
+                    returnResponse.status = LlmResponseStatus.Completed;
+                    return returnResponse;
+                }
+                // If we've reached the maximum number of turns, exit the loop
+                if (currentTurn >= maxTurns) {
+                    const error = new errors.TooManyRequestsError();
+                    const detail = `Model requested function call but exceeded ${maxTurns} turns`;
+                    log.warn(detail);
+                    returnResponse.status = LlmResponseStatus.Incomplete;
+                    returnResponse.error = {
+                        detail,
+                        status: error.status,
+                        title: error.title,
+                    };
+                    return returnResponse;
+                }
+                // Continue to next turn
+                break;
+            }
+            catch (error) {
+                // Check if we've reached the maximum number of retries
+                if (retryCount >= maxRetries) {
+                    log.error(`OpenAI API call failed after ${maxRetries} retries`);
+                    log.var({ error });
+                    // Execute onUnrecoverableModelError hook if defined
+                    if (options.hooks?.onUnrecoverableModelError) {
+                        await core.resolveValue(options.hooks.onUnrecoverableModelError({
+                            input,
+                            options,
+                            providerRequest: requestOptions,
+                            error,
+                        }));
+                    }
+                    throw new errors.BadGatewayError();
+                }
+                // Check if the error is not retryable
+                let isNotRetryable = false;
+                for (const notRetryableError of NOT_RETRYABLE_ERRORS) {
+                    if (error instanceof notRetryableError) {
+                        isNotRetryable = true;
+                        break;
+                    }
+                }
+                if (isNotRetryable) {
+                    log.error("OpenAI API call failed with non-retryable error");
+                    log.var({ error });
+                    // Execute onUnrecoverableModelError hook if defined
+                    if (options.hooks?.onUnrecoverableModelError) {
+                        await core.resolveValue(options.hooks.onUnrecoverableModelError({
+                            input,
+                            options,
+                            providerRequest: requestOptions,
+                            error,
+                        }));
+                    }
+                    throw new errors.BadGatewayError();
+                }
+                // Warn if this error is not in our known retryable errors
+                let isUnknownError = true;
+                for (const retryableError of RETRYABLE_ERRORS) {
+                    if (error instanceof retryableError) {
+                        isUnknownError = false;
+                        break;
+                    }
+                }
+                if (isUnknownError) {
+                    log.warn("OpenAI API returned unknown error");
+                    log.var({ error });
+                }
+                // Log the error and retry
+                log.warn(`OpenAI API call failed. Retrying in ${retryDelay}ms...`);
+                // Execute onRetryableModelError hook if defined
+                if (options.hooks?.onRetryableModelError) {
+                    await core.resolveValue(options.hooks.onRetryableModelError({
+                        input,
+                        options,
+                        providerRequest: requestOptions,
+                        error,
+                    }));
+                }
+                // Wait before retrying
+                await core.sleep(retryDelay);
+                // Increase retry count and delay for next attempt (exponential backoff)
+                retryCount++;
+                retryDelay = Math.min(retryDelay * RETRY_BACKOFF_FACTOR, MAX_RETRY_DELAY_MS);
+            }
+        }
+    }
+    // * All possible paths should return a response; getting here is an error
+    // The main loop is `currentTurn < maxTurns` and `currentTurn >= maxTurns` within the loop returns
+    log.warn("This should never happen");
+    returnResponse.status = LlmResponseStatus.Incomplete;
+    // Always return the full LlmOperateResponse object for consistency
+    return returnResponse;
+}
+
+// Logger
+const getLogger$1 = () => core.log.lib({ lib: core.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");
+    }
+    const client = new openai.OpenAI({ apiKey: resolvedApiKey });
+    logger.trace("Initialized OpenAI client");
+    return client;
+}
+function formatSystemMessage$1(systemPrompt, { data, placeholders } = {}) {
+    const content = placeholders?.system === false
+        ? systemPrompt
+        : core.placeholders(systemPrompt, data);
+    return {
+        role: "developer",
+        content,
+    };
+}
+function formatUserMessage$1(message, { data, placeholders } = {}) {
+    const content = placeholders?.message === false
+        ? message
+        : core.placeholders(message, data);
+    return {
+        role: "user",
+        content,
+    };
+}
+function prepareMessages$1(message, { system, data, placeholders } = {}) {
+    const logger = getLogger$1();
+    const messages = [];
+    if (system) {
+        const systemMessage = formatSystemMessage$1(system, { data, placeholders });
+        messages.push(systemMessage);
+        logger.trace(`System message: ${systemMessage.content?.length} characters`);
+    }
+    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$1(client, { messages, responseSchema, model, }) {
+    const logger = getLogger$1();
+    logger.trace("Using structured output");
+    const zodSchema = responseSchema instanceof v4.z.ZodType
+        ? responseSchema
+        : naturalZodSchema(responseSchema);
+    const responseFormat = zod.zodResponseFormat(zodSchema, "response");
+    const jsonSchema = v4.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" && current[key] !== null) {
+                checks.push(current[key]);
+            }
+        });
+        checks.shift();
+    }
+    responseFormat.json_schema.schema = jsonSchema;
+    const completion = await client.beta.chat.completions.parse({
+        messages,
+        model,
+        response_format: responseFormat,
+    });
+    logger.var({ assistantReply: completion.choices[0].message.parsed });
+    return completion.choices[0].message.parsed;
+}
+async function createTextCompletion$1(client, { messages, model, }) {
+    const logger = getLogger$1();
+    logger.trace("Using text output (unstructured)");
+    const completion = await client.chat.completions.create({
+        messages,
+        model,
+    });
+    logger.trace(`Assistant reply: ${completion.choices[0]?.message?.content?.length} characters`);
+    return completion.choices[0]?.message?.content || "";
+}
+
+class OpenAiProvider {
+    constructor(model = PROVIDER.OPENAI.MODEL.DEFAULT, { apiKey } = {}) {
+        this.log = getLogger$1();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient$1({ apiKey: this.apiKey });
+        return this._client;
+    }
+    async send(message, options) {
+        const client = await this.getClient();
+        const messages = prepareMessages$1(message, options || {});
+        const modelToUse = options?.model || this.model;
+        if (options?.response) {
+            return createStructuredCompletion$1(client, {
+                messages,
+                responseSchema: options.response,
+                model: modelToUse,
+            });
+        }
+        return createTextCompletion$1(client, {
+            messages,
+            model: modelToUse,
+        });
+    }
+    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$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;
+        }
+        return response;
+    }
+}
+
+// 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
+                ? core.placeholders(options.instructions, options.data)
+                : options.instructions;
+    }
+    if (options?.system) {
+        systemPrompt =
+            options.data && options.placeholders?.system !== false
+                ? core.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.total += usage.input_tokens + usage.output_tokens;
+}
+function handleMaxTurns(maxTurns, history, inputMessages, response, totalUsage) {
+    const error = new errors.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 v4.z.ZodType
+                ? format
+                : naturalZodSchema(format);
+            schema = v4.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.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: exports.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 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient({ apiKey, } = {}) {
+    const logger = getLogger();
+    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");
+    }
+    const client = new Anthropic({ apiKey: resolvedApiKey });
+    logger.trace("Initialized Anthropic client");
+    return client;
+}
+// Message formatting functions
+function formatSystemMessage(systemPrompt, { data, placeholders } = {}) {
+    return placeholders?.system === false
+        ? systemPrompt
+        : core.placeholders(systemPrompt, data);
+}
+function formatUserMessage(message, { data, placeholders } = {}) {
+    const content = placeholders?.message === false
+        ? message
+        : core.placeholders(message, data);
+    return {
+        role: PROVIDER.ANTHROPIC.ROLE.USER,
+        content,
+    };
+}
+function prepareMessages(message, { data, placeholders } = {}) {
+    const logger = getLogger();
+    const messages = [];
+    // Add user message (necessary for all requests)
+    const userMessage = formatUserMessage(message, { data, placeholders });
+    messages.push(userMessage);
+    logger.trace(`User message: ${userMessage.content.length} characters`);
+    return messages;
+}
+// Basic text completion
+async function createTextCompletion(client, messages, model, systemMessage) {
+    core.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;
+        core.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`);
+    return text;
+}
+// Structured output completion
+async function createStructuredCompletion(client, messages, model, responseSchema, systemMessage) {
+    core.log.trace("Using structured output");
+    // Get the JSON schema for the response
+    const schema = responseSchema instanceof v4.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(v4.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 firstContent = response.content[0];
+        const responseText = firstContent && "text" in firstContent ? firstContent.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}`);
+                }
+                core.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) {
+        core.log.error("Error creating structured completion", { error });
+        throw error;
+    }
+}
+
+// Maps Jaypie roles to Anthropic roles
+({
+    [exports.LlmMessageRole.User]: PROVIDER.ANTHROPIC.ROLE.USER,
+    [exports.LlmMessageRole.System]: PROVIDER.ANTHROPIC.ROLE.SYSTEM,
+    [exports.LlmMessageRole.Assistant]: PROVIDER.ANTHROPIC.ROLE.ASSISTANT,
+    [exports.LlmMessageRole.Developer]: PROVIDER.ANTHROPIC.ROLE.SYSTEM,
+});
+
+// Main class implementation
+class AnthropicProvider {
+    constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT, { 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;
+    }
+    // Main send method
+    async send(message, options) {
+        const client = await this.getClient();
+        const messages = prepareMessages(message, options || {});
+        const modelToUse = options?.model || this.model;
+        // Process system message if provided
+        let systemMessage;
+        if (options?.system) {
+            systemMessage = formatSystemMessage(options.system, {
+                data: options.data,
+                placeholders: options.placeholders,
+            });
+        }
+        if (options?.response) {
+            return createStructuredCompletion(client, messages, modelToUse, options.response, systemMessage);
+        }
+        return createTextCompletion(client, messages, modelToUse, systemMessage);
+    }
+    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;
+    }
+}
+
+class Llm {
+    constructor(providerName = DEFAULT.PROVIDER.NAME, 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 errors.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;
+        switch (providerName) {
+            case PROVIDER.OPENAI.NAME:
+                return new OpenAiProvider(model || PROVIDER.OPENAI.MODEL.DEFAULT, {
+                    apiKey,
+                });
+            case PROVIDER.ANTHROPIC.NAME:
+                return new AnthropicProvider(model || PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey });
+            default:
+                throw new errors.ConfigurationError(`Unsupported provider: ${providerName}`);
+        }
+    }
+    async send(message, options) {
+        return this._llm.send(message, options);
+    }
+    async operate(input, options = {}) {
+        if (!this._llm.operate) {
+            throw new errors.NotImplementedError(`Provider ${this._provider} does not support operate method`);
+        }
+        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(input, options) {
+        const { llm, apiKey, model, ...operateOptions } = options || {};
+        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);
+    }
+}
+
+const random = {
+    description: "Generate a random number with optional distribution, precision, range, and seeding",
+    name: "random",
+    parameters: {
+        type: "object",
+        properties: {
+            min: {
+                type: "number",
+                description: "Minimum value (inclusive). Default: 0. When used with mean/stddev, acts as a clamp on the normal distribution",
+            },
+            max: {
+                type: "number",
+                description: "Maximum value (inclusive). Default: 1. When used with mean/stddev, acts as a clamp on the normal distribution",
+            },
+            mean: {
+                type: "number",
+                description: "Mean value for normal distribution. When set with stddev, uses normal distribution (clamped by min/max if provided)",
+            },
+            stddev: {
+                type: "number",
+                description: "Standard deviation for normal distribution. When set with mean, uses normal distribution (clamped by min/max if provided)",
+            },
+            integer: {
+                type: "boolean",
+                description: "Whether to return an integer value. Default: false",
+            },
+            seed: {
+                type: "string",
+                description: "Seed string for consistent random generation. Default: undefined (uses default RNG)",
+            },
+            precision: {
+                type: "number",
+                description: "Number of decimal places for the result. Default: undefined (full precision)",
+            },
+            currency: {
+                type: "boolean",
+                description: "Whether to format as currency (2 decimal places). Default: false",
+            },
+        },
+        required: [],
+    },
+    type: "function",
+    call: (options) => {
+        const rng = random$1();
+        return rng(options);
+    },
+    message: ({ min, max, mean, stddev, integer, seed, precision, currency, } = {}) => {
+        let description = "Generating";
+        if (seed) {
+            description += ` seeded`;
+        }
+        else {
+            description += " random";
+        }
+        if (integer) {
+            description += " integer";
+        }
+        else if (currency) {
+            description += " currency";
+        }
+        else if (precision) {
+            description += ` with precision \`${precision}\``;
+        }
+        else {
+            description += " number";
+        }
+        if (min && max) {
+            description += ` between \`${min}\` and \`${max}\``;
+        }
+        if (mean && stddev) {
+            description += ` with normal distribution around \`${mean}\` with standard deviation \`${stddev}\``;
+        }
+        return description;
+    },
+};
+
+const roll = {
+    description: "Roll one or more dice with a specified number of sides",
+    name: "roll",
+    parameters: {
+        type: "object",
+        properties: {
+            number: {
+                type: "number",
+                description: "Number of dice to roll. Default: 1",
+            },
+            sides: {
+                type: "number",
+                description: "Number of sides on each die. Default: 6",
+            },
+        },
+        required: ["number", "sides"],
+    },
+    type: "function",
+    call: ({ number = 1, sides = 6 } = {}) => {
+        const rng = random$1();
+        const rolls = [];
+        let total = 0;
+        const parsedNumber = tryParseNumber(number, {
+            defaultValue: 1,
+            warnFunction: log.warn,
+        });
+        const parsedSides = tryParseNumber(sides, {
+            defaultValue: 6,
+            warnFunction: log.warn,
+        });
+        for (let i = 0; i < parsedNumber; i++) {
+            const rollValue = rng({ min: 1, max: parsedSides, integer: true });
+            rolls.push(rollValue);
+            total += rollValue;
+        }
+        return { rolls, total };
+    },
+    message: ({ number = 1, sides = 6 } = {}) => {
+        return `Rolling ${number} ${sides}-sided dice`;
+    },
+};
+
+const time = {
+    description: "Returns the provided date as an ISO UTC string or the current time if no date provided.",
+    name: "time",
+    parameters: {
+        type: "object",
+        properties: {
+            date: {
+                type: "string",
+                description: "Date string to convert to ISO UTC format. Default: current time",
+            },
+        },
+        required: [],
+    },
+    type: "function",
+    call: ({ date } = {}) => {
+        if (typeof date === "number" || typeof date === "string") {
+            const parsedDate = new Date(date);
+            if (isNaN(parsedDate.getTime())) {
+                throw new Error(`Invalid date format: ${date}`);
+            }
+            return parsedDate.toISOString();
+        }
+        return new Date().toISOString();
+    },
+    message: ({ date } = {}) => {
+        if (typeof date === "number" || typeof date === "string") {
+            return `Converting date to ISO UTC format`;
+        }
+        return "Checking current time";
+    },
+};
+
+const weather = {
+    description: "Get current weather and forecast data for a specific location",
+    name: "weather",
+    parameters: {
+        type: "object",
+        properties: {
+            latitude: {
+                type: "number",
+                description: "Latitude of the location. Default: 42.051554533384866 (Evanston, IL)",
+            },
+            location: {
+                type: "string",
+                description: "Human-readable description of the location, not used for the API call. Default: Evanston, IL",
+            },
+            longitude: {
+                type: "number",
+                description: "Longitude of the location. Default: -87.6759911441785 (Evanston, IL)",
+            },
+            timezone: {
+                type: "string",
+                description: "Timezone for the results. Default: America/Chicago",
+            },
+            past_days: {
+                type: "number",
+                description: "Number of past days to include in the forecast. Default: 1",
+            },
+            forecast_days: {
+                type: "number",
+                description: "Number of forecast days to include. Default: 1",
+            },
+        },
+        required: ["latitude", "location", "longitude"],
+    },
+    type: "function",
+    call: async ({ latitude = 42.051554533384866, longitude = -87.6759911441785, timezone = "America/Chicago", past_days = 1, forecast_days = 1, } = {}) => {
+        try {
+            const params = {
+                latitude,
+                longitude,
+                hourly: [
+                    "temperature_2m",
+                    "precipitation_probability",
+                    "precipitation",
+                ],
+                current: [
+                    "temperature_2m",
+                    "is_day",
+                    "showers",
+                    "cloud_cover",
+                    "wind_speed_10m",
+                    "relative_humidity_2m",
+                    "precipitation",
+                    "snowfall",
+                    "rain",
+                    "apparent_temperature",
+                ],
+                timezone,
+                past_days,
+                forecast_days,
+                wind_speed_unit: "mph",
+                temperature_unit: "fahrenheit",
+                precipitation_unit: "inch",
+            };
+            const url = "https://api.open-meteo.com/v1/forecast";
+            const responses = await openmeteo.fetchWeatherApi(url, params);
+            // Helper function to form time ranges
+            const range = (start, stop, step) => Array.from({ length: (stop - start) / step }, (_, i) => start + i * step);
+            // Process first location
+            const response = responses[0];
+            // Attributes for timezone and location
+            const utcOffsetSeconds = response.utcOffsetSeconds();
+            const timezoneAbbreviation = response.timezoneAbbreviation();
+            const current = response.current();
+            const hourly = response.hourly();
+            // Create weather data object
+            const weatherData = {
+                location: {
+                    latitude: response.latitude(),
+                    longitude: response.longitude(),
+                    timezone: response.timezone(),
+                    timezoneAbbreviation,
+                    utcOffsetSeconds,
+                },
+                current: {
+                    time: new Date((Number(current.time()) + utcOffsetSeconds) * 1000).toISOString(),
+                    temperature2m: current.variables(0).value(),
+                    isDay: current.variables(1).value(),
+                    showers: current.variables(2).value(),
+                    cloudCover: current.variables(3).value(),
+                    windSpeed10m: current.variables(4).value(),
+                    relativeHumidity2m: current.variables(5).value(),
+                    precipitation: current.variables(6).value(),
+                    snowfall: current.variables(7).value(),
+                    rain: current.variables(8).value(),
+                    apparentTemperature: current.variables(9).value(),
+                },
+                hourly: {
+                    time: range(Number(hourly.time()), Number(hourly.timeEnd()), hourly.interval()).map((t) => new Date((t + utcOffsetSeconds) * 1000).toISOString()),
+                    temperature2m: Array.from(hourly.variables(0).valuesArray()),
+                    precipitationProbability: Array.from(hourly.variables(1).valuesArray()),
+                    precipitation: Array.from(hourly.variables(2).valuesArray()),
+                },
+            };
+            return weatherData;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Weather API error: ${error.message}`);
+            }
+            throw new Error("Unknown error occurred while fetching weather data");
+        }
+    },
+    message: ({ latitude = 42.051554533384866, longitude = -87.6759911441785, location = "Evanston, IL", } = {}) => {
+        return `Getting weather for ${location} (${latitude}, ${longitude})`;
+    },
+};
+
+const tools = [random, roll, time, weather];
+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);
+
+exports.JaypieToolkit = JaypieToolkit;
+exports.LLM = constants;
+exports.Llm = Llm;
+exports.Toolkit = Toolkit;
+exports.toolkit = toolkit;
+exports.tools = tools;
+//# sourceMappingURL=index.cjs.map