@standardagents/builder 0.40.5 → 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"() {
   }
@@ -13978,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,
@@ -14010,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));
@@ -14085,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) {
@@ -68892,7 +68862,7 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
 });
 
 // src/version.ts
-var BUILDER_VERSION = "0.40.5".length > 0 ? "0.40.5" : "dev";
+var BUILDER_VERSION = "0.40.6".length > 0 ? "0.40.6" : "dev";
 
 // src/api/diagnostics.get.ts
 init_LLMRequest();