@standardagents/builder 0.37.3 → 0.37.5

package/dist/built-in-routes.js

@@ -9983,10 +9983,18 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
           const mimeType = match2[1];
           const base64Data = match2[2];
           const ext = mimeType.split("/")[1] || "png";
+          if (base64Data.length < 64) {
+            console.error("[FlowEngine] Generated image payload is empty/truncated, skipping");
+            continue;
+          }
           const attachmentId = crypto.randomUUID();
           const path10 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
           try {
-            await state.thread.instance.writeFile(path10, base64Data, mimeType);
+            const written = await state.thread.instance.writeFile(path10, base64Data, mimeType);
+            if (written && written.success === false) {
+              console.error("[FlowEngine] Generated image write failed:", written.error);
+              continue;
+            }
             if (image.id) {
               imagePathMap.set(image.id, path10);
             }
@@ -10053,10 +10061,18 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
           const mimeType = imageUrl.slice(dataPrefix.length, base64Index);
           const base64Data = imageUrl.slice(base64Index + base64Marker.length);
           const ext = mimeType.split("/")[1] || "png";
+          if (base64Data.length < 64) {
+            console.error(`[FlowEngine] ${toolName} image payload is empty/truncated, skipping`);
+            continue;
+          }
           const attachmentId = crypto.randomUUID();
           const path10 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
           try {
-            await state.thread.instance.writeFile(path10, base64Data, mimeType);
+            const written = await state.thread.instance.writeFile(path10, base64Data, mimeType);
+            if (written && written.success === false) {
+              console.error(`[FlowEngine] ${toolName} image write failed:`, written.error);
+              continue;
+            }
             const attachmentRef = {
               id: attachmentId,
               type: "file",
@@ -13304,8 +13320,25 @@ var init_ThreadStateImpl = __esm({
         const mustParkForApproval = await this.forwardedCallNeedsApproval(request);
         if (mustParkForApproval && canPark && toolCallId && typeof instance.hasBridge === "function" && await instance.hasBridge()) {
           await instance.dispatchClientTool(request, toolCallId, side);
-          const getDelivered = instance.getDeliveredClientToolResult;
-          if (typeof getDelivered === "function") {
+          const withDelivery = instance;
+          if (typeof withDelivery.awaitDeliveredClientToolResult === "function") {
+            try {
+              const delivered = await withDelivery.awaitDeliveredClientToolResult.call(
+                instance,
+                toolCallId,
+                4e3
+              );
+              if (delivered) {
+                return {
+                  ok: delivered.toolStatus !== "error",
+                  result: delivered.content,
+                  data: { toolCallId }
+                };
+              }
+            } catch {
+            }
+          } else if (typeof withDelivery.getDeliveredClientToolResult === "function") {
+            const getDelivered = withDelivery.getDeliveredClientToolResult;
             const graceDeadline = Date.now() + 4e3;
             while (Date.now() < graceDeadline) {
               await new Promise((r) => setTimeout(r, 150));
@@ -13395,7 +13428,14 @@ var init_ThreadStateImpl = __esm({
             if (typeof stub.proxyStreamOpen === "function") {
               const opened = await stub.proxyStreamOpen(withWake(parentId));
               if (opened.ok && opened.id) {
-                return { ok: true, duplex: this.buildProxyDuplex(stub, opened.id) };
+                return {
+                  ok: true,
+                  duplex: this.buildProxyDuplex(
+                    stub,
+                    opened.id,
+                    opened.parkedPull === true
+                  )
+                };
               }
               if (opened.error && !opened.noClient) {
                 return {
@@ -13413,11 +13453,15 @@ var init_ThreadStateImpl = __esm({
       }
       /**
        * Build a client duplex that bridges to a stream opened on an ancestor DO
-       * (the bridge holder) via chunk-pull RPCs. `readable` polls `proxyStreamPull`;
-       * `writable` forwards each chunk with `proxyStreamWrite`; teardown calls
+       * (the bridge holder) via chunk-pull RPCs. `readable` issues PARKED pulls —
+       * a current ancestor holds one `proxyStreamPull` until bytes, completion,
+       * error, or abort, so an idle open stream performs zero repeated pulls.
+       * Older ancestors use the bounded long-pull compatibility path. `writable`
+       * forwards each chunk with `proxyStreamWrite`; teardown calls
        * `proxyStreamAbort`.
        */
-      buildProxyDuplex(stub, id) {
+      static PROXY_PULL_MAX_WAIT_MS = 2e4;
+      buildProxyDuplex(stub, id, supportsParkedPull = false) {
         let settleDone;
         const done = new Promise((r) => settleDone = r);
         let closed = false;
@@ -13430,9 +13474,13 @@ var init_ThreadStateImpl = __esm({
         const readable = new ReadableStream({
           async pull(controller) {
             while (!closed) {
+              const pullStartedAt = Date.now();
               let res;
               try {
-                res = await stub.proxyStreamPull(id);
+                res = await stub.proxyStreamPull(
+                  id,
+                  supportsParkedPull ? void 0 : _ThreadStateImpl.PROXY_PULL_MAX_WAIT_MS
+                );
               } catch (error) {
                 controller.error(error instanceof Error ? error : new Error(String(error)));
                 settle({ ok: false, error: "proxy stream pull failed" });
@@ -13447,7 +13495,14 @@ var init_ThreadStateImpl = __esm({
                 return;
               }
               if (res.chunks.length > 0) return;
-              await new Promise((r) => setTimeout(r, 25));
+              if (supportsParkedPull) {
+                controller.error(new Error("parked proxy pull returned without data"));
+                settle({ ok: false, error: "parked proxy pull returned without data" });
+                return;
+              }
+              if (Date.now() - pullStartedAt < 250) {
+                await new Promise((r) => setTimeout(r, 250));
+              }
             }
           },
           cancel() {
@@ -67912,7 +67967,7 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
 });
 
 // src/version.ts
-var BUILDER_VERSION = "0.37.3".length > 0 ? "0.37.3" : "dev";
+var BUILDER_VERSION = "0.37.5".length > 0 ? "0.37.5" : "dev";
 
 // src/api/diagnostics.get.ts
 init_LLMRequest();
@@ -70302,6 +70357,33 @@ var id_patch_default = defineController2(async ({ req, env: env2, params }) => {
   }
 });
 
+// src/middleware/request-auth.ts
+async function resolveRequestAuth(context) {
+  if (context.auth) return context.auth;
+  return requireAuth(context.req, context.env);
+}
+async function resolveOptionalRequestAuth(context) {
+  if (context.auth) return context.auth;
+  return authenticate(context.req, context.env);
+}
+async function resolveRequestPermission(context, permission) {
+  if (context.auth) {
+    if (!hasPermission(context.auth.user, permission)) {
+      return Response.json(
+        { error: `Forbidden: '${permission}' access required` },
+        { status: 403 }
+      );
+    }
+    return context.auth;
+  }
+  return requirePermission(context.req, context.env, permission);
+}
+function routerAuthorizedThread(context, threadId) {
+  const access = context.threadAccess;
+  if (!access || !threadId) return null;
+  return access.threadId === threadId ? access.thread : null;
+}
+
 // src/api/threads/[id].ts
 function resolveIconUrl2(icon, origin) {
   if (!icon) return void 0;
@@ -70313,8 +70395,9 @@ function resolveIconUrl2(icon, origin) {
   }
   return icon;
 }
-var id_default = defineController2(async ({ req, params, env: env2 }) => {
-  const authResult = await requireAuth(req, env2);
+var id_default = defineController2(async (context) => {
+  const { req, params, env: env2 } = context;
+  const authResult = await resolveRequestAuth(context);
   if (authResult instanceof Response) {
     return authResult;
   }
@@ -70324,20 +70407,22 @@ var id_default = defineController2(async ({ req, params, env: env2 }) => {
     return Response.json({ error: "Thread ID required" }, { status: 400 });
   }
   try {
-    const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
-    const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
-    const thread = await agentBuilder.getThread(threadId);
-    if (!thread) {
-      return Response.json(
-        { error: `Thread not found: ${threadId}` },
-        { status: 404 }
-      );
-    }
-    if (!canAccessThread(auth, thread)) {
-      return Response.json(
-        { error: "Forbidden: You don't have access to this thread" },
-        { status: 403 }
-      );
+    if (!routerAuthorizedThread(context, threadId)) {
+      const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
+      const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
+      const thread = await agentBuilder.getThread(threadId);
+      if (!thread) {
+        return Response.json(
+          { error: `Thread not found: ${threadId}` },
+          { status: 404 }
+        );
+      }
+      if (!canAccessThread(auth, thread)) {
+        return Response.json(
+          { error: "Forbidden: You don't have access to this thread" },
+          { status: 403 }
+        );
+      }
     }
     const durableId = env2.AGENT_BUILDER_THREAD.idFromName(threadId);
     const stub = env2.AGENT_BUILDER_THREAD.get(durableId);
@@ -73443,31 +73528,34 @@ var diagnostics_get_default2 = defineController2(async ({ req, params, env: env2
 });
 
 // src/api/threads/[id]/effects.get.ts
-async function getAuthorizedThreadStub(req, env2, threadId) {
-  const authResult = await requireAuth(req, env2);
+async function getAuthorizedThreadStub(context, threadId) {
+  const { env: env2 } = context;
+  const authResult = await resolveRequestAuth(context);
   if (authResult instanceof Response) {
     return authResult;
   }
-  const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
-  const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
-  if (typeof agentBuilder.getThread !== "function") {
-    return Response.json(
-      { error: "Thread lookup is not supported by this runtime" },
-      { status: 500 }
-    );
-  }
-  const thread = await agentBuilder.getThread(threadId);
-  if (!thread) {
-    return Response.json(
-      { error: `Thread not found: ${threadId}` },
-      { status: 404 }
-    );
-  }
-  if (!canAccessThread(authResult, thread)) {
-    return Response.json(
-      { error: "Forbidden: You don't have access to this thread" },
-      { status: 403 }
-    );
+  if (!routerAuthorizedThread(context, threadId)) {
+    const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
+    if (typeof agentBuilder.getThread !== "function") {
+      return Response.json(
+        { error: "Thread lookup is not supported by this runtime" },
+        { status: 500 }
+      );
+    }
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    if (!canAccessThread(authResult, thread)) {
+      return Response.json(
+        { error: "Forbidden: You don't have access to this thread" },
+        { status: 403 }
+      );
+    }
   }
   const durableId = env2.AGENT_BUILDER_THREAD.idFromName(threadId);
   return env2.AGENT_BUILDER_THREAD.get(durableId);
@@ -73476,13 +73564,14 @@ function parseInteger(value, fallback) {
   const parsed = value ? Number.parseInt(value, 10) : Number.NaN;
   return Number.isFinite(parsed) ? parsed : fallback;
 }
-var effects_get_default = defineController2(async ({ req, params, env: env2, url }) => {
+var effects_get_default = defineController2(async (context) => {
+  const { params, url } = context;
   const threadId = params.id;
   if (!threadId) {
     return Response.json({ error: "Thread ID required" }, { status: 400 });
   }
   try {
-    const stub = await getAuthorizedThreadStub(req, env2, threadId);
+    const stub = await getAuthorizedThreadStub(context, threadId);
     if (stub instanceof Response) return stub;
     if (typeof stub.listEffectRuns !== "function") {
       return Response.json(
@@ -73566,31 +73655,34 @@ var fs_default = defineController2(async ({ req, params, env: env2 }) => {
 });
 
 // src/api/threads/[id]/kv/index.ts
-async function getAuthorizedThreadStub2(req, env2, threadId) {
-  const authResult = await requireAuth(req, env2);
+async function getAuthorizedThreadStub2(context, threadId) {
+  const { env: env2 } = context;
+  const authResult = await resolveRequestAuth(context);
   if (authResult instanceof Response) {
     return authResult;
   }
-  const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
-  const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
-  if (typeof agentBuilder.getThread !== "function") {
-    return Response.json(
-      { error: "Thread lookup is not supported by this runtime" },
-      { status: 500 }
-    );
-  }
-  const thread = await agentBuilder.getThread(threadId);
-  if (!thread) {
-    return Response.json(
-      { error: `Thread not found: ${threadId}` },
-      { status: 404 }
-    );
-  }
-  if (!canAccessThread(authResult, thread)) {
-    return Response.json(
-      { error: "Forbidden: You don't have access to this thread" },
-      { status: 403 }
-    );
+  if (!routerAuthorizedThread(context, threadId)) {
+    const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
+    if (typeof agentBuilder.getThread !== "function") {
+      return Response.json(
+        { error: "Thread lookup is not supported by this runtime" },
+        { status: 500 }
+      );
+    }
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    if (!canAccessThread(authResult, thread)) {
+      return Response.json(
+        { error: "Forbidden: You don't have access to this thread" },
+        { status: 403 }
+      );
+    }
   }
   const durableId = env2.AGENT_BUILDER_THREAD.idFromName(threadId);
   return env2.AGENT_BUILDER_THREAD.get(durableId);
@@ -73688,13 +73780,14 @@ async function handleDelete(stub, req, url) {
   await stub.setValue(key, null);
   return new Response(null, { status: 204 });
 }
-var kv_default = defineController2(async ({ req, params, env: env2, url }) => {
+var kv_default = defineController2(async (context) => {
+  const { req, params, url } = context;
   const threadId = params.id;
   if (!threadId) {
     return Response.json({ error: "Thread ID required" }, { status: 400 });
   }
   try {
-    const stub = await getAuthorizedThreadStub2(req, env2, threadId);
+    const stub = await getAuthorizedThreadStub2(context, threadId);
     if (stub instanceof Response) return stub;
     switch (req.method) {
       case "GET":
@@ -73719,14 +73812,15 @@ var kv_default = defineController2(async ({ req, params, env: env2, url }) => {
 });
 
 // src/api/threads/[id]/logs.get.ts
-var logs_get_default = defineController2(async ({ req, params, env: env2 }) => {
+var logs_get_default = defineController2(async (context) => {
+  const { req, params, env: env2 } = context;
   if (isPlatformHosted(env2)) {
-    const authResult = await requirePermission(req, env2, "logs");
+    const authResult = await resolveRequestPermission(context, "logs");
     if (authResult instanceof Response) {
       return authResult;
     }
   } else {
-    const authContext = await authenticate(req, env2);
+    const authContext = await resolveOptionalRequestAuth(context);
     if (authContext && !hasPermission(authContext.user, "logs")) {
       return Response.json(
         { error: "Forbidden: 'logs' access required" },
@@ -73740,9 +73834,12 @@ var logs_get_default = defineController2(async ({ req, params, env: env2 }) => {
     return Response.json({ error: "Thread ID required" }, { status: 400 });
   }
   try {
-    const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
-    const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
-    const thread = await agentBuilder.getThread(threadId);
+    let thread = routerAuthorizedThread(context, threadId);
+    if (!thread) {
+      const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
+      const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
+      thread = await agentBuilder.getThread(threadId);
+    }
     if (!thread) {
       return Response.json(
         { error: `Thread not found: ${threadId}` },