@jaypie/llm 1.1.27 → 1.1.30-rc.0

package/dist/cjs/index.cjs

@@ -1,17 +1,43 @@
 '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 openmeteo = require('openmeteo');
 
 const PROVIDER = {
+    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,6 +146,12 @@ 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,
@@ -135,6 +167,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) {
@@ -154,6 +195,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") {
@@ -179,129 +229,42 @@ function determineModelProvider(input) {
     };
 }
 
-const DEFAULT_TOOL_TYPE = "function";
-const log$1 = core.log.lib({ lib: core.JAYPIE.LIB.LLM });
-function logToolMessage(message, context) {
-    log$1.trace.var({ [context.name]: message });
-}
-class Toolkit {
-    constructor(tools, options) {
-        this._tools = tools;
-        this._options = options || {};
-        this.explain = this._options.explain ? true : false;
-        this.log = this._options.log !== undefined ? this._options.log : true;
-    }
-    get tools() {
-        return this._tools.map((tool) => {
-            const toolCopy = { ...tool };
-            delete toolCopy.call;
-            delete toolCopy.message;
-            if (this.explain && toolCopy.parameters?.type === "object") {
-                if (toolCopy.parameters?.properties) {
-                    if (!toolCopy.parameters.properties.__Explanation) {
-                        toolCopy.parameters.properties.__Explanation = {
-                            type: "string",
-                            description: `Clearly state why the tool is being called and what larger question it helps answer. For example, "I am checking the location API because the user asked for nearby pizza and I need coordinates to proceed"`,
-                        };
-                    }
-                }
-            }
-            // Set default type if not provided
-            if (!toolCopy.type) {
-                toolCopy.type = DEFAULT_TOOL_TYPE;
-            }
-            return toolCopy;
-        });
-    }
-    async call({ name, arguments: args }) {
-        const tool = this._tools.find((t) => t.name === name);
-        if (!tool) {
-            throw new Error(`Tool '${name}' not found`);
-        }
-        let parsedArgs;
-        try {
-            parsedArgs = JSON.parse(args);
-            if (this.explain) {
-                delete parsedArgs.__Explanation;
-            }
-        }
-        catch {
-            parsedArgs = args;
-        }
-        if (this.log !== false) {
-            try {
-                const context = {
-                    name,
-                    args: parsedArgs,
-                };
-                let message;
-                if (this.explain) {
-                    context.explanation = parsedArgs.__Explanation;
-                }
-                if (tool.message) {
-                    if (typeof tool.message === "string") {
-                        log$1.trace("[Toolkit] Tool provided string message");
-                        message = tool.message;
-                    }
-                    else if (typeof tool.message === "function") {
-                        log$1.trace("[Toolkit] Tool provided function message");
-                        log$1.trace("[Toolkit] Resolving message result");
-                        message = await core.resolveValue(tool.message(parsedArgs, { name }));
-                    }
-                    else {
-                        log$1.warn("[Toolkit] Tool provided unknown message type");
-                        message = String(tool.message);
-                    }
-                }
-                else {
-                    log$1.trace("[Toolkit] Log tool call with default message");
-                    message = `${tool.name}:${JSON.stringify(parsedArgs)}`;
-                }
-                if (typeof this.log === "function") {
-                    log$1.trace("[Toolkit] Log tool call with custom logger");
-                    await core.resolveValue(this.log(message, context));
-                }
-                else {
-                    log$1.trace("[Toolkit] Log tool call with default logger");
-                    logToolMessage(message, context);
-                }
-            }
-            catch (error) {
-                log$1.error("[Toolkit] Caught error during logToolCall");
-                log$1.var({ error });
-                log$1.debug("[Toolkit] Continuing...");
-            }
-        }
-        return await core.resolveValue(tool.call(parsedArgs));
-    }
-    extend(tools, options = {}) {
-        for (const tool of tools) {
-            const existingIndex = this._tools.findIndex((t) => t.name === tool.name);
-            if (existingIndex !== -1) {
-                if (options.replace === false) {
-                    continue;
-                }
-                if (options.warn !== false) {
-                    if (typeof this.log === "function") {
-                        this.log(`[Toolkit] Tool '${tool.name}' already exists, replacing with new tool`, { name: tool.name, args: {} });
-                    }
-                    else if (this.log) {
-                        log$1.warn(`[Toolkit] Tool '${tool.name}' already exists, replacing with new tool`);
-                    }
-                }
-                this._tools[existingIndex] = tool;
-            }
-            else {
-                this._tools.push(tool);
-            }
-        }
-        if (Object.prototype.hasOwnProperty.call(options, "log")) {
-            this.log = options.log;
-        }
-        if (Object.prototype.hasOwnProperty.call(options, "explain")) {
-            this.explain = options.explain;
-        }
-        return this;
+//
+//
+// 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;
+    }
+    /**
+     * Default implementation checks error category via classifyError
+     */
+    isRateLimitError(error) {
+        const classified = this.classifyError(error);
+        return classified.category === "rate_limit";
+    }
+    /**
+     * Default implementation returns false - override for providers with native structured output
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hasStructuredOutput(_response) {
+        return false;
+    }
+    /**
+     * 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 +342,8 @@ function formatOperateInput(input, options) {
     return [input];
 }
 
-const getLogger$2 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
-const log = getLogger$2();
+const getLogger$3 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const log$1 = getLogger$3();
 
 // Turn policy constants
 const MAX_TURNS_ABSOLUTE_LIMIT = 72;
@@ -660,937 +623,2095 @@ 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$1 = "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);
+        const anthropicRequest = {
+            model: (request.model ||
+                this.defaultModel),
+            messages,
+            max_tokens: PROVIDER.ANTHROPIC.MAX_TOKENS.DEFAULT,
+            stream: false,
+        };
+        if (request.system) {
+            anthropicRequest.system = request.system;
+        }
+        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$1);
+            anthropicRequest.tool_choice = {
+                type: hasStructuredOutput ? "any" : "auto",
+            };
         }
-        // Skip reasoning items when extracting content
-        if (output.type === "reasoning") {
-            continue;
+        if (request.providerOptions) {
+            Object.assign(anthropicRequest, request.providerOptions);
         }
+        return anthropicRequest;
     }
-    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,
-            };
+    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"; // Validator does not recognize "json_schema"
         }
         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]);
-                    }
+            // 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 (causes issues with validator)
+        if (jsonSchema.$schema) {
+            delete jsonSchema.$schema;
+        }
+        return jsonSchema;
+    }
+    //
+    // API Execution
+    //
+    async executeRequest(client, request) {
+        const anthropic = client;
+        return (await anthropic.messages.create(request));
+    }
+    //
+    // Response Parsing
+    //
+    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,
+        };
+    }
+    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,
                 });
-                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,
-                },
-            };
         }
+        return toolCalls;
     }
-    // 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;
+    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,
+        };
+    }
+    //
+    // Tool Result Handling
+    //
+    formatToolResult(toolCall, result) {
+        return {
+            type: "tool_result",
+            tool_use_id: toolCall.callId,
+            content: result.output,
+        };
+    }
+    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,
+            });
         }
-        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 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,
+                };
+            }
         }
-        if (toolkit) {
-            requestOptions.tools = toolkit.tools;
+        // 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,
+        };
     }
-    return requestOptions;
-}
-//
-//
-// Main
-//
-async function operate$1(input, options = {}, context = {
-    client: new openai.OpenAI(),
-}) {
     //
+    // 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$1);
+    }
+    extractStructuredOutput(response) {
+        const anthropicResponse = response;
+        const lastBlock = anthropicResponse.content[anthropicResponse.content.length - 1];
+        if (lastBlock?.type === "tool_use" &&
+            lastBlock.name === STRUCTURED_OUTPUT_TOOL_NAME$1) {
+            return lastBlock.input;
+        }
+        return undefined;
+    }
     //
-    // Setup
+    // Private Helpers
     //
-    const openai = context.client;
-    if (!context.maxRetries) {
-        context.maxRetries = MAX_RETRIES_DEFAULT_LIMIT;
-    }
-    let retryCount = 0;
-    let retryDelay = INITIAL_RETRY_DELAY_MS;
-    const maxRetries = Math.min(context.maxRetries, MAX_RETRIES_ABSOLUTE_LIMIT);
-    const returnResponse = {
-        history: [],
-        model: options?.model || PROVIDER.OPENAI.MODEL.DEFAULT,
-        output: [],
-        provider: PROVIDER.OPENAI.NAME,
-        responses: [],
-        status: LlmResponseStatus.InProgress,
-        usage: [], // Initialize as empty array, will add entry for each response
-    };
-    // Convert string input to array format with placeholders if needed
-    let currentInput = formatOperateInput(input);
-    if (options?.data &&
-        (options.placeholders?.input === undefined || options.placeholders?.input)) {
-        currentInput = formatOperateInput(input, {
-            data: options?.data,
-        });
+    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;
     }
-    // If history is provided, merge it with currentInput
-    if (options.history) {
-        currentInput = [...options.history, ...currentInput];
+}
+// Export singleton instance
+const anthropicAdapter = new AnthropicAdapter();
+
+//
+//
+// Constants
+//
+const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
+// Gemini uses HTTP status codes for error classification
+// Documented at: https://ai.google.dev/api/rest/v1beta/Status
+const RETRYABLE_STATUS_CODES = [
+    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;
     }
-    // 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,
+    //
+    // Request Building
+    //
+    buildRequest(request) {
+        // Convert messages to Gemini format (Content[])
+        const contents = this.convertMessagesToContents(request.messages);
+        const geminiRequest = {
+            model: request.model || this.defaultModel,
+            contents,
         };
-        // Check if history starts with an identical system message
-        const firstMessage = currentInput[0];
-        const isIdenticalSystemMessage = firstMessage?.type === exports.LlmMessageType.Message &&
-            firstMessage?.role === exports.LlmMessageRole.System &&
-            firstMessage?.content === systemMessage;
-        // Only prepend if not identical
-        if (!isIdenticalSystemMessage) {
-            // Remove any existing system message from the beginning
-            if (currentInput[0]?.type === exports.LlmMessageType.Message &&
-                currentInput[0]?.role === exports.LlmMessageRole.System) {
-                currentInput = currentInput.slice(1);
-            }
-            currentInput = [systemInputMessage, ...currentInput];
-        }
-    }
-    // Initialize history with currentInput
-    returnResponse.history = [...currentInput];
-    // Determine max turns from options
-    const maxTurns = maxTurnsFromOptions(options);
-    const enableMultipleTurns = maxTurns > 1;
-    let currentTurn = 0;
-    // Build request options outside the retry loop
-    const requestOptions = createRequestOptions(currentInput, options);
-    // OpenAI Multi-turn Loop
-    while (currentTurn < maxTurns) {
-        currentTurn++;
-        retryCount = 0;
-        retryDelay = INITIAL_RETRY_DELAY_MS;
-        // OpenAI Retry Loop
-        while (true) {
-            try {
-                // Log appropriate message based on turn number
-                if (currentTurn > 1) {
-                    log.trace(`[operate] Calling OpenAI Responses API - ${currentTurn}`);
-                }
-                else {
-                    log.trace("[operate] Calling OpenAI Responses API");
-                }
-                // Execute beforeEachModelRequest hook if defined
-                if (options.hooks?.beforeEachModelRequest) {
-                    await core.resolveValue(options.hooks.beforeEachModelRequest({
-                        input,
-                        options,
-                        providerRequest: requestOptions,
-                    }));
+        // 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;
                 }
-                // Use type assertion to handle the OpenAI SDK response type
-                log.trace.var({ "openai.responses.create": requestOptions });
-                const currentResponse = (await openai.responses.create(
-                // @ts-expect-error error claims missing non-required id, status
-                requestOptions));
-                if (retryCount > 0) {
-                    log.debug(`OpenAI API call succeeded after ${retryCount} retries`);
+            }
+        }
+        // Add 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,
+                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.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;
+    }
+    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) {
+            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 || "{}");
                 }
-                // 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,
-                    });
+                catch {
+                    responseData = { result: message.output };
                 }
-                // 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,
-                    }));
+                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]);
                 }
-                // 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
+            });
+            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;
                 }
-                catch (error) {
-                    // If there's an error processing the response, log it but don't fail
-                    // This helps with test mocks that might not have the expected structure
-                    log.warn("Error processing response for function calls");
-                    log.var({ error });
-                }
-                // Set content using the shared extraction function
-                returnResponse.content = extractContentFromResponse(currentResponse, options);
-                // If there's no function call or we can't take another turn, exit the loop
-                if (!hasFunctionCall || !enableMultipleTurns) {
-                    returnResponse.status = LlmResponseStatus.Completed;
-                    return returnResponse;
-                }
-                // If we've reached the maximum number of turns, exit the loop
-                if (currentTurn >= maxTurns) {
-                    const error = new errors.TooManyRequestsError();
-                    const detail = `Model requested function call but exceeded ${maxTurns} turns`;
-                    log.warn(detail);
-                    returnResponse.status = LlmResponseStatus.Incomplete;
-                    returnResponse.error = {
-                        detail,
-                        status: error.status,
-                        title: error.title,
-                    };
-                    return returnResponse;
-                }
-                // Continue to next turn
-                break;
             }
-            catch (error) {
-                // Check if we've reached the maximum number of retries
-                if (retryCount >= maxRetries) {
-                    log.error(`OpenAI API call failed after ${maxRetries} retries`);
-                    log.var({ error });
-                    // Execute onUnrecoverableModelError hook if defined
-                    if (options.hooks?.onUnrecoverableModelError) {
-                        await core.resolveValue(options.hooks.onUnrecoverableModelError({
-                            input,
-                            options,
-                            providerRequest: requestOptions,
-                            error,
-                        }));
+            // 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();
+
+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"`,
+                        };
                     }
-                    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;
-                    }
+            }
+            // 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 (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,
-                        }));
+                if (tool.message) {
+                    if (typeof tool.message === "string") {
+                        log.trace("[Toolkit] Tool provided string message");
+                        message = tool.message;
                     }
-                    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;
+                    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);
                     }
                 }
-                if (isUnknownError) {
-                    log.warn("OpenAI API returned unknown error");
-                    log.var({ error });
+                else {
+                    log.trace("[Toolkit] Log tool call with default message");
+                    message = `${tool.name}:${JSON.stringify(parsedArgs)}`;
                 }
-                // 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,
-                    }));
+                if (typeof this.log === "function") {
+                    log.trace("[Toolkit] Log tool call with custom logger");
+                    await core.resolveValue(this.log(message, context));
+                }
+                else {
+                    log.trace("[Toolkit] Log tool call with default logger");
+                    logToolMessage(message, context);
                 }
-                // 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 (error) {
+                log.error("[Toolkit] Caught error during logToolCall");
+                log.var({ error });
+                log.debug("[Toolkit] Continuing...");
             }
         }
+        return await core.resolveValue(tool.call(parsedArgs));
     }
-    // * All possible paths should return a response; getting here is an error
-    // The main loop is `currentTurn < maxTurns` and `currentTurn >= maxTurns` within the loop returns
-    log.warn("This should never happen");
-    returnResponse.status = LlmResponseStatus.Incomplete;
-    // Always return the full LlmOperateResponse object for consistency
-    return returnResponse;
-}
-
-// Logger
-const getLogger$1 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
-// Client initialization
-async function initializeClient$1({ apiKey, } = {}) {
-    const logger = getLogger$1();
-    const resolvedApiKey = apiKey || (await aws.getEnvSecret("OPENAI_API_KEY"));
-    if (!resolvedApiKey) {
-        throw new core.ConfigurationError("The application could not resolve the requested keys");
-    }
-    const client = new openai.OpenAI({ apiKey: resolvedApiKey });
-    logger.trace("Initialized OpenAI client");
-    return client;
-}
-function formatSystemMessage$1(systemPrompt, { data, placeholders } = {}) {
-    const content = placeholders?.system === false
-        ? systemPrompt
-        : core.placeholders(systemPrompt, data);
-    return {
-        role: "developer",
-        content,
-    };
-}
-function formatUserMessage$1(message, { data, placeholders } = {}) {
-    const content = placeholders?.message === false
-        ? message
-        : core.placeholders(message, data);
-    return {
-        role: "user",
-        content,
-    };
-}
-function prepareMessages$1(message, { system, data, placeholders } = {}) {
-    const logger = getLogger$1();
-    const messages = [];
-    if (system) {
-        const systemMessage = formatSystemMessage$1(system, { data, placeholders });
-        messages.push(systemMessage);
-        logger.trace(`System message: ${systemMessage.content?.length} characters`);
-    }
-    const userMessage = formatUserMessage$1(message, { data, placeholders });
-    messages.push(userMessage);
-    logger.trace(`User message: ${userMessage.content?.length} characters`);
-    return messages;
-}
-// Completion requests
-async function createStructuredCompletion$1(client, { messages, responseSchema, model, }) {
-    const logger = getLogger$1();
-    logger.trace("Using structured output");
-    const zodSchema = responseSchema instanceof v4.z.ZodType
-        ? responseSchema
-        : naturalZodSchema(responseSchema);
-    const responseFormat = zod.zodResponseFormat(zodSchema, "response");
-    const jsonSchema = v4.z.toJSONSchema(zodSchema);
-    // Temporary hack because OpenAI requires additional_properties to be false on all objects
-    const checks = [jsonSchema];
-    while (checks.length > 0) {
-        const current = checks[0];
-        if (current.type == "object") {
-            current.additionalProperties = false;
-        }
-        Object.keys(current).forEach((key) => {
-            if (typeof current[key] == "object" && current[key] !== null) {
-                checks.push(current[key]);
+    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`);
+                    }
+                }
+                this._tools[existingIndex] = tool;
             }
-        });
-        checks.shift();
+            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;
     }
-    responseFormat.json_schema.schema = jsonSchema;
-    const completion = await client.beta.chat.completions.parse({
-        messages,
-        model,
-        response_format: responseFormat,
-    });
-    logger.var({ assistantReply: completion.choices[0].message.parsed });
-    return completion.choices[0].message.parsed;
-}
-async function createTextCompletion$1(client, { messages, model, }) {
-    const logger = getLogger$1();
-    logger.trace("Using text output (unstructured)");
-    const completion = await client.chat.completions.create({
-        messages,
-        model,
-    });
-    logger.trace(`Assistant reply: ${completion.choices[0]?.message?.content?.length} characters`);
-    return completion.choices[0]?.message?.content || "";
 }
 
-class OpenAiProvider {
-    constructor(model = PROVIDER.OPENAI.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger$1();
-        this.conversationHistory = [];
-        this.model = model;
-        this.apiKey = apiKey;
+//
+//
+// 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));
+        }
     }
-    async getClient() {
-        if (this._client) {
-            return this._client;
+    /**
+     * Execute the onRetryableModelError hook if defined
+     */
+    async runOnRetryableError(hooks, context) {
+        if (hooks?.onRetryableModelError) {
+            await core.resolveValue(hooks.onRetryableModelError(context));
         }
-        this._client = await initializeClient$1({ apiKey: this.apiKey });
-        return this._client;
     }
-    async send(message, options) {
-        const client = await this.getClient();
-        const messages = prepareMessages$1(message, options || {});
-        const modelToUse = options?.model || this.model;
-        if (options?.response) {
-            return createStructuredCompletion$1(client, {
-                messages,
-                responseSchema: options.response,
-                model: modelToUse,
-            });
+    /**
+     * Execute the onUnrecoverableModelError hook if defined
+     */
+    async runOnUnrecoverableError(hooks, context) {
+        if (hooks?.onUnrecoverableModelError) {
+            await core.resolveValue(hooks.onUnrecoverableModelError(context));
         }
-        return createTextCompletion$1(client, {
-            messages,
-            model: modelToUse,
-        });
     }
-    async operate(input, options = {}) {
-        const client = await this.getClient();
-        options.model = options?.model || this.model;
-        // Create a merged history including both the tracked history and any explicitly provided history
-        const mergedOptions = { ...options };
-        if (this.conversationHistory.length > 0) {
-            // If options.history exists, merge with instance history, otherwise use instance history
-            mergedOptions.history = options.history
-                ? [...this.conversationHistory, ...options.history]
-                : [...this.conversationHistory];
+}
+// 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);
         }
-        // Call operate with the updated options
-        const response = await operate$1(input, mergedOptions, { client });
-        // Update conversation history with the new history from the response
-        if (response.history && response.history.length > 0) {
-            this.conversationHistory = response.history;
+        return {
+            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;
         }
-        return response;
+        // 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();
 
-// 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,
-        });
+//
+//
+// 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;
     }
-    if (options?.instructions) {
-        llmInstructions =
-            options.data && options.placeholders?.instructions !== false
-                ? core.placeholders(options.instructions, options.data)
-                : options.instructions;
+    /**
+     * Build and return the final response object
+     */
+    build() {
+        return { ...this.response };
     }
-    if (options?.system) {
-        systemPrompt =
-            options.data && options.placeholders?.system !== false
-                ? core.placeholders(options.system, options.data)
-                : options.system;
+}
+/**
+ * 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;
     }
-    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;
+// 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`);
+                }
+                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();
+                }
+                // 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();
+                }
+                // 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 });
+                }
+                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++;
+            }
+        }
+    }
 }
-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);
+
+//
+//
+// Constants
+//
+const ERROR = {
+    BAD_FUNCTION_CALL: "Bad Function Call",
+};
+//
+//
+// Helpers
+//
+/**
+ * Create an ErrorClassifier from a ProviderAdapter
+ */
+function createErrorClassifier(adapter) {
     return {
-        //model: model,
-        //provider: PROVIDER.ANTHROPIC,
-        error: {
-            detail,
-            status: error.status,
-            title: error.title,
+        isRetryable: (error) => adapter.isRetryableError(error),
+        isKnownError: (error) => {
+            const classified = adapter.classifyError(error);
+            return classified.category !== "unknown";
         },
-        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
+//
+//
+// 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,
+            };
         }
-        else {
-            // Convert NaturalSchema to JSON schema through Zod
-            const zodSchema = format instanceof v4.z.ZodType
-                ? format
-                : naturalZodSchema(format);
-            schema = v4.z.toJSONSchema(zodSchema);
+        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 });
+            }
         }
-        if (schema.$schema) {
-            delete schema.$schema; // Hack to fix issue with validator
+        // Format output schema through adapter if provided
+        let formattedFormat;
+        if (options.format) {
+            formattedFormat = this.adapter.formatOutputSchema(options.format);
         }
-        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;
-        });
+        // Format tools through adapter
+        const formattedTools = toolkit
+            ? this.adapter.formatTools(toolkit, formattedFormat)
+            : undefined;
+        return {
+            currentInput: processedInput.history,
+            currentTurn: 0,
+            formattedFormat,
+            formattedTools,
+            maxTurns,
+            responseBuilder,
+            toolkit,
+        };
     }
-    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",
-        });
+    createContext(options) {
+        return {
+            hooks: options.hooks ?? {},
+            options,
+        };
     }
-    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;
+    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,
+        };
     }
-    if (hooks?.beforeEachTool) {
-        await hooks.beforeEachTool({
-            toolName: toolUse.name,
-            args: JSON.stringify(toolUse.input),
+    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,
         });
-    }
-    let result;
-    try {
-        result = await toolkit?.call({
-            name: toolUse.name,
-            arguments: JSON.stringify(toolUse.input),
+        // Build provider-specific request
+        const providerRequest = this.adapter.buildRequest(request);
+        // Execute beforeEachModelRequest hook
+        await this.hookRunnerInstance.runBeforeModelRequest(context.hooks, {
+            input: state.currentInput,
+            options,
+            providerRequest,
         });
-    }
-    catch (error) {
-        if (hooks?.onToolError) {
-            await hooks.onToolError({
-                error: error,
-                toolName: toolUse.name,
-                args: JSON.stringify(toolUse.input),
-            });
+        // 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 });
+                    }
+                }
+                // 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 ${state.maxTurns} turns`;
+                    log$1.warn(detail);
+                    state.responseBuilder.setError({
+                        detail,
+                        status: error.status,
+                        title: error.title,
+                    });
+                    state.responseBuilder.incomplete();
+                    return false; // Stop loop
+                }
+                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 || "",
+                    });
+                }
+            }
         }
-        throw error;
+        return history;
     }
-    if (hooks?.afterEachTool) {
-        await hooks.afterEachTool({
-            result,
-            toolName: toolUse.name,
-            args: JSON.stringify(toolUse.input),
-        });
+    /**
+     * 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);
+        }
     }
-    inputMessages.push({
-        role: PROVIDER.ANTHROPIC.ROLE.USER,
-        content: [
-            {
-                type: "tool_result",
-                content: JSON.stringify(result),
-                tool_use_id: toolUse.id,
-            },
-        ],
-    });
-    return false;
 }
 //
 //
-// Main
+// Factory
 //
-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],
-    };
+/**
+ * Create an OperateLoop instance with the specified configuration.
+ */
+function createOperateLoop(config) {
+    return new OperateLoop(config);
 }
 
 // Logger
-const getLogger = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+const getLogger$2 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
 // Client initialization
-async function initializeClient({ apiKey, } = {}) {
-    const logger = getLogger();
+async function initializeClient$2({ apiKey, } = {}) {
+    const logger = getLogger$2();
     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");
@@ -1600,12 +2721,12 @@ async function initializeClient({ apiKey, } = {}) {
     return client;
 }
 // Message formatting functions
-function formatSystemMessage(systemPrompt, { data, placeholders } = {}) {
+function formatSystemMessage$1(systemPrompt, { data, placeholders } = {}) {
     return placeholders?.system === false
         ? systemPrompt
         : core.placeholders(systemPrompt, data);
 }
-function formatUserMessage(message, { data, placeholders } = {}) {
+function formatUserMessage$2(message, { data, placeholders } = {}) {
     const content = placeholders?.message === false
         ? message
         : core.placeholders(message, data);
@@ -1614,17 +2735,17 @@ function formatUserMessage(message, { data, placeholders } = {}) {
         content,
     };
 }
-function prepareMessages(message, { data, placeholders } = {}) {
-    const logger = getLogger();
+function prepareMessages$2(message, { data, placeholders } = {}) {
+    const logger = getLogger$2();
     const messages = [];
     // Add user message (necessary for all requests)
-    const userMessage = formatUserMessage(message, { data, placeholders });
+    const userMessage = formatUserMessage$2(message, { data, placeholders });
     messages.push(userMessage);
     logger.trace(`User message: ${userMessage.content.length} characters`);
     return messages;
 }
 // Basic text completion
-async function createTextCompletion(client, messages, model, systemMessage) {
+async function createTextCompletion$1(client, messages, model, systemMessage) {
     core.log.trace("Using text output (unstructured)");
     const params = {
         model,
@@ -1643,7 +2764,7 @@ async function createTextCompletion(client, messages, model, systemMessage) {
     return text;
 }
 // Structured output completion
-async function createStructuredCompletion(client, messages, model, responseSchema, systemMessage) {
+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
@@ -1704,7 +2825,7 @@ async function createStructuredCompletion(client, messages, model, responseSchem
 // Main class implementation
 class AnthropicProvider {
     constructor(model = PROVIDER.ANTHROPIC.MODEL.DEFAULT, { apiKey } = {}) {
-        this.log = getLogger();
+        this.log = getLogger$2();
         this.conversationHistory = [];
         this.model = model;
         this.apiKey = apiKey;
@@ -1713,40 +2834,314 @@ class AnthropicProvider {
         if (this._client) {
             return this._client;
         }
-        this._client = await initializeClient({ apiKey: this.apiKey });
+        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: anthropicAdapter,
+            client,
+        });
+        return this._operateLoop;
+    }
     // Main send method
     async send(message, options) {
         const client = await this.getClient();
-        const messages = prepareMessages(message, options || {});
+        const messages = prepareMessages$2(message, options || {});
         const modelToUse = options?.model || this.model;
         // Process system message if provided
         let systemMessage;
         if (options?.system) {
-            systemMessage = formatSystemMessage(options.system, {
+            systemMessage = formatSystemMessage$1(options.system, {
                 data: options.data,
                 placeholders: options.placeholders,
             });
         }
         if (options?.response) {
-            return createStructuredCompletion(client, messages, modelToUse, options.response, systemMessage);
+            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$1 = () => core.log.lib({ lib: core.JAYPIE.LIB.LLM });
+// Client initialization
+async function initializeClient$1({ apiKey, } = {}) {
+    const logger = getLogger$1();
+    const resolvedApiKey = apiKey || (await aws.getEnvSecret("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$1(message, { data, placeholders } = {}) {
+    const content = placeholders?.message === false
+        ? message
+        : core.placeholders(message, data);
+    return {
+        role: "user",
+        content,
+    };
+}
+function prepareMessages$1(message, { data, placeholders } = {}) {
+    const logger = getLogger$1();
+    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$1(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$1();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient$1({ apiKey: this.apiKey });
+        return this._client;
+    }
+    async 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$1(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 {
+                return text || "";
+            }
         }
-        return createTextCompletion(client, messages, modelToUse, systemMessage);
+        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;
+    }
+}
+
+// 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("OPENAI_API_KEY"));
+    if (!resolvedApiKey) {
+        throw new core.ConfigurationError("The application could not resolve the requested keys");
+    }
+    const client = new openai.OpenAI({ apiKey: resolvedApiKey });
+    logger.trace("Initialized OpenAI client");
+    return client;
+}
+function formatSystemMessage(systemPrompt, { data, placeholders } = {}) {
+    const content = placeholders?.system === false
+        ? systemPrompt
+        : core.placeholders(systemPrompt, data);
+    return {
+        role: "developer",
+        content,
+    };
+}
+function formatUserMessage(message, { data, placeholders } = {}) {
+    const content = placeholders?.message === false
+        ? message
+        : core.placeholders(message, data);
+    return {
+        role: "user",
+        content,
+    };
+}
+function prepareMessages(message, { system, data, placeholders } = {}) {
+    const logger = getLogger();
+    const messages = [];
+    if (system) {
+        const systemMessage = formatSystemMessage(system, { data, placeholders });
+        messages.push(systemMessage);
+        logger.trace(`System message: ${systemMessage.content?.length} characters`);
+    }
+    const userMessage = formatUserMessage(message, { data, placeholders });
+    messages.push(userMessage);
+    logger.trace(`User message: ${userMessage.content?.length} characters`);
+    return messages;
+}
+// Completion requests
+async function createStructuredCompletion(client, { messages, responseSchema, model, }) {
+    const logger = getLogger();
+    logger.trace("Using structured output");
+    const zodSchema = responseSchema instanceof v4.z.ZodType
+        ? responseSchema
+        : naturalZodSchema(responseSchema);
+    const responseFormat = zod.zodResponseFormat(zodSchema, "response");
+    const jsonSchema = v4.z.toJSONSchema(zodSchema);
+    // Temporary hack because OpenAI requires additional_properties to be false on all objects
+    const checks = [jsonSchema];
+    while (checks.length > 0) {
+        const current = checks[0];
+        if (current.type == "object") {
+            current.additionalProperties = false;
+        }
+        Object.keys(current).forEach((key) => {
+            if (typeof current[key] == "object" && current[key] !== null) {
+                checks.push(current[key]);
+            }
+        });
+        checks.shift();
+    }
+    responseFormat.json_schema.schema = jsonSchema;
+    const completion = await client.chat.completions.parse({
+        messages,
+        model,
+        response_format: responseFormat,
+    });
+    logger.var({ assistantReply: completion.choices[0].message.parsed });
+    return completion.choices[0].message.parsed;
+}
+async function createTextCompletion(client, { messages, model, }) {
+    const logger = getLogger();
+    logger.trace("Using text output (unstructured)");
+    const completion = await client.chat.completions.create({
+        messages,
+        model,
+    });
+    logger.trace(`Assistant reply: ${completion.choices[0]?.message?.content?.length} characters`);
+    return completion.choices[0]?.message?.content || "";
+}
+
+class OpenAiProvider {
+    constructor(model = PROVIDER.OPENAI.MODEL.DEFAULT, { apiKey } = {}) {
+        this.log = getLogger();
+        this.conversationHistory = [];
+        this.model = model;
+        this.apiKey = apiKey;
+    }
+    async getClient() {
+        if (this._client) {
+            return this._client;
+        }
+        this._client = await initializeClient({ apiKey: this.apiKey });
+        return this._client;
+    }
+    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();
-        options.model = options?.model || this.model;
+        const messages = prepareMessages(message, options || {});
+        const modelToUse = options?.model || this.model;
+        if (options?.response) {
+            return createStructuredCompletion(client, {
+                messages,
+                responseSchema: options.response,
+                model: modelToUse,
+            });
+        }
+        return createTextCompletion(client, {
+            messages,
+            model: modelToUse,
+        });
+    }
+    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
-        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 +3188,16 @@ 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 });
             default:
                 throw new errors.ConfigurationError(`Unsupported provider: ${providerName}`);
         }
@@ -1940,11 +3339,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,6 +3518,18 @@ 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;