@standardagents/builder 0.9.17 → 0.10.1-dev.616ec2e

package/dist/index.js

@@ -1,10 +1,16 @@
+import { probe, sip } from '@standardagents/sip';
+import { decode as decode$1, encode } from '@jsquash/png';
+import { decode } from '@jsquash/avif';
 import fs2 from 'fs';
 import path3 from 'path';
 import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
 import { DurableObject } from 'cloudflare:workers';
 
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -12,6 +18,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/agents/types.ts
 var MAX_TURNS, MAX_RETRIES_PER_MODEL, TIMESTAMP_MULTIPLIER, STREAM_COOLDOWN, BACKOFF_BASE;
@@ -250,9 +265,27 @@ var init_BaseProvider = __esm({
       /**
        * Helper: Update log with actual request body before making API call
        * This ensures we have the complete request even if the call fails
+       *
+       * NOTE: Only updates if request_body is NULL - LLMRequest may have already
+       * set a transformed request_body (with image paths instead of base64 data URLs)
+       *
+       * We check if request_body is already set BEFORE serializing to avoid
+       * processing megabytes of base64 image data unnecessarily.
        */
       async logActualRequest(request, logId, state) {
         try {
+          let needsUpdate = false;
+          await state.stream.waitFor(async () => {
+            const result = await state.storage.sql.exec(
+              `SELECT COUNT(*) as cnt FROM logs WHERE id = ?1 AND request_body IS NULL`,
+              logId
+            );
+            const rows = result.toArray();
+            needsUpdate = rows.length > 0 && rows[0].cnt > 0;
+          });
+          if (!needsUpdate) {
+            return;
+          }
           const requestBody = JSON.stringify(request);
           await state.stream.waitFor(async () => {
             await state.storage.sql.exec(
@@ -324,6 +357,81 @@ ${errorStack}` : ""}`,
           console.error(`[${this.name}] Failed to log error:`, logError);
         }
       }
+      /**
+       * Helper: Check if a MIME type is an image
+       */
+      isImageMimeType(mimeType) {
+        return mimeType.startsWith("image/");
+      }
+      /**
+       * Helper: Create image content part for OpenAI/OpenRouter format
+       * Converts base64 data to a data URL
+       */
+      createImageContentPart(base64Data, mimeType, detail = "auto") {
+        const dataUrl = `data:${mimeType};base64,${base64Data}`;
+        return {
+          type: "image_url",
+          image_url: {
+            url: dataUrl,
+            detail
+          }
+        };
+      }
+      /**
+       * Helper: Create text content part
+       */
+      createTextContentPart(text) {
+        return {
+          type: "text",
+          text
+        };
+      }
+      /**
+       * Helper: Convert message content and attachments to multimodal format
+       * Returns multimodal content array if there are images, otherwise returns string
+       *
+       * @param textContent The text content of the message
+       * @param attachments Array of attachment references with resolved base64 data
+       * @returns MessageContent - either string or multimodal array
+       */
+      buildMultimodalContent(textContent, attachments) {
+        if (!attachments || attachments.length === 0) {
+          return textContent || "";
+        }
+        const imageAttachments = attachments.filter(
+          (a) => this.isImageMimeType(a.ref.mimeType)
+        );
+        if (imageAttachments.length === 0) {
+          return textContent || "";
+        }
+        const parts = [];
+        if (textContent) {
+          parts.push(this.createTextContentPart(textContent));
+        }
+        for (const attachment of imageAttachments) {
+          parts.push(
+            this.createImageContentPart(attachment.base64, attachment.ref.mimeType)
+          );
+        }
+        return parts;
+      }
+      /**
+       * Helper: Convert MessageContent to string for logging/display
+       * Extracts text from multimodal content, describes images
+       */
+      contentToString(content) {
+        if (!content) return "";
+        if (typeof content === "string") return content;
+        const parts = [];
+        for (const part of content) {
+          if (part.type === "text") {
+            parts.push(part.text);
+          } else if (part.type === "image_url") {
+            parts.push("[Image]");
+          }
+        }
+        return parts.join(" ");
+      }
     };
   }
 });
@@ -762,6 +870,11 @@ var init_TestScript = __esm({
 });
 
 // src/agents/providers/TestProvider.ts
+function contentToString(content) {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  return content.filter((part) => part.type === "text").map((part) => part.text).join(" ");
+}
 var TestProvider;
 var init_TestProvider = __esm({
   "src/agents/providers/TestProvider.ts"() {
@@ -804,8 +917,9 @@ var init_TestProvider = __esm({
         const responses = this.script.getResponses();
         if (this.responseIndex >= responses.length) {
           const lastMessage = context.messages.slice(-1)[0];
+          const lastContent = contentToString(lastMessage?.content);
           throw new Error(
-            `TestProvider: Script exhausted after ${this.responseIndex} responses. Expected ${responses.length} total requests. Received request with ${context.messages.length} messages. Last message role: "${lastMessage?.role}", content: "${lastMessage?.content?.substring(0, 100)}..."`
+            `TestProvider: Script exhausted after ${this.responseIndex} responses. Expected ${responses.length} total requests. Received request with ${context.messages.length} messages. Last message role: "${lastMessage?.role}", content: "${lastContent.substring(0, 100)}..."`
           );
         }
         const scripted = responses[this.responseIndex];
@@ -882,8 +996,9 @@ var init_TestProvider = __esm({
         if (expectations.containsMessage) {
           const pattern = expectations.containsMessage;
           const found = context.messages.some((m) => {
-            if (!m.content) return false;
-            return typeof pattern === "string" ? m.content.includes(pattern) : pattern.test(m.content);
+            const content = contentToString(m.content);
+            if (!content) return false;
+            return typeof pattern === "string" ? content.includes(pattern) : pattern.test(content);
           });
           if (!found) {
             throw new Error(
@@ -895,8 +1010,9 @@ var init_TestProvider = __esm({
           const { toolName, resultContains } = expectations.containsToolResult;
           const found = context.messages.some((m) => {
             if (m.role !== "tool") return false;
-            if (!m.content) return false;
-            return !resultContains || m.content.includes(resultContains);
+            const content = contentToString(m.content);
+            if (!content) return false;
+            return !resultContains || content.includes(resultContains);
           });
           if (!found) {
             throw new Error(
@@ -907,10 +1023,11 @@ var init_TestProvider = __esm({
         if (expectations.systemPromptContains) {
           const pattern = expectations.systemPromptContains;
           const systemMessage = context.messages.find((m) => m.role === "system");
-          if (!systemMessage?.content) {
+          const systemContent = contentToString(systemMessage?.content);
+          if (!systemContent) {
             throw new Error(`TestProvider: No system message found`);
           }
-          const matches = typeof pattern === "string" ? systemMessage.content.includes(pattern) : pattern.test(systemMessage.content);
+          const matches = typeof pattern === "string" ? systemContent.includes(pattern) : pattern.test(systemContent);
           if (!matches) {
             throw new Error(
               `TestProvider: System prompt does not contain "${pattern}"`
@@ -923,7 +1040,7 @@ var init_TestProvider = __esm({
        */
       estimateTokens(messages) {
         return messages.reduce((sum, m) => {
-          const content = m.content || "";
+          const content = contentToString(m.content);
           return sum + Math.ceil(content.length / 4);
         }, 0);
       }
@@ -1131,6 +1248,37 @@ var init_providers = __esm({
 });
 
 // src/agents/LLMRequest.ts
+function transformMessagesForLog(messages, imagePathMap) {
+  console.log("[DEBUG] transformMessagesForLog called, imagePathMap size:", imagePathMap?.size ?? 0);
+  if (!imagePathMap || imagePathMap.size === 0) {
+    console.log("[DEBUG] No imagePathMap, returning original");
+    return messages;
+  }
+  const result = messages.map((msg) => {
+    if (!Array.isArray(msg.content)) {
+      return msg;
+    }
+    return {
+      ...msg,
+      content: msg.content.map((part) => {
+        if (typeof part === "object" && part !== null && "type" in part && part.type === "image_url" && "image_url" in part && part.image_url?.url) {
+          const path4 = imagePathMap.get(part.image_url.url);
+          console.log("[DEBUG] Found image_url, lookup result:", path4 ? path4 : "NOT FOUND");
+          if (path4) {
+            return {
+              ...part,
+              image_url: { ...part.image_url, url: path4 }
+            };
+          }
+        }
+        return part;
+      })
+    };
+  });
+  const hasDataUrl = JSON.stringify(result).includes("data:image");
+  console.log("[DEBUG] After transform, still has data URL:", hasDataUrl);
+  return result;
+}
 var LLMRequest;
 var init_LLMRequest = __esm({
   "src/agents/LLMRequest.ts"() {
@@ -1278,6 +1426,23 @@ var init_LLMRequest = __esm({
           } catch (err) {
             console.error("Failed to fetch model name:", err);
           }
+          const messagesForLog = transformMessagesForLog(context.messages, context.imagePathMap);
+          const requestBodyObj = {
+            model: modelName || modelId,
+            messages: messagesForLog,
+            tools: context.tools,
+            stream: context.stream ?? true
+          };
+          const requestBodyStr = JSON.stringify(requestBodyObj);
+          const hasDataUrlInFinal = requestBodyStr.includes("data:image");
+          console.log("[DEBUG] request_body has data URL:", hasDataUrlInFinal);
+          if (hasDataUrlInFinal) {
+            console.log("[DEBUG] PROBLEM! Data URL still in request_body after transform");
+            console.log(
+              "[DEBUG] messagesForLog first user msg content type:",
+              messagesForLog.find((m) => m.role === "user")?.content
+            );
+          }
           const logData = {
             id,
             message_id: state.rootMessageId || crypto.randomUUID(),
@@ -1285,13 +1450,7 @@ var init_LLMRequest = __esm({
             model: modelId,
             model_name: modelName ?? void 0,
             endpoint: "chat.completions",
-            request_body: JSON.stringify({
-              model: modelName || modelId,
-              // Use actual model name sent to API, fallback to ID
-              messages: context.messages,
-              tools: context.tools,
-              stream: context.stream ?? true
-            }),
+            request_body: requestBodyStr,
             tools_available: context.tools ? context.tools.length : 0,
             message_history_length: context.messages.length,
             prompt_name: context.promptName ?? void 0,
@@ -2543,6 +2702,112 @@ ${errorStack}` : ""}`;
   }
 });
 
+// src/agents/context.ts
+function hasImageAttachments(message) {
+  if (!message.attachments) return false;
+  try {
+    const attachments = typeof message.attachments === "string" ? JSON.parse(message.attachments) : message.attachments;
+    return attachments.some((att) => att.mimeType.startsWith("image/"));
+  } catch {
+    return false;
+  }
+}
+function getUnsummarizedImageAttachments(message) {
+  if (!message.attachments) return [];
+  try {
+    const attachments = typeof message.attachments === "string" ? JSON.parse(message.attachments) : message.attachments;
+    return attachments.filter(
+      (att) => att.mimeType.startsWith("image/") && !att.description
+    );
+  } catch {
+    return [];
+  }
+}
+function getMessagesToSummarize(messages, config = DEFAULT_CONFIG) {
+  const indices = [];
+  const threshold = messages.length - config.recentMessageThreshold;
+  for (let i = 0; i < threshold; i++) {
+    const msg = messages[i];
+    if (msg.role === "user" && hasImageAttachments(msg)) {
+      indices.push(i);
+    }
+  }
+  return indices;
+}
+function buildImageDescription(attachment) {
+  if (attachment.description) {
+    return `[Image: ${attachment.name}] ${attachment.description}`;
+  }
+  const dimensions = attachment.width && attachment.height ? ` (${attachment.width}x${attachment.height})` : "";
+  return `[Image: ${attachment.name}${dimensions}]`;
+}
+function replaceImagesWithDescriptions(content, attachments) {
+  if (typeof content === "string") {
+    const imageDescriptions2 = attachments.filter((att) => att.mimeType.startsWith("image/")).map(buildImageDescription).join("\n");
+    if (!imageDescriptions2) return content;
+    if (!content) return imageDescriptions2;
+    return `${imageDescriptions2}
+
+${content}`;
+  }
+  const textParts = content.filter((part) => part.type === "text");
+  const imageAttachments = attachments.filter(
+    (att) => att.mimeType.startsWith("image/")
+  );
+  if (imageAttachments.length === 0) {
+    return content;
+  }
+  const imageDescriptions = imageAttachments.map(buildImageDescription).join("\n");
+  if (textParts.length > 0) {
+    const existingText = textParts.map((p) => p.text).join(" ");
+    return `${imageDescriptions}
+
+${existingText}`;
+  }
+  return imageDescriptions;
+}
+function optimizeImageContext(messages, config = DEFAULT_CONFIG) {
+  const messagesToSummarize = getMessagesToSummarize(messages, config);
+  if (messagesToSummarize.length === 0) {
+    return messages;
+  }
+  return messages.map((msg, index) => {
+    if (!messagesToSummarize.includes(index)) {
+      return msg;
+    }
+    let attachments;
+    try {
+      attachments = typeof msg.attachments === "string" ? JSON.parse(msg.attachments) : msg.attachments || [];
+    } catch {
+      return msg;
+    }
+    const optimizedContent = replaceImagesWithDescriptions(
+      msg.content || "",
+      attachments
+    );
+    return {
+      ...msg,
+      content: typeof optimizedContent === "string" ? optimizedContent : JSON.stringify(optimizedContent),
+      // Clear attachments since we've inlined descriptions
+      attachments: JSON.stringify(
+        attachments.filter((att) => !att.mimeType.startsWith("image/"))
+      )
+    };
+  });
+}
+async function generateImageDescription(_imageBase64, _mimeType, _state) {
+  return null;
+}
+var DEFAULT_CONFIG;
+var init_context = __esm({
+  "src/agents/context.ts"() {
+    DEFAULT_CONFIG = {
+      recentMessageThreshold: 10,
+      descriptionPrompt: "Describe this image concisely in 1-2 sentences, focusing on the key visual elements and any text visible."
+    };
+  }
+});
+
 // src/agents/FlowEngine.ts
 var FlowEngine_exports = {};
 __export(FlowEngine_exports, {
@@ -2555,6 +2820,7 @@ var init_FlowEngine = __esm({
     init_StreamManager();
     init_LLMRequest();
     init_ToolExecutor();
+    init_context();
     FlowEngine = class {
       /**
        * Main execution entry point
@@ -3014,6 +3280,7 @@ var init_FlowEngine = __esm({
        */
       static async assembleContext(state) {
         const messages = [];
+        const imagePathMap = /* @__PURE__ */ new Map();
         const model = state.prompt.model;
         const promptName = state.prompt.name;
         const parallelToolCalls = state.prompt.parallel_tool_calls;
@@ -3042,6 +3309,9 @@ var init_FlowEngine = __esm({
             toolCallsWithResponses.add(msg.tool_call_id);
           }
         }
+        const recentMessageThreshold = state.prompt.recentImageThreshold ?? 10;
+        const oldMessageThreshold = completedMessages.length - recentMessageThreshold;
+        let messageIndex = 0;
         for (const msg of completedMessages) {
           if (!includePastTools && msg.role === "tool") {
             continue;
@@ -3071,7 +3341,36 @@ var init_FlowEngine = __esm({
               role = state.currentSide === "a" ? "user" : "assistant";
             }
           }
-          const messageContent = msg.content || void 0;
+          let messageContent;
+          const hasAttachments = msg.attachments && msg.attachments !== "[]";
+          const isOldMessage = messageIndex < oldMessageThreshold;
+          if (hasAttachments && msg.role === "user") {
+            const attachments = JSON.parse(msg.attachments);
+            const imageAttachments = attachments.filter(
+              (a) => a.mimeType.startsWith("image/")
+            );
+            if (isOldMessage && imageAttachments.length > 0) {
+              const imageDescriptions = imageAttachments.map(buildImageDescription).join("\n");
+              const nonImageFiles = attachments.filter((a) => !a.mimeType.startsWith("image/")).map((a) => a.name);
+              const nonImageList = nonImageFiles.length > 0 ? `
+[Other files: ${nonImageFiles.join(", ")}]` : "";
+              messageContent = msg.content ? `${imageDescriptions}${nonImageList}
+
+${msg.content}` : `${imageDescriptions}${nonImageList}`;
+            } else {
+              if (imageAttachments.length > 0) {
+                messageContent = await this.resolveAttachmentsToContent(msg, state, imagePathMap);
+              } else {
+                const fileList = attachments.map((a) => a.name).join(", ");
+                messageContent = msg.content ? `${msg.content}
+
+[Attached files: ${fileList}]` : `[Attached files: ${fileList}]`;
+              }
+            }
+          } else {
+            messageContent = msg.content || "";
+          }
+          messageIndex++;
           const messageToAdd = {
             role,
             content: messageContent,
@@ -3170,7 +3469,8 @@ var init_FlowEngine = __esm({
           // Retries now apply to all prompts (top-level and sub-prompts), only for provider errors
           parallel_tool_calls: parallelToolCalls,
           tool_choice: finalToolChoice,
-          reasoning
+          reasoning,
+          imagePathMap: imagePathMap.size > 0 ? imagePathMap : void 0
         };
       }
       /**
@@ -4039,6 +4339,7 @@ var init_FlowEngine = __esm({
               "role",
               "content",
               "name",
+              "attachments",
               ...includeToolCalls ? ["tool_calls", "tool_call_id", "tool_status"] : [],
               "log_id",
               "created_at",
@@ -4070,6 +4371,7 @@ var init_FlowEngine = __esm({
             role: row.role,
             content: row.content,
             name: row.name,
+            attachments: row.attachments,
             tool_calls: row.tool_calls,
             tool_call_id: row.tool_call_id,
             log_id: row.log_id,
@@ -4148,8 +4450,691 @@ ${errorStack}` : ""}`,
           console.error("Failed to log error to database:", logError);
         }
       }
+      /**
+       * Check if a MIME type is an image
+       */
+      static isImageMimeType(mimeType) {
+        return mimeType.startsWith("image/");
+      }
+      /**
+       * Resolve attachments from a message and build multimodal content
+       * Returns the message content (string or multimodal array)
+       *
+       * @param msg - Message with potential attachments
+       * @param state - Flow state with storage access
+       * @returns MessageContent - either string or multimodal array
+       */
+      static async resolveAttachmentsToContent(msg, state, imagePathMap) {
+        const textContent = msg.content || "";
+        if (!msg.attachments) {
+          return textContent;
+        }
+        let attachments;
+        try {
+          attachments = JSON.parse(msg.attachments);
+        } catch (e) {
+          console.error(`Failed to parse attachments for message ${msg.id}:`, e);
+          return textContent;
+        }
+        if (!attachments || attachments.length === 0) {
+          return textContent;
+        }
+        const imageAttachments = attachments.filter(
+          (a) => this.isImageMimeType(a.mimeType)
+        );
+        if (imageAttachments.length === 0) {
+          const nonImageFiles2 = attachments.filter(
+            (a) => !this.isImageMimeType(a.mimeType)
+          );
+          if (nonImageFiles2.length > 0) {
+            const fileList = nonImageFiles2.map((a) => a.name).join(", ");
+            return `${textContent}
+
+[Attached files: ${fileList}]`;
+          }
+          return textContent;
+        }
+        const multimodalParts = [];
+        if (textContent) {
+          multimodalParts.push({
+            type: "text",
+            text: textContent
+          });
+        }
+        for (const attachment of imageAttachments) {
+          try {
+            const result = await state.thread.instance.readFile(
+              attachment.path
+            );
+            if (result.success && result.data) {
+              const dataUrl = `data:${attachment.mimeType};base64,${result.data}`;
+              if (imagePathMap) {
+                imagePathMap.set(dataUrl, attachment.path);
+              }
+              multimodalParts.push({
+                type: "image_url",
+                image_url: {
+                  url: dataUrl,
+                  detail: "auto"
+                }
+              });
+            } else {
+              console.warn(
+                `Failed to load image attachment ${attachment.path}:`,
+                result.error
+              );
+              multimodalParts.push({
+                type: "text",
+                text: `[Image not available: ${attachment.name}]`
+              });
+            }
+          } catch (error) {
+            console.error(`Error loading image attachment ${attachment.path}:`, error);
+            multimodalParts.push({
+              type: "text",
+              text: `[Error loading image: ${attachment.name}]`
+            });
+          }
+        }
+        const nonImageFiles = attachments.filter(
+          (a) => !this.isImageMimeType(a.mimeType)
+        );
+        if (nonImageFiles.length > 0) {
+          const fileList = nonImageFiles.map((a) => a.name).join(", ");
+          multimodalParts.push({
+            type: "text",
+            text: `
+
+[Attached files: ${fileList}]`
+          });
+        }
+        return multimodalParts;
+      }
+    };
+  }
+});
+
+// src/durable-objects/files.ts
+var files_exports = {};
+__export(files_exports, {
+  FileStorage: () => FileStorage,
+  basename: () => basename,
+  detectStorageBackend: () => detectStorageBackend,
+  dirname: () => dirname,
+  isTextMimeType: () => isTextMimeType,
+  normalizePath: () => normalizePath,
+  rowToFileRecord: () => rowToFileRecord
+});
+function isTextMimeType(mimeType) {
+  return TEXT_MIME_TYPES.some((prefix) => mimeType.startsWith(prefix));
+}
+function detectStorageBackend(location) {
+  if (location.startsWith("s3://")) return "s3";
+  if (location.startsWith("r2://")) return "r2";
+  if (location.startsWith("http://") || location.startsWith("https://"))
+    return "url";
+  return "local";
+}
+function basename(path4) {
+  const parts = path4.split("/").filter(Boolean);
+  return parts[parts.length - 1] || "";
+}
+function normalizePath(path4) {
+  let normalized = path4.replace(/\/+/g, "/");
+  if (!normalized.startsWith("/")) normalized = "/" + normalized;
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function dirname(path4) {
+  const normalized = normalizePath(path4);
+  const lastSlash = normalized.lastIndexOf("/");
+  if (lastSlash <= 0) return "/";
+  return normalized.slice(0, lastSlash);
+}
+function rowToFileRecord(row) {
+  return {
+    path: row.path,
+    name: row.name,
+    mimeType: row.mime_type,
+    storage: row.storage,
+    location: row.location,
+    size: row.size,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    isDirectory: row.is_directory === 1,
+    createdAt: row.created_at
+  };
+}
+function inferMimeType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  const mimeTypes = {
+    // Text
+    txt: "text/plain",
+    md: "text/markdown",
+    html: "text/html",
+    css: "text/css",
+    csv: "text/csv",
+    // Code
+    js: "application/javascript",
+    ts: "application/typescript",
+    json: "application/json",
+    xml: "application/xml",
+    yaml: "application/yaml",
+    yml: "application/yaml",
+    // Images
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    // Documents
+    pdf: "application/pdf",
+    // Archives
+    zip: "application/zip",
+    tar: "application/x-tar",
+    gz: "application/gzip"
+  };
+  return mimeTypes[ext || ""] || "application/octet-stream";
+}
+var TEXT_MIME_TYPES, FileStorage;
+var init_files = __esm({
+  "src/durable-objects/files.ts"() {
+    TEXT_MIME_TYPES = [
+      "text/",
+      "application/json",
+      "application/javascript",
+      "application/xml",
+      "application/x-yaml",
+      "application/yaml"
+    ];
+    FileStorage = class {
+      constructor(sql) {
+        this.sql = sql;
+      }
+      /**
+       * Write a file to storage
+       */
+      async writeFile(path4, data, mimeType, options) {
+        const normalizedPath = normalizePath(path4);
+        const name = basename(normalizedPath);
+        const isText = isTextMimeType(mimeType);
+        const now = Date.now();
+        let content = null;
+        let blobData = null;
+        let size;
+        if (isText) {
+          content = typeof data === "string" ? data : new TextDecoder().decode(data);
+          size = new TextEncoder().encode(content).length;
+        } else {
+          blobData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+          size = blobData.byteLength;
+        }
+        const metadataJson = options?.metadata ? JSON.stringify(options.metadata) : null;
+        await this.sql.exec(
+          `INSERT OR REPLACE INTO files (path, name, mime_type, storage, location, data, content, size, metadata, thumbnail, is_directory, created_at)
+       VALUES (?, ?, ?, 'local', NULL, ?, ?, ?, ?, ?, 0, ?)`,
+          normalizedPath,
+          name,
+          mimeType,
+          blobData,
+          content,
+          size,
+          metadataJson,
+          options?.thumbnail || null,
+          now
+        );
+        await this.updateStats();
+        return {
+          path: normalizedPath,
+          name,
+          mimeType,
+          storage: "local",
+          location: null,
+          size,
+          metadata: options?.metadata || null,
+          isDirectory: false,
+          createdAt: now
+        };
+      }
+      /**
+       * Link to an external file (URL, S3, R2)
+       */
+      async linkFile(path4, location, options) {
+        const normalizedPath = normalizePath(path4);
+        const name = basename(normalizedPath);
+        const storage = detectStorageBackend(location);
+        const now = Date.now();
+        const mimeType = options?.mimeType || inferMimeType(name);
+        const metadataJson = options?.metadata ? JSON.stringify(options.metadata) : null;
+        await this.sql.exec(
+          `INSERT OR REPLACE INTO files (path, name, mime_type, storage, location, data, content, size, metadata, thumbnail, is_directory, created_at)
+       VALUES (?, ?, ?, ?, ?, NULL, NULL, ?, ?, NULL, 0, ?)`,
+          normalizedPath,
+          name,
+          mimeType,
+          storage,
+          location,
+          options?.size || 0,
+          metadataJson,
+          now
+        );
+        await this.updateStats();
+        return {
+          path: normalizedPath,
+          name,
+          mimeType,
+          storage,
+          location,
+          size: options?.size || 0,
+          metadata: options?.metadata || null,
+          isDirectory: false,
+          createdAt: now
+        };
+      }
+      /**
+       * Read file data from storage
+       * Returns null if file doesn't exist or is external
+       */
+      async readFile(path4) {
+        const normalizedPath = normalizePath(path4);
+        const cursor = await this.sql.exec(
+          `SELECT data, content, storage FROM files WHERE path = ? AND is_directory = 0`,
+          normalizedPath
+        );
+        const rows = cursor.toArray();
+        if (rows.length === 0) return null;
+        const row = rows[0];
+        if (row.storage !== "local") return null;
+        if (row.content !== null) {
+          return new TextEncoder().encode(row.content);
+        }
+        return row.data;
+      }
+      /**
+       * Read text file content
+       */
+      async readTextFile(path4) {
+        const normalizedPath = normalizePath(path4);
+        const cursor = await this.sql.exec(
+          `SELECT content, data, storage FROM files WHERE path = ? AND is_directory = 0`,
+          normalizedPath
+        );
+        const rows = cursor.toArray();
+        if (rows.length === 0) return null;
+        const row = rows[0];
+        if (row.storage !== "local") return null;
+        if (row.content !== null) return row.content;
+        if (row.data !== null) {
+          return new TextDecoder().decode(row.data);
+        }
+        return null;
+      }
+      /**
+       * Get file metadata (stat)
+       */
+      async stat(path4) {
+        const normalizedPath = normalizePath(path4);
+        const cursor = await this.sql.exec(
+          `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at
+       FROM files WHERE path = ?`,
+          normalizedPath
+        );
+        const rows = cursor.toArray();
+        if (rows.length === 0) return null;
+        return rowToFileRecord(rows[0]);
+      }
+      /**
+       * Check if file or directory exists
+       */
+      async exists(path4) {
+        const normalizedPath = normalizePath(path4);
+        const cursor = await this.sql.exec(
+          `SELECT COUNT(*) as count FROM files WHERE path = ?`,
+          normalizedPath
+        );
+        return cursor.one().count > 0;
+      }
+      /**
+       * Delete a file
+       */
+      async unlink(path4) {
+        const normalizedPath = normalizePath(path4);
+        await this.sql.exec(
+          `DELETE FROM files WHERE path = ? AND is_directory = 0`,
+          normalizedPath
+        );
+        await this.updateStats();
+      }
+      /**
+       * Create a directory marker
+       */
+      async mkdir(path4) {
+        const normalizedPath = normalizePath(path4);
+        const name = basename(normalizedPath);
+        const now = Date.now();
+        await this.sql.exec(
+          `INSERT OR IGNORE INTO files (path, name, mime_type, storage, location, data, content, size, metadata, thumbnail, is_directory, created_at)
+       VALUES (?, ?, 'inode/directory', 'local', NULL, NULL, NULL, 0, NULL, NULL, 1, ?)`,
+          normalizedPath,
+          name,
+          now
+        );
+        return {
+          path: normalizedPath,
+          name,
+          mimeType: "inode/directory",
+          storage: "local",
+          location: null,
+          size: 0,
+          metadata: null,
+          isDirectory: true,
+          createdAt: now
+        };
+      }
+      /**
+       * List directory contents
+       */
+      async readdir(path4) {
+        const normalizedPath = normalizePath(path4);
+        const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
+        const cursor = await this.sql.exec(
+          `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at
+       FROM files
+       WHERE path LIKE ? || '%'
+         AND path != ?
+         AND SUBSTR(path, LENGTH(?) + 1) NOT LIKE '%/%'
+       ORDER BY is_directory DESC, name ASC`,
+          prefix,
+          normalizedPath,
+          prefix
+        );
+        return cursor.toArray().map(rowToFileRecord);
+      }
+      /**
+       * Remove empty directory
+       */
+      async rmdir(path4) {
+        const normalizedPath = normalizePath(path4);
+        const prefix = normalizedPath + "/";
+        const cursor = await this.sql.exec(
+          `SELECT COUNT(*) as count FROM files WHERE path LIKE ? || '%'`,
+          prefix
+        );
+        if (cursor.one().count > 0) {
+          throw new Error("Directory not empty");
+        }
+        await this.sql.exec(
+          `DELETE FROM files WHERE path = ? AND is_directory = 1`,
+          normalizedPath
+        );
+      }
+      /**
+       * Get storage statistics
+       */
+      async getFileStats() {
+        const cursor = await this.sql.exec(`SELECT total_size, file_count FROM file_stats WHERE id = 1`);
+        const rows = cursor.toArray();
+        if (rows.length === 0) {
+          return { totalSize: 0, fileCount: 0 };
+        }
+        return {
+          totalSize: rows[0].total_size,
+          fileCount: rows[0].file_count
+        };
+      }
+      /**
+       * Update file statistics (call after writes/deletes)
+       */
+      async updateStats() {
+        await this.sql.exec(`
+      UPDATE file_stats SET
+        total_size = (SELECT COALESCE(SUM(size), 0) FROM files WHERE is_directory = 0),
+        file_count = (SELECT COUNT(*) FROM files WHERE is_directory = 0)
+      WHERE id = 1
+    `);
+      }
+      /**
+       * Get thumbnail for an image
+       */
+      async getThumbnail(path4) {
+        const normalizedPath = normalizePath(path4);
+        const cursor = await this.sql.exec(
+          `SELECT thumbnail FROM files WHERE path = ? AND is_directory = 0`,
+          normalizedPath
+        );
+        const rows = cursor.toArray();
+        if (rows.length === 0) return null;
+        return rows[0].thumbnail;
+      }
+      /**
+       * Search file contents using FTS5
+       */
+      async grep(pattern, options) {
+        const limit = options?.limit || 100;
+        let query = `
+      SELECT files.path, files.name, snippet(files_fts, 2, '<mark>', '</mark>', '...', 32) as snippet
+      FROM files_fts
+      JOIN files ON files.rowid = files_fts.rowid
+      WHERE files_fts MATCH ?
+    `;
+        const params = [pattern];
+        if (options?.path) {
+          query += ` AND files.path LIKE ? || '%'`;
+          params.push(normalizePath(options.path));
+        }
+        query += ` LIMIT ?`;
+        params.push(limit);
+        const cursor = await this.sql.exec(query, ...params);
+        return cursor.toArray();
+      }
+      /**
+       * Find files by path pattern (glob-like)
+       */
+      async find(pattern, options) {
+        const limit = options?.limit || 100;
+        const type = options?.type || "all";
+        let sqlPattern = pattern.replace(/\*\*/g, "%").replace(/\*/g, "%").replace(/\?/g, "_");
+        if (!sqlPattern.startsWith("/")) {
+          sqlPattern = "%" + sqlPattern;
+        }
+        let typeClause = "";
+        if (type === "file") typeClause = " AND is_directory = 0";
+        if (type === "directory") typeClause = " AND is_directory = 1";
+        const cursor = await this.sql.exec(
+          `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at
+       FROM files
+       WHERE path LIKE ?${typeClause}
+       ORDER BY path
+       LIMIT ?`,
+          sqlPattern,
+          limit
+        );
+        return cursor.toArray().map(rowToFileRecord);
+      }
+    };
+  }
+});
+
+// src/image-processing/index.ts
+var image_processing_exports = {};
+__export(image_processing_exports, {
+  arrayBufferToBase64: () => arrayBufferToBase64,
+  base64ToArrayBuffer: () => base64ToArrayBuffer,
+  needsProcessing: () => needsProcessing,
+  processImage: () => processImage
+});
+async function processImage(input, inputMimeType) {
+  if (input.byteLength > MAX_INPUT_SIZE) {
+    throw new Error(`Image too large: ${input.byteLength} bytes exceeds ${MAX_INPUT_SIZE} byte limit`);
+  }
+  const probeResult = probe(input);
+  const format = probeResult.format !== "unknown" ? probeResult.format : detectFormat(input, inputMimeType);
+  const hasAlpha = probeResult.hasAlpha;
+  if (hasAlpha && (format === "png" || format === "avif" || format === "webp")) {
+    return await processPngWithAlpha(input, format);
+  }
+  try {
+    const result = await sip.process(input, {
+      maxWidth: MAX_DIMENSION,
+      maxHeight: MAX_DIMENSION,
+      maxBytes: MAX_SIZE,
+      quality: 85
+    });
+    return {
+      data: result.data,
+      mimeType: "image/jpeg",
+      width: result.width,
+      height: result.height
+    };
+  } catch (err) {
+    console.error("[sip] Processing failed, falling back:", err);
+    throw err;
+  }
+}
+async function processPngWithAlpha(input, format) {
+  let imageData;
+  if (format === "avif") {
+    imageData = await decode(input);
+  } else {
+    imageData = await decode$1(input);
+  }
+  const originalWidth = imageData.width;
+  const originalHeight = imageData.height;
+  let encoded = await encode(imageData);
+  if (encoded.byteLength <= MAX_SIZE) {
+    return {
+      data: encoded,
+      mimeType: "image/png",
+      width: originalWidth,
+      height: originalHeight
     };
   }
+  let scale = 0.9;
+  while (encoded.byteLength > MAX_SIZE && scale > 0.15) {
+    const newWidth = Math.floor(originalWidth * scale);
+    const newHeight = Math.floor(originalHeight * scale);
+    if (newWidth < 100 || newHeight < 100) {
+      scale *= 0.9;
+      continue;
+    }
+    const resized = resizeRgba(
+      new Uint8ClampedArray(imageData.data),
+      originalWidth,
+      originalHeight,
+      newWidth,
+      newHeight
+    );
+    const resizedImageData = { data: resized, width: newWidth, height: newHeight };
+    encoded = await encode(resizedImageData);
+    if (encoded.byteLength <= MAX_SIZE) {
+      return {
+        data: encoded,
+        mimeType: "image/png",
+        width: newWidth,
+        height: newHeight
+      };
+    }
+    scale *= 0.9;
+  }
+  const finalWidth = Math.floor(originalWidth * 0.15);
+  const finalHeight = Math.floor(originalHeight * 0.15);
+  const finalResized = resizeRgba(
+    new Uint8ClampedArray(imageData.data),
+    originalWidth,
+    originalHeight,
+    finalWidth,
+    finalHeight
+  );
+  encoded = await encode({ data: finalResized, width: finalWidth, height: finalHeight });
+  return {
+    data: encoded,
+    mimeType: "image/png",
+    width: finalWidth,
+    height: finalHeight
+  };
+}
+function resizeRgba(src, srcWidth, srcHeight, dstWidth, dstHeight) {
+  const dst = new Uint8ClampedArray(dstWidth * dstHeight * 4);
+  const xScale = srcWidth / dstWidth;
+  const yScale = srcHeight / dstHeight;
+  for (let dstY = 0; dstY < dstHeight; dstY++) {
+    for (let dstX = 0; dstX < dstWidth; dstX++) {
+      const srcXFloat = dstX * xScale;
+      const srcYFloat = dstY * yScale;
+      const srcX0 = Math.floor(srcXFloat);
+      const srcY0 = Math.floor(srcYFloat);
+      const srcX1 = Math.min(srcX0 + 1, srcWidth - 1);
+      const srcY1 = Math.min(srcY0 + 1, srcHeight - 1);
+      const tx = srcXFloat - srcX0;
+      const ty = srcYFloat - srcY0;
+      const idx00 = (srcY0 * srcWidth + srcX0) * 4;
+      const idx10 = (srcY0 * srcWidth + srcX1) * 4;
+      const idx01 = (srcY1 * srcWidth + srcX0) * 4;
+      const idx11 = (srcY1 * srcWidth + srcX1) * 4;
+      const dstIdx = (dstY * dstWidth + dstX) * 4;
+      for (let c = 0; c < 4; c++) {
+        const v00 = src[idx00 + c];
+        const v10 = src[idx10 + c];
+        const v01 = src[idx01 + c];
+        const v11 = src[idx11 + c];
+        const top = v00 * (1 - tx) + v10 * tx;
+        const bottom = v01 * (1 - tx) + v11 * tx;
+        dst[dstIdx + c] = Math.round(top * (1 - ty) + bottom * ty);
+      }
+    }
+  }
+  return dst;
+}
+function detectFormat(data, mimeType) {
+  const bytes = new Uint8Array(data.slice(0, 12));
+  if (bytes[4] === 102 && bytes[5] === 116 && bytes[6] === 121 && bytes[7] === 112) {
+    const brand = String.fromCharCode(...bytes.slice(8, 12));
+    if (brand === "avif" || brand === "avis") return "avif";
+  }
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "png";
+  }
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "jpeg";
+  }
+  if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) {
+    return "webp";
+  }
+  if (mimeType.includes("png")) return "png";
+  if (mimeType.includes("webp")) return "webp";
+  if (mimeType.includes("avif")) return "avif";
+  return "jpeg";
+}
+function needsProcessing(data, mimeType) {
+  const binaryLength = Math.ceil(data.length * 3 / 4);
+  return binaryLength > MAX_SIZE || mimeType.includes("avif") || mimeType.includes("webp");
+}
+function base64ToArrayBuffer(base64) {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+function arrayBufferToBase64(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+var MAX_SIZE, MAX_DIMENSION, MAX_INPUT_SIZE;
+var init_image_processing = __esm({
+  "src/image-processing/index.ts"() {
+    MAX_SIZE = 1.5 * 1024 * 1024;
+    MAX_DIMENSION = 4096;
+    MAX_INPUT_SIZE = 20 * 1024 * 1024;
+  }
 });
 var TSCONFIG_CONTENT = `{
   "compilerOptions": {
@@ -5134,7 +6119,7 @@ function generateAgentFile(data) {
   if (data.type && data.type !== "ai_human") {
     lines.push(`  type: '${data.type}',`);
   }
-  if (data.maxSessionTurns !== void 0) {
+  if (data.maxSessionTurns !== void 0 && data.maxSessionTurns !== null) {
     lines.push(`  maxSessionTurns: ${data.maxSessionTurns},`);
   }
   lines.push(`  sideA: ${formatSideConfig(data.sideA)},`);
@@ -5777,7 +6762,7 @@ function validateAgentData(data) {
   if (data.exposeAsTool && !data.toolDescription) {
     return "toolDescription is required when exposeAsTool is true";
   }
-  if (data.maxSessionTurns !== void 0) {
+  if (data.maxSessionTurns !== void 0 && data.maxSessionTurns !== null) {
     if (typeof data.maxSessionTurns !== "number" || data.maxSessionTurns <= 0) {
       return "maxSessionTurns must be a positive number";
     }
@@ -5796,6 +6781,7 @@ function validateAgentData(data) {
 }
 
 // src/plugin.ts
+createRequire(import.meta.url);
 var VIRTUAL_TOOLS_ID = "virtual:@standardagents-tools";
 var RESOLVED_VIRTUAL_TOOLS_ID = "\0" + VIRTUAL_TOOLS_ID;
 var VIRTUAL_ROUTES_ID = "virtual:@standardagents-routes";
@@ -6204,13 +7190,28 @@ function agentbuilder(options = {}) {
       const depsToExclude = [
         "@standardagents/builder",
         "@standardagents/builder/runtime",
-        "@standardagents/builder/built-in-routes"
+        "@standardagents/builder/built-in-routes",
+        "@standardagents/builder/image-processing",
+        // WASM image processing deps - must be excluded to avoid pre-bundle cache issues
+        "@cf-wasm/photon",
+        "@cf-wasm/photon/workerd",
+        "@jsquash/avif",
+        "@jsquash/jpeg",
+        "@jsquash/png",
+        "@jsquash/webp",
+        "@standardagents/sip"
+      ];
+      const depsToInclude = [
+        "zod",
+        "openai"
       ];
       return {
         optimizeDeps: {
           // Exclude our packages from pre-bundling - they contain cloudflare:workers imports
           // that cannot be resolved during dependency optimization
-          exclude: depsToExclude
+          exclude: depsToExclude,
+          // Include common deps upfront to prevent re-optimization during dev
+          include: depsToInclude
         },
         ssr: {
           // noExternal ensures Vite transforms these instead of leaving as external
@@ -6223,18 +7224,35 @@ function agentbuilder(options = {}) {
         }
       };
     },
-    // Apply exclusions to ALL environments including Cloudflare worker
+    // Apply exclusions and inclusions to ALL environments including Cloudflare worker
     configEnvironment(name, config) {
       const depsToExclude = [
         "@standardagents/builder",
         "@standardagents/builder/runtime",
-        "@standardagents/builder/built-in-routes"
+        "@standardagents/builder/built-in-routes",
+        "@standardagents/builder/image-processing",
+        // WASM image processing deps
+        "@cf-wasm/photon",
+        "@cf-wasm/photon/workerd",
+        "@jsquash/avif",
+        "@jsquash/jpeg",
+        "@jsquash/png",
+        "@jsquash/webp",
+        "@standardagents/sip"
+      ];
+      const depsToInclude = [
+        "zod",
+        "openai"
       ];
       config.optimizeDeps = config.optimizeDeps || {};
       config.optimizeDeps.exclude = [
         ...config.optimizeDeps.exclude || [],
         ...depsToExclude.filter((dep) => !config.optimizeDeps?.exclude?.includes(dep))
       ];
+      config.optimizeDeps.include = [
+        ...config.optimizeDeps.include || [],
+        ...depsToInclude.filter((dep) => !config.optimizeDeps?.include?.includes(dep))
+      ];
     },
     resolveId(id) {
       if (id === VIRTUAL_TOOLS_ID) {
@@ -6672,6 +7690,11 @@ export const agentNames = ${JSON.stringify(agents.filter((a) => !a.error).map((a
 import { DurableThread as _BaseDurableThread } from '@standardagents/builder/runtime';
 import { DurableAgentBuilder as _BaseDurableAgentBuilder } from '@standardagents/builder/runtime';
 
+// Import sip WASM module and initializer
+// Static import allows workerd to pre-compile the WASM at bundle time
+import _sipWasm from '@standardagents/sip/dist/sip.wasm';
+import { initWithWasmModule as _initSipWasm } from '@standardagents/sip';
+
 // Re-export router from virtual:@standardagents-routes
 export { router } from 'virtual:@standardagents-routes';
 
@@ -6701,6 +7724,16 @@ ${agentsCode}
  * Simply extend this class in your agents/Thread.ts file.
  */
 export class DurableThread extends _BaseDurableThread {
+  constructor(ctx, env) {
+    super(ctx, env);
+    // Initialize sip WASM in DO constructor
+    // blockConcurrencyWhile ensures WASM is ready before handling any requests
+    // Pass the statically imported WASM module for workerd to pre-compile
+    ctx.blockConcurrencyWhile(async () => {
+      await _initSipWasm(_sipWasm);
+    });
+  }
+
   tools() {
     return _tools;
   }
@@ -8116,8 +9149,88 @@ var migration16 = {
   }
 };
 
+// src/durable-objects/migrations/017_add_files.ts
+var migration17 = {
+  version: 17,
+  async up(sql) {
+    await sql.exec(`
+      CREATE TABLE files (
+        path TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        mime_type TEXT NOT NULL,
+
+        -- Storage backend: 'local' | 'url' | 's3' | 'r2'
+        storage TEXT NOT NULL DEFAULT 'local',
+        -- External reference: URL, s3://bucket/key, r2://bucket/key
+        location TEXT,
+
+        -- Local storage (NULL if external)
+        data BLOB,
+        content TEXT,
+
+        size INTEGER NOT NULL DEFAULT 0,
+        metadata TEXT,
+        thumbnail BLOB,
+        is_directory INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    await sql.exec(`
+      CREATE VIRTUAL TABLE files_fts USING fts5(
+        path,
+        name,
+        content,
+        content='files',
+        content_rowid='rowid'
+      )
+    `);
+    await sql.exec(`
+      CREATE TRIGGER files_ai AFTER INSERT ON files BEGIN
+        INSERT INTO files_fts(rowid, path, name, content)
+        VALUES (new.rowid, new.path, new.name, new.content);
+      END
+    `);
+    await sql.exec(`
+      CREATE TRIGGER files_ad AFTER DELETE ON files BEGIN
+        INSERT INTO files_fts(files_fts, rowid, path, name, content)
+        VALUES('delete', old.rowid, old.path, old.name, old.content);
+      END
+    `);
+    await sql.exec(`
+      CREATE TRIGGER files_au AFTER UPDATE ON files BEGIN
+        INSERT INTO files_fts(files_fts, rowid, path, name, content)
+        VALUES('delete', old.rowid, old.path, old.name, old.content);
+        INSERT INTO files_fts(rowid, path, name, content)
+        VALUES (new.rowid, new.path, new.name, new.content);
+      END
+    `);
+    await sql.exec(`
+      CREATE TABLE file_stats (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        total_size INTEGER DEFAULT 0,
+        file_count INTEGER DEFAULT 0
+      )
+    `);
+    await sql.exec(`
+      INSERT INTO file_stats (id, total_size, file_count) VALUES (1, 0, 0)
+    `);
+    await sql.exec(`
+      ALTER TABLE messages ADD COLUMN attachments TEXT
+    `);
+    await sql.exec(`
+      CREATE INDEX idx_files_created_at ON files(created_at)
+    `);
+    await sql.exec(`
+      CREATE INDEX idx_files_mime_type ON files(mime_type)
+    `);
+    await sql.exec(`
+      UPDATE _metadata SET value = '17' WHERE key = 'schema_version'
+    `);
+  }
+};
+
 // src/durable-objects/migrations/index.ts
-var migrations = [migration, migration2, migration3, migration4, migration5, migration6, migration7, migration8, migration9, migration10, migration11, migration12, migration13, migration14, migration15, migration16];
+var migrations = [migration, migration2, migration3, migration4, migration5, migration6, migration7, migration8, migration9, migration10, migration11, migration12, migration13, migration14, migration15, migration16, migration17];
 var LATEST_SCHEMA_VERSION = migrations.length;
 
 // src/durable-objects/DurableThread.ts
@@ -8327,7 +9440,7 @@ var DurableThread = class extends DurableObject {
             );
             break;
           case "processMessage":
-            await this.processMessage(args.threadId, args.content, args.role);
+            await this.processMessage(args.threadId, args.content, args.role, args.attachments);
             break;
           case "testOperation":
             await this.testOperation(args.id, args.label, args.expectedOrder);
@@ -8518,9 +9631,9 @@ var DurableThread = class extends DurableObject {
    * Each migration is run in order, starting from the current version + 1.
    */
   async runMigrations(fromVersion) {
-    for (const migration18 of migrations) {
-      if (migration18.version > fromVersion) {
-        await migration18.up(this.ctx.storage.sql);
+    for (const migration19 of migrations) {
+      if (migration19.version > fromVersion) {
+        await migration19.up(this.ctx.storage.sql);
       }
     }
   }
@@ -8578,7 +9691,7 @@ var DurableThread = class extends DurableObject {
    * Send a new message to the thread (RPC method)
    * Enqueues the message processing to be handled by the alarm handler
    */
-  async sendMessage(threadId, content, role = "user") {
+  async sendMessage(threadId, content, role = "user", attachments) {
     await this.ensureMigrated();
     try {
       const queueId = await this.alarmQueue.enqueue(
@@ -8586,7 +9699,8 @@ var DurableThread = class extends DurableObject {
         {
           threadId,
           content,
-          role
+          role,
+          attachments
         },
         1
         // Execute almost immediately (1ms)
@@ -8797,7 +9911,7 @@ var DurableThread = class extends DurableObject {
       const total = countResult.one().total;
       const result = await this.ctx.storage.sql.exec(
         `
-        SELECT id, role, content, name, tool_calls, tool_call_id, tool_status, log_id, created_at, silent, parent_id, depth, status, reasoning_content, reasoning_details
+        SELECT id, role, content, name, tool_calls, tool_call_id, tool_status, log_id, created_at, silent, parent_id, depth, status, reasoning_content, reasoning_details, attachments
         FROM messages
         ${whereClause}
         ORDER BY created_at ${order === "ASC" ? "ASC" : "DESC"}
@@ -8821,7 +9935,8 @@ var DurableThread = class extends DurableObject {
         depth: row.depth,
         status: row.status,
         reasoning_content: row.reasoning_content,
-        reasoning_details: row.reasoning_details
+        reasoning_details: row.reasoning_details,
+        attachments: row.attachments ? JSON.parse(row.attachments) : null
       }));
       if (order === "DESC") {
         messages = messages.reverse();
@@ -9104,6 +10219,8 @@ var DurableThread = class extends DurableObject {
           id: threadMetadata.agent_name,
           title: agentDef.title || threadMetadata.agent_name,
           type: agentDef.type,
+          description: agentDef.description,
+          icon: agentDef.icon,
           side_a_label: agentDef.sideA?.label,
           side_b_label: agentDef.sideB?.label
         };
@@ -9526,7 +10643,7 @@ var DurableThread = class extends DurableObject {
    * Internal method: Process a message (called by alarm queue)
    * This is the actual message processing logic, separate from the public sendMessage() RPC method
    */
-  async processMessage(threadId, content, role = "user") {
+  async processMessage(threadId, content, role = "user", attachments) {
     if (role === "user") {
       await this.ctx.storage.sql.exec(
         `UPDATE execution_state SET value = 'false' WHERE key = 'stopped'`
@@ -9576,6 +10693,7 @@ var DurableThread = class extends DurableObject {
         id: messageId,
         role,
         content,
+        attachments: attachments || null,
         created_at: timestamp
       };
       const state = {
@@ -9591,16 +10709,18 @@ var DurableThread = class extends DurableObject {
       const { FlowEngine: FlowEngine2 } = await Promise.resolve().then(() => (init_FlowEngine(), FlowEngine_exports));
       message = await FlowEngine2.runBeforeCreateMessageHook(state, message);
       await this.ctx.storage.sql.exec(
-        `INSERT INTO messages (id, role, content, created_at) VALUES (?, ?, ?, ?)`,
+        `INSERT INTO messages (id, role, content, attachments, created_at) VALUES (?, ?, ?, ?, ?)`,
         message.id,
         message.role,
         message.content,
+        message.attachments,
         message.created_at
       );
       this.broadcastMessage({
         id: message.id,
         role: message.role,
         content: message.content,
+        attachments: message.attachments,
         created_at: message.created_at
       });
       const nextSide = role === "assistant" ? "b" : "a";
@@ -9769,10 +10889,297 @@ var DurableThread = class extends DurableObject {
       now
     );
   }
+  // ============================================================
+  // File Storage Methods (RPC)
+  // ============================================================
+  /**
+   * Get file storage helper instance
+   */
+  getFileStorage() {
+    const { FileStorage: FileStorage2 } = (init_files(), __toCommonJS(files_exports));
+    return new FileStorage2(this.ctx.storage.sql);
+  }
+  /**
+   * Write a file to storage (RPC method)
+   */
+  async writeFile(path4, data, mimeType, options) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const binaryString = atob(data);
+      const dataBuffer = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        dataBuffer[i] = binaryString.charCodeAt(i);
+      }
+      let thumbnailBuffer;
+      if (options?.thumbnail) {
+        const thumbBinary = atob(options.thumbnail);
+        thumbnailBuffer = new Uint8Array(thumbBinary.length);
+        for (let i = 0; i < thumbBinary.length; i++) {
+          thumbnailBuffer[i] = thumbBinary.charCodeAt(i);
+        }
+      }
+      const record = await fs4.writeFile(path4, dataBuffer, mimeType, {
+        metadata: options?.metadata,
+        thumbnail: thumbnailBuffer
+      });
+      return { success: true, file: record };
+    } catch (error) {
+      console.error("Error in writeFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Write a text file to storage (RPC method)
+   */
+  async writeTextFile(path4, content, mimeType = "text/plain", options) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const record = await fs4.writeFile(path4, content, mimeType, options);
+      return { success: true, file: record };
+    } catch (error) {
+      console.error("Error in writeTextFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Process an image using sip (WASM-based image processing)
+   * This runs inside the DO where WASM is properly initialized.
+   *
+   * @param data - base64 encoded image data
+   * @param mimeType - MIME type of the input image
+   * @returns Processed image data, dimensions, and mimeType
+   */
+  async processImage(data, mimeType) {
+    try {
+      const { processImage: processImage2, base64ToArrayBuffer: base64ToArrayBuffer2, arrayBufferToBase64: arrayBufferToBase642 } = await Promise.resolve().then(() => (init_image_processing(), image_processing_exports));
+      const buffer = base64ToArrayBuffer2(data);
+      const processed = await processImage2(buffer, mimeType);
+      return {
+        success: true,
+        data: arrayBufferToBase642(processed.data),
+        mimeType: processed.mimeType,
+        width: processed.width,
+        height: processed.height
+      };
+    } catch (error) {
+      console.error("[DurableThread.processImage] Error:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Link to an external file (RPC method)
+   */
+  async linkFile(path4, location, options) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const record = await fs4.linkFile(path4, location, options);
+      return { success: true, file: record };
+    } catch (error) {
+      console.error("Error in linkFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Read a file from storage (RPC method)
+   * Returns base64-encoded data
+   */
+  async readFile(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const data = await fs4.readFile(path4);
+      if (data === null) {
+        return { success: false, error: "File not found or external" };
+      }
+      const bytes = new Uint8Array(data);
+      let binary = "";
+      for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      const base64 = btoa(binary);
+      return { success: true, data: base64 };
+    } catch (error) {
+      console.error("Error in readFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Read a text file from storage (RPC method)
+   */
+  async readTextFile(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const content = await fs4.readTextFile(path4);
+      if (content === null) {
+        return { success: false, error: "File not found or external" };
+      }
+      return { success: true, content };
+    } catch (error) {
+      console.error("Error in readTextFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Get file metadata (RPC method)
+   */
+  async statFile(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const record = await fs4.stat(path4);
+      if (record === null) {
+        return { success: false, error: "File not found" };
+      }
+      return { success: true, file: record };
+    } catch (error) {
+      console.error("Error in statFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Check if file exists (RPC method)
+   */
+  async fileExists(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const exists2 = await fs4.exists(path4);
+      return { success: true, exists: exists2 };
+    } catch (error) {
+      console.error("Error in fileExists:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Delete a file (RPC method)
+   */
+  async unlinkFile(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      await fs4.unlink(path4);
+      return { success: true };
+    } catch (error) {
+      console.error("Error in unlinkFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Create a directory (RPC method)
+   */
+  async mkdirFile(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const record = await fs4.mkdir(path4);
+      return { success: true, directory: record };
+    } catch (error) {
+      console.error("Error in mkdirFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * List directory contents (RPC method)
+   */
+  async readdirFile(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const files = await fs4.readdir(path4);
+      return { success: true, files };
+    } catch (error) {
+      console.error("Error in readdirFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Remove empty directory (RPC method)
+   */
+  async rmdirFile(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      await fs4.rmdir(path4);
+      return { success: true };
+    } catch (error) {
+      console.error("Error in rmdirFile:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Get file storage statistics (RPC method)
+   */
+  async getFileStats() {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const stats = await fs4.getFileStats();
+      return { success: true, stats };
+    } catch (error) {
+      console.error("Error in getFileStats:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Get thumbnail for an image (RPC method)
+   * Returns base64-encoded data
+   */
+  async getFileThumbnail(path4) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const data = await fs4.getThumbnail(path4);
+      if (data === null) {
+        return { success: false, error: "Thumbnail not found" };
+      }
+      const bytes = new Uint8Array(data);
+      let binary = "";
+      for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      const base64 = btoa(binary);
+      return { success: true, data: base64 };
+    } catch (error) {
+      console.error("Error in getFileThumbnail:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Search file contents using FTS5 (RPC method)
+   */
+  async grepFiles(pattern, options) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const results = await fs4.grep(pattern, options);
+      return { success: true, results };
+    } catch (error) {
+      console.error("Error in grepFiles:", error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * Find files by path pattern (RPC method)
+   */
+  async findFiles(pattern, options) {
+    await this.ensureMigrated();
+    try {
+      const fs4 = this.getFileStorage();
+      const files = await fs4.find(pattern, options);
+      return { success: true, files };
+    } catch (error) {
+      console.error("Error in findFiles:", error);
+      return { success: false, error: error.message };
+    }
+  }
 };
 
 // src/durable-objects/agentbuilder-migrations/0001_initial.ts
-var migration17 = {
+var migration18 = {
   version: 1,
   async up(sql) {
     sql.exec(`
@@ -9871,7 +11278,7 @@ var migration17 = {
 };
 
 // src/durable-objects/agentbuilder-migrations/index.ts
-var migrations2 = [migration17];
+var migrations2 = [migration18];
 var LATEST_SCHEMA_VERSION2 = 1;
 
 // src/durable-objects/DurableAgentBuilder.ts
@@ -9961,9 +11368,9 @@ var DurableAgentBuilder = class extends DurableObject {
     }
   }
   async runMigrations(fromVersion) {
-    for (const migration18 of migrations2) {
-      if (migration18.version > fromVersion) {
-        await migration18.up(this.ctx.storage.sql);
+    for (const migration19 of migrations2) {
+      if (migration19.version > fromVersion) {
+        await migration19.up(this.ctx.storage.sql);
       }
     }
   }
@@ -10731,6 +12138,12 @@ function definePrompt(options) {
       `Invalid reasoning.effort '${options.reasoning.effort}'. Must be one of: low, medium, high`
     );
   }
+  if (options.maxImagePixels !== void 0 && (options.maxImagePixels <= 0 || !Number.isInteger(options.maxImagePixels))) {
+    throw new Error("maxImagePixels must be a positive integer");
+  }
+  if (options.recentImageThreshold !== void 0 && (options.recentImageThreshold <= 0 || !Number.isInteger(options.recentImageThreshold))) {
+    throw new Error("recentImageThreshold must be a positive integer");
+  }
   return options;
 }
 
@@ -10769,7 +12182,7 @@ function defineAgent(options) {
   if (options.sideB?.maxTurns !== void 0 && options.sideB.maxTurns <= 0) {
     throw new Error("sideB.maxTurns must be a positive number");
   }
-  if (options.maxSessionTurns !== void 0 && options.maxSessionTurns <= 0) {
+  if (options.maxSessionTurns !== void 0 && options.maxSessionTurns !== null && options.maxSessionTurns <= 0) {
     throw new Error("maxSessionTurns must be a positive number");
   }
   if (!["ai_human", "dual_ai"].includes(type)) {
@@ -10923,6 +12336,165 @@ async function updateThread(thread, params) {
   }
   return result.thread;
 }
+async function writeFile(flow, path4, data, mimeType, options) {
+  const instance = flow.thread.instance;
+  let base64Data;
+  if (typeof data === "string") {
+    base64Data = btoa(data);
+  } else {
+    const bytes = new Uint8Array(data);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    base64Data = btoa(binary);
+  }
+  let base64Thumbnail;
+  if (options?.thumbnail) {
+    const bytes = new Uint8Array(options.thumbnail);
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    base64Thumbnail = btoa(binary);
+  }
+  const result = await instance.writeFile(path4, base64Data, mimeType, {
+    metadata: options?.metadata,
+    thumbnail: base64Thumbnail
+  });
+  if (!result.success) {
+    throw new Error(result.error || "Failed to write file");
+  }
+  return result.file;
+}
+async function writeImage(flow, path4, data, mimeType, options) {
+  return writeFile(flow, path4, data, mimeType, options);
+}
+async function linkFile(flow, path4, location, options) {
+  const instance = flow.thread.instance;
+  const result = await instance.linkFile(path4, location, options);
+  if (!result.success) {
+    throw new Error(result.error || "Failed to link file");
+  }
+  return result.file;
+}
+async function readFile(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.readFile(path4);
+  if (!result.success) {
+    return null;
+  }
+  const binary = atob(result.data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+async function stat(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.statFile(path4);
+  if (!result.success) {
+    return null;
+  }
+  return result.file;
+}
+async function exists(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.fileExists(path4);
+  return result.success && result.exists;
+}
+async function unlink(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.unlinkFile(path4);
+  if (!result.success) {
+    throw new Error(result.error || "Failed to delete file");
+  }
+}
+async function mkdir(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.mkdirFile(path4);
+  if (!result.success) {
+    throw new Error(result.error || "Failed to create directory");
+  }
+  return result.directory;
+}
+async function readdir(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.readdirFile(path4);
+  if (!result.success) {
+    throw new Error(result.error || "Failed to read directory");
+  }
+  return result.files;
+}
+async function rmdir(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.rmdirFile(path4);
+  if (!result.success) {
+    throw new Error(result.error || "Failed to remove directory");
+  }
+}
+async function getFileStats(flow) {
+  const instance = flow.thread.instance;
+  const result = await instance.getFileStats();
+  if (!result.success) {
+    throw new Error(result.error || "Failed to get file stats");
+  }
+  return result.stats;
+}
+async function getThumbnail(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.getFileThumbnail(path4);
+  if (!result.success) {
+    return null;
+  }
+  const binary = atob(result.data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+async function cat(flow, path4) {
+  const instance = flow.thread.instance;
+  const result = await instance.readTextFile(path4);
+  if (!result.success) {
+    return null;
+  }
+  return result.content;
+}
+async function head(flow, path4, lines = 10) {
+  const content = await cat(flow, path4);
+  if (content === null) return null;
+  const allLines = content.split("\n");
+  return allLines.slice(0, lines).join("\n");
+}
+async function tail(flow, path4, lines = 10) {
+  const content = await cat(flow, path4);
+  if (content === null) return null;
+  const allLines = content.split("\n");
+  return allLines.slice(-lines).join("\n");
+}
+async function grep(flow, pattern, options) {
+  const instance = flow.thread.instance;
+  const result = await instance.grepFiles(pattern, options);
+  if (!result.success) {
+    throw new Error(result.error || "Search failed");
+  }
+  return result.results.map((r) => ({
+    path: r.path,
+    name: r.name,
+    matches: [r.snippet]
+  }));
+}
+async function find(flow, pattern, options) {
+  const instance = flow.thread.instance;
+  const result = await instance.findFiles(pattern, options);
+  if (!result.success) {
+    throw new Error(result.error || "Find failed");
+  }
+  return result.files;
+}
 
 // src/agents/FlowStateSdk.ts
 init_types();
@@ -11257,6 +12829,9 @@ function enhanceFlowState(flow) {
   return enhanced;
 }
 
+// src/index.ts
+init_context();
+
 // src/github/GitHubClient.ts
 var GITHUB_API_BASE = "https://api.github.com";
 var GitHubClient = class _GitHubClient {
@@ -11494,6 +13069,6 @@ var GitHubApiError = class extends Error {
   }
 };
 
-export { DurableAgentBuilder, DurableThread, FlowStateSdk, GitHubApiError, GitHubClient, agentbuilder, authenticate, defineAgent, defineController, defineHook, defineModel, definePrompt, defineThreadEndpoint, defineTool, emitThreadEvent, enhanceFlowState, forceTurn, generateAgentFile, generateModelFile, generatePromptFile, getMessages, injectMessage, queueTool, reloadHistory, requireAdmin, requireAuth, updateThread };
+export { DurableAgentBuilder, DurableThread, FlowStateSdk, GitHubApiError, GitHubClient, agentbuilder, authenticate, buildImageDescription, cat, defineAgent, defineController, defineHook, defineModel, definePrompt, defineThreadEndpoint, defineTool, emitThreadEvent, enhanceFlowState, exists, find, forceTurn, generateAgentFile, generateImageDescription, generateModelFile, generatePromptFile, getFileStats, getMessages, getMessagesToSummarize, getThumbnail, getUnsummarizedImageAttachments, grep, hasImageAttachments, head, injectMessage, linkFile, mkdir, optimizeImageContext, queueTool, readFile, readdir, reloadHistory, replaceImagesWithDescriptions, requireAdmin, requireAuth, rmdir, stat, tail, unlink, updateThread, writeFile, writeImage };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map