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

package/dist/built-in-routes.js

@@ -848,12 +848,23 @@ var index_post_default3 = defineController(async ({ req, env }) => {
 });
 
 // src/api/threads/index.ts
+function resolveIconUrl(icon, origin) {
+  if (!icon) return void 0;
+  if (icon.startsWith("http://") || icon.startsWith("https://")) {
+    return icon;
+  }
+  if (icon.startsWith("/")) {
+    return `${origin}${icon}`;
+  }
+  return icon;
+}
 var threads_default = defineController(async ({ req, env }) => {
   if (req.method !== "GET") {
     return new Response("Method Not Allowed", { status: 405 });
   }
   try {
     const url = new URL(req.url);
+    const origin = url.origin;
     const limit = parseInt(url.searchParams.get("limit") || "50", 10);
     const offset = parseInt(url.searchParams.get("offset") || "0", 10);
     const agentName = url.searchParams.get("agent_id");
@@ -872,11 +883,14 @@ var threads_default = defineController(async ({ req, env }) => {
         try {
           const agentDef = await agentBuilder.loadAgent(thread.agent_name);
           agentDetails = {
-            title: agentDef.title,
-            type: agentDef.type || "ai_human"
+            name: thread.agent_name,
+            title: agentDef.title || thread.agent_name,
+            type: agentDef.type || "ai_human",
+            description: agentDef.description,
+            icon: resolveIconUrl(agentDef.icon, origin)
           };
         } catch {
-          agentDetails = { title: thread.agent_name, type: "unknown" };
+          agentDetails = { name: thread.agent_name, title: thread.agent_name, type: "unknown" };
         }
         return {
           id: thread.id,
@@ -1447,6 +1461,16 @@ var id_patch_default = defineController(async ({ req, env, params }) => {
 });
 
 // src/api/threads/[id].ts
+function resolveIconUrl2(icon, origin) {
+  if (!icon) return void 0;
+  if (icon.startsWith("http://") || icon.startsWith("https://")) {
+    return icon;
+  }
+  if (icon.startsWith("/")) {
+    return `${origin}${icon}`;
+  }
+  return icon;
+}
 var id_default = defineController(async ({ req, params, env }) => {
   const threadId = params.id;
   if (!threadId) {
@@ -1462,6 +1486,10 @@ var id_default = defineController(async ({ req, params, env }) => {
         { status: 404 }
       );
     }
+    if (doData.agent?.icon) {
+      const origin = new URL(req.url).origin;
+      doData.agent.icon = resolveIconUrl2(doData.agent.icon, origin);
+    }
     return Response.json(doData);
   } catch (error) {
     console.error(`Error fetching thread ${threadId}:`, error);
@@ -1979,6 +2007,66 @@ var cost_get_default = defineController(async ({ req, params, env }) => {
   }
 });
 
+// src/api/threads/[id]/fs/index.ts
+var fs_default = defineController(async ({ req, params, env }) => {
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  if (req.method !== "GET") {
+    return Response.json(
+      { error: `Method ${req.method} not allowed` },
+      { status: 405 }
+    );
+  }
+  const url = new URL(req.url);
+  try {
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    if (url.searchParams.has("stats")) {
+      const result2 = await stub.getFileStats();
+      if (!result2.success) {
+        return Response.json({ error: result2.error }, { status: 500 });
+      }
+      return Response.json(result2.stats);
+    }
+    const grepPattern = url.searchParams.get("grep");
+    if (grepPattern) {
+      const path = url.searchParams.get("path") || void 0;
+      const limit = parseInt(url.searchParams.get("limit") || "100", 10);
+      const result2 = await stub.grepFiles(grepPattern, { path, limit });
+      if (!result2.success) {
+        return Response.json({ error: result2.error }, { status: 500 });
+      }
+      return Response.json({ results: result2.results, pattern: grepPattern });
+    }
+    const findPattern = url.searchParams.get("find");
+    if (findPattern) {
+      const type = url.searchParams.get("type");
+      const limit = parseInt(url.searchParams.get("limit") || "100", 10);
+      const result2 = await stub.findFiles(findPattern, {
+        type: type || "all",
+        limit
+      });
+      if (!result2.success) {
+        return Response.json({ error: result2.error }, { status: 500 });
+      }
+      return Response.json({ files: result2.files, pattern: findPattern });
+    }
+    const result = await stub.readdirFile("/");
+    if (!result.success) {
+      return Response.json({ error: result.error }, { status: 500 });
+    }
+    return Response.json({ files: result.files, path: "/" });
+  } catch (error) {
+    console.error(`Error in fs root API for thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "File operation failed" },
+      { status: 500 }
+    );
+  }
+});
+
 // src/api/threads/[id]/logs.get.ts
 var logs_get_default = defineController(async ({ req, params, env }) => {
   const url = new URL(req.url);
@@ -2017,8 +2105,19 @@ var logs_get_default = defineController(async ({ req, params, env }) => {
   }
 });
 
-// src/api/threads/[id]/message.post.ts
-var message_post_default = defineController(async ({ req, params, env }) => {
+// src/api/threads/[id]/messages.post.ts
+function needsProcessing(base64Data, mimeType) {
+  const binarySize = Math.ceil(base64Data.length * 3 / 4);
+  const MAX_SIZE = 2 * 1024 * 1024;
+  if (binarySize > MAX_SIZE) {
+    return true;
+  }
+  if (mimeType !== "image/jpeg" && mimeType !== "image/png") {
+    return true;
+  }
+  return false;
+}
+var messages_post_default = defineController(async ({ req, params, env }) => {
   const threadId = params.id;
   if (!threadId) {
     return Response.json({ error: "Thread ID required" }, { status: 400 });
@@ -2034,16 +2133,83 @@ var message_post_default = defineController(async ({ req, params, env }) => {
       );
     }
     const body = await req.json();
-    const { content, role } = body;
-    if (!content || typeof content !== "string") {
+    const { content = "", role, attachments, silent } = body;
+    const hasContent = content && typeof content === "string" && content.trim().length > 0;
+    const hasAttachments = attachments && Array.isArray(attachments) && attachments.length > 0;
+    if (!hasContent && !hasAttachments) {
       return Response.json(
-        { error: "Message content is required" },
+        { error: "Message content or attachments required" },
         { status: 400 }
       );
     }
     const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
     const stub = env.AGENT_BUILDER_THREAD.get(durableId);
-    return await stub.sendMessage(threadId, content, role);
+    let attachmentRefs;
+    if (attachments && attachments.length > 0) {
+      attachmentRefs = [];
+      for (const attachment of attachments) {
+        const attachmentId = crypto.randomUUID();
+        const timestamp = Date.now();
+        let fileData = attachment.data;
+        let mimeType = attachment.mimeType;
+        let width = attachment.width;
+        let height = attachment.height;
+        if (mimeType.startsWith("image/") && needsProcessing(fileData, mimeType)) {
+          try {
+            const originalSize = Math.ceil(fileData.length * 3 / 4);
+            const processed = await stub.processImage(fileData, mimeType);
+            if (processed.success && processed.data) {
+              fileData = processed.data;
+              mimeType = processed.mimeType;
+              width = processed.width;
+              height = processed.height;
+              const newSize = Math.ceil(fileData.length * 3 / 4);
+              console.log(
+                `[image-processing] Processed ${attachment.name}: ${(originalSize / 1024 / 1024).toFixed(2)}MB \u2192 ${(newSize / 1024 / 1024).toFixed(2)}MB, ${processed.width}x${processed.height}, ${processed.mimeType}`
+              );
+            } else {
+              console.error(`[image-processing] Failed to process ${attachment.name}:`, processed.error);
+            }
+          } catch (err) {
+            console.error(`[image-processing] Failed to process ${attachment.name}:`, err);
+          }
+        }
+        const ext = mimeType === "image/png" ? "png" : mimeType === "image/jpeg" ? "jpg" : attachment.name.split(".").pop() || "bin";
+        const path = `/attachments/${timestamp}-${attachmentId}.${ext}`;
+        const metadata = {};
+        if (width) metadata.width = width;
+        if (height) metadata.height = height;
+        const base64Size = fileData.length;
+        const binarySize = Math.ceil(base64Size * 3 / 4);
+        console.log(`[writeFile] Storing ${attachment.name}: ${(binarySize / 1024 / 1024).toFixed(2)}MB binary (${(base64Size / 1024 / 1024).toFixed(2)}MB base64) to ${path}`);
+        const result = await stub.writeFile(
+          path,
+          fileData,
+          mimeType,
+          {
+            metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
+            thumbnail: attachment.thumbnail
+          }
+        );
+        console.log(`[writeFile] Result:`, result.success ? "success" : result.error);
+        if (!result.success) {
+          console.error(`Failed to store attachment ${attachment.name}:`, result.error);
+          continue;
+        }
+        const ref = {
+          id: attachmentId,
+          type: "file",
+          path,
+          name: attachment.name,
+          mimeType
+        };
+        if (width) ref.width = width;
+        if (height) ref.height = height;
+        attachmentRefs.push(ref);
+      }
+    }
+    const attachmentsJson = attachmentRefs && attachmentRefs.length > 0 ? JSON.stringify(attachmentRefs) : void 0;
+    return await stub.sendMessage(threadId, content, role, attachmentsJson);
   } catch (error) {
     console.error(`Error sending message to thread ${threadId}:`, error);
     return Response.json(
@@ -2184,6 +2350,190 @@ var stream_default = defineController(async ({ req, params, env }) => {
   }
 });
 
+// src/api/threads/[id]/fs/[...path].ts
+function toAttachmentRef(file) {
+  const metadata = file.metadata;
+  return {
+    id: file.path,
+    // Use path as unique ID
+    type: "file",
+    path: file.path,
+    name: file.name,
+    mimeType: file.mimeType,
+    size: file.size,
+    ...metadata?.width && { width: metadata.width },
+    ...metadata?.height && { height: metadata.height }
+  };
+}
+var path_default = defineController(async ({ req, params, env }) => {
+  console.log("[fs] params received:", JSON.stringify(params));
+  const threadId = params.id;
+  const pathParam = params._ || params.path || params["*"] || "";
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  console.log("[fs] threadId:", threadId, "pathParam:", pathParam);
+  const path = pathParam ? `/${pathParam}` : "/";
+  const url = new URL(req.url);
+  try {
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    switch (req.method) {
+      case "GET":
+        return handleGet(stub, path, url);
+      case "PUT":
+        return handlePut(stub, path, req);
+      case "DELETE":
+        return handleDelete(stub, path);
+      default:
+        return Response.json(
+          { error: `Method ${req.method} not allowed` },
+          { status: 405 }
+        );
+    }
+  } catch (error) {
+    console.error(`Error in fs API for thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "File operation failed" },
+      { status: 500 }
+    );
+  }
+});
+async function handleGet(stub, path, url) {
+  if (url.searchParams.has("stats")) {
+    const result2 = await stub.getFileStats();
+    if (!result2.success) {
+      return Response.json({ error: result2.error }, { status: 500 });
+    }
+    return Response.json(result2.stats);
+  }
+  if (url.searchParams.has("thumbnail")) {
+    const result2 = await stub.getFileThumbnail(path);
+    if (!result2.success) {
+      return Response.json({ error: result2.error }, { status: 404 });
+    }
+    const binary2 = atob(result2.data);
+    const bytes2 = new Uint8Array(binary2.length);
+    for (let i = 0; i < binary2.length; i++) {
+      bytes2[i] = binary2.charCodeAt(i);
+    }
+    return new Response(bytes2, {
+      headers: {
+        "Content-Type": "image/jpeg",
+        // Thumbnails are typically JPEG
+        "Cache-Control": "public, max-age=31536000"
+        // Cache for 1 year
+      }
+    });
+  }
+  const statResult = await stub.statFile(path);
+  if (!statResult.success) {
+    return Response.json({ error: "Not found" }, { status: 404 });
+  }
+  const file = statResult.file;
+  if (file.isDirectory) {
+    const result2 = await stub.readdirFile(path);
+    if (!result2.success) {
+      return Response.json({ error: result2.error }, { status: 500 });
+    }
+    return Response.json({ files: result2.files, path });
+  }
+  if (file.storage !== "local") {
+    return Response.json({
+      file,
+      external: true,
+      location: file.location
+    });
+  }
+  const acceptHeader = url.searchParams.get("format") || "auto";
+  if (acceptHeader === "json") {
+    return Response.json({ file });
+  }
+  const result = await stub.readFile(path);
+  if (!result.success) {
+    return Response.json({ error: result.error }, { status: 404 });
+  }
+  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 new Response(bytes, {
+    headers: {
+      "Content-Type": file.mimeType,
+      "Content-Length": String(file.size),
+      "Content-Disposition": `inline; filename="${file.name}"`
+    }
+  });
+}
+async function handlePut(stub, path, req) {
+  const contentType = req.headers.get("Content-Type") || "";
+  if (contentType.includes("application/json")) {
+    const body = await req.json();
+    if (body.type === "directory") {
+      const result2 = await stub.mkdirFile(path);
+      if (!result2.success) {
+        return Response.json({ error: result2.error }, { status: 400 });
+      }
+      return Response.json({ directory: result2.directory }, { status: 201 });
+    }
+    if (body.location) {
+      const result2 = await stub.linkFile(path, body.location, {
+        mimeType: body.mimeType,
+        size: body.size,
+        metadata: body.metadata
+      });
+      if (!result2.success) {
+        return Response.json({ error: result2.error }, { status: 400 });
+      }
+      return Response.json(toAttachmentRef(result2.file), { status: 201 });
+    }
+    if (body.data) {
+      const result2 = await stub.writeFile(path, body.data, body.mimeType || "application/octet-stream", {
+        metadata: body.metadata,
+        thumbnail: body.thumbnail
+      });
+      if (!result2.success) {
+        return Response.json({ error: result2.error }, { status: 400 });
+      }
+      return Response.json(toAttachmentRef(result2.file), { status: 201 });
+    }
+    return Response.json({ error: "Invalid request body" }, { status: 400 });
+  }
+  const data = await req.arrayBuffer();
+  const mimeType = contentType.split(";")[0].trim() || "application/octet-stream";
+  const bytes = new Uint8Array(data);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  const base64 = btoa(binary);
+  const result = await stub.writeFile(path, base64, mimeType, {});
+  if (!result.success) {
+    return Response.json({ error: result.error }, { status: 400 });
+  }
+  return Response.json(toAttachmentRef(result.file), { status: 201 });
+}
+async function handleDelete(stub, path) {
+  const statResult = await stub.statFile(path);
+  if (!statResult.success) {
+    return Response.json({ error: "Not found" }, { status: 404 });
+  }
+  const file = statResult.file;
+  if (file.isDirectory) {
+    const result = await stub.rmdirFile(path);
+    if (!result.success) {
+      return Response.json({ error: result.error }, { status: 400 });
+    }
+  } else {
+    const result = await stub.unlinkFile(path);
+    if (!result.success) {
+      return Response.json({ error: result.error }, { status: 400 });
+    }
+  }
+  return new Response(null, { status: 204 });
+}
+
 // src/api/threads/[id]/logs/[logId].get.ts
 var logId_get_default = defineController(async ({ req, params, env }) => {
   const threadId = params.id;
@@ -2344,12 +2694,14 @@ var routeHandlers = {
   "POST:/models/available": available_post_default,
   "POST:/models/endpoints": endpoints_post_default,
   "GET:/threads/:id/cost": cost_get_default,
+  "GET:/threads/:id/fs": fs_default,
   "GET:/threads/:id/logs": logs_get_default,
-  "POST:/threads/:id/message": message_post_default,
+  "POST:/threads/:id/messages": messages_post_default,
   "GET:/threads/:id/messages": messages_get_default,
   "POST:/threads/:id/rpc": rpc_post_default,
   "POST:/threads/:id/stop": stop_post_default,
   "GET:/threads/:id/stream": stream_default,
+  "GET:/threads/:id/fs/**": path_default,
   "GET:/threads/:id/logs/:logId": logId_get_default,
   "DELETE:/threads/:id/messages/:messageId": messageId_delete_default,
   "PATCH:/threads/:id/messages/:messageId": messageId_patch_default