@standardagents/builder 0.10.0 → 0.10.1-dev.114898

package/dist/index.js

@@ -1,6 +1,10 @@
+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;
@@ -264,13 +268,28 @@ var init_BaseProvider = __esm({
        *
        * 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(
-              `UPDATE logs SET request_body = ?1 WHERE id = ?2 AND request_body IS NULL`,
+              `UPDATE logs SET request_body = ?1 WHERE id = ?2`,
               requestBody,
               logId
             );
@@ -4938,6 +4957,185 @@ var init_files = __esm({
     };
   }
 });
+
+// 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": {
     "composite": true,
@@ -5921,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)},`);
@@ -6564,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";
     }
@@ -6583,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";
@@ -6998,13 +7197,21 @@ function agentbuilder(options = {}) {
         "@cf-wasm/photon/workerd",
         "@jsquash/avif",
         "@jsquash/jpeg",
-        "@jsquash/png"
+        "@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
@@ -7017,7 +7224,7 @@ 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",
@@ -7029,13 +7236,23 @@ function agentbuilder(options = {}) {
         "@cf-wasm/photon/workerd",
         "@jsquash/avif",
         "@jsquash/jpeg",
-        "@jsquash/png"
+        "@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) {
@@ -7473,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';
 
@@ -7502,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;
   }
@@ -9987,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
         };
@@ -10672,8 +10906,19 @@ var DurableThread = class extends DurableObject {
     await this.ensureMigrated();
     try {
       const fs4 = this.getFileStorage();
-      const dataBuffer = Uint8Array.from(atob(data), (c) => c.charCodeAt(0));
-      const thumbnailBuffer = options?.thumbnail ? Uint8Array.from(atob(options.thumbnail), (c) => c.charCodeAt(0)) : void 0;
+      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
@@ -10698,6 +10943,31 @@ var DurableThread = class extends DurableObject {
       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)
    */
@@ -11912,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)) {