@jaypie/llm 1.1.29 → 1.1.30

package/dist/cjs/index.cjs

@@ -1,17 +1,64 @@
 'use strict';
 
 var errors = require('@jaypie/errors');
+var Anthropic = require('@anthropic-ai/sdk');
+var v4 = require('zod/v4');
 var core = require('@jaypie/core');
+var RandomLib = require('random');
 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 genai = require('@google/genai');
+var sdk = require('@openrouter/sdk');
 var openmeteo = require('openmeteo');
 
 const PROVIDER = {
+    OPENROUTER: {
+        // https://openrouter.ai/models
+        // OpenRouter provides access to hundreds of models from various providers
+        // The model format is: provider/model-name (e.g., "openai/gpt-4", "anthropic/claude-3-opus")
+        MODEL: {
+            // Default uses env var OPENROUTER_MODEL if set, otherwise a reasonable default
+            DEFAULT: "openai/gpt-4o",
+            SMALL: "openai/gpt-4o-mini",
+            LARGE: "anthropic/claude-3-opus",
+            TINY: "openai/gpt-4o-mini",
+        },
+        MODEL_MATCH_WORDS: ["openrouter"],
+        NAME: "openrouter",
+        ROLE: {
+            ASSISTANT: "assistant",
+            SYSTEM: "system",
+            TOOL: "tool",
+            USER: "user",
+        },
+    },
+    GEMINI: {
+        // https://ai.google.dev/gemini-api/docs/models
+        MODEL: {
+            // Jaypie Aliases
+            DEFAULT: "gemini-2.5-flash",
+            SMALL: "gemini-2.5-flash",
+            LARGE: "gemini-2.5-pro",
+            TINY: "gemini-2.0-flash-lite",
+            // Gemini 2.5 Models
+            GEMINI_2_5_PRO: "gemini-2.5-pro",
+            GEMINI_2_5_FLASH: "gemini-2.5-flash",
+            // Gemini 2.0 Models
+            GEMINI_2_0_FLASH: "gemini-2.0-flash",
+            GEMINI_2_0_FLASH_LITE: "gemini-2.0-flash-lite",
+            // Gemini 1.5 Models (backward compatibility)
+            GEMINI_1_5_PRO: "gemini-1.5-pro",
+            GEMINI_1_5_FLASH: "gemini-1.5-flash",
+            GEMINI_1_5_FLASH_8B: "gemini-1.5-flash-8b",
+        },
+        MODEL_MATCH_WORDS: ["gemini", "google"],
+        NAME: "gemini",
+        ROLE: {
+            MODEL: "model",
+            USER: "user",
+        },
+    },
     ANTHROPIC: {
         // https://docs.anthropic.com/en/docs/about-claude/models/overview
         MODEL: {
@@ -120,12 +167,24 @@ function determineModelProvider(input) {
             provider: PROVIDER.ANTHROPIC.NAME,
         };
     }
+    if (input === PROVIDER.GEMINI.NAME) {
+        return {
+            model: PROVIDER.GEMINI.MODEL.DEFAULT,
+            provider: PROVIDER.GEMINI.NAME,
+        };
+    }
     if (input === PROVIDER.OPENAI.NAME) {
         return {
             model: PROVIDER.OPENAI.MODEL.DEFAULT,
             provider: PROVIDER.OPENAI.NAME,
         };
     }
+    if (input === PROVIDER.OPENROUTER.NAME) {
+        return {
+            model: PROVIDER.OPENROUTER.MODEL.DEFAULT,
+            provider: PROVIDER.OPENROUTER.NAME,
+        };
+    }
     // Check if input matches an Anthropic model exactly
     for (const [, modelValue] of Object.entries(PROVIDER.ANTHROPIC.MODEL)) {
         if (input === modelValue) {
@@ -135,6 +194,15 @@ function determineModelProvider(input) {
             };
         }
     }
+    // Check if input matches a Gemini model exactly
+    for (const [, modelValue] of Object.entries(PROVIDER.GEMINI.MODEL)) {
+        if (input === modelValue) {
+            return {
+                model: input,
+                provider: PROVIDER.GEMINI.NAME,
+            };
+        }
+    }
     // Check if input matches an OpenAI model exactly
     for (const [, modelValue] of Object.entries(PROVIDER.OPENAI.MODEL)) {
         if (input === modelValue) {
@@ -144,6 +212,15 @@ function determineModelProvider(input) {
             };
         }
     }
+    // Check if input matches an OpenRouter model exactly
+    for (const [, modelValue] of Object.entries(PROVIDER.OPENROUTER.MODEL)) {
+        if (input === modelValue) {
+            return {
+                model: input,
+                provider: PROVIDER.OPENROUTER.NAME,
+            };
+        }
+    }
     // Check Anthropic match words
     const lowerInput = input.toLowerCase();
     for (const matchWord of PROVIDER.ANTHROPIC.MODEL_MATCH_WORDS) {
@@ -154,6 +231,15 @@ function determineModelProvider(input) {
             };
         }
     }
+    // Check Gemini match words
+    for (const matchWord of PROVIDER.GEMINI.MODEL_MATCH_WORDS) {
+        if (lowerInput.includes(matchWord)) {
+            return {
+                model: input,
+                provider: PROVIDER.GEMINI.NAME,
+            };
+        }
+    }
     // Check OpenAI match words
     for (const matchWord of PROVIDER.OPENAI.MODEL_MATCH_WORDS) {
         if (typeof matchWord === "string") {
@@ -173,135 +259,57 @@ function determineModelProvider(input) {
             }
         }
     }
+    // Check OpenRouter match words
+    for (const matchWord of PROVIDER.OPENROUTER.MODEL_MATCH_WORDS) {
+        if (lowerInput.includes(matchWord)) {
+            return {
+                model: input,
+                provider: PROVIDER.OPENROUTER.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;
+//
+//
+// Abstract Base Adapter
+//
+/**
+ * BaseProviderAdapter provides default implementations for common adapter methods.
+ * Providers can extend this class to reduce boilerplate.
+ */
+class BaseProviderAdapter {
+    /**
+     * Default implementation checks if error is retryable via classifyError
+     */
+    isRetryableError(error) {
+        const classified = this.classifyError(error);
+        return classified.shouldRetry;
     }
-    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;
-        });
+    /**
+     * Default implementation checks error category via classifyError
+     */
+    isRateLimitError(error) {
+        const classified = this.classifyError(error);
+        return classified.category === "rate_limit";
     }
-    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));
+    /**
+     * Default implementation returns false - override for providers with native structured output
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hasStructuredOutput(_response) {
+        return false;
     }
-    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;
+    /**
+     * Default implementation returns undefined - override for providers with native structured output
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    extractStructuredOutput(_response) {
+        return undefined;
     }
 }
 
@@ -379,8 +387,8 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
-const getLogger$2 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
-const log = getLogger$2();
+const getLogger$4 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const log$1 = getLogger$4();
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
@@ -660,532 +668,2786 @@ function tryParseNumber(input, options) {
     }
 }
 
+//
+//
+// Error Classification Types
+//
+/**
+ * Categories of errors for retry logic
+ */
+var ErrorCategory;
+(function (ErrorCategory) {
+    /** Error is transient and can be retried */
+    ErrorCategory["Retryable"] = "retryable";
+    /** Error is due to rate limiting */
+    ErrorCategory["RateLimit"] = "rate_limit";
+    /** Error cannot be recovered from */
+    ErrorCategory["Unrecoverable"] = "unrecoverable";
+    /** Error type is unknown */
+    ErrorCategory["Unknown"] = "unknown";
+})(ErrorCategory || (ErrorCategory = {}));
+
 //
 //
 // 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 STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
+const RETRYABLE_ERROR_TYPES$1 = [
+    Anthropic.APIConnectionError,
+    Anthropic.APIConnectionTimeoutError,
+    Anthropic.InternalServerError,
 ];
-const NOT_RETRYABLE_ERRORS = [
-    openai.APIUserAbortError,
-    openai.AuthenticationError,
-    openai.BadRequestError,
-    openai.ConflictError,
-    openai.NotFoundError,
-    openai.PermissionDeniedError,
-    openai.RateLimitError,
-    openai.UnprocessableEntityError,
+const NOT_RETRYABLE_ERROR_TYPES$1 = [
+    Anthropic.AuthenticationError,
+    Anthropic.BadRequestError,
+    Anthropic.NotFoundError,
+    Anthropic.PermissionDeniedError,
 ];
-const ERROR = {
-    BAD_FUNCTION_CALL: "Bad Function Call",
-};
 //
 //
-// Helpers
+// Main
 //
 /**
- * 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
+ * AnthropicAdapter implements the ProviderAdapter interface for Anthropic's API.
+ * It handles request building, response parsing, and error classification
+ * specific to Anthropic's Messages API.
  */
-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;
+class AnthropicAdapter extends BaseProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = PROVIDER.ANTHROPIC.NAME;
+        this.defaultModel = PROVIDER.ANTHROPIC.MODEL.DEFAULT;
+    }
+    //
+    // Request Building
+    //
+    buildRequest(request) {
+        // Convert messages to Anthropic format (remove 'type' property)
+        const messages = request.messages.map((msg) => {
+            const anthropicMsg = structuredClone(msg);
+            delete anthropicMsg.type;
+            return anthropicMsg;
+        });
+        // Append instructions to last message if provided
+        if (request.instructions && messages.length > 0) {
+            const lastMsg = messages[messages.length - 1];
+            if (typeof lastMsg.content === "string") {
+                lastMsg.content = lastMsg.content + "\n\n" + request.instructions;
             }
         }
-        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,
-            };
+        const anthropicRequest = {
+            model: (request.model ||
+                this.defaultModel),
+            messages,
+            max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
+            stream: false,
+        };
+        if (request.system) {
+            anthropicRequest.system = request.system;
         }
-        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,
+        if (request.tools && request.tools.length > 0) {
+            anthropicRequest.tools = request.tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                input_schema: {
+                    ...tool.parameters,
+                    type: "object",
                 },
+                type: "custom",
+            }));
+            // Determine tool choice based on whether structured output is requested
+            const hasStructuredOutput = request.tools.some((t) => t.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
+            anthropicRequest.tool_choice = {
+                type: hasStructuredOutput ? "any" : "auto",
             };
         }
+        if (request.providerOptions) {
+            Object.assign(anthropicRequest, request.providerOptions);
+        }
+        return anthropicRequest;
     }
-    // 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;
+    formatTools(toolkit, outputSchema) {
+        const tools = toolkit.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                ...tool.parameters,
+                type: "object",
+            },
+        }));
+        // Add structured output tool if schema is provided
+        if (outputSchema) {
+            tools.push({
+                name: STRUCTURED_OUTPUT_TOOL_NAME$2,
+                description: "Output a structured JSON object, " +
+                    "use this before your final response to give structured outputs to the user",
+                parameters: outputSchema,
+            });
         }
-        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 });
+        return tools;
+    }
+    formatOutputSchema(schema) {
+        let jsonSchema;
+        // Check if schema is already a JsonObject with type "json_schema"
+        if (typeof schema === "object" &&
+            schema !== null &&
+            !Array.isArray(schema) &&
+            schema.type === "json_schema") {
+            jsonSchema = structuredClone(schema);
+            jsonSchema.type = "object"; // Validator does not recognize "json_schema"
+        }
+        else {
+            // Convert NaturalSchema to JSON schema through Zod
+            const zodSchema = schema instanceof v4.z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            jsonSchema = v4.z.toJSONSchema(zodSchema);
         }
-        if (toolkit) {
-            requestOptions.tools = toolkit.tools;
+        // Remove $schema property (causes issues with validator)
+        if (jsonSchema.$schema) {
+            delete jsonSchema.$schema;
         }
+        return jsonSchema;
     }
-    return requestOptions;
-}
-//
-//
-// Main
-//
-async function operate$1(input, options = {}, context = {
-    client: new openai.OpenAI(),
-}) {
     //
+    // API Execution
+    //
+    async executeRequest(client, request) {
+        const anthropic = client;
+        return (await anthropic.messages.create(request));
+    }
     //
-    // Setup
+    // Response Parsing
     //
-    const openai = context.client;
-    if (!context.maxRetries) {
-        context.maxRetries = MAX_RETRIES_DEFAULT_LIMIT;
+    parseResponse(response, _options) {
+        const anthropicResponse = response;
+        const content = this.extractContent(anthropicResponse);
+        const hasToolCalls = anthropicResponse.stop_reason === "tool_use";
+        return {
+            content,
+            hasToolCalls,
+            stopReason: anthropicResponse.stop_reason ?? undefined,
+            usage: this.extractUsage(anthropicResponse, anthropicResponse.model),
+            raw: anthropicResponse,
+        };
     }
-    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,
-        });
+    extractToolCalls(response) {
+        const anthropicResponse = response;
+        const toolCalls = [];
+        for (const block of anthropicResponse.content) {
+            if (block.type === "tool_use") {
+                toolCalls.push({
+                    callId: block.id,
+                    name: block.name,
+                    arguments: JSON.stringify(block.input),
+                    raw: block,
+                });
+            }
+        }
+        return toolCalls;
     }
-    // If history is provided, merge it with currentInput
-    if (options.history) {
-        currentInput = [...options.history, ...currentInput];
+    extractUsage(response, model) {
+        const anthropicResponse = response;
+        return {
+            input: anthropicResponse.usage.input_tokens,
+            output: anthropicResponse.usage.output_tokens,
+            reasoning: 0, // Anthropic doesn't expose reasoning tokens
+            total: anthropicResponse.usage.input_tokens +
+                anthropicResponse.usage.output_tokens,
+            provider: this.name,
+            model,
+        };
     }
-    // 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,
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        return {
+            type: "tool_result",
+            tool_use_id: toolCall.callId,
+            content: result.output,
         };
-        // 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}`);
+    }
+    appendToolResult(request, toolCall, result) {
+        const anthropicRequest = request;
+        const toolCallRaw = toolCall.raw;
+        // Add assistant message with the tool use
+        anthropicRequest.messages.push({
+            role: "assistant",
+            content: [toolCallRaw],
+        });
+        // Add user message with the tool result
+        anthropicRequest.messages.push({
+            role: "user",
+            content: [this.formatToolResult(toolCall, result)],
+        });
+        return anthropicRequest;
+    }
+    //
+    // History Management
+    //
+    responseToHistoryItems(response) {
+        const anthropicResponse = response;
+        const historyItems = [];
+        // Check if this is a tool use response
+        if (anthropicResponse.stop_reason === "tool_use") {
+            // Don't add to history yet - will be added after tool execution
+            return historyItems;
+        }
+        // Extract text content for non-tool responses
+        const textBlock = anthropicResponse.content.find((block) => block.type === "text");
+        if (textBlock) {
+            historyItems.push({
+                content: textBlock.text,
+                role: PROVIDER.ANTHROPIC.ROLE.ASSISTANT,
+                type: exports.LlmMessageType.Message,
+            });
+        }
+        return historyItems;
+    }
+    //
+    // Error Classification
+    //
+    classifyError(error) {
+        // Check for rate limit error
+        if (error instanceof Anthropic.RateLimitError) {
+            return {
+                error,
+                category: ErrorCategory.RateLimit,
+                shouldRetry: false,
+                suggestedDelayMs: 60000,
+            };
+        }
+        // Check for retryable errors
+        for (const ErrorType of RETRYABLE_ERROR_TYPES$1) {
+            if (error instanceof ErrorType) {
+                return {
+                    error,
+                    category: ErrorCategory.Retryable,
+                    shouldRetry: true,
+                };
+            }
+        }
+        // Check for non-retryable errors
+        for (const ErrorType of NOT_RETRYABLE_ERROR_TYPES$1) {
+            if (error instanceof ErrorType) {
+                return {
+                    error,
+                    category: ErrorCategory.Unrecoverable,
+                    shouldRetry: false,
+                };
+            }
+        }
+        // Unknown error - treat as potentially retryable
+        return {
+            error,
+            category: ErrorCategory.Unknown,
+            shouldRetry: true,
+        };
+    }
+    //
+    // Provider-Specific Features
+    //
+    isComplete(response) {
+        const anthropicResponse = response;
+        return anthropicResponse.stop_reason !== "tool_use";
+    }
+    hasStructuredOutput(response) {
+        const anthropicResponse = response;
+        // Check if the last content block is a tool_use with structured_output
+        const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
+        return (lastBlock?.type === "tool_use" &&
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2);
+    }
+    extractStructuredOutput(response) {
+        const anthropicResponse = response;
+        const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
+        if (lastBlock?.type === "tool_use" &&
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$2) {
+            return lastBlock.input;
+        }
+        return undefined;
+    }
+    //
+    // Private Helpers
+    //
+    extractContent(response) {
+        // Check for structured output first
+        if (this.hasStructuredOutput(response)) {
+            return this.extractStructuredOutput(response);
+        }
+        // Extract text content
+        const textBlock = response.content.find((block) => block.type === "text");
+        return textBlock?.text;
+    }
+}
+// Export singleton instance
+const anthropicAdapter = new AnthropicAdapter();
+
+//
+//
+// Constants
+//
+const STRUCTURED_OUTPUT_TOOL_NAME$1 = "structured_output";
+// Gemini uses HTTP status codes for error classification
+// Documented at: https://ai.google.dev/api/rest/v1beta/Status
+const RETRYABLE_STATUS_CODES$1 = [
+    408, // Request Timeout
+    429, // Too Many Requests (Rate Limit)
+    500, // Internal Server Error
+    502, // Bad Gateway
+    503, // Service Unavailable
+    504, // Gateway Timeout
+];
+const NOT_RETRYABLE_STATUS_CODES = [
+    400, // Bad Request
+    401, // Unauthorized
+    403, // Forbidden
+    404, // Not Found
+    409, // Conflict
+    422, // Unprocessable Entity
+];
+//
+//
+// Main
+//
+/**
+ * GeminiAdapter implements the ProviderAdapter interface for Google's Gemini API.
+ * It handles request building, response parsing, and error classification
+ * specific to Gemini's generateContent API.
+ */
+class GeminiAdapter extends BaseProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = PROVIDER.GEMINI.NAME;
+        this.defaultModel = PROVIDER.GEMINI.MODEL.DEFAULT;
+    }
+    //
+    // Request Building
+    //
+    buildRequest(request) {
+        // Convert messages to Gemini format (Content[])
+        const contents = this.convertMessagesToContents(request.messages);
+        const geminiRequest = {
+            model: request.model || this.defaultModel,
+            contents,
+        };
+        // Add system instruction if provided
+        if (request.system) {
+            geminiRequest.config = {
+                ...geminiRequest.config,
+                systemInstruction: request.system,
+            };
+        }
+        // Append instructions to the last user message if provided
+        if (request.instructions && contents.length > 0) {
+            const lastContent = contents[contents.length - 1];
+            if (lastContent.role === "user" && lastContent.parts) {
+                const lastPart = lastContent.parts[lastContent.parts.length - 1];
+                if (lastPart.text) {
+                    lastPart.text = lastPart.text + "\n\n" + request.instructions;
+                }
+            }
+        }
+        // Add tools if provided
+        if (request.tools && request.tools.length > 0) {
+            const functionDeclarations = request.tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            }));
+            geminiRequest.config = {
+                ...geminiRequest.config,
+                tools: [{ functionDeclarations }],
+            };
+        }
+        // Add structured output format if provided (but NOT when tools are present)
+        // Gemini doesn't support combining function calling with responseMimeType: 'application/json'
+        // When tools are present, structured output is handled via the structured_output tool
+        if (request.format && !(request.tools && request.tools.length > 0)) {
+            geminiRequest.config = {
+                ...geminiRequest.config,
+                responseMimeType: "application/json",
+                responseJsonSchema: request.format,
+            };
+        }
+        // When format is specified with tools, add instruction to use structured_output tool
+        if (request.format && request.tools && request.tools.length > 0) {
+            const structuredOutputInstruction = "IMPORTANT: Before providing your final response, you MUST use the structured_output tool " +
+                "to output your answer in the required JSON format.";
+            // Add to system instruction if it exists, otherwise create one
+            const existingSystem = geminiRequest.config?.systemInstruction || "";
+            geminiRequest.config = {
+                ...geminiRequest.config,
+                systemInstruction: existingSystem
+                    ? `${existingSystem}\n\n${structuredOutputInstruction}`
+                    : structuredOutputInstruction,
+            };
+        }
+        // Add provider-specific options
+        if (request.providerOptions) {
+            geminiRequest.config = {
+                ...geminiRequest.config,
+                ...request.providerOptions,
+            };
+        }
+        return geminiRequest;
+    }
+    formatTools(toolkit, outputSchema) {
+        const tools = toolkit.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                ...tool.parameters,
+                type: "object",
+            },
+        }));
+        // Add structured output tool if schema is provided
+        if (outputSchema) {
+            tools.push({
+                name: STRUCTURED_OUTPUT_TOOL_NAME$1,
+                description: "Output a structured JSON object, " +
+                    "use this before your final response to give structured outputs to the user",
+                parameters: outputSchema,
+            });
+        }
+        return tools;
+    }
+    formatOutputSchema(schema) {
+        let jsonSchema;
+        // Check if schema is already a JsonObject with type "json_schema"
+        if (typeof schema === "object" &&
+            schema !== null &&
+            !Array.isArray(schema) &&
+            schema.type === "json_schema") {
+            jsonSchema = structuredClone(schema);
+            jsonSchema.type = "object";
+        }
+        else {
+            // Convert NaturalSchema to JSON schema through Zod
+            const zodSchema = schema instanceof v4.z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            jsonSchema = v4.z.toJSONSchema(zodSchema);
+        }
+        // Remove $schema property (Gemini doesn't need it)
+        if (jsonSchema.$schema) {
+            delete jsonSchema.$schema;
+        }
+        return jsonSchema;
+    }
+    //
+    // API Execution
+    //
+    async executeRequest(client, request) {
+        const genAI = client;
+        const geminiRequest = request;
+        // Cast config to any to bypass strict type checking between our internal types
+        // and the SDK's types. The SDK will validate at runtime.
+        const response = await genAI.models.generateContent({
+            model: geminiRequest.model,
+            contents: geminiRequest.contents,
+            config: geminiRequest.config,
+        });
+        return response;
+    }
+    //
+    // Response Parsing
+    //
+    parseResponse(response, options) {
+        const geminiResponse = response;
+        const content = this.extractContent(geminiResponse, options);
+        const hasToolCalls = this.hasToolCalls(geminiResponse);
+        return {
+            content,
+            hasToolCalls,
+            stopReason: this.getFinishReason(geminiResponse),
+            usage: this.extractUsage(geminiResponse, options?.model || this.defaultModel),
+            raw: geminiResponse,
+        };
+    }
+    extractToolCalls(response) {
+        const geminiResponse = response;
+        const toolCalls = [];
+        const candidate = geminiResponse.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            return toolCalls;
+        }
+        for (const part of candidate.content.parts) {
+            if (part.functionCall) {
+                const functionCall = part.functionCall;
+                toolCalls.push({
+                    callId: functionCall.id || this.generateCallId(),
+                    name: functionCall.name || "",
+                    arguments: JSON.stringify(functionCall.args || {}),
+                    raw: part,
+                });
+            }
+        }
+        return toolCalls;
+    }
+    extractUsage(response, model) {
+        const geminiResponse = response;
+        if (!geminiResponse.usageMetadata) {
+            return {
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                total: 0,
+                provider: this.name,
+                model,
+            };
+        }
+        const usage = geminiResponse.usageMetadata;
+        return {
+            input: usage.promptTokenCount || 0,
+            output: usage.candidatesTokenCount || 0,
+            reasoning: usage.thoughtsTokenCount || 0,
+            total: usage.totalTokenCount || 0,
+            provider: this.name,
+            model,
+        };
+    }
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        // Gemini expects the response to be the actual result object, not wrapped in "result"
+        // The output from StandardToolResult is JSON-stringified, so we need to parse it
+        let responseData;
+        try {
+            responseData = JSON.parse(result.output);
+        }
+        catch {
+            // If parsing fails, wrap the output as a string result
+            responseData = { result: result.output };
+        }
+        return {
+            functionResponse: {
+                name: toolCall.name,
+                response: responseData,
+            },
+        };
+    }
+    appendToolResult(request, toolCall, result) {
+        const geminiRequest = request;
+        const toolCallRaw = toolCall.raw;
+        const toolResponse = this.formatToolResult(toolCall, result);
+        // Get the last two contents to check for existing tool call/response pattern
+        const lastContent = geminiRequest.contents[geminiRequest.contents.length - 1];
+        const secondLastContent = geminiRequest.contents[geminiRequest.contents.length - 2];
+        // Check if we're adding to an existing tool call batch
+        // Pattern: [..., model (with functionCall), user (with functionResponse)]
+        const hasExistingToolBatch = lastContent?.role === "user" &&
+            lastContent?.parts?.some((p) => p.functionResponse) &&
+            secondLastContent?.role === "model" &&
+            secondLastContent?.parts?.some((p) => p.functionCall);
+        if (hasExistingToolBatch) {
+            // Append to existing batch
+            secondLastContent.parts.push(toolCallRaw);
+            lastContent.parts.push(toolResponse);
+        }
+        else {
+            // Create new batch
+            geminiRequest.contents.push({
+                role: "model",
+                parts: [toolCallRaw],
+            });
+            geminiRequest.contents.push({
+                role: "user",
+                parts: [toolResponse],
+            });
+        }
+        return geminiRequest;
+    }
+    //
+    // History Management
+    //
+    responseToHistoryItems(response) {
+        const geminiResponse = response;
+        const historyItems = [];
+        const candidate = geminiResponse.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            return historyItems;
+        }
+        // Check if this is a function call response
+        const hasFunctionCalls = candidate.content.parts.some((part) => part.functionCall);
+        if (hasFunctionCalls) {
+            // Don't add to history yet - will be added after tool execution
+            return historyItems;
+        }
+        // Extract text content for non-tool responses
+        const textParts = candidate.content.parts.filter((part) => part.text && !part.thought);
+        if (textParts.length > 0) {
+            const textContent = textParts.map((part) => part.text).join("");
+            historyItems.push({
+                content: textContent,
+                role: exports.LlmMessageRole.Assistant,
+                type: exports.LlmMessageType.Message,
+            });
+        }
+        return historyItems;
+    }
+    //
+    // Error Classification
+    //
+    classifyError(error) {
+        const geminiError = error;
+        // Extract status code from error
+        const statusCode = geminiError.status || geminiError.code;
+        // Check for rate limit error (429)
+        if (statusCode === 429) {
+            return {
+                error,
+                category: ErrorCategory.RateLimit,
+                shouldRetry: false,
+                suggestedDelayMs: 60000,
+            };
+        }
+        // Check for retryable errors
+        if (typeof statusCode === "number" &&
+            RETRYABLE_STATUS_CODES$1.includes(statusCode)) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
+        // Check for non-retryable errors
+        if (typeof statusCode === "number" &&
+            NOT_RETRYABLE_STATUS_CODES.includes(statusCode)) {
+            return {
+                error,
+                category: ErrorCategory.Unrecoverable,
+                shouldRetry: false,
+            };
+        }
+        // Check error message for common patterns
+        const errorMessage = geminiError.message || String(error) || "";
+        if (errorMessage.includes("rate limit") ||
+            errorMessage.includes("quota exceeded")) {
+            return {
+                error,
+                category: ErrorCategory.RateLimit,
+                shouldRetry: false,
+                suggestedDelayMs: 60000,
+            };
+        }
+        if (errorMessage.includes("timeout") ||
+            errorMessage.includes("connection") ||
+            errorMessage.includes("ECONNREFUSED")) {
+            return {
+                error,
+                category: ErrorCategory.Retryable,
+                shouldRetry: true,
+            };
+        }
+        // Unknown error - treat as potentially retryable
+        return {
+            error,
+            category: ErrorCategory.Unknown,
+            shouldRetry: true,
+        };
+    }
+    //
+    // Provider-Specific Features
+    //
+    isComplete(response) {
+        const geminiResponse = response;
+        const candidate = geminiResponse.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            return true;
+        }
+        // Check if there are any function calls
+        const hasFunctionCalls = candidate.content.parts.some((part) => part.functionCall);
+        return !hasFunctionCalls;
+    }
+    hasStructuredOutput(response) {
+        const geminiResponse = response;
+        const candidate = geminiResponse.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            return false;
+        }
+        // Check if the last part is a function call with structured_output
+        const lastPart = candidate.content.parts[candidate.content.parts.length - 1];
+        return lastPart?.functionCall?.name === STRUCTURED_OUTPUT_TOOL_NAME$1;
+    }
+    extractStructuredOutput(response) {
+        const geminiResponse = response;
+        const candidate = geminiResponse.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            return undefined;
+        }
+        const lastPart = candidate.content.parts[candidate.content.parts.length - 1];
+        if (lastPart?.functionCall?.name === STRUCTURED_OUTPUT_TOOL_NAME$1) {
+            return lastPart.functionCall.args;
+        }
+        return undefined;
+    }
+    //
+    // Private Helpers
+    //
+    convertMessagesToContents(messages) {
+        const contents = [];
+        for (const message of messages) {
+            // Handle input/output messages
+            if ("role" in message && "content" in message) {
+                const role = this.mapRole(message.role);
+                const content = typeof message.content === "string"
+                    ? message.content
+                    : JSON.stringify(message.content);
+                contents.push({
+                    role,
+                    parts: [{ text: content }],
+                });
+            }
+            // Handle function call items
+            else if ("type" in message &&
+                message.type === exports.LlmMessageType.FunctionCall) {
+                contents.push({
+                    role: "model",
+                    parts: [
+                        {
+                            functionCall: {
+                                name: message.name,
+                                args: JSON.parse(message.arguments || "{}"),
+                                id: message.call_id,
+                            },
+                        },
+                    ],
+                });
+            }
+            // Handle function call output items
+            else if ("type" in message &&
+                message.type === exports.LlmMessageType.FunctionCallOutput) {
+                // Parse the output to get the actual response object
+                let responseData;
+                try {
+                    responseData = JSON.parse(message.output || "{}");
+                }
+                catch {
+                    responseData = { result: message.output };
+                }
+                contents.push({
+                    role: "user",
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: message.name || "function",
+                                response: responseData,
+                            },
+                        },
+                    ],
+                });
+            }
+        }
+        return contents;
+    }
+    mapRole(role) {
+        switch (role) {
+            case exports.LlmMessageRole.User:
+            case exports.LlmMessageRole.System:
+            case exports.LlmMessageRole.Developer:
+                return "user";
+            case exports.LlmMessageRole.Assistant:
+                return "model";
+            default:
+                return "user";
+        }
+    }
+    hasToolCalls(response) {
+        const candidate = response.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            return false;
+        }
+        return candidate.content.parts.some((part) => part.functionCall);
+    }
+    getFinishReason(response) {
+        const candidate = response.candidates?.[0];
+        return candidate?.finishReason;
+    }
+    extractContent(response, options) {
+        // Check for structured output first
+        if (this.hasStructuredOutput(response)) {
+            return this.extractStructuredOutput(response);
+        }
+        const candidate = response.candidates?.[0];
+        if (!candidate?.content?.parts) {
+            return undefined;
+        }
+        // Extract text content (excluding thought parts)
+        const textParts = candidate.content.parts.filter((part) => part.text && !part.thought);
+        if (textParts.length === 0) {
+            return undefined;
+        }
+        const textContent = textParts.map((part) => part.text).join("");
+        // If format is provided, try to parse the content as JSON
+        if (options?.format && typeof textContent === "string") {
+            try {
+                return JSON.parse(textContent);
+            }
+            catch {
+                // If parsing fails, return the original string
+                return textContent;
+            }
+        }
+        return textContent;
+    }
+    generateCallId() {
+        return `call_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    }
+}
+// Export singleton instance
+const geminiAdapter = new GeminiAdapter();
+
+//
+//
+// Constants
+//
+const RETRYABLE_ERROR_TYPES = [
+    openai.APIConnectionError,
+    openai.APIConnectionTimeoutError,
+    openai.InternalServerError,
+];
+const NOT_RETRYABLE_ERROR_TYPES = [
+    openai.APIUserAbortError,
+    openai.AuthenticationError,
+    openai.BadRequestError,
+    openai.ConflictError,
+    openai.NotFoundError,
+    openai.PermissionDeniedError,
+    openai.RateLimitError,
+    openai.UnprocessableEntityError,
+];
+//
+//
+// Main
+//
+/**
+ * OpenAiAdapter implements the ProviderAdapter interface for OpenAI's API.
+ * It handles request building, response parsing, and error classification
+ * specific to OpenAI's Responses API.
+ */
+class OpenAiAdapter extends BaseProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = PROVIDER.OPENAI.NAME;
+        this.defaultModel = PROVIDER.OPENAI.MODEL.DEFAULT;
+    }
+    //
+    // Request Building
+    //
+    buildRequest(request) {
+        const openaiRequest = {
+            model: request.model || this.defaultModel,
+            input: request.messages,
+        };
+        if (request.user) {
+            openaiRequest.user = request.user;
+        }
+        if (request.instructions) {
+            openaiRequest.instructions = request.instructions;
+        }
+        if (request.tools && request.tools.length > 0) {
+            openaiRequest.tools = request.tools.map((tool) => ({
+                type: "function",
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            }));
+        }
+        if (request.format) {
+            openaiRequest.text = {
+                format: request.format,
+            };
+        }
+        if (request.providerOptions) {
+            Object.assign(openaiRequest, request.providerOptions);
+        }
+        return openaiRequest;
+    }
+    formatTools(toolkit, _outputSchema) {
+        return toolkit.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        }));
+    }
+    formatOutputSchema(schema) {
+        // Check if schema is already a JsonObject with type "json_schema"
+        if (typeof schema === "object" &&
+            schema !== null &&
+            !Array.isArray(schema) &&
+            schema.type === "json_schema") {
+            return schema;
+        }
+        // Convert NaturalSchema to Zod schema if needed
+        const zodSchema = schema instanceof v4.z.ZodType
+            ? schema
+            : naturalZodSchema(schema);
+        const responseFormat = zod.zodResponseFormat(zodSchema, "response");
+        const jsonSchema = v4.z.toJSONSchema(zodSchema);
+        // OpenAI requires additionalProperties 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();
+        }
+        return {
+            name: responseFormat.json_schema.name,
+            schema: jsonSchema,
+            strict: responseFormat.json_schema.strict,
+            type: responseFormat.type,
+        };
+    }
+    //
+    // API Execution
+    //
+    async executeRequest(client, request) {
+        const openai = client;
+        // @ts-expect-error OpenAI SDK types don't match our request format exactly
+        return await openai.responses.create(request);
+    }
+    //
+    // Response Parsing
+    //
+    parseResponse(response, options) {
+        const openaiResponse = response;
+        const content = this.extractContent(openaiResponse, options);
+        const hasToolCalls = this.hasToolCalls(openaiResponse);
+        return {
+            content,
+            hasToolCalls,
+            stopReason: openaiResponse.status,
+            usage: this.extractUsage(openaiResponse, options?.model || this.defaultModel),
+            raw: openaiResponse,
+        };
+    }
+    extractToolCalls(response) {
+        const openaiResponse = response;
+        const toolCalls = [];
+        if (!openaiResponse.output || !Array.isArray(openaiResponse.output)) {
+            return toolCalls;
+        }
+        for (const output of openaiResponse.output) {
+            if (output.type === exports.LlmMessageType.FunctionCall) {
+                toolCalls.push({
+                    callId: output.call_id,
+                    name: output.name,
+                    arguments: output.arguments,
+                    raw: output,
+                });
+            }
+        }
+        return toolCalls;
+    }
+    extractUsage(response, model) {
+        const openaiResponse = response;
+        if (!openaiResponse.usage) {
+            return {
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                total: 0,
+                provider: this.name,
+                model,
+            };
+        }
+        return {
+            input: openaiResponse.usage.input_tokens || 0,
+            output: openaiResponse.usage.output_tokens || 0,
+            reasoning: openaiResponse.usage.output_tokens_details?.reasoning_tokens || 0,
+            total: openaiResponse.usage.total_tokens || 0,
+            provider: this.name,
+            model,
+        };
+    }
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        return {
+            call_id: toolCall.callId,
+            output: result.output,
+            type: exports.LlmMessageType.FunctionCallOutput,
+        };
+    }
+    appendToolResult(request, toolCall, result) {
+        const openaiRequest = request;
+        const input = openaiRequest.input;
+        // Note: The function_call item has already been added via responseToHistoryItems
+        // which is called before processing tool calls. This includes any required
+        // reasoning items that precede the function_call.
+        // Add only the function call result
+        input.push({
+            call_id: toolCall.callId,
+            output: result.output,
+            type: exports.LlmMessageType.FunctionCallOutput,
+        });
+        return openaiRequest;
+    }
+    //
+    // History Management
+    //
+    responseToHistoryItems(response) {
+        const openaiResponse = response;
+        const historyItems = [];
+        if (!openaiResponse.output || !Array.isArray(openaiResponse.output)) {
+            return historyItems;
+        }
+        // Include all output items, including reasoning items
+        // OpenAI requires reasoning items to be present when a function_call references them
+        for (const output of openaiResponse.output) {
+            historyItems.push(output);
+        }
+        return historyItems;
+    }
+    //
+    // Error Classification
+    //
+    classifyError(error) {
+        // Check for rate limit error
+        if (error instanceof openai.RateLimitError) {
+            return {
+                error,
+                category: ErrorCategory.RateLimit,
+                shouldRetry: false, // Rate limit requires waiting, not immediate retry
+                suggestedDelayMs: 60000, // 1 minute default
+            };
+        }
+        // Check for retryable errors
+        for (const ErrorType of RETRYABLE_ERROR_TYPES) {
+            if (error instanceof ErrorType) {
+                return {
+                    error,
+                    category: ErrorCategory.Retryable,
+                    shouldRetry: true,
+                };
+            }
+        }
+        // Check for non-retryable errors
+        for (const ErrorType of NOT_RETRYABLE_ERROR_TYPES) {
+            if (error instanceof ErrorType) {
+                return {
+                    error,
+                    category: ErrorCategory.Unrecoverable,
+                    shouldRetry: false,
+                };
+            }
+        }
+        // Unknown error - treat as potentially retryable
+        return {
+            error,
+            category: ErrorCategory.Unknown,
+            shouldRetry: true,
+        };
+    }
+    //
+    // Provider-Specific Features
+    //
+    isComplete(response) {
+        const openaiResponse = response;
+        // Check if there are any function calls in the output
+        if (!openaiResponse.output || !Array.isArray(openaiResponse.output)) {
+            return true;
+        }
+        for (const output of openaiResponse.output) {
+            if (output.type === exports.LlmMessageType.FunctionCall) {
+                return false;
+            }
+        }
+        return true;
+    }
+    //
+    // Private Helpers
+    //
+    hasToolCalls(response) {
+        if (!response.output || !Array.isArray(response.output)) {
+            return false;
+        }
+        return response.output.some((output) => output.type === exports.LlmMessageType.FunctionCall);
+    }
+    extractContent(response, options) {
+        if (!response.output || !Array.isArray(response.output)) {
+            return undefined;
+        }
+        for (const output of response.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 {
+                            return JSON.parse(rawContent);
+                        }
+                        catch {
+                            // If parsing fails, return the original string
+                            return rawContent;
+                        }
+                    }
+                    return rawContent;
+                }
+            }
+            // Skip reasoning and function call items when extracting content
+            if (output.type === "reasoning" ||
+                output.type === exports.LlmMessageType.FunctionCall) {
+                continue;
+            }
+        }
+        return undefined;
+    }
+}
+// Export singleton instance
+const openAiAdapter = new OpenAiAdapter();
+
+//
+//
+// Constants
+//
+const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
+// OpenRouter SDK error types based on HTTP status codes
+const RETRYABLE_STATUS_CODES = [408, 500, 502, 503, 524, 529];
+const RATE_LIMIT_STATUS_CODE = 429;
+//
+//
+// Main
+//
+/**
+ * OpenRouterAdapter implements the ProviderAdapter interface for OpenRouter's API.
+ * OpenRouter provides a unified API to access hundreds of AI models through OpenAI-compatible endpoints.
+ * It handles request building, response parsing, and error classification
+ * specific to OpenRouter's Chat Completions API.
+ */
+class OpenRouterAdapter extends BaseProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = PROVIDER.OPENROUTER.NAME;
+        this.defaultModel = PROVIDER.OPENROUTER.MODEL.DEFAULT;
+    }
+    //
+    // Request Building
+    //
+    buildRequest(request) {
+        // Convert messages to OpenRouter format (OpenAI-compatible)
+        const messages = this.convertMessagesToOpenRouter(request.messages, request.system);
+        // Append instructions to last message if provided
+        if (request.instructions && messages.length > 0) {
+            const lastMsg = messages[messages.length - 1];
+            if (lastMsg.content && typeof lastMsg.content === "string") {
+                lastMsg.content = lastMsg.content + "\n\n" + request.instructions;
+            }
+        }
+        const openRouterRequest = {
+            model: request.model || this.defaultModel,
+            messages,
+        };
+        if (request.user) {
+            openRouterRequest.user = request.user;
+        }
+        if (request.tools && request.tools.length > 0) {
+            openRouterRequest.tools = request.tools.map((tool) => ({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters,
+                },
+            }));
+            // Determine tool choice based on whether structured output is requested
+            const hasStructuredOutput = request.tools.some((t) => t.name === STRUCTURED_OUTPUT_TOOL_NAME);
+            openRouterRequest.tool_choice = hasStructuredOutput ? "required" : "auto";
+        }
+        if (request.providerOptions) {
+            Object.assign(openRouterRequest, request.providerOptions);
+        }
+        return openRouterRequest;
+    }
+    formatTools(toolkit, outputSchema) {
+        const tools = toolkit.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        }));
+        // Add structured output tool if schema is provided
+        // (OpenRouter doesn't have native structured output like OpenAI, so use tool approach)
+        if (outputSchema) {
+            tools.push({
+                name: STRUCTURED_OUTPUT_TOOL_NAME,
+                description: "REQUIRED: You MUST call this tool to provide your final response. " +
+                    "After gathering all necessary information (including results from other tools), " +
+                    "call this tool with the structured data to complete the request.",
+                parameters: outputSchema,
+            });
+        }
+        return tools;
+    }
+    formatOutputSchema(schema) {
+        let jsonSchema;
+        // Check if schema is already a JsonObject with type "json_schema"
+        if (typeof schema === "object" &&
+            schema !== null &&
+            !Array.isArray(schema) &&
+            schema.type === "json_schema") {
+            jsonSchema = structuredClone(schema);
+            jsonSchema.type = "object"; // Normalize type
+        }
+        else {
+            // Convert NaturalSchema to JSON schema through Zod
+            const zodSchema = schema instanceof v4.z.ZodType
+                ? schema
+                : naturalZodSchema(schema);
+            jsonSchema = v4.z.toJSONSchema(zodSchema);
+        }
+        // Remove $schema property (can cause issues with some providers)
+        if (jsonSchema.$schema) {
+            delete jsonSchema.$schema;
+        }
+        return jsonSchema;
+    }
+    //
+    // API Execution
+    //
+    async executeRequest(client, request) {
+        const openRouter = client;
+        const openRouterRequest = request;
+        const response = await openRouter.chat.send({
+            model: openRouterRequest.model,
+            messages: openRouterRequest.messages,
+            tools: openRouterRequest.tools,
+            toolChoice: openRouterRequest.tool_choice,
+            user: openRouterRequest.user,
+        });
+        return response;
+    }
+    //
+    // Response Parsing
+    //
+    parseResponse(response, _options) {
+        const openRouterResponse = response;
+        const choice = openRouterResponse.choices[0];
+        const content = this.extractContent(openRouterResponse);
+        const hasToolCalls = this.hasToolCalls(openRouterResponse);
+        // SDK returns camelCase (finishReason), but support snake_case as fallback
+        const stopReason = choice?.finishReason ?? choice?.finish_reason ?? undefined;
+        return {
+            content,
+            hasToolCalls,
+            stopReason,
+            usage: this.extractUsage(openRouterResponse, openRouterResponse.model),
+            raw: openRouterResponse,
+        };
+    }
+    extractToolCalls(response) {
+        const openRouterResponse = response;
+        const toolCalls = [];
+        const choice = openRouterResponse.choices[0];
+        // SDK returns camelCase (toolCalls)
+        if (!choice?.message?.toolCalls) {
+            return toolCalls;
+        }
+        for (const toolCall of choice.message.toolCalls) {
+            toolCalls.push({
+                callId: toolCall.id,
+                name: toolCall.function.name,
+                arguments: toolCall.function.arguments,
+                raw: toolCall,
+            });
+        }
+        return toolCalls;
+    }
+    extractUsage(response, model) {
+        const openRouterResponse = response;
+        if (!openRouterResponse.usage) {
+            return {
+                input: 0,
+                output: 0,
+                reasoning: 0,
+                total: 0,
+                provider: this.name,
+                model,
+            };
+        }
+        // SDK returns camelCase, but support snake_case as fallback
+        const usage = openRouterResponse.usage;
+        return {
+            input: usage.promptTokens || usage.prompt_tokens || 0,
+            output: usage.completionTokens || usage.completion_tokens || 0,
+            reasoning: 0, // OpenRouter doesn't expose reasoning tokens in standard format
+            total: usage.totalTokens || usage.total_tokens || 0,
+            provider: this.name,
+            model,
+        };
+    }
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        return {
+            role: "tool",
+            toolCallId: toolCall.callId,
+            content: result.output,
+        };
+    }
+    appendToolResult(request, toolCall, result) {
+        const openRouterRequest = request;
+        const toolCallRaw = toolCall.raw;
+        // Add assistant message with the tool call (SDK uses camelCase)
+        openRouterRequest.messages.push({
+            role: "assistant",
+            content: null,
+            toolCalls: [toolCallRaw],
+        });
+        // Add tool result message
+        openRouterRequest.messages.push(this.formatToolResult(toolCall, result));
+        return openRouterRequest;
+    }
+    //
+    // History Management
+    //
+    responseToHistoryItems(response) {
+        const openRouterResponse = response;
+        const historyItems = [];
+        const choice = openRouterResponse.choices[0];
+        if (!choice?.message) {
+            return historyItems;
+        }
+        // Check if this is a tool use response (SDK returns camelCase)
+        if (choice.message.toolCalls && choice.message.toolCalls.length > 0) {
+            // Don't add to history yet - will be added after tool execution
+            return historyItems;
+        }
+        // Extract text content for non-tool responses
+        if (choice.message.content) {
+            historyItems.push({
+                content: choice.message.content,
+                role: exports.LlmMessageRole.Assistant,
+                type: exports.LlmMessageType.Message,
+            });
+        }
+        return historyItems;
+    }
+    //
+    // Error Classification
+    //
+    classifyError(error) {
+        // Check if error has a status code (HTTP error)
+        const errorWithStatus = error;
+        const statusCode = errorWithStatus.status || errorWithStatus.statusCode;
+        if (statusCode) {
+            // Rate limit error
+            if (statusCode === RATE_LIMIT_STATUS_CODE) {
+                return {
+                    error,
+                    category: ErrorCategory.RateLimit,
+                    shouldRetry: false,
+                    suggestedDelayMs: 60000,
+                };
+            }
+            // Retryable errors (server errors, timeouts, etc.)
+            if (RETRYABLE_STATUS_CODES.includes(statusCode)) {
+                return {
+                    error,
+                    category: ErrorCategory.Retryable,
+                    shouldRetry: true,
+                };
+            }
+            // Client errors (4xx except 429) are unrecoverable
+            if (statusCode >= 400 && statusCode < 500) {
+                return {
+                    error,
+                    category: ErrorCategory.Unrecoverable,
+                    shouldRetry: false,
+                };
+            }
+        }
+        // Check error message for rate limit indicators
+        const errorMessage = error instanceof Error ? error.message.toLowerCase() : "";
+        if (errorMessage.includes("rate limit") ||
+            errorMessage.includes("too many requests")) {
+            return {
+                error,
+                category: ErrorCategory.RateLimit,
+                shouldRetry: false,
+                suggestedDelayMs: 60000,
+            };
+        }
+        // Unknown error - treat as potentially retryable
+        return {
+            error,
+            category: ErrorCategory.Unknown,
+            shouldRetry: true,
+        };
+    }
+    //
+    // Provider-Specific Features
+    //
+    isComplete(response) {
+        const openRouterResponse = response;
+        const choice = openRouterResponse.choices[0];
+        // Complete if no tool calls (SDK returns camelCase)
+        if (!choice?.message?.toolCalls?.length) {
+            return true;
+        }
+        return false;
+    }
+    hasStructuredOutput(response) {
+        const openRouterResponse = response;
+        const choice = openRouterResponse.choices[0];
+        // SDK returns camelCase (toolCalls)
+        if (!choice?.message?.toolCalls?.length) {
+            return false;
+        }
+        // Check if the last tool call is structured_output
+        const lastToolCall = choice.message.toolCalls[choice.message.toolCalls.length - 1];
+        return lastToolCall?.function?.name === STRUCTURED_OUTPUT_TOOL_NAME;
+    }
+    extractStructuredOutput(response) {
+        const openRouterResponse = response;
+        const choice = openRouterResponse.choices[0];
+        // SDK returns camelCase (toolCalls)
+        if (!choice?.message?.toolCalls?.length) {
+            return undefined;
+        }
+        const lastToolCall = choice.message.toolCalls[choice.message.toolCalls.length - 1];
+        if (lastToolCall?.function?.name === STRUCTURED_OUTPUT_TOOL_NAME) {
+            try {
+                return JSON.parse(lastToolCall.function.arguments);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    //
+    // Private Helpers
+    //
+    hasToolCalls(response) {
+        const choice = response.choices[0];
+        // SDK returns camelCase (toolCalls)
+        return (choice?.message?.toolCalls?.length ?? 0) > 0;
+    }
+    extractContent(response) {
+        // Check for structured output first
+        if (this.hasStructuredOutput(response)) {
+            return this.extractStructuredOutput(response);
+        }
+        const choice = response.choices[0];
+        return choice?.message?.content ?? undefined;
+    }
+    convertMessagesToOpenRouter(messages, system) {
+        const openRouterMessages = [];
+        // Add system message if provided
+        if (system) {
+            openRouterMessages.push({
+                role: "system",
+                content: system,
+            });
+        }
+        for (const msg of messages) {
+            const message = msg;
+            // Handle different message types
+            if (message.role === "system") {
+                openRouterMessages.push({
+                    role: "system",
+                    content: message.content,
+                });
+            }
+            else if (message.role === "user") {
+                openRouterMessages.push({
+                    role: "user",
+                    content: message.content,
+                });
+            }
+            else if (message.role === "assistant") {
+                const assistantMsg = {
+                    role: "assistant",
+                    content: message.content || null,
+                };
+                // Include toolCalls if present (check both camelCase and snake_case for compatibility)
+                if (message.toolCalls) {
+                    assistantMsg.toolCalls = message.toolCalls;
+                }
+                else if (message.tool_calls) {
+                    assistantMsg.toolCalls = message.tool_calls;
+                }
+                openRouterMessages.push(assistantMsg);
+            }
+            else if (message.role === "tool") {
+                openRouterMessages.push({
+                    role: "tool",
+                    toolCallId: message.toolCallId || message.tool_call_id,
+                    content: message.content,
+                });
+            }
+            else if (message.type === exports.LlmMessageType.Message) {
+                // Handle internal message format
+                const role = message.role?.toLowerCase();
+                if (role === "assistant") {
+                    openRouterMessages.push({
+                        role: "assistant",
+                        content: message.content,
+                    });
+                }
+                else {
+                    openRouterMessages.push({
+                        role: "user",
+                        content: message.content,
+                    });
+                }
+            }
+        }
+        return openRouterMessages;
+    }
+}
+// Export singleton instance
+const openRouterAdapter = new OpenRouterAdapter();
+
+const DEFAULT_TOOL_TYPE = "function";
+const log = core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+function logToolMessage(message, context) {
+    log.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.trace("[Toolkit] Tool provided string message");
+                        message = tool.message;
+                    }
+                    else if (typeof tool.message === "function") {
+                        log.trace("[Toolkit] Tool provided function message");
+                        log.trace("[Toolkit] Resolving message result");
+                        message = await core.resolveValue(tool.message(parsedArgs, { name }));
+                    }
+                    else {
+                        log.warn("[Toolkit] Tool provided unknown message type");
+                        message = String(tool.message);
+                    }
+                }
+                else {
+                    log.trace("[Toolkit] Log tool call with default message");
+                    message = `${tool.name}:${JSON.stringify(parsedArgs)}`;
+                }
+                if (typeof this.log === "function") {
+                    log.trace("[Toolkit] Log tool call with custom logger");
+                    await core.resolveValue(this.log(message, context));
                 }
                 else {
-                    log.trace("[operate] Calling OpenAI Responses API");
+                    log.trace("[Toolkit] Log tool call with default logger");
+                    logToolMessage(message, context);
+                }
+            }
+            catch (error) {
+                log.error("[Toolkit] Caught error during logToolCall");
+                log.var({ error });
+                log.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.warn(`[Toolkit] Tool '${tool.name}' already exists, replacing with new tool`);
+                    }
                 }
-                // Execute beforeEachModelRequest hook if defined
-                if (options.hooks?.beforeEachModelRequest) {
-                    await core.resolveValue(options.hooks.beforeEachModelRequest({
-                        input,
-                        options,
-                        providerRequest: requestOptions,
-                    }));
+                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;
+    }
+}
+
+//
+//
+// Main
+//
+/**
+ * HookRunner provides a centralized, consistent way to execute lifecycle hooks
+ * during the LLM operate loop. It handles async resolution and provides error
+ * isolation for hook execution.
+ */
+class HookRunner {
+    /**
+     * Execute the beforeEachModelRequest hook if defined
+     */
+    async runBeforeModelRequest(hooks, context) {
+        if (hooks?.beforeEachModelRequest) {
+            await core.resolveValue(hooks.beforeEachModelRequest(context));
+        }
+    }
+    /**
+     * Execute the afterEachModelResponse hook if defined
+     */
+    async runAfterModelResponse(hooks, context) {
+        if (hooks?.afterEachModelResponse) {
+            await core.resolveValue(hooks.afterEachModelResponse(context));
+        }
+    }
+    /**
+     * Execute the beforeEachTool hook if defined
+     */
+    async runBeforeTool(hooks, context) {
+        if (hooks?.beforeEachTool) {
+            await core.resolveValue(hooks.beforeEachTool(context));
+        }
+    }
+    /**
+     * Execute the afterEachTool hook if defined
+     */
+    async runAfterTool(hooks, context) {
+        if (hooks?.afterEachTool) {
+            await core.resolveValue(hooks.afterEachTool(context));
+        }
+    }
+    /**
+     * Execute the onToolError hook if defined
+     */
+    async runOnToolError(hooks, context) {
+        if (hooks?.onToolError) {
+            await core.resolveValue(hooks.onToolError(context));
+        }
+    }
+    /**
+     * Execute the onRetryableModelError hook if defined
+     */
+    async runOnRetryableError(hooks, context) {
+        if (hooks?.onRetryableModelError) {
+            await core.resolveValue(hooks.onRetryableModelError(context));
+        }
+    }
+    /**
+     * Execute the onUnrecoverableModelError hook if defined
+     */
+    async runOnUnrecoverableError(hooks, context) {
+        if (hooks?.onUnrecoverableModelError) {
+            await core.resolveValue(hooks.onUnrecoverableModelError(context));
+        }
+    }
+}
+// Export singleton instance for convenience
+const hookRunner = new HookRunner();
+
+//
+//
+// Main
+//
+/**
+ * InputProcessor handles input normalization, placeholder substitution,
+ * and history merging for the operate loop.
+ */
+class InputProcessor {
+    /**
+     * Process input with placeholders, history merging, and system message handling
+     *
+     * @param input - The raw input (string, message, or history)
+     * @param options - The operate options containing data, history, system, etc.
+     * @returns Processed input with all transformations applied
+     */
+    process(input, options = {}) {
+        // Convert input to history format with placeholder substitution
+        let history = this.formatInputWithPlaceholders(input, options);
+        // Process instructions with placeholders
+        const instructions = this.processInstructions(options);
+        // Process system prompt with placeholders
+        const system = this.processSystem(options);
+        // Merge with provided history
+        if (options.history) {
+            history = [...options.history, ...history];
+        }
+        // Handle system message prepending
+        if (system) {
+            history = this.prependSystemMessage(history, system);
+        }
+        return {
+            history,
+            instructions,
+            system,
+        };
+    }
+    /**
+     * Format input and apply placeholders if data is provided
+     */
+    formatInputWithPlaceholders(input, options) {
+        // Apply placeholders to input if data is provided and placeholders.input is not false
+        if (options.data &&
+            (options.placeholders?.input === undefined || options.placeholders?.input)) {
+            return formatOperateInput(input, { data: options.data });
+        }
+        return formatOperateInput(input);
+    }
+    /**
+     * Process instructions with placeholder substitution
+     */
+    processInstructions(options) {
+        if (!options.instructions) {
+            return undefined;
+        }
+        // Apply placeholders to instructions if data is provided and placeholders.instructions is not false
+        if (options.data &&
+            (options.placeholders?.instructions === undefined ||
+                options.placeholders?.instructions)) {
+            return core.placeholders(options.instructions, options.data);
+        }
+        return options.instructions;
+    }
+    /**
+     * Process system prompt with placeholder substitution
+     */
+    processSystem(options) {
+        if (!options.system) {
+            return undefined;
+        }
+        // Apply placeholders to system if data is provided and placeholders.system is not false
+        if (options.data && options.placeholders?.system !== false) {
+            return core.placeholders(options.system, options.data);
+        }
+        return options.system;
+    }
+    /**
+     * Prepend system message to history, handling duplicates
+     */
+    prependSystemMessage(history, systemContent) {
+        // Create system message
+        const systemMessage = {
+            content: systemContent,
+            role: exports.LlmMessageRole.System,
+            type: exports.LlmMessageType.Message,
+        };
+        // Check if history starts with an identical system message
+        const firstMessage = history[0];
+        const isIdenticalSystemMessage = firstMessage?.type === exports.LlmMessageType.Message &&
+            firstMessage?.role === exports.LlmMessageRole.System &&
+            firstMessage?.content === systemContent;
+        // If identical, return as-is
+        if (isIdenticalSystemMessage) {
+            return history;
+        }
+        // Remove any existing system message from the beginning
+        if (firstMessage?.type === exports.LlmMessageType.Message &&
+            firstMessage?.role === exports.LlmMessageRole.System) {
+            return [systemMessage, ...history.slice(1)];
+        }
+        // Prepend new system message
+        return [systemMessage, ...history];
+    }
+}
+// Export singleton instance for convenience
+const inputProcessor = new InputProcessor();
+
+//
+//
+// Main
+//
+/**
+ * ResponseBuilder provides a fluent API for constructing LlmOperateResponse objects.
+ * It standardizes response construction across providers.
+ */
+class ResponseBuilder {
+    constructor(config) {
+        this.response = {
+            content: undefined,
+            error: undefined,
+            history: [],
+            model: config.model,
+            output: [],
+            provider: config.provider,
+            responses: [],
+            status: LlmResponseStatus.InProgress,
+            usage: [],
+        };
+    }
+    /**
+     * Set the response content
+     */
+    setContent(content) {
+        this.response.content = content;
+        return this;
+    }
+    /**
+     * Set the response status
+     */
+    setStatus(status) {
+        this.response.status = status;
+        return this;
+    }
+    /**
+     * Set an error on the response
+     */
+    setError(error) {
+        this.response.error = error;
+        return this;
+    }
+    /**
+     * Set the history
+     */
+    setHistory(history) {
+        this.response.history = history;
+        return this;
+    }
+    /**
+     * Append items to the history
+     */
+    appendToHistory(...items) {
+        this.response.history.push(...items);
+        return this;
+    }
+    /**
+     * Set the output
+     */
+    setOutput(output) {
+        this.response.output = output;
+        return this;
+    }
+    /**
+     * Append items to the output
+     */
+    appendToOutput(...items) {
+        this.response.output.push(...items);
+        return this;
+    }
+    /**
+     * Add a raw provider response
+     */
+    addResponse(response) {
+        this.response.responses.push(response);
+        return this;
+    }
+    /**
+     * Add a usage entry for a single API call
+     */
+    addUsage(usage) {
+        this.response.usage.push(usage);
+        return this;
+    }
+    /**
+     * Set the entire usage array
+     */
+    setUsage(usage) {
+        this.response.usage = usage;
+        return this;
+    }
+    /**
+     * Get the current usage array for modifications
+     */
+    getUsage() {
+        return this.response.usage;
+    }
+    /**
+     * Get the current history for modifications
+     */
+    getHistory() {
+        return this.response.history;
+    }
+    /**
+     * Get the current output for modifications
+     */
+    getOutput() {
+        return this.response.output;
+    }
+    /**
+     * Mark response as completed
+     */
+    complete() {
+        this.response.status = LlmResponseStatus.Completed;
+        return this;
+    }
+    /**
+     * Mark response as incomplete (e.g., max turns exceeded)
+     */
+    incomplete() {
+        this.response.status = LlmResponseStatus.Incomplete;
+        return this;
+    }
+    /**
+     * Build and return the final response object
+     */
+    build() {
+        return { ...this.response };
+    }
+}
+/**
+ * Factory function to create a new ResponseBuilder
+ */
+function createResponseBuilder(config) {
+    return new ResponseBuilder(config);
+}
+
+//
+//
+// Constants
+//
+const DEFAULT_INITIAL_DELAY_MS = 1000; // 1 second
+const DEFAULT_MAX_DELAY_MS = 32000; // 32 seconds
+const DEFAULT_BACKOFF_FACTOR = 2; // Exponential backoff multiplier
+const DEFAULT_MAX_RETRIES = 6;
+const MAX_RETRIES_ABSOLUTE_LIMIT = 72;
+//
+//
+// Main
+//
+/**
+ * RetryPolicy encapsulates retry configuration and delay calculation
+ * for the operate loop's retry logic.
+ */
+class RetryPolicy {
+    constructor(config = {}) {
+        this.initialDelayMs = config.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+        this.maxDelayMs = config.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+        this.backoffFactor = config.backoffFactor ?? DEFAULT_BACKOFF_FACTOR;
+        this.maxRetries = Math.min(config.maxRetries ?? DEFAULT_MAX_RETRIES, MAX_RETRIES_ABSOLUTE_LIMIT);
+    }
+    /**
+     * Calculate the delay for a given attempt number (0-indexed)
+     */
+    getDelayForAttempt(attempt) {
+        const delay = this.initialDelayMs * Math.pow(this.backoffFactor, attempt);
+        return Math.min(delay, this.maxDelayMs);
+    }
+    /**
+     * Check if another retry should be attempted
+     */
+    shouldRetry(currentAttempt) {
+        return currentAttempt < this.maxRetries;
+    }
+}
+// Export a default policy instance
+const defaultRetryPolicy = new RetryPolicy();
+
+//
+//
+// Main
+//
+/**
+ * RetryExecutor handles the retry loop logic for LLM API calls.
+ * It provides exponential backoff, error classification, and hook execution.
+ */
+class RetryExecutor {
+    constructor(config) {
+        this.policy = config.policy ?? defaultRetryPolicy;
+        this.hookRunner = config.hookRunner ?? hookRunner;
+        this.errorClassifier = config.errorClassifier;
+    }
+    /**
+     * Execute an operation with retry logic
+     *
+     * @param operation - The async operation to execute
+     * @param options - Execution options including context and hooks
+     * @returns The result of the operation
+     * @throws BadGatewayError if all retries are exhausted or error is not retryable
+     */
+    async execute(operation, options) {
+        let attempt = 0;
+        while (true) {
+            try {
+                const result = await operation();
+                if (attempt > 0) {
+                    log$1.debug(`API call succeeded after ${attempt} retries`);
                 }
-                // Use type assertion to handle the OpenAI SDK response type
-                log.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`);
+                return result;
+            }
+            catch (error) {
+                // Check if we've exhausted retries
+                if (!this.policy.shouldRetry(attempt)) {
+                    log$1.error(`API call failed after ${this.policy.maxRetries} retries`);
+                    log$1.var({ error });
+                    await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                        input: options.context.input,
+                        options: options.context.options,
+                        providerRequest: options.context.providerRequest,
+                        error,
+                    });
+                    throw new errors.BadGatewayError();
                 }
-                // 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,
+                // Check if error is not retryable
+                if (!this.errorClassifier.isRetryable(error)) {
+                    log$1.error("API call failed with non-retryable error");
+                    log$1.var({ error });
+                    await this.hookRunner.runOnUnrecoverableError(options.hooks, {
+                        input: options.context.input,
+                        options: options.context.options,
+                        providerRequest: options.context.providerRequest,
+                        error,
                     });
+                    throw new errors.BadGatewayError();
                 }
-                // 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,
-                    }));
+                // Warn if this is an unknown error type
+                if (!this.errorClassifier.isKnownError(error)) {
+                    log$1.warn("API returned unknown error type, will retry");
+                    log$1.var({ error });
                 }
-                // 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
-                        }
+                const delay = this.policy.getDelayForAttempt(attempt);
+                log$1.warn(`API call failed. Retrying in ${delay}ms...`);
+                await this.hookRunner.runOnRetryableError(options.hooks, {
+                    input: options.context.input,
+                    options: options.context.options,
+                    providerRequest: options.context.providerRequest,
+                    error,
+                });
+                await core.sleep(delay);
+                attempt++;
+            }
+        }
+    }
+}
+
+//
+//
+// Constants
+//
+const ERROR = {
+    BAD_FUNCTION_CALL: "Bad Function Call",
+};
+//
+//
+// Helpers
+//
+/**
+ * Create an ErrorClassifier from a ProviderAdapter
+ */
+function createErrorClassifier(adapter) {
+    return {
+        isRetryable: (error) => adapter.isRetryableError(error),
+        isKnownError: (error) => {
+            const classified = adapter.classifyError(error);
+            return classified.category !== "unknown";
+        },
+    };
+}
+//
+//
+// Main
+//
+/**
+ * OperateLoop implements the core multi-turn conversation loop.
+ * It orchestrates provider adapters, retry logic, hook execution, and tool calling.
+ *
+ * This class uses Template Method + Strategy patterns:
+ * - Template Method: The execute() method defines the algorithm skeleton
+ * - Strategy: Provider adapters handle provider-specific operations
+ */
+class OperateLoop {
+    constructor(config) {
+        this.adapter = config.adapter;
+        this.client = config.client;
+        this.hookRunnerInstance = config.hookRunner ?? hookRunner;
+        this.inputProcessorInstance = config.inputProcessor ?? inputProcessor;
+        this.maxRetries = config.maxRetries ?? 6;
+        this.retryPolicy = config.retryPolicy ?? defaultRetryPolicy;
+    }
+    /**
+     * Execute the operate loop for multi-turn conversations with tool calling.
+     */
+    async execute(input, options = {}) {
+        // Initialize state
+        const state = this.initializeState(input, options);
+        const context = this.createContext(options);
+        // Build initial request
+        let request = this.buildInitialRequest(state, options);
+        // Multi-turn loop
+        while (state.currentTurn < state.maxTurns) {
+            state.currentTurn++;
+            // Execute one turn with retry logic
+            const shouldContinue = await this.executeOneTurn(request, state, context, options);
+            if (!shouldContinue) {
+                break;
+            }
+            // Rebuild request with updated history for next turn
+            request = {
+                format: state.formattedFormat,
+                instructions: options.instructions,
+                messages: state.currentInput,
+                model: options.model ?? this.adapter.defaultModel,
+                providerOptions: options.providerOptions,
+                system: options.system,
+                tools: state.formattedTools,
+                user: options.user,
+            };
+        }
+        return state.responseBuilder.build();
+    }
+    //
+    // Private Methods
+    //
+    initializeState(input, options) {
+        // Process input with placeholders
+        const processedInput = this.inputProcessorInstance.process(input, options);
+        // Determine max turns
+        const maxTurns = maxTurnsFromOptions(options);
+        // Initialize response builder
+        const responseBuilderConfig = {
+            model: options.model ?? this.adapter.defaultModel,
+            provider: this.adapter.name,
+        };
+        const responseBuilder = createResponseBuilder(responseBuilderConfig);
+        // Set initial history
+        responseBuilder.setHistory([...processedInput.history]);
+        // Get toolkit
+        let toolkit;
+        if (options.tools) {
+            if (options.tools instanceof Toolkit) {
+                toolkit = options.tools;
+            }
+            else if (Array.isArray(options.tools) && options.tools.length > 0) {
+                const explain = options.explain ?? false;
+                toolkit = new Toolkit(options.tools, { explain });
+            }
+        }
+        // Format output schema through adapter if provided
+        let formattedFormat;
+        if (options.format) {
+            formattedFormat = this.adapter.formatOutputSchema(options.format);
+        }
+        // Format tools through adapter
+        const formattedTools = toolkit
+            ? this.adapter.formatTools(toolkit, formattedFormat)
+            : undefined;
+        return {
+            currentInput: processedInput.history,
+            currentTurn: 0,
+            formattedFormat,
+            formattedTools,
+            maxTurns,
+            responseBuilder,
+            toolkit,
+        };
+    }
+    createContext(options) {
+        return {
+            hooks: options.hooks ?? {},
+            options,
+        };
+    }
+    buildInitialRequest(state, options) {
+        return {
+            format: state.formattedFormat,
+            instructions: options.instructions,
+            messages: state.currentInput,
+            model: options.model ?? this.adapter.defaultModel,
+            providerOptions: options.providerOptions,
+            system: options.system,
+            tools: state.formattedTools,
+            user: options.user,
+        };
+    }
+    async executeOneTurn(request, state, context, options) {
+        // Create error classifier from adapter
+        const errorClassifier = createErrorClassifier(this.adapter);
+        // Create retry executor for this turn
+        const retryExecutor = new RetryExecutor({
+            errorClassifier,
+            hookRunner: this.hookRunnerInstance,
+            policy: this.retryPolicy,
+        });
+        // Build provider-specific request
+        const providerRequest = this.adapter.buildRequest(request);
+        // Execute beforeEachModelRequest hook
+        await this.hookRunnerInstance.runBeforeModelRequest(context.hooks, {
+            input: state.currentInput,
+            options,
+            providerRequest,
+        });
+        // Execute with retry (RetryExecutor handles error hooks and throws appropriate errors)
+        const response = await retryExecutor.execute(() => this.adapter.executeRequest(this.client, providerRequest), {
+            context: {
+                input: state.currentInput,
+                options,
+                providerRequest,
+            },
+            hooks: context.hooks,
+        });
+        // Parse response
+        const parsed = this.adapter.parseResponse(response, options);
+        // Track usage
+        if (parsed.usage) {
+            state.responseBuilder.addUsage(parsed.usage);
+        }
+        // Add raw response
+        state.responseBuilder.addResponse(parsed.raw);
+        // Execute afterEachModelResponse hook
+        const currentUsage = state.responseBuilder.build().usage;
+        await this.hookRunnerInstance.runAfterModelResponse(context.hooks, {
+            content: parsed.content ?? "",
+            input: state.currentInput,
+            options,
+            providerRequest,
+            providerResponse: response,
+            usage: currentUsage,
+        });
+        // Check for structured output (Anthropic magic tool pattern)
+        if (this.adapter.hasStructuredOutput(response)) {
+            const structuredOutput = this.adapter.extractStructuredOutput(response);
+            if (structuredOutput) {
+                state.responseBuilder.setContent(structuredOutput);
+                state.responseBuilder.complete();
+                return false; // Stop loop
+            }
+        }
+        // Handle tool calls
+        if (parsed.hasToolCalls) {
+            const toolCalls = this.adapter.extractToolCalls(response);
+            if (toolCalls.length > 0 && state.toolkit && state.maxTurns > 1) {
+                // Track updated provider request for tool results
+                let currentProviderRequest = providerRequest;
+                // Add all response output items to the request BEFORE processing tool calls
+                // This is critical for OpenAI which requires reasoning items to be present
+                // when function_call items reference them
+                const responseItems = this.adapter.responseToHistoryItems(response);
+                this.appendResponseItemsToRequest(currentProviderRequest, responseItems);
+                // Process each tool call
+                for (const toolCall of toolCalls) {
+                    try {
+                        // Execute beforeEachTool hook
+                        await this.hookRunnerInstance.runBeforeTool(context.hooks, {
+                            args: toolCall.arguments,
+                            toolName: toolCall.name,
+                        });
+                        // Call the tool
+                        log$1.trace(`[operate] Calling tool - ${toolCall.name}`);
+                        const result = await state.toolkit.call({
+                            arguments: toolCall.arguments,
+                            name: toolCall.name,
+                        });
+                        // Execute afterEachTool hook
+                        await this.hookRunnerInstance.runAfterTool(context.hooks, {
+                            args: toolCall.arguments,
+                            result,
+                            toolName: toolCall.name,
+                        });
+                        // Format result and append to request
+                        const formattedResult = {
+                            callId: toolCall.callId,
+                            output: JSON.stringify(result),
+                            success: true,
+                        };
+                        // Update provider request with tool result
+                        currentProviderRequest = this.adapter.appendToolResult(currentProviderRequest, toolCall, formattedResult);
+                        // Sync state from updated request
+                        this.syncInputFromRequest(state, currentProviderRequest);
+                        // Add tool result to history
+                        const toolResultFormatted = this.adapter.formatToolResult(toolCall, formattedResult);
+                        state.responseBuilder.appendToHistory(toolResultFormatted);
+                    }
+                    catch (error) {
+                        // Execute onToolError hook
+                        await this.hookRunnerInstance.runOnToolError(context.hooks, {
+                            args: toolCall.arguments,
+                            error: error,
+                            toolName: toolCall.name,
+                        });
+                        // Set error on response
+                        const jaypieError = new errors.BadGatewayError();
+                        const detail = [
+                            `Error executing function call ${toolCall.name}.`,
+                            error.message,
+                        ].join("\n");
+                        state.responseBuilder.setError({
+                            detail,
+                            status: jaypieError.status,
+                            title: ERROR.BAD_FUNCTION_CALL,
+                        });
+                        log$1.error(`Error executing function call ${toolCall.name}`);
+                        log$1.var({ error });
                     }
                 }
-                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) {
+                // Check if we've reached max turns
+                if (state.currentTurn >= state.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 = {
+                    const detail = `Model requested function call but exceeded ${state.maxTurns} turns`;
+                    log$1.warn(detail);
+                    state.responseBuilder.setError({
                         detail,
                         status: error.status,
                         title: error.title,
-                    };
-                    return returnResponse;
+                    });
+                    state.responseBuilder.incomplete();
+                    return false; // Stop loop
                 }
-                // Continue to next turn
-                break;
+                return true; // Continue to next turn
+            }
+        }
+        // No tool calls or no toolkit - we're done
+        state.responseBuilder.setContent(parsed.content);
+        state.responseBuilder.complete();
+        // Add final history items
+        const historyItems = this.adapter.responseToHistoryItems(parsed.raw);
+        for (const item of historyItems) {
+            state.responseBuilder.appendToHistory(item);
+        }
+        return false; // Stop loop
+    }
+    /**
+     * Sync the current input state from the updated provider request.
+     * This is necessary because appendToolResult modifies the provider-specific request,
+     * and we need to keep our state in sync.
+     */
+    syncInputFromRequest(state, updatedRequest) {
+        // Extract input/messages from the updated request
+        // This is provider-specific but follows common patterns
+        const request = updatedRequest;
+        if (Array.isArray(request.input)) {
+            // OpenAI format
+            state.currentInput = request.input;
+        }
+        else if (Array.isArray(request.messages)) {
+            // Anthropic format
+            state.currentInput = request.messages;
+        }
+        else if (Array.isArray(request.contents)) {
+            // Gemini format - convert contents to history items
+            state.currentInput = this.convertGeminiContentsToHistory(request.contents);
+        }
+    }
+    /**
+     * Convert Gemini contents format to internal history format.
+     */
+    convertGeminiContentsToHistory(contents) {
+        const history = [];
+        for (const content of contents) {
+            if (!content.parts)
+                continue;
+            for (const part of content.parts) {
+                if (part.text && typeof part.text === "string") {
+                    // Regular text message
+                    history.push({
+                        role: content.role === "model"
+                            ? exports.LlmMessageRole.Assistant
+                            : exports.LlmMessageRole.User,
+                        content: part.text,
+                        type: exports.LlmMessageType.Message,
+                    });
+                }
+                else if (part.functionCall) {
+                    // Function call
+                    const fc = part.functionCall;
+                    history.push({
+                        type: exports.LlmMessageType.FunctionCall,
+                        name: fc.name || "",
+                        arguments: JSON.stringify(fc.args || {}),
+                        call_id: fc.id || "",
+                        id: fc.id || "",
+                    });
+                }
+                else if (part.functionResponse) {
+                    // Function response
+                    const fr = part.functionResponse;
+                    // Store name in the object even though it's not part of LlmToolResult type
+                    // This allows round-trip conversion back to Gemini format
+                    history.push({
+                        type: exports.LlmMessageType.FunctionCallOutput,
+                        output: JSON.stringify(fr.response || {}),
+                        call_id: "",
+                        name: fr.name || "",
+                    });
+                }
+            }
+        }
+        return history;
+    }
+    /**
+     * Append response items to the provider request.
+     * This adds all output items from a response (including reasoning, function_calls, etc.)
+     * to the request's input/messages array.
+     *
+     * This is critical for OpenAI which requires reasoning items to be present
+     * when function_call items reference them.
+     */
+    appendResponseItemsToRequest(request, responseItems) {
+        const requestObj = request;
+        if (Array.isArray(requestObj.input)) {
+            // OpenAI format
+            requestObj.input.push(...responseItems);
+        }
+        else if (Array.isArray(requestObj.messages)) {
+            // Anthropic format
+            requestObj.messages.push(...responseItems);
+        }
+    }
+}
+//
+//
+// Factory
+//
+/**
+ * Create an OperateLoop instance with the specified configuration.
+ */
+function createOperateLoop(config) {
+    return new OperateLoop(config);
+}
+
+// Logger
+const getLogger$3 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient$3({ apiKey, } = {}) {
+    const logger = getLogger$3();
+    const resolvedApiKey = apiKey || (await aws.getEnvSecret("ANTHROPIC_API_KEY"));
+    if (!resolvedApiKey) {
+        throw new core.ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
+    }
+    const client = new Anthropic({ apiKey: resolvedApiKey });
+    logger.trace("Initialized Anthropic client");
+    return client;
+}
+// Message formatting functions
+function formatSystemMessage$2(systemPrompt, { data, placeholders } = {}) {
+    return placeholders?.system === false
+        ? systemPrompt
+        : core.placeholders(systemPrompt, data);
+}
+function formatUserMessage$3(message, { data, placeholders } = {}) {
+    const content = placeholders?.message === false
+        ? message
+        : core.placeholders(message, data);
+    return {
+        role: PROVIDER.ANTHROPIC.ROLE.USER,
+        content,
+    };
+}
+function prepareMessages$3(message, { data, placeholders } = {}) {
+    const logger = getLogger$3();
+    const messages = [];
+    // Add user message (necessary for all requests)
+    const userMessage = formatUserMessage$3(message, { data, placeholders });
+    messages.push(userMessage);
+    logger.trace(`User message: ${userMessage.content.length} characters`);
+    return messages;
+}
+// Basic text completion
+async function createTextCompletion$1(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$1(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$3();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient$3({ apiKey: this.apiKey });
+        return this._client;
+    }
+    async getOperateLoop() {
+        if (this._operateLoop) {
+            return this._operateLoop;
+        }
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({
+            adapter: anthropicAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
+    // Main send method
+    async send(message, options) {
+        const client = await this.getClient();
+        const messages = prepareMessages$3(message, options || {});
+        const modelToUse = options?.model || this.model;
+        // Process system message if provided
+        let systemMessage;
+        if (options?.system) {
+            systemMessage = formatSystemMessage$2(options.system, {
+                data: options.data,
+                placeholders: options.placeholders,
+            });
+        }
+        if (options?.response) {
+            return createStructuredCompletion$1(client, messages, modelToUse, options.response, systemMessage);
+        }
+        return createTextCompletion$1(client, messages, modelToUse, systemMessage);
+    }
+    async operate(input, options = {}) {
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        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];
+        }
+        // Execute operate loop
+        const response = await operateLoop.execute(input, mergedOptions);
+        // Update conversation history with the new history from the response
+        if (response.history && response.history.length > 0) {
+            this.conversationHistory = response.history;
+        }
+        return response;
+    }
+}
+
+// Logger
+const getLogger$2 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient$2({ apiKey, } = {}) {
+    const logger = getLogger$2();
+    const resolvedApiKey = apiKey || (await aws.getEnvSecret("GEMINI_API_KEY"));
+    if (!resolvedApiKey) {
+        throw new core.ConfigurationError("The application could not resolve the requested keys");
+    }
+    const client = new genai.GoogleGenAI({ apiKey: resolvedApiKey });
+    logger.trace("Initialized Gemini client");
+    return client;
+}
+function formatUserMessage$2(message, { data, placeholders } = {}) {
+    const content = placeholders?.message === false
+        ? message
+        : core.placeholders(message, data);
+    return {
+        role: "user",
+        content,
+    };
+}
+function prepareMessages$2(message, { data, placeholders } = {}) {
+    const logger = getLogger$2();
+    const messages = [];
+    let systemInstruction;
+    // Note: Gemini handles system prompts differently via systemInstruction config
+    // This function is kept for compatibility but system prompts should be passed
+    // via the systemInstruction parameter in generateContent
+    const userMessage = formatUserMessage$2(message, { data, placeholders });
+    messages.push(userMessage);
+    logger.trace(`User message: ${userMessage.content?.length} characters`);
+    return { messages, systemInstruction };
+}
+
+class GeminiProvider {
+    constructor(model = PROVIDER.GEMINI.MODEL.DEFAULT, { apiKey } = {}) {
+        this.log = getLogger$2();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient$2({ apiKey: this.apiKey });
+        return this._client;
+    }
+    async getOperateLoop() {
+        if (this._operateLoop) {
+            return this._operateLoop;
+        }
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({
+            adapter: geminiAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
+    async send(message, options) {
+        const client = await this.getClient();
+        const { messages } = prepareMessages$2(message, options);
+        const modelToUse = options?.model || this.model;
+        // Build the request config
+        const config = {};
+        if (options?.system) {
+            config.systemInstruction = options.system;
+        }
+        // Handle structured output via responseSchema
+        if (options?.response) {
+            config.responseMimeType = "application/json";
+            // Convert the response schema to JSON schema format
+            // Note: For simple send() calls, we'll use Gemini's native JSON response
+        }
+        const response = await client.models.generateContent({
+            model: modelToUse,
+            contents: messages.map((m) => ({
+                role: m.role,
+                parts: [{ text: m.content }],
+            })),
+            config: Object.keys(config).length > 0 ? config : undefined,
+        });
+        const text = response.text;
+        this.log.trace(`Assistant reply: ${text?.length || 0} characters`);
+        // If structured output was requested, try to parse the response
+        if (options?.response && text) {
+            try {
+                return JSON.parse(text);
             }
-            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);
+            catch {
+                return text || "";
             }
         }
+        return text || "";
+    }
+    async operate(input, options = {}) {
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...options, model: options.model ?? this.model };
+        // Create a merged history including both the tracked history and any explicitly provided history
+        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];
+        }
+        // Execute operate loop
+        const response = await operateLoop.execute(input, mergedOptions);
+        // Update conversation history with the new history from the response
+        if (response.history && response.history.length > 0) {
+            this.conversationHistory = response.history;
+        }
+        return response;
     }
-    // * 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
@@ -1233,7 +3495,7 @@ function prepareMessages$1(message, { system, data, placeholders } = {}) {
     return messages;
 }
 // Completion requests
-async function createStructuredCompletion$1(client, { messages, responseSchema, model, }) {
+async function createStructuredCompletion(client, { messages, responseSchema, model, }) {
     const logger = getLogger$1();
     logger.trace("Using structured output");
     const zodSchema = responseSchema instanceof v4.z.ZodType
@@ -1256,7 +3518,7 @@ async function createStructuredCompletion$1(client, { messages, responseSchema,
         checks.shift();
     }
     responseFormat.json_schema.schema = jsonSchema;
-    const completion = await client.beta.chat.completions.parse({
+    const completion = await client.chat.completions.parse({
         messages,
         model,
         response_format: responseFormat,
@@ -1264,7 +3526,7 @@ async function createStructuredCompletion$1(client, { messages, responseSchema,
     logger.var({ assistantReply: completion.choices[0].message.parsed });
     return completion.choices[0].message.parsed;
 }
-async function createTextCompletion$1(client, { messages, model, }) {
+async function createTextCompletion(client, { messages, model, }) {
     const logger = getLogger$1();
     logger.trace("Using text output (unstructured)");
     const completion = await client.chat.completions.create({
@@ -1289,35 +3551,45 @@ class OpenAiProvider {
         this._client = await initializeClient$1({ apiKey: this.apiKey });
         return this._client;
     }
+    async getOperateLoop() {
+        if (this._operateLoop) {
+            return this._operateLoop;
+        }
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({
+            adapter: openAiAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
     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, {
+            return createStructuredCompletion(client, {
                 messages,
                 responseSchema: options.response,
                 model: modelToUse,
             });
         }
-        return createTextCompletion$1(client, {
+        return createTextCompletion(client, {
             messages,
             model: modelToUse,
         });
     }
     async operate(input, options = {}) {
-        const client = await this.getClient();
-        options.model = options?.model || this.model;
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...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 });
+        // Execute operate loop
+        const response = await operateLoop.execute(input, mergedOptions);
         // Update conversation history with the new history from the response
         if (response.history && response.history.length > 0) {
             this.conversationHistory = response.history;
@@ -1326,384 +3598,57 @@ class OpenAiProvider {
     }
 }
 
-// Handle placeholder logic
-// Convert string input to array format if needed
-// Apply placeholders to fields if data is provided and placeholders.* is undefined or true
-function handleInputAndPlaceholders(input, options) {
-    let history = formatOperateInput(input);
-    let llmInstructions;
-    let systemPrompt;
-    if (options?.data &&
-        (options.placeholders?.input === undefined || options.placeholders?.input)) {
-        history = formatOperateInput(input, {
-            data: options?.data,
-        });
-    }
-    if (options?.instructions) {
-        llmInstructions =
-            options.data && options.placeholders?.instructions !== false
-                ? 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"));
+    const resolvedApiKey = apiKey || (await aws.getEnvSecret("OPENROUTER_API_KEY"));
     if (!resolvedApiKey) {
-        throw new core.ConfigurationError("The application could not resolve the required API key: ANTHROPIC_API_KEY");
+        throw new core.ConfigurationError("The application could not resolve the requested keys");
     }
-    const client = new Anthropic({ apiKey: resolvedApiKey });
-    logger.trace("Initialized Anthropic client");
+    const client = new sdk.OpenRouter({ apiKey: resolvedApiKey });
+    logger.trace("Initialized OpenRouter client");
     return client;
 }
-// Message formatting functions
+// Get default model from environment or constants
+function getDefaultModel() {
+    return process.env.OPENROUTER_MODEL || PROVIDER.OPENROUTER.MODEL.DEFAULT;
+}
 function formatSystemMessage(systemPrompt, { data, placeholders } = {}) {
-    return placeholders?.system === false
+    const content = placeholders?.system === false
         ? systemPrompt
         : core.placeholders(systemPrompt, data);
+    return {
+        role: "system",
+        content,
+    };
 }
 function formatUserMessage(message, { data, placeholders } = {}) {
     const content = placeholders?.message === false
         ? message
         : core.placeholders(message, data);
     return {
-        role: PROVIDER.ANTHROPIC.ROLE.USER,
+        role: "user",
         content,
     };
 }
-function prepareMessages(message, { data, placeholders } = {}) {
+function prepareMessages(message, { system, data, placeholders } = {}) {
     const logger = getLogger();
     const messages = [];
-    // Add user message (necessary for all requests)
+    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`);
+    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 } = {}) {
+class OpenRouterProvider {
+    constructor(model = getDefaultModel(), { apiKey } = {}) {
         this.log = getLogger();
         this.conversationHistory = [];
         this.model = model;
@@ -1716,37 +3661,60 @@ class AnthropicProvider {
         this._client = await initializeClient({ apiKey: this.apiKey });
         return this._client;
     }
-    // Main send method
+    async getOperateLoop() {
+        if (this._operateLoop) {
+            return this._operateLoop;
+        }
+        const client = await this.getClient();
+        this._operateLoop = createOperateLoop({
+            adapter: openRouterAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
     async send(message, options) {
         const client = await this.getClient();
-        const messages = prepareMessages(message, options || {});
+        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);
+        // Build the request
+        const response = await client.chat.send({
+            model: modelToUse,
+            messages: messages,
+        });
+        const rawContent = response.choices?.[0]?.message?.content;
+        // Extract text content - content could be string or array of content items
+        const content = typeof rawContent === "string"
+            ? rawContent
+            : Array.isArray(rawContent)
+                ? rawContent
+                    .filter((item) => item.type === "text")
+                    .map((item) => item.text)
+                    .join("")
+                : "";
+        this.log.trace(`Assistant reply: ${content?.length || 0} characters`);
+        // If structured output was requested, try to parse the response
+        if (options?.response && content) {
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                return content || "";
+            }
         }
-        return createTextCompletion(client, messages, modelToUse, systemMessage);
+        return content || "";
     }
     async operate(input, options = {}) {
-        const client = await this.getClient();
-        options.model = options?.model || this.model;
+        const operateLoop = await this.getOperateLoop();
+        const mergedOptions = { ...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 });
+        // Execute operate loop
+        const response = await operateLoop.execute(input, mergedOptions);
         // Update conversation history with the new history from the response
         if (response.history && response.history.length > 0) {
             this.conversationHistory = response.history;
@@ -1793,12 +3761,20 @@ class Llm {
     createProvider(providerName, options = {}) {
         const { apiKey, model } = options;
         switch (providerName) {
+            case PROVIDER.ANTHROPIC.NAME:
+                return new AnthropicProvider(model || PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey });
+            case PROVIDER.GEMINI.NAME:
+                return new GeminiProvider(model || PROVIDER.GEMINI.MODEL.DEFAULT, {
+                    apiKey,
+                });
             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 });
+            case PROVIDER.OPENROUTER.NAME:
+                return new OpenRouterProvider(model || PROVIDER.OPENROUTER.MODEL.DEFAULT, {
+                    apiKey,
+                });
             default:
                 throw new errors.ConfigurationError(`Unsupported provider: ${providerName}`);
         }
@@ -1940,11 +3916,11 @@ const roll = {
         let total = 0;
         const parsedNumber = tryParseNumber(number, {
             defaultValue: 1,
-            warnFunction: log.warn,
+            warnFunction: log$1.warn,
         });
         const parsedSides = tryParseNumber(sides, {
             defaultValue: 6,
-            warnFunction: log.warn,
+            warnFunction: log$1.warn,
         });
         for (let i = 0; i < parsedNumber; i++) {
             const rollValue = rng({ min: 1, max: parsedSides, integer: true });
@@ -2119,9 +4095,22 @@ class JaypieToolkit extends Toolkit {
 }
 const toolkit = new JaypieToolkit(tools);
 
+//
+//
+// Role Mapping
+//
+({
+    [exports.LlmMessageRole.User]: "user",
+    [exports.LlmMessageRole.System]: "user", // Gemini doesn't have system role in contents
+    [exports.LlmMessageRole.Assistant]: "model",
+    [exports.LlmMessageRole.Developer]: "user",
+});
+
+exports.GeminiProvider = GeminiProvider;
 exports.JaypieToolkit = JaypieToolkit;
 exports.LLM = constants;
 exports.Llm = Llm;
+exports.OpenRouterProvider = OpenRouterProvider;
 exports.Toolkit = Toolkit;
 exports.toolkit = toolkit;
 exports.tools = tools;