@jaypie/llm 1.2.1 → 1.2.2

package/dist/esm/index.js

@@ -5,7 +5,10 @@ import { log as log$2 } from '@jaypie/logger';
 import RandomLib from 'random';
 import { RateLimitError, APIConnectionError, APIConnectionTimeoutError, InternalServerError, APIUserAbortError, AuthenticationError, BadRequestError, ConflictError, NotFoundError, PermissionDeniedError, UnprocessableEntityError, OpenAI } from 'openai';
 import { zodResponseFormat } from 'openai/helpers/zod';
-import { getEnvSecret } from '@jaypie/aws';
+import { PDFDocument } from 'pdf-lib';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { getS3FileBuffer, getEnvSecret } from '@jaypie/aws';
 import { fetchWeatherApi } from 'openmeteo';
 
 const PROVIDER = {
@@ -15,10 +18,10 @@ const PROVIDER = {
         // The model format is: provider/model-name (e.g., "openai/gpt-4", "anthropic/claude-3-opus")
         MODEL: {
             // Default uses env var OPENROUTER_MODEL if set, otherwise a reasonable default
-            DEFAULT: "openai/gpt-4o",
-            SMALL: "openai/gpt-4o-mini",
-            LARGE: "anthropic/claude-3-opus",
-            TINY: "openai/gpt-4o-mini",
+            DEFAULT: "z-ai/glm-4.7",
+            SMALL: "z-ai/glm-4.7",
+            LARGE: "z-ai/glm-4.7",
+            TINY: "z-ai/glm-4.7",
         },
         MODEL_MATCH_WORDS: ["openrouter"],
         NAME: "openrouter",
@@ -33,20 +36,23 @@ const PROVIDER = {
         // 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",
+            DEFAULT: "gemini-3-pro-preview",
+            LARGE: "gemini-3-pro-preview",
+            SMALL: "gemini-3-flash-preview",
             TINY: "gemini-2.0-flash-lite",
+            // Gemini 3 Models
+            GEMINI_3_FLASH_PREVIEW: "gemini-3-flash-preview",
+            GEMINI_3_PRO_PREVIEW: "gemini-3-pro-preview",
             // Gemini 2.5 Models
-            GEMINI_2_5_PRO: "gemini-2.5-pro",
             GEMINI_2_5_FLASH: "gemini-2.5-flash",
+            GEMINI_2_5_PRO: "gemini-2.5-pro",
             // 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",
+            GEMINI_1_5_PRO: "gemini-1.5-pro",
         },
         MODEL_MATCH_WORDS: ["gemini", "google"],
         NAME: "gemini",
@@ -110,10 +116,10 @@ const PROVIDER = {
         // https://platform.openai.com/docs/models
         MODEL: {
             // Jaypie Aliases
-            DEFAULT: "gpt-5",
-            SMALL: "gpt-5-mini",
-            LARGE: "gpt-5",
-            TINY: "gpt-5-nano",
+            DEFAULT: "gpt-4.1",
+            SMALL: "gpt-4.1-mini",
+            LARGE: "gpt-4.1",
+            TINY: "gpt-4.1-nano",
             // OpenAI Official
             GPT_5: "gpt-5",
             GPT_5_MINI: "gpt-5-mini",
@@ -365,6 +371,76 @@ var LlmStreamChunkType;
     LlmStreamChunkType["ToolResult"] = "tool_result";
 })(LlmStreamChunkType || (LlmStreamChunkType = {}));
 
+/**
+ * Type guard to check if an item is a dedicated reasoning item (OpenAI)
+ */
+function isReasoningItem(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        item.type === "reasoning");
+}
+/**
+ * Type guard to check if an item is a thinking item (Anthropic)
+ */
+function isThinkingItem(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        item.type === "thinking" &&
+        typeof item.thinking === "string");
+}
+/**
+ * Type guard to check if an item has a reasoning property
+ */
+function hasReasoningProperty(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        typeof item.reasoning === "string" &&
+        item.reasoning !== "");
+}
+/**
+ * Extracts reasoning text from LLM history items.
+ *
+ * Reasoning items may have text in different locations depending on the provider:
+ * - OpenAI: `summary` array with objects containing `text` property (type: "reasoning")
+ * - OpenAI: `content` property on reasoning items (type: "reasoning")
+ * - Anthropic: `thinking` property on thinking items (type: "thinking")
+ * - OpenRouter/z-ai: `reasoning` property on message items
+ *
+ * @param history - The LLM history array to extract reasoning from
+ * @returns Array of reasoning text strings
+ */
+function extractReasoning(history) {
+    const reasoningTexts = [];
+    for (const item of history) {
+        // Cast to unknown first for type checking
+        const entry = item;
+        // Handle dedicated reasoning items (OpenAI extended thinking)
+        if (isReasoningItem(entry)) {
+            // Handle summary array format
+            if (Array.isArray(entry.summary)) {
+                for (const summaryItem of entry.summary) {
+                    if (summaryItem?.text && typeof summaryItem.text === "string") {
+                        reasoningTexts.push(summaryItem.text);
+                    }
+                }
+            }
+            // Handle direct content format
+            if (entry.content && typeof entry.content === "string") {
+                reasoningTexts.push(entry.content);
+            }
+        }
+        // Handle thinking items (Anthropic extended thinking)
+        if (isThinkingItem(entry)) {
+            reasoningTexts.push(entry.thinking);
+        }
+        // Handle reasoning property on message items (OpenRouter/z-ai format)
+        if (hasReasoningProperty(entry)) {
+            reasoningTexts.push(entry.reasoning);
+        }
+    }
+    return reasoningTexts;
+}
+
 /**
  * Converts a string to a standardized LlmInputMessage
  * @param input - String to format
@@ -717,6 +793,73 @@ var ErrorCategory;
 // Constants
 //
 const STRUCTURED_OUTPUT_TOOL_NAME$2 = "structured_output";
+// Regular expression to parse data URLs: data:mime/type;base64,data
+const DATA_URL_REGEX = /^data:([^;]+);base64,(.+)$/;
+/**
+ * Parse a data URL into its components
+ */
+function parseDataUrl(dataUrl) {
+    const match = dataUrl.match(DATA_URL_REGEX);
+    if (!match)
+        return null;
+    return { mediaType: match[1], data: match[2] };
+}
+/**
+ * Convert standardized content items to Anthropic format
+ */
+function convertContentToAnthropic(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content.map((item) => {
+        // Text content
+        if (item.type === LlmMessageType.InputText) {
+            return { type: "text", text: item.text };
+        }
+        // Image content
+        if (item.type === LlmMessageType.InputImage) {
+            const imageUrl = item.image_url || "";
+            const parsed = parseDataUrl(imageUrl);
+            if (parsed) {
+                return {
+                    type: "image",
+                    source: {
+                        type: "base64",
+                        media_type: parsed.mediaType,
+                        data: parsed.data,
+                    },
+                };
+            }
+            // Fallback for URL-based images (not base64)
+            return {
+                type: "image",
+                source: {
+                    type: "url",
+                    url: imageUrl,
+                },
+            };
+        }
+        // File/Document content (PDF, etc.)
+        if (item.type === LlmMessageType.InputFile) {
+            const fileData = typeof item.file_data === "string" ? item.file_data : "";
+            const parsed = parseDataUrl(fileData);
+            if (parsed) {
+                return {
+                    type: "document",
+                    source: {
+                        type: "base64",
+                        media_type: parsed.mediaType,
+                        data: parsed.data,
+                    },
+                };
+            }
+            // Fallback - return as text with the filename
+            return { type: "text", text: `[File: ${item.filename || "unknown"}]` };
+        }
+        // Unknown type - return as text
+        return { type: "text", text: JSON.stringify(item) };
+    });
+}
 // Error names for classification (using string names since SDK is optional)
 const RETRYABLE_ERROR_NAMES = [
     "APIConnectionError",
@@ -748,7 +891,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
     // Request Building
     //
     buildRequest(request) {
-        // Convert messages to Anthropic format (remove 'type' property)
+        // Convert messages to Anthropic format
         // Filter out system messages - Anthropic only accepts system as a top-level field
         const messages = request.messages
             .filter((msg) => {
@@ -756,9 +899,11 @@ class AnthropicAdapter extends BaseProviderAdapter {
             return role !== "system";
         })
             .map((msg) => {
-            const anthropicMsg = structuredClone(msg);
-            delete anthropicMsg.type;
-            return anthropicMsg;
+            const typedMsg = msg;
+            return {
+                role: typedMsg.role,
+                content: convertContentToAnthropic(typedMsg.content),
+            };
         });
         // Append instructions to last message if provided
         if (request.instructions && messages.length > 0) {
@@ -860,6 +1005,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
         // Track usage for final chunk
         let inputTokens = 0;
         let outputTokens = 0;
+        let thinkingTokens = 0;
         let model = streamRequest.model;
         for await (const event of stream) {
             if (event.type === "message_start") {
@@ -912,6 +1058,11 @@ class AnthropicAdapter extends BaseProviderAdapter {
                 // Extract final usage
                 if (event.usage) {
                     outputTokens = event.usage.output_tokens;
+                    // Check for thinking tokens in extended thinking responses
+                    const extendedUsage = event.usage;
+                    if (extendedUsage.thinking_tokens) {
+                        thinkingTokens = extendedUsage.thinking_tokens;
+                    }
                 }
             }
             else if (event.type === "message_stop") {
@@ -922,7 +1073,7 @@ class AnthropicAdapter extends BaseProviderAdapter {
                         {
                             input: inputTokens,
                             output: outputTokens,
-                            reasoning: 0,
+                            reasoning: thinkingTokens,
                             total: inputTokens + outputTokens,
                             provider: this.name,
                             model,
@@ -964,12 +1115,14 @@ class AnthropicAdapter extends BaseProviderAdapter {
     }
     extractUsage(response, model) {
         const anthropicResponse = response;
+        // Check for thinking tokens in the usage (extended thinking feature)
+        // Anthropic includes thinking tokens in a separate field when enabled
+        const usage = anthropicResponse.usage;
         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,
+            input: usage.input_tokens,
+            output: usage.output_tokens,
+            reasoning: usage.thinking_tokens || 0,
+            total: usage.input_tokens + usage.output_tokens,
             provider: this.name,
             model,
         };
@@ -1010,6 +1163,15 @@ class AnthropicAdapter extends BaseProviderAdapter {
             // Don't add to history yet - will be added after tool execution
             return historyItems;
         }
+        // Include thinking blocks for extended thinking support
+        // Thinking blocks are preserved in history so extractReasoning can find them
+        for (const block of anthropicResponse.content) {
+            if (block.type === "thinking") {
+                // Push raw block - types are loosely checked at runtime
+                // This allows extractReasoning to access the thinking property
+                historyItems.push(block);
+            }
+        }
         // Extract text content for non-tool responses
         const textBlock = anthropicResponse.content.find((block) => block.type === "text");
         if (textBlock) {
@@ -1577,28 +1739,31 @@ class GeminiAdapter extends BaseProviderAdapter {
             // 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);
+                const parts = this.convertContentToParts(message.content);
                 contents.push({
                     role,
-                    parts: [{ text: content }],
+                    parts,
                 });
             }
             // Handle function call items
             else if ("type" in message &&
                 message.type === LlmMessageType.FunctionCall) {
+                // Build the function call part, including thoughtSignature if present
+                // (required for Gemini 3 models)
+                const functionCallPart = {
+                    functionCall: {
+                        name: message.name,
+                        args: JSON.parse(message.arguments || "{}"),
+                        id: message.call_id,
+                    },
+                };
+                // Preserve thoughtSignature for Gemini 3 models
+                if (message.thoughtSignature) {
+                    functionCallPart.thoughtSignature = message.thoughtSignature;
+                }
                 contents.push({
                     role: "model",
-                    parts: [
-                        {
-                            functionCall: {
-                                name: message.name,
-                                args: JSON.parse(message.arguments || "{}"),
-                                id: message.call_id,
-                            },
-                        },
-                    ],
+                    parts: [functionCallPart],
                 });
             }
             // Handle function call output items
@@ -1627,6 +1792,91 @@ class GeminiAdapter extends BaseProviderAdapter {
         }
         return contents;
     }
+    convertContentToParts(content) {
+        // Handle string content
+        if (typeof content === "string") {
+            return [{ text: content }];
+        }
+        // Handle array content
+        if (Array.isArray(content)) {
+            const parts = [];
+            for (const item of content) {
+                // Handle Gemini-native parts (already have inlineData, text, etc.)
+                if (item.inlineData) {
+                    parts.push({ inlineData: item.inlineData });
+                    continue;
+                }
+                if (item.text && !item.type) {
+                    // Plain text part
+                    parts.push({ text: item.text });
+                    continue;
+                }
+                if (item.fileData) {
+                    parts.push({ fileData: item.fileData });
+                    continue;
+                }
+                // Handle standardized LlmInputContentText
+                if (item.type === LlmMessageType.InputText) {
+                    parts.push({ text: item.text });
+                    continue;
+                }
+                // Handle standardized LlmInputContentImage
+                if (item.type === LlmMessageType.InputImage) {
+                    const imageUrl = item.image_url;
+                    // Parse data URL format: data:image/png;base64,<data>
+                    if (imageUrl?.startsWith("data:")) {
+                        const match = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
+                        if (match) {
+                            parts.push({
+                                inlineData: {
+                                    mimeType: match[1],
+                                    data: match[2],
+                                },
+                            });
+                            continue;
+                        }
+                    }
+                    // If not a data URL, try to use as file URI
+                    if (imageUrl) {
+                        parts.push({
+                            fileData: {
+                                mimeType: "image/png",
+                                fileUri: imageUrl,
+                            },
+                        });
+                    }
+                    continue;
+                }
+                // Handle standardized LlmInputContentFile
+                if (item.type === LlmMessageType.InputFile) {
+                    const fileData = item.file_data;
+                    // Parse data URL format: data:application/pdf;base64,<data>
+                    if (fileData?.startsWith("data:")) {
+                        const match = fileData.match(/^data:([^;]+);base64,(.+)$/);
+                        if (match) {
+                            parts.push({
+                                inlineData: {
+                                    mimeType: match[1],
+                                    data: match[2],
+                                },
+                            });
+                            continue;
+                        }
+                    }
+                    // If not a data URL, just add as text (fallback)
+                    if (typeof fileData === "string") {
+                        parts.push({ text: `[File: ${item.filename || "unknown"}]` });
+                    }
+                    continue;
+                }
+                // Fallback: stringify unknown content
+                parts.push({ text: JSON.stringify(item) });
+            }
+            return parts;
+        }
+        // Fallback for other types
+        return [{ text: JSON.stringify(content) }];
+    }
     mapRole(role) {
         switch (role) {
             case LlmMessageRole.User:
@@ -1684,6 +1934,28 @@ class GeminiAdapter extends BaseProviderAdapter {
 // Export singleton instance
 const geminiAdapter = new GeminiAdapter();
 
+// OpenAI reasoning models that support extended thinking
+const REASONING_MODELS = [
+    // GPT-5 series
+    PROVIDER.OPENAI.MODEL.GPT_5,
+    PROVIDER.OPENAI.MODEL.GPT_5_MINI,
+    PROVIDER.OPENAI.MODEL.GPT_5_NANO,
+    // O-series
+    PROVIDER.OPENAI.MODEL.O1,
+    PROVIDER.OPENAI.MODEL.O1_MINI,
+    PROVIDER.OPENAI.MODEL.O1_PRO,
+    PROVIDER.OPENAI.MODEL.O3,
+    PROVIDER.OPENAI.MODEL.O3_MINI,
+    PROVIDER.OPENAI.MODEL.O3_MINI_HIGH,
+    PROVIDER.OPENAI.MODEL.O3_PRO,
+    PROVIDER.OPENAI.MODEL.O4_MINI,
+];
+/**
+ * Check if a model is a reasoning model that supports extended thinking
+ */
+function isReasoningModel(model) {
+    return REASONING_MODELS.some((reasoningModel) => model === reasoningModel || model.startsWith(`${reasoningModel}-`));
+}
 //
 //
 // Constants
@@ -1722,8 +1994,9 @@ class OpenAiAdapter extends BaseProviderAdapter {
     // Request Building
     //
     buildRequest(request) {
+        const model = request.model || this.defaultModel;
         const openaiRequest = {
-            model: request.model || this.defaultModel,
+            model,
             input: request.messages,
         };
         if (request.user) {
@@ -1745,6 +2018,13 @@ class OpenAiAdapter extends BaseProviderAdapter {
                 format: request.format,
             };
         }
+        // Enable reasoning summary for reasoning models (o1, o3, etc.)
+        // This allows us to extract reasoning text from the response
+        if (isReasoningModel(model)) {
+            openaiRequest.reasoning = {
+                summary: "auto",
+            };
+        }
         if (request.providerOptions) {
             Object.assign(openaiRequest, request.providerOptions);
         }
@@ -1868,7 +2148,8 @@ class OpenAiAdapter extends BaseProviderAdapter {
                 if (response?.usage) {
                     inputTokens = response.usage.input_tokens || 0;
                     outputTokens = response.usage.output_tokens || 0;
-                    reasoningTokens = response.usage.output_tokens_details?.reasoning_tokens || 0;
+                    reasoningTokens =
+                        response.usage.output_tokens_details?.reasoning_tokens || 0;
                 }
             }
             else if (eventType === "response.done") {
@@ -2087,6 +2368,41 @@ const openAiAdapter = new OpenAiAdapter();
 // Constants
 //
 const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
+/**
+ * Convert standardized content items to OpenRouter format
+ * Note: OpenRouter does not support native file/image uploads.
+ * Images and files are discarded with a warning.
+ */
+function convertContentToOpenRouter(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    const parts = [];
+    for (const item of content) {
+        // Text content - pass through
+        if (item.type === LlmMessageType.InputText) {
+            parts.push({ type: "text", text: item.text });
+            continue;
+        }
+        // Image content - warn and discard
+        if (item.type === LlmMessageType.InputImage) {
+            log$2.warn("OpenRouter does not support image uploads; image discarded");
+            continue;
+        }
+        // File/Document content - warn and discard
+        if (item.type === LlmMessageType.InputFile) {
+            log$2.warn({ filename: item.filename }, "OpenRouter does not support file uploads; file discarded");
+            continue;
+        }
+        // Unknown type - warn and skip
+        log$2.warn({ item }, "Unknown content type for OpenRouter; discarded");
+    }
+    // If no text parts remain, return empty string to avoid empty array
+    if (parts.length === 0) {
+        return "";
+    }
+    return parts;
+}
 // OpenRouter SDK error types based on HTTP status codes
 const RETRYABLE_STATUS_CODES = [408, 500, 502, 503, 524, 529];
 const RATE_LIMIT_STATUS_CODE = 429;
@@ -2135,9 +2451,9 @@ class OpenRouterAdapter extends BaseProviderAdapter {
                     parameters: tool.parameters,
                 },
             }));
-            // Determine tool choice based on whether structured output is requested
-            const hasStructuredOutput = request.tools.some((t) => t.name === STRUCTURED_OUTPUT_TOOL_NAME);
-            openRouterRequest.tool_choice = hasStructuredOutput ? "required" : "auto";
+            // Use "auto" for tool_choice - many OpenRouter models don't support "required"
+            // The structured_output tool prompt already emphasizes it must be called
+            openRouterRequest.tool_choice = "auto";
         }
         if (request.providerOptions) {
             Object.assign(openRouterRequest, request.providerOptions);
@@ -2358,7 +2674,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         return {
             input: usage.promptTokens || usage.prompt_tokens || 0,
             output: usage.completionTokens || usage.completion_tokens || 0,
-            reasoning: 0, // OpenRouter doesn't expose reasoning tokens in standard format
+            reasoning: usage.completionTokensDetails?.reasoningTokens || 0,
             total: usage.totalTokens || usage.total_tokens || 0,
             provider: this.name,
             model,
@@ -2404,11 +2720,16 @@ class OpenRouterAdapter extends BaseProviderAdapter {
         }
         // Extract text content for non-tool responses
         if (choice.message.content) {
-            historyItems.push({
+            const historyItem = {
                 content: choice.message.content,
                 role: LlmMessageRole.Assistant,
                 type: LlmMessageType.Message,
-            });
+            };
+            // Preserve reasoning if present (z-ai/glm models include this)
+            if (choice.message.reasoning) {
+                historyItem.reasoning = choice.message.reasoning;
+            }
+            historyItems.push(historyItem);
         }
         return historyItems;
     }
@@ -2542,7 +2863,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
             else if (message.role === "user") {
                 openRouterMessages.push({
                     role: "user",
-                    content: message.content,
+                    content: convertContentToOpenRouter(message.content),
                 });
             }
             else if (message.role === "assistant") {
@@ -2578,7 +2899,7 @@ class OpenRouterAdapter extends BaseProviderAdapter {
                 else {
                     openRouterMessages.push({
                         role: "user",
-                        content: message.content,
+                        content: convertContentToOpenRouter(message.content),
                     });
                 }
             }
@@ -2785,6 +3106,265 @@ class HookRunner {
 // Export singleton instance for convenience
 const hookRunner = new HookRunner();
 
+/**
+ * Type guard to check if an item is an LlmOperateInputFile
+ */
+function isLlmOperateInputFile(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        "file" in item &&
+        typeof item.file === "string");
+}
+/**
+ * Type guard to check if an item is an LlmOperateInputImage
+ */
+function isLlmOperateInputImage(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        "image" in item &&
+        typeof item.image === "string");
+}
+/**
+ * Type guard to check if an item is an LlmOperateInputContent
+ */
+function isLlmOperateInputContent(item) {
+    return (typeof item === "string" ||
+        isLlmOperateInputFile(item) ||
+        isLlmOperateInputImage(item));
+}
+/**
+ * Type guard to check if input is an LlmOperateInput array
+ */
+function isLlmOperateInput(input) {
+    return (Array.isArray(input) &&
+        input.length > 0 &&
+        input.every(isLlmOperateInputContent));
+}
+
+/**
+ * Image extensions that are auto-detected from file paths
+ */
+const IMAGE_EXTENSIONS = new Set([
+    "avif",
+    "bmp",
+    "gif",
+    "ico",
+    "jpeg",
+    "jpg",
+    "png",
+    "svg",
+    "tiff",
+    "webp",
+]);
+/**
+ * Mapping of file extensions to MIME types
+ */
+const EXTENSION_TO_MIME = {
+    // Images
+    avif: "image/avif",
+    bmp: "image/bmp",
+    gif: "image/gif",
+    ico: "image/x-icon",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    png: "image/png",
+    svg: "image/svg+xml",
+    tiff: "image/tiff",
+    webp: "image/webp",
+    // Documents
+    pdf: "application/pdf",
+    // Text
+    json: "application/json",
+    txt: "text/plain",
+};
+/**
+ * Extract file extension from a path or filename
+ */
+function getFileExtension(filePath) {
+    const match = filePath.match(/\.(\w+)$/);
+    return match ? match[1].toLowerCase() : undefined;
+}
+/**
+ * Determine MIME type from file extension
+ */
+function getMimeType(filePath) {
+    const ext = getFileExtension(filePath);
+    return ext ? EXTENSION_TO_MIME[ext] : undefined;
+}
+/**
+ * Check if a file path has an image extension
+ */
+function isImageExtension(filePath) {
+    const ext = getFileExtension(filePath);
+    return ext ? IMAGE_EXTENSIONS.has(ext) : false;
+}
+/**
+ * Check if a file path has a PDF extension
+ */
+function isPdfExtension(filePath) {
+    const ext = getFileExtension(filePath);
+    return ext === "pdf";
+}
+
+/**
+ * Extract specific pages from a PDF buffer
+ * @param pdfBytes - Buffer containing the PDF data
+ * @param pages - Array of page numbers to extract (1-indexed)
+ * @returns Buffer containing a new PDF with only the specified pages
+ */
+async function extractPdfPages(pdfBytes, pages) {
+    const pdfDoc = await PDFDocument.load(pdfBytes);
+    const totalPages = pdfDoc.getPageCount();
+    // Validate page numbers
+    for (const pageNum of pages) {
+        if (pageNum < 1 || pageNum > totalPages) {
+            throw new Error(`Page number ${pageNum} is out of range. Document has ${totalPages} pages.`);
+        }
+    }
+    // Create a new PDF with only the specified pages
+    const newPdfDoc = await PDFDocument.create();
+    // Convert 1-indexed page numbers to 0-indexed for pdf-lib
+    const pageIndices = pages.map((p) => p - 1);
+    const copiedPages = await newPdfDoc.copyPages(pdfDoc, pageIndices);
+    for (const page of copiedPages) {
+        newPdfDoc.addPage(page);
+    }
+    const newPdfBytes = await newPdfDoc.save();
+    return Buffer.from(newPdfBytes);
+}
+
+/**
+ * Load a file from the local filesystem
+ * @param filePath - Path to the file (relative paths resolve from process.cwd())
+ * @returns Buffer containing the file contents
+ */
+async function loadLocalFile(filePath) {
+    const absolutePath = resolve(process.cwd(), filePath);
+    return readFile(absolutePath);
+}
+
+/**
+ * Load a file from S3
+ * @param bucket - S3 bucket name
+ * @param key - S3 object key
+ * @returns Buffer containing the file contents
+ */
+async function loadS3File(bucket, key) {
+    return getS3FileBuffer({ bucket, key });
+}
+
+/**
+ * Load file data from source (provided data, S3, or local filesystem)
+ */
+async function loadFileData(item) {
+    // Get the path from either file or image property
+    const path = "file" in item ? item.file : item.image;
+    // Priority 1: Use provided data directly
+    if (item.data) {
+        return Buffer.from(item.data, "base64");
+    }
+    // Priority 2: Load from S3 (explicit bucket or CDK_ENV_BUCKET fallback)
+    const bucket = item.bucket ?? process.env.CDK_ENV_BUCKET;
+    if (bucket) {
+        return loadS3File(bucket, path);
+    }
+    // Priority 3: Load from local filesystem
+    return loadLocalFile(path);
+}
+/**
+ * Resolve a file input to content ready for LLM
+ */
+async function resolveFileInput(item) {
+    let buffer = await loadFileData(item);
+    const mimeType = getMimeType(item.file) || "application/octet-stream";
+    const filename = item.file.split("/").pop() || item.file;
+    // Handle PDF page extraction
+    if (isPdfExtension(item.file) && item.pages && item.pages.length > 0) {
+        buffer = await extractPdfPages(buffer, item.pages);
+    }
+    return {
+        data: buffer.toString("base64"),
+        filename,
+        mimeType,
+    };
+}
+/**
+ * Resolve an image input to content ready for LLM
+ */
+async function resolveImageInput(item) {
+    const buffer = await loadFileData(item);
+    const mimeType = getMimeType(item.image) || "image/png";
+    const filename = item.image.split("/").pop() || item.image;
+    return {
+        data: buffer.toString("base64"),
+        filename,
+        mimeType,
+    };
+}
+/**
+ * Convert resolved content to LlmInputContent
+ */
+function toInputContent(resolved, isImage) {
+    if (isImage) {
+        const imageContent = {
+            image_url: `data:${resolved.mimeType};base64,${resolved.data}`,
+            type: LlmMessageType.InputImage,
+        };
+        return imageContent;
+    }
+    const fileContent = {
+        file_data: `data:${resolved.mimeType};base64,${resolved.data}`,
+        filename: resolved.filename,
+        type: LlmMessageType.InputFile,
+    };
+    return fileContent;
+}
+/**
+ * Resolve a single content item
+ */
+async function resolveContentItem(item) {
+    // String becomes text content
+    if (typeof item === "string") {
+        const textContent = {
+            text: item,
+            type: LlmMessageType.InputText,
+        };
+        return textContent;
+    }
+    // Image input
+    if (isLlmOperateInputImage(item)) {
+        const resolved = await resolveImageInput(item);
+        return toInputContent(resolved, true);
+    }
+    // File input
+    if (isLlmOperateInputFile(item)) {
+        const resolved = await resolveFileInput(item);
+        // Check if the file is actually an image based on extension
+        const isImage = isImageExtension(item.file);
+        return toInputContent(resolved, isImage);
+    }
+    // Fallback - shouldn't reach here if types are correct
+    throw new Error(`Unknown content item type: ${JSON.stringify(item)}`);
+}
+/**
+ * Resolve LlmOperateInput to LlmInputMessage
+ *
+ * This function takes the simplified LlmOperateInput format and resolves
+ * all files/images from their sources (provided data, S3, or local filesystem),
+ * converting them to the standard LlmInputMessage format.
+ *
+ * @param input - LlmOperateInput array
+ * @returns LlmInputMessage ready for LLM providers
+ */
+async function resolveOperateInput(input) {
+    const content = await Promise.all(input.map(resolveContentItem));
+    return {
+        content,
+        role: LlmMessageRole.User,
+        type: LlmMessageType.Message,
+    };
+}
+
 //
 //
 // Main
@@ -2797,13 +3377,18 @@ class InputProcessor {
     /**
      * Process input with placeholders, history merging, and system message handling
      *
-     * @param input - The raw input (string, message, or history)
+     * @param input - The raw input (string, message, history, or LlmOperateInput)
      * @param options - The operate options containing data, history, system, etc.
      * @returns Processed input with all transformations applied
      */
-    process(input, options = {}) {
+    async process(input, options = {}) {
+        // Handle LlmOperateInput by resolving files first
+        let resolvedInput = input;
+        if (isLlmOperateInput(input)) {
+            resolvedInput = await resolveOperateInput(input);
+        }
         // Convert input to history format with placeholder substitution
-        let history = this.formatInputWithPlaceholders(input, options);
+        let history = this.formatInputWithPlaceholders(resolvedInput, options);
         // Process instructions with placeholders
         const instructions = this.processInstructions(options);
         // Process system prompt with placeholders
@@ -2909,6 +3494,7 @@ class ResponseBuilder {
             model: config.model,
             output: [],
             provider: config.provider,
+            reasoning: [],
             responses: [],
             status: LlmResponseStatus.InProgress,
             usage: [],
@@ -2963,6 +3549,26 @@ class ResponseBuilder {
         this.response.output.push(...items);
         return this;
     }
+    /**
+     * Set the reasoning array
+     */
+    setReasoning(reasoning) {
+        this.response.reasoning = reasoning;
+        return this;
+    }
+    /**
+     * Append reasoning text items
+     */
+    appendToReasoning(...items) {
+        this.response.reasoning.push(...items);
+        return this;
+    }
+    /**
+     * Get the current reasoning array
+     */
+    getReasoning() {
+        return this.response.reasoning;
+    }
     /**
      * Add a raw provider response
      */
@@ -3017,9 +3623,14 @@ class ResponseBuilder {
         return this;
     }
     /**
-     * Build and return the final response object
+     * Build and return the final response object.
+     * Automatically extracts reasoning from history if not already set.
      */
     build() {
+        // Extract reasoning from history if not already populated
+        if (this.response.reasoning.length === 0) {
+            this.response.reasoning = extractReasoning(this.response.history);
+        }
         return { ...this.response };
     }
 }
@@ -3200,7 +3811,7 @@ class OperateLoop {
         log$1.var({ "operate.input": input });
         log$1.var({ "operate.options": options });
         // Initialize state
-        const state = this.initializeState(input, options);
+        const state = await this.initializeState(input, options);
         const context = this.createContext(options);
         // Build initial request
         let request = this.buildInitialRequest(state, options);
@@ -3229,9 +3840,9 @@ class OperateLoop {
     //
     // Private Methods
     //
-    initializeState(input, options) {
+    async initializeState(input, options) {
         // Process input with placeholders
-        const processedInput = this.inputProcessorInstance.process(input, options);
+        const processedInput = await this.inputProcessorInstance.process(input, options);
         // Determine max turns
         const maxTurns = maxTurnsFromOptions(options);
         // Initialize response builder
@@ -3259,9 +3870,22 @@ class OperateLoop {
             formattedFormat = this.adapter.formatOutputSchema(options.format);
         }
         // Format tools through adapter
-        const formattedTools = toolkit
-            ? this.adapter.formatTools(toolkit, formattedFormat)
-            : undefined;
+        // If format is provided but no toolkit, create an empty toolkit
+        // so that structured_output tool can be added for providers that need it
+        // (Anthropic, OpenRouter use tool-based structured output)
+        let formattedTools;
+        if (toolkit) {
+            formattedTools = this.adapter.formatTools(toolkit, formattedFormat);
+        }
+        else if (formattedFormat) {
+            // Create empty toolkit just for structured output
+            const emptyToolkit = new Toolkit([]);
+            formattedTools = this.adapter.formatTools(emptyToolkit, formattedFormat);
+            // Only include if there are tools (structured_output was added)
+            if (formattedTools.length === 0) {
+                formattedTools = undefined;
+            }
+        }
         return {
             currentInput: processedInput.history,
             currentTurn: 0,
@@ -3486,12 +4110,16 @@ class OperateLoop {
                 else if (part.functionCall) {
                     // Function call
                     const fc = part.functionCall;
+                    // Preserve thoughtSignature for Gemini 3 models (required for tool calls)
+                    const thoughtSignature = part
+                        .thoughtSignature;
                     history.push({
                         type: LlmMessageType.FunctionCall,
                         name: fc.name || "",
                         arguments: JSON.stringify(fc.args || {}),
                         call_id: fc.id || "",
                         id: fc.id || "",
+                        ...(thoughtSignature && { thoughtSignature }),
                     });
                 }
                 else if (part.functionResponse) {
@@ -3574,7 +4202,7 @@ class StreamLoop {
             throw new BadGatewayError(`Provider ${this.adapter.name} does not support streaming`);
         }
         // Initialize state
-        const state = this.initializeState(input, options);
+        const state = await this.initializeState(input, options);
         const context = this.createContext(options);
         // Build initial request
         let request = this.buildInitialRequest(state, options);
@@ -3629,9 +4257,9 @@ class StreamLoop {
     //
     // Private Methods
     //
-    initializeState(input, options) {
+    async initializeState(input, options) {
         // Process input with placeholders
-        const processedInput = this.inputProcessorInstance.process(input, options);
+        const processedInput = await this.inputProcessorInstance.process(input, options);
         // Determine max turns
         const maxTurns = maxTurnsFromOptions(options);
         // Get toolkit
@@ -4972,5 +5600,5 @@ const toolkit = new JaypieToolkit(tools);
     [LlmMessageRole.Developer]: "user",
 });
 
-export { GeminiProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, toolkit, tools };
+export { GeminiProvider, JaypieToolkit, constants as LLM, Llm, LlmMessageRole, LlmMessageType, LlmStreamChunkType, OpenRouterProvider, Toolkit, extractReasoning, isLlmOperateInput, isLlmOperateInputContent, isLlmOperateInputFile, isLlmOperateInputImage, toolkit, tools };
 //# sourceMappingURL=index.js.map