@standardagents/builder 0.37.4 → 0.37.6

package/dist/built-in-routes.js

@@ -13320,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));
@@ -13411,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 {
@@ -13429,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;
@@ -13446,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" });
@@ -13463,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() {
@@ -13638,7 +13677,7 @@ var init_ThreadStateImpl = __esm({
         return bytes.buffer;
       }
       async readFileStream(path10, options) {
-        const fileInfo = await this._threadInstance.statFile(path10);
+        const fileInfo = this._unwrapStatRecord(await this._threadInstance.statFile(path10));
         if (!fileInfo) {
           return null;
         }
@@ -13693,12 +13732,32 @@ var init_ThreadStateImpl = __esm({
           }
         };
       }
+      /**
+       * Unwrap the thread DO's `{ success, file }` stat envelope (older shapes
+       * returned the record directly). A failed or absent lookup is NULL — the
+       * old code mapped the envelope itself, producing a truthy record with
+       * every field defaulted (size 0, application/octet-stream) even for
+       * NONEXISTENT paths, which let a phantom asset pass an existence check and
+       * a real 1.2MB image read as "0 bytes" (2026-08-11).
+       */
+      _unwrapStatRecord(result) {
+        const record24 = result?.file ?? result;
+        if (!record24 || typeof record24 !== "object") return null;
+        if (!("path" in record24) && !("name" in record24)) return null;
+        return record24;
+      }
       async statFile(path10) {
-        const result = await this._threadInstance.statFile(path10);
-        return result ? this._mapFileRecord(result) : null;
+        const record24 = this._unwrapStatRecord(await this._threadInstance.statFile(path10));
+        return record24 ? this._mapFileRecord(record24) : null;
       }
       async readdirFile(path10) {
-        const entries = await this._threadInstance.readdirFile(path10);
+        const result = await this._threadInstance.readdirFile(path10);
+        const entries = Array.isArray(result) ? result : result?.files;
+        if (!Array.isArray(entries)) {
+          throw new Error(
+            result?.error || `Could not list directory: ${path10}`
+          );
+        }
         return {
           entries: entries.map((e) => this._mapFileRecord(e))
         };
@@ -67928,7 +67987,7 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
 });
 
 // src/version.ts
-var BUILDER_VERSION = "0.37.4".length > 0 ? "0.37.4" : "dev";
+var BUILDER_VERSION = "0.37.6".length > 0 ? "0.37.6" : "dev";
 
 // src/api/diagnostics.get.ts
 init_LLMRequest();
@@ -70318,6 +70377,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;
@@ -70329,8 +70415,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;
   }
@@ -70340,20 +70427,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);
@@ -73459,31 +73548,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);
@@ -73492,13 +73584,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(
@@ -73582,31 +73675,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);
@@ -73704,13 +73800,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":
@@ -73735,14 +73832,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" },
@@ -73756,9 +73854,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}` },