@standardagents/builder 0.10.0 → 0.10.1-dev.b8746e9

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);
@@ -2077,15 +2105,19 @@ var logs_get_default = defineController(async ({ req, params, env }) => {
   }
 });
 
-// src/api/threads/[id]/message.post.ts
-var imageProcessingModule = null;
-async function getImageProcessing() {
-  if (!imageProcessingModule) {
-    imageProcessingModule = await import('@standardagents/builder/image-processing');
+// 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 imageProcessingModule;
+  return false;
 }
-var message_post_default = defineController(async ({ req, params, env }) => {
+var messages_post_default = defineController(async ({ req, params, env }) => {
   const threadId = params.id;
   if (!threadId) {
     return Response.json({ error: "Thread ID required" }, { status: 400 });
@@ -2122,18 +2154,22 @@ var message_post_default = defineController(async ({ req, params, env }) => {
         let mimeType = attachment.mimeType;
         let width = attachment.width;
         let height = attachment.height;
-        const imgProc = await getImageProcessing();
-        if (mimeType.startsWith("image/") && imgProc.needsProcessing(fileData, mimeType)) {
+        if (mimeType.startsWith("image/") && needsProcessing(fileData, mimeType)) {
           try {
-            const buffer = imgProc.base64ToArrayBuffer(fileData);
-            const processed = await imgProc.processImage(buffer, mimeType);
-            fileData = imgProc.arrayBufferToBase64(processed.data);
-            mimeType = processed.mimeType;
-            width = processed.width;
-            height = processed.height;
-            console.log(
-              `[image-processing] Processed ${attachment.name}: ${(buffer.byteLength / 1024 / 1024).toFixed(2)}MB \u2192 ${(processed.data.byteLength / 1024 / 1024).toFixed(2)}MB, ${processed.width}x${processed.height}, ${processed.mimeType}`
-            );
+            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);
           }
@@ -2315,6 +2351,20 @@ 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;
@@ -2436,7 +2486,7 @@ async function handlePut(stub, path, req) {
       if (!result2.success) {
         return Response.json({ error: result2.error }, { status: 400 });
       }
-      return Response.json({ file: result2.file }, { status: 201 });
+      return Response.json(toAttachmentRef(result2.file), { status: 201 });
     }
     if (body.data) {
       const result2 = await stub.writeFile(path, body.data, body.mimeType || "application/octet-stream", {
@@ -2446,7 +2496,7 @@ async function handlePut(stub, path, req) {
       if (!result2.success) {
         return Response.json({ error: result2.error }, { status: 400 });
       }
-      return Response.json({ file: result2.file }, { status: 201 });
+      return Response.json(toAttachmentRef(result2.file), { status: 201 });
     }
     return Response.json({ error: "Invalid request body" }, { status: 400 });
   }
@@ -2462,7 +2512,7 @@ async function handlePut(stub, path, req) {
   if (!result.success) {
     return Response.json({ error: result.error }, { status: 400 });
   }
-  return Response.json({ file: result.file }, { status: 201 });
+  return Response.json(toAttachmentRef(result.file), { status: 201 });
 }
 async function handleDelete(stub, path) {
   const statResult = await stub.statFile(path);
@@ -2646,7 +2696,7 @@ var routeHandlers = {
   "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,