@jaypie/llm 1.1.4 → 1.1.6

package/dist/index.js

@@ -1,8 +1,11 @@
-import { getEnvSecret } from '@jaypie/aws';
-import { log, JAYPIE, ConfigurationError, placeholders } from '@jaypie/core';
-import { OpenAI } from 'openai';
+import { BadGatewayError, NotImplementedError, ConfigurationError as ConfigurationError$1 } from '@jaypie/errors';
+import { log, JAYPIE, ConfigurationError, placeholders, sleep } 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 { getEnvSecret } from '@jaypie/aws';
+import RandomLib from 'random';
+import { fetchWeatherApi } from 'openmeteo';
 
 const PROVIDER = {
     ANTHROPIC: {
@@ -18,7 +21,14 @@ const PROVIDER = {
         MODEL: {
             DEFAULT: "gpt-4o",
             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",
         },
         NAME: "openai",
     },
@@ -96,72 +106,457 @@ function naturalZodSchema(definition) {
     }
 }
 
+// Logger
+const getLogger = () => log.lib({ lib: JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient({ apiKey, } = {}) {
+    const logger = getLogger();
+    const resolvedApiKey = apiKey || (await getEnvSecret("OPENAI_API_KEY"));
+    if (!resolvedApiKey) {
+        throw new ConfigurationError("The application could not resolve the requested keys");
+    }
+    const client = new OpenAI({ apiKey: resolvedApiKey });
+    logger.trace("Initialized OpenAI client");
+    return client;
+}
+function formatSystemMessage(systemPrompt, { data, placeholders: placeholders$1 } = {}) {
+    const content = placeholders$1?.system === false
+        ? systemPrompt
+        : placeholders(systemPrompt, data);
+    return {
+        role: "developer",
+        content,
+    };
+}
+function formatUserMessage(message, { data, placeholders: placeholders$1 } = {}) {
+    const content = placeholders$1?.message === false
+        ? message
+        : placeholders(message, data);
+    return {
+        role: "user",
+        content,
+    };
+}
+function prepareMessages(message, { system, data, placeholders } = {}) {
+    const logger = getLogger();
+    const messages = [];
+    if (system) {
+        const systemMessage = formatSystemMessage(system, { data, placeholders });
+        messages.push(systemMessage);
+        logger.trace(`System message: ${systemMessage.content?.length} characters`);
+    }
+    const userMessage = formatUserMessage(message, { data, placeholders });
+    messages.push(userMessage);
+    logger.trace(`User message: ${userMessage.content?.length} characters`);
+    return messages;
+}
+// Completion requests
+async function createStructuredCompletion(client, { messages, responseSchema, model, }) {
+    const logger = getLogger();
+    logger.trace("Using structured output");
+    const zodSchema = responseSchema instanceof z.ZodType
+        ? responseSchema
+        : naturalZodSchema(responseSchema);
+    const completion = await client.beta.chat.completions.parse({
+        messages,
+        model,
+        response_format: zodResponseFormat(zodSchema, "response"),
+    });
+    logger.var({ assistantReply: completion.choices[0].message.parsed });
+    return completion.choices[0].message.parsed;
+}
+async function createTextCompletion(client, { messages, model, }) {
+    const logger = getLogger();
+    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 || "";
+}
+
+const DEFAULT_TOOL_TYPE = "function";
+class Toolkit {
+    constructor(tools, options) {
+        this._tools = tools;
+        this._options = options || {};
+        this.explain = this._options.explain ? true : false;
+    }
+    get tools() {
+        return this._tools.map((tool) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const toolCopy = { ...tool };
+            delete toolCopy.call;
+            if (this.explain && toolCopy.parameters?.type === "object") {
+                if (toolCopy.parameters?.properties) {
+                    if (!toolCopy.parameters.properties.__Explanation) {
+                        toolCopy.parameters.properties.__Explanation = {
+                            type: "string",
+                            description: "Explain the reasoning behind this function call. What is the expected result? Describe possible next steps and the conditions under which they should be taken.",
+                        };
+                    }
+                }
+            }
+            // 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;
+        }
+        const result = tool.call(parsedArgs);
+        if (result instanceof Promise) {
+            return await result;
+        }
+        return result;
+    }
+}
+
+// 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 = [
+    APIConnectionError,
+    APIConnectionTimeoutError,
+    InternalServerError,
+];
+const NOT_RETRYABLE_ERRORS = [
+    APIUserAbortError,
+    AuthenticationError,
+    BadRequestError,
+    ConflictError,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
+    UnprocessableEntityError,
+];
+// Turn policy constants
+const MAX_TURNS_ABSOLUTE_LIMIT = 72;
+const MAX_TURNS_DEFAULT_LIMIT = 12;
+//
+//
+// Helpers
+//
+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;
+}
+//
+//
+// Main
+//
+async function operate(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+input, options = {}, context = {
+    client: new OpenAI(),
+}) {
+    const log = getLogger();
+    const openai = context.client;
+    // Validate
+    if (!context.maxRetries) {
+        context.maxRetries = MAX_RETRIES_DEFAULT_LIMIT;
+    }
+    const model = options?.model || PROVIDER.OPENAI.MODEL.DEFAULT;
+    // Setup
+    let retryCount = 0;
+    let retryDelay = INITIAL_RETRY_DELAY_MS;
+    const maxRetries = Math.min(context.maxRetries, MAX_RETRIES_ABSOLUTE_LIMIT);
+    const allResponses = [];
+    // Determine max turns from options
+    const maxTurns = maxTurnsFromOptions(options);
+    const enableMultipleTurns = maxTurns > 1;
+    let currentTurn = 0;
+    let currentInput = input;
+    let toolkit;
+    const explain = options?.explain ?? false;
+    // Initialize toolkit if tools are provided
+    if (options.tools?.length) {
+        toolkit = new Toolkit(options.tools, { explain });
+    }
+    // OpenAI Multi-turn Loop
+    while (currentTurn < maxTurns) {
+        currentTurn++;
+        retryCount = 0;
+        retryDelay = INITIAL_RETRY_DELAY_MS;
+        // OpenAI Retry Loop
+        while (true) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const requestOptions = {
+                    model,
+                    input: typeof currentInput === "string" &&
+                        options?.data &&
+                        (options.placeholders?.input === undefined ||
+                            options.placeholders?.input)
+                        ? placeholders(currentInput, options.data)
+                        : currentInput,
+                };
+                if (options?.user) {
+                    requestOptions.user = options.user;
+                }
+                // Add any provider-specific options
+                if (options?.providerOptions) {
+                    Object.assign(requestOptions, options.providerOptions);
+                }
+                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)
+                            ? placeholders(options.instructions, options.data)
+                            : options.instructions;
+                }
+                else if (options?.system) {
+                    // Check for illegal system option, use it as instructions, and log a warning
+                    log.warn("[operate] Use 'instructions' instead of 'system'.");
+                    // Apply placeholders to system if data is provided and placeholders.instructions is undefined or true
+                    requestOptions.instructions =
+                        options.data &&
+                            (options.placeholders?.instructions === undefined ||
+                                options.placeholders?.instructions)
+                            ? placeholders(options.system, options.data)
+                            : options.system;
+                }
+                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 z.ZodType
+                            ? options.format
+                            : naturalZodSchema(options.format);
+                        const responseFormat = zodResponseFormat(zodSchema, "response");
+                        // 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,
+                                strict: responseFormat.json_schema.strict,
+                                type: responseFormat.type,
+                            },
+                        };
+                    }
+                }
+                // Add tools if toolkit is initialized
+                if (toolkit) {
+                    requestOptions.tools = toolkit.tools;
+                }
+                if (currentTurn > 1) {
+                    log.trace(`[operate] Calling OpenAI Responses API - ${currentTurn}`);
+                }
+                else {
+                    log.trace("[operate] Calling OpenAI Responses API");
+                }
+                log.var({ requestOptions });
+                // Use type assertion to handle the OpenAI SDK response type
+                const currentResponse = (await openai.responses.create(requestOptions));
+                if (retryCount > 0) {
+                    log.debug(`OpenAI API call succeeded after ${retryCount} retries`);
+                }
+                // Add the entire response to allResponses
+                allResponses.push(currentResponse);
+                // Check if we need to process function calls for multi-turn conversations
+                let hasFunctionCall = false;
+                try {
+                    if (currentResponse.output && Array.isArray(currentResponse.output)) {
+                        // New OpenAI API format with output array
+                        for (const output of currentResponse.output) {
+                            if (output.type === "function_call") {
+                                hasFunctionCall = true;
+                                if (toolkit && enableMultipleTurns) {
+                                    try {
+                                        // Parse arguments for validation
+                                        JSON.parse(output.arguments);
+                                        // Call the tool and ensure the result is resolved if it's a Promise
+                                        log.trace(`[operate] Calling tool - ${output.name}`);
+                                        const result = await toolkit.call({
+                                            name: output.name,
+                                            arguments: output.arguments,
+                                        });
+                                        // Prepare for next turn by adding function call and result
+                                        // Add the function call to the input for the next turn
+                                        if (typeof currentInput === "string") {
+                                            // Convert string input to array format for the first turn
+                                            currentInput = [{ content: currentInput, role: "user" }];
+                                        }
+                                        // Add model's function call and result
+                                        if (Array.isArray(currentInput)) {
+                                            currentInput.push(output);
+                                            // Add function call result
+                                            currentInput.push({
+                                                type: "function_call_output",
+                                                call_id: output.call_id,
+                                                output: JSON.stringify(result),
+                                            });
+                                        }
+                                    }
+                                    catch (error) {
+                                        log.error(`Error executing function call ${output.name}:`, 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");
+                                }
+                            }
+                        }
+                    }
+                }
+                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 });
+                }
+                // If there's no function call or we can't take another turn, exit the loop
+                if (!hasFunctionCall || !enableMultipleTurns) {
+                    return allResponses;
+                }
+                // If we've reached the maximum number of turns, exit the loop
+                if (currentTurn >= maxTurns) {
+                    log.warn(`Model requested function call but exceeded ${maxTurns} turns`);
+                    return allResponses;
+                }
+                // 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 });
+                    throw new 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 });
+                    throw new 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...`);
+                // Wait before retrying
+                await sleep(retryDelay);
+                // Increase retry count and delay for next attempt (exponential backoff)
+                retryCount++;
+                retryDelay = Math.min(retryDelay * RETRY_BACKOFF_FACTOR, MAX_RETRY_DELAY_MS);
+            }
+        }
+    }
+    // If we've reached the maximum number of turns, return all responses
+    return allResponses;
+}
+
 class OpenAiProvider {
     constructor(model = PROVIDER.OPENAI.MODEL.DEFAULT, { apiKey } = {}) {
+        this.log = getLogger();
         this.model = model;
         this.apiKey = apiKey;
-        this.log = log.lib({ lib: JAYPIE.LIB.LLM });
     }
     async getClient() {
         if (this._client) {
             return this._client;
         }
-        const apiKey = this.apiKey || (await getEnvSecret("OPENAI_API_KEY"));
-        if (!apiKey) {
-            throw new ConfigurationError("The application could not resolve the requested keys");
-        }
-        this._client = new OpenAI({ apiKey });
-        this.log.trace("Initialized OpenAI client");
+        this._client = await initializeClient({ apiKey: this.apiKey });
         return this._client;
     }
     async send(message, options) {
         const client = await this.getClient();
-        const messages = [];
-        if (options?.system) {
-            const systemMessage = {
-                role: "developer",
-                content: options?.placeholders?.system === false
-                    ? options.system
-                    : placeholders(options.system, options?.data),
-            };
-            messages.push(systemMessage);
-            this.log.var({ systemMessage });
-        }
-        const formattedMessage = options?.placeholders?.message === false
-            ? message
-            : placeholders(message, options?.data);
-        const userMessage = {
-            role: "user",
-            content: formattedMessage,
-        };
-        messages.push(userMessage);
-        this.log.var({ userMessage });
+        const messages = prepareMessages(message, options || {});
+        const modelToUse = options?.model || this.model;
         if (options?.response) {
-            this.log.trace("Using structured output");
-            const zodSchema = options.response instanceof z.ZodType
-                ? options.response
-                : naturalZodSchema(options.response);
-            const completion = await client.beta.chat.completions.parse({
+            return createStructuredCompletion(client, {
                 messages,
-                model: options?.model || this.model,
-                response_format: zodResponseFormat(zodSchema, "response"),
+                responseSchema: options.response,
+                model: modelToUse,
             });
-            this.log.var({ assistantReply: completion.choices[0].message.parsed });
-            return completion.choices[0].message.parsed;
         }
-        this.log.trace("Using text output (unstructured)");
-        const completion = await client.chat.completions.create({
+        return createTextCompletion(client, {
             messages,
-            model: options?.model || this.model,
+            model: modelToUse,
         });
-        this.log.var({ assistantReply: completion.choices[0].message.content });
-        return completion.choices[0]?.message?.content || "";
+    }
+    async operate(input, options = {}) {
+        const client = await this.getClient();
+        options.model = options?.model || this.model;
+        return operate(input, options, { client });
     }
 }
 
 class AnthropicProvider {
-    constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT) {
+    constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey } = {}) {
         this.model = model;
+        this.apiKey = apiKey;
     }
     async send(message) {
         // TODO: Implement Anthropic API call
@@ -170,16 +565,20 @@ class AnthropicProvider {
 }
 
 class Llm {
-    constructor(providerName = DEFAULT.PROVIDER.NAME) {
+    constructor(providerName = DEFAULT.PROVIDER.NAME, options = {}) {
         this._provider = providerName;
-        this._llm = this.createProvider(providerName);
+        this._options = options;
+        this._llm = this.createProvider(providerName, options);
     }
-    createProvider(providerName) {
+    createProvider(providerName, options = {}) {
+        const { apiKey, model } = options;
         switch (providerName) {
             case PROVIDER.OPENAI.NAME:
-                return new OpenAiProvider();
+                return new OpenAiProvider(model || PROVIDER.OPENAI.MODEL.DEFAULT, {
+                    apiKey,
+                });
             case PROVIDER.ANTHROPIC.NAME:
-                return new AnthropicProvider();
+                return new AnthropicProvider(model || PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey });
             default:
                 throw new Error(`Unsupported provider: ${providerName}`);
         }
@@ -187,12 +586,374 @@ class Llm {
     async send(message, options) {
         return this._llm.send(message, options);
     }
+    async operate(message, options = {}) {
+        if (!this._llm.operate) {
+            throw new NotImplementedError(`Provider ${this._provider} does not support operate method`);
+        }
+        return this._llm.operate(message, options);
+    }
     static async send(message, options) {
-        const { llm, ...messageOptions } = options || {};
-        const instance = new Llm(llm);
+        const { llm, apiKey, model, ...messageOptions } = options || {};
+        const instance = new Llm(llm, { apiKey, model });
         return instance.send(message, messageOptions);
     }
+    static async operate(message, options) {
+        const { llm, apiKey, model, ...operateOptions } = options || {};
+        const instance = new Llm(llm, { apiKey, model });
+        return instance.operate(message, operateOptions);
+    }
 }
 
-export { constants as LLM, Llm };
+//
+// 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 ConfigurationError$1(`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" });
+ */
+const 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;
+};
+
+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);
+    },
+};
+
+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;
+        for (let i = 0; i < number; i++) {
+            const rollValue = rng({ min: 1, max: sides, integer: true });
+            rolls.push(rollValue);
+            total += rollValue;
+        }
+        return { rolls, total };
+    },
+};
+
+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 (date) {
+            const parsedDate = new Date(date);
+            if (isNaN(parsedDate.getTime())) {
+                throw new Error(`Invalid date format: ${date}`);
+            }
+            return parsedDate.toISOString();
+        }
+        return new Date().toISOString();
+    },
+};
+
+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)",
+            },
+            longitude: {
+                type: "number",
+                description: "Longitude of the location. Default: -87.6759911441785 (Evanston, IL)",
+            },
+            timezone: {
+                type: "string",
+                description: "Timezone for the location. 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: [],
+    },
+    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 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");
+        }
+    },
+};
+
+const toolkit = {
+    random,
+    roll,
+    time,
+    weather,
+};
+const tools = Object.values(toolkit);
+
+export { constants as LLM, Llm, toolkit, tools };
 //# sourceMappingURL=index.js.map