@standardagents/builder 0.40.5-next.3b25e2a → 0.40.6

package/dist/built-in-routes.js

@@ -99,12 +99,6 @@ function encodeStreamChunk(bytes) {
   }
   return btoa(binary);
 }
-function decodeStreamChunk(data) {
-  const binary = atob(data);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-  return bytes;
-}
 var init_client_forwarding = __esm({
   "src/agents/client-forwarding.ts"() {
   }
@@ -5047,9 +5041,7 @@ Message one with subagent_message(referenceId, message).`
             if (resumable) {
               await this.settleResumableChildAfterRun(
                 state,
-                stub,
-                childThreadId,
-                childResult
+                childThreadId
               );
             } else if (stub.terminateThread) {
               await stub.terminateThread(childThreadId);
@@ -5061,7 +5053,7 @@ Message one with subagent_message(referenceId, message).`
               attachments: copiedAttachments,
               subagent_id: childThreadId
             };
-            return resumable && !this.isTerminalSubagentResult(childResult) ? this.withReferenceInToolResult(toolResult, childThreadId) : toolResult;
+            return resumable ? this.withReferenceInToolResult(toolResult, childThreadId) : toolResult;
           }
           const backgroundRun = (async () => {
             try {
@@ -5096,9 +5088,7 @@ Message one with subagent_message(referenceId, message).`
               if (resumable) {
                 await this.settleResumableChildAfterRun(
                   state,
-                  stub,
-                  childThreadId,
-                  childResult
+                  childThreadId
                 );
               } else if (stub.terminateThread) {
                 await stub.terminateThread(childThreadId);
@@ -5493,18 +5483,8 @@ Message one with subagent_message(referenceId, message).`
           JSON.stringify(next)
         );
       }
-      static isTerminalSubagentResult(result) {
-        return result.terminal === true;
-      }
-      static async settleResumableChildAfterRun(state, childThread, reference, result) {
-        if (!this.isTerminalSubagentResult(result)) {
-          await this.updateChildStatus(state, reference, "idle");
-          return;
-        }
-        await this.updateChildStatus(state, reference, "terminated");
-        if (typeof childThread.terminateThread === "function") {
-          await childThread.terminateThread(reference);
-        }
+      static async settleResumableChildAfterRun(state, reference) {
+        await this.updateChildStatus(state, reference, "idle");
       }
       static async buildChildInvocationMessages(state, childThread, content, receivesMessages, parentAttachments, initialArguments) {
         const copiedAttachments = await this.copyAttachmentsBetweenThreads(
@@ -13992,27 +13972,51 @@ var init_ThreadStateImpl = __esm({
         const withWake = (threadId) => wakeUserId ? { ...request, wake: { threadId, userId: wakeUserId } } : request;
         const local = await instance.openClientStream(withWake(this._metadata.id));
         if (local.ok || !this.isNoClient(local)) return local;
-        const env2 = this._threadInstance.env;
-        if (!env2?.AGENT_BUILDER_THREAD) return local;
+        if (typeof instance.createProxyStreamReceiver !== "function" || typeof instance.proxyStreamReceive !== "function") {
+          return local;
+        }
+        let abortRemote = null;
+        const receiver = instance.createProxyStreamReceiver((error) => abortRemote?.(error));
+        const discardReceiver = async (error) => {
+          await instance.proxyStreamReceive(receiver.id, { type: "abort", error });
+        };
+        const namespace = instance.env.AGENT_BUILDER_THREAD;
         const seen = /* @__PURE__ */ new Set([this._metadata.id]);
         let parentId = await this.resolveParentThreadId(this._metadata.id);
         while (parentId && !seen.has(parentId)) {
           seen.add(parentId);
           try {
-            const stub = env2.AGENT_BUILDER_THREAD.get(env2.AGENT_BUILDER_THREAD.idFromName(parentId));
+            const stub = namespace.get(namespace.idFromName(parentId));
             if (typeof stub.proxyStreamOpen === "function") {
-              const opened = await stub.proxyStreamOpen(withWake(parentId));
+              const opened = await stub.proxyStreamOpen(withWake(parentId), {
+                threadId: this._metadata.id,
+                receiverId: receiver.id
+              });
               if (opened.ok && opened.id) {
+                if (opened.eventDriven !== true) {
+                  await stub.proxyStreamAbort(opened.id).catch(() => {
+                  });
+                  await discardReceiver("The ancestor runtime does not support event-driven streams.");
+                  return {
+                    ok: false,
+                    error: "The ancestor runtime does not support event-driven streams.",
+                    data: { code: "unsupported" }
+                  };
+                }
+                abortRemote = (error) => {
+                  void stub.proxyStreamAbort(opened.id).catch(() => {
+                  });
+                  if (error) {
+                    void instance.proxyStreamReceive(receiver.id, { type: "abort", error });
+                  }
+                };
                 return {
                   ok: true,
-                  duplex: this.buildProxyDuplex(
-                    stub,
-                    opened.id,
-                    opened.parkedPull === true
-                  )
+                  duplex: this.buildEventProxyDuplex(stub, opened.id, receiver, instance)
                 };
               }
               if (opened.error && !opened.noClient) {
+                await discardReceiver(opened.error);
                 return {
                   ok: false,
                   error: opened.error,
@@ -14024,69 +14028,21 @@ var init_ThreadStateImpl = __esm({
           }
           parentId = await this.resolveParentThreadId(parentId);
         }
+        await discardReceiver(local.error ?? "No execution-owner bridge is available.");
         return local;
       }
       /**
        * Build a client duplex that bridges to a stream opened on an ancestor DO
-       * (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`.
+       * (the bridge holder). The readable is the receiver registered on this DO;
+       * writes and terminal actions are the only child-to-ancestor RPCs.
        */
-      static PROXY_PULL_MAX_WAIT_MS = 2e4;
-      buildProxyDuplex(stub, id, supportsParkedPull = false) {
-        let settleDone;
-        const done = new Promise((r) => settleDone = r);
+      buildEventProxyDuplex(stub, id, receiver, instance) {
         let closed = false;
-        let settled = false;
-        const settle = (result) => {
-          if (settled) return;
-          settled = true;
-          settleDone(result);
+        const settleLocal = (error) => {
+          if (typeof instance.proxyStreamReceive !== "function") return;
+          const frame = error ? { type: "abort", error } : { type: "end" };
+          void instance.proxyStreamReceive(receiver.id, frame);
         };
-        const readable = new ReadableStream({
-          async pull(controller) {
-            while (!closed) {
-              const pullStartedAt = Date.now();
-              let res;
-              try {
-                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" });
-                return;
-              }
-              for (const chunk of res.chunks) {
-                controller.enqueue(decodeStreamChunk(chunk));
-              }
-              if (res.done) {
-                controller.close();
-                settle(res.error ? { ok: false, error: res.error } : { ok: true });
-                return;
-              }
-              if (res.chunks.length > 0) return;
-              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() {
-            closed = true;
-            void stub.proxyStreamAbort(id).catch(() => {
-            });
-            settle({ ok: false, error: "proxy stream reader canceled" });
-          }
-        });
         const writable = new WritableStream({
           async write(chunk) {
             await stub.proxyStreamWrite(id, encodeStreamChunk(chunk));
@@ -14099,20 +14055,20 @@ var init_ThreadStateImpl = __esm({
             closed = true;
             void stub.proxyStreamAbort(id).catch(() => {
             });
-            settle({ ok: false, error: "proxy stream writer aborted" });
+            settleLocal("The proxy stream writer was aborted.");
           }
         });
         return {
-          readable,
+          readable: receiver.readable,
           writable,
           close: (error) => {
             if (closed) return;
             closed = true;
             void stub.proxyStreamAbort(id).catch(() => {
             });
-            settle(error ? { ok: false, error } : { ok: true });
+            settleLocal(error);
           },
-          done
+          done: receiver.done
         };
       }
       isNoClient(res) {
@@ -68027,7 +67983,14 @@ function isHostedInstance(env2) {
   }
   return Boolean(value);
 }
-function isTrustedLocalDevelopmentRequest(request, env2) {
+function compiledTrustedDevHosts() {
+  try {
+    return typeof __STANDARD_AGENTS_TRUSTED_DEV_HOSTS__ !== "undefined" && Array.isArray(__STANDARD_AGENTS_TRUSTED_DEV_HOSTS__) ? __STANDARD_AGENTS_TRUSTED_DEV_HOSTS__ : [];
+  } catch {
+    return [];
+  }
+}
+function isTrustedLocalDevelopmentRequest(request, env2, trustedDevHosts = compiledTrustedDevHosts()) {
   if (isHostedInstance(env2)) return false;
   let hostname;
   try {
@@ -68035,7 +67998,7 @@ function isTrustedLocalDevelopmentRequest(request, env2) {
   } catch {
     return false;
   }
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local");
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local") || trustedDevHosts.some((trusted) => trusted.trim().toLowerCase() === hostname);
 }
 function requestObservedOrigins(request) {
   const origins = /* @__PURE__ */ new Set();
@@ -68899,7 +68862,7 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
 });
 
 // src/version.ts
-var BUILDER_VERSION = "0.40.5-next.3b25e2a".length > 0 ? "0.40.5-next.3b25e2a" : "dev";
+var BUILDER_VERSION = "0.40.6".length > 0 ? "0.40.6" : "dev";
 
 // src/api/diagnostics.get.ts
 init_LLMRequest();
@@ -75494,11 +75457,8 @@ var tool_result_post_default = defineController2(async ({ req, params, env: env2
     if (!delivered) {
       return Response.json({ status: "ignored" }, { status: 200 });
     }
-    if (delivered.resume) {
-      await stub.continueExecution(threadId, delivered.side);
-      return Response.json({ status: "resumed", side: delivered.side }, { status: 200 });
-    }
-    return Response.json({ status: "delivered", side: delivered.side }, { status: 200 });
+    await stub.continueExecution(threadId, delivered.side);
+    return Response.json({ status: "resumed", side: delivered.side }, { status: 200 });
   } catch (error) {
     console.error(`Error delivering tool result for thread ${threadId}:`, error);
     return Response.json(