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

package/dist/index.js

@@ -5083,9 +5083,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);
@@ -5097,7 +5095,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 {
@@ -5132,9 +5130,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);
@@ -5529,18 +5525,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(
@@ -14736,27 +14722,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 env = this._threadInstance.env;
-        if (!env?.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 = env.AGENT_BUILDER_THREAD.get(env.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,
@@ -14768,69 +14778,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));
@@ -14843,20 +14805,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) {
@@ -16819,7 +16781,7 @@ function createHmrReloader() {
       const isConfigFile = isModelFile || isProviderFile || isPromptFile || isAgentFile || isEffectFile;
       if (!isToolFile && !isThreadApiFile && !isHookFile && !isConfigFile && !isUserEndpointFile) return;
       reloader.invalidateSourceFileModule(server, file);
-      if (isConfigFile || isToolFile) regenerateTypes();
+      if (isConfigFile || isToolFile || isHookFile) regenerateTypes();
       if (isToolFile) await reloader.reloadToolsModule(server);
       if (isModelFile) await reloader.reloadModelsModule(server);
       if (isProviderFile) await reloader.reloadProvidersModule(server);
@@ -18947,6 +18909,29 @@ async function scanPromptsDirectory(dir) {
 async function scanAgentsDirectory(dir) {
   return scanConfigDirectory(dir, /export\s+default\s+defineAgent/);
 }
+function findLegacyRootAgentFiles(agentsDir) {
+  const agentsRoot = path9__default.dirname(agentsDir);
+  if (path9__default.basename(agentsDir) !== "agents" || path9__default.basename(agentsRoot) !== "agents") {
+    return [];
+  }
+  if (!fs9__default.existsSync(agentsRoot)) return [];
+  return fs9__default.readdirSync(agentsRoot, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => path9__default.join(agentsRoot, entry.name)).filter((filePath) => {
+    try {
+      return /export\s+default\s+defineAgent/.test(fs9__default.readFileSync(filePath, "utf8"));
+    } catch {
+      return false;
+    }
+  }).sort();
+}
+function warnLegacyRootAgentFiles(agentsDir) {
+  const expectedDir = path9__default.relative(process.cwd(), agentsDir).replace(/\\/g, "/");
+  for (const filePath of findLegacyRootAgentFiles(agentsDir)) {
+    const source = path9__default.relative(process.cwd(), filePath).replace(/\\/g, "/");
+    console.warn(
+      `[agentbuilder] Agent definition "${source}" is outside the scanned agent directory. Move it to "${expectedDir}/" so it is registered.`
+    );
+  }
+}
 async function scanEffectsDirectory(dir) {
   const effects = [];
   if (!fs9__default.existsSync(dir)) {
@@ -22657,7 +22642,32 @@ function isHostedInstance(env) {
   }
   return Boolean(value);
 }
-function isTrustedLocalDevelopmentRequest(request, env) {
+function normalizeTrustedDevHosts(hosts) {
+  const normalized = /* @__PURE__ */ new Set();
+  for (const rawHost of hosts ?? []) {
+    const candidate = rawHost.trim().toLowerCase().replace(/\.$/, "");
+    try {
+      const parsed = new URL(`http://${candidate}`);
+      if (!candidate || candidate.includes("*") || parsed.hostname.toLowerCase().replace(/\.$/, "") !== candidate || parsed.port || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+        throw new Error("invalid hostname");
+      }
+    } catch {
+      throw new Error(
+        `Invalid trusted development hostname "${rawHost}". Use an exact hostname without a scheme, port, path, or wildcard.`
+      );
+    }
+    normalized.add(candidate);
+  }
+  return [...normalized];
+}
+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, env, trustedDevHosts = compiledTrustedDevHosts()) {
   if (isHostedInstance(env)) return false;
   let hostname;
   try {
@@ -22665,7 +22675,7 @@ function isTrustedLocalDevelopmentRequest(request, env) {
   } 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 isPublicApiRoute(routePath, request, env) {
   if (PUBLIC_ROUTES.has(routePath)) return true;
@@ -22814,7 +22824,8 @@ function createDevMiddleware(server, context) {
     installedProviderPackageMap,
     hmr,
     sourceDirs,
-    regenerateTypes
+    regenerateTypes,
+    trustedDevHosts
   } = context;
   server.watcher.on("add", async (file) => {
     await hmr.handleFileChange(file, server, sourceDirs, regenerateTypes);
@@ -22848,7 +22859,8 @@ function createDevMiddleware(server, context) {
     try {
       trustedLocalHost = isTrustedLocalDevelopmentRequest(
         new Request(`http://${req.headers.host || "invalid.remote"}${routePath}`),
-        {}
+        {},
+        trustedDevHosts
       );
     } catch {
     }
@@ -24082,7 +24094,7 @@ var firstPartyProviderPackages = [
   "@standardagents/openrouter",
   "@standardagents/xai"
 ];
-var depsToInclude = [
+var baseDepsToInclude = [
   "zod",
   "zod/v3",
   "zod/v4",
@@ -24093,17 +24105,24 @@ var depsToInclude = [
   // a root dep). The `parent > child` form pre-bundles it at startup so Vite
   // doesn't discover it mid-request and reload the worker (which would destroy
   // an in-flight Durable Object execution and drop the client bridge).
-  "@standardagents/openrouter > @openrouter/sdk",
   "magic-string",
   "@standardagents/spec",
   // Incremental JSON reader used by the runtime to surface a tool's progress
   // argument from partial streamed tool-call arguments (tool_call_started).
-  "@formkit/jsonreader",
-  // Pre-bundle the provider packages themselves so their whole subtree (SDKs,
-  // pricing tables) lands in the initial optimized bundle and nothing is
-  // discovered lazily by workerd.
-  ...firstPartyProviderPackages
+  "@formkit/jsonreader"
 ];
+function depsToInclude(options = {}) {
+  const installedProviders = options.isPackageInstalled ? firstPartyProviderPackages.filter(options.isPackageInstalled) : firstPartyProviderPackages;
+  const openRouterTransitive = installedProviders.includes("@standardagents/openrouter") ? ["@standardagents/openrouter > @openrouter/sdk"] : [];
+  return [...baseDepsToInclude, ...openRouterTransitive, ...installedProviders];
+}
+function trustedDevHostDefines(options) {
+  return {
+    __STANDARD_AGENTS_TRUSTED_DEV_HOSTS__: JSON.stringify(
+      normalizeTrustedDevHosts(options.trustedDevHosts)
+    )
+  };
+}
 var packingDeps = [
   "rollup",
   "@rollup/plugin-commonjs",
@@ -24112,7 +24131,7 @@ var packingDeps = [
   "fsevents",
   "typescript"
 ];
-function createPluginViteConfig(pluginModuleUrl) {
+function createPluginViteConfig(pluginModuleUrl, options = {}) {
   const currentDir = path9__default.dirname(fileURLToPath(pluginModuleUrl));
   const isInDist = currentDir.endsWith("dist");
   const builderClientDir = path9__default.resolve(
@@ -24120,6 +24139,7 @@ function createPluginViteConfig(pluginModuleUrl) {
     isInDist ? "./client" : "../dist/client"
   );
   return {
+    define: trustedDevHostDefines(options),
     publicDir: fs9__default.existsSync(builderClientDir) ? builderClientDir : void 0,
     build: {
       rollupOptions: {
@@ -24135,7 +24155,7 @@ function createPluginViteConfig(pluginModuleUrl) {
       // `npm run dev` ("There is a new version of the pre-bundle for X").
       holdUntilCrawlEnd: true,
       exclude: depsToExclude,
-      include: depsToInclude.filter((dep) => dep !== "zod/v3" && dep !== "zod/v4" && dep !== "zod/v4/core")
+      include: depsToInclude(options).filter((dep) => dep !== "zod/v3" && dep !== "zod/v4" && dep !== "zod/v4/core")
     },
     ssr: {
       noExternal: [
@@ -24240,7 +24260,11 @@ function createAgentBuilderCloudflarePlugins(options) {
     }
   });
 }
-function applyPluginEnvironmentConfig(config) {
+function applyPluginEnvironmentConfig(config, options = {}) {
+  config.define = {
+    ...config.define || {},
+    ...trustedDevHostDefines(options)
+  };
   config.optimizeDeps = config.optimizeDeps || {};
   config.optimizeDeps.holdUntilCrawlEnd = true;
   config.optimizeDeps.exclude = [
@@ -24249,7 +24273,7 @@ function applyPluginEnvironmentConfig(config) {
   ];
   config.optimizeDeps.include = [
     ...config.optimizeDeps.include || [],
-    ...depsToInclude.filter((dep) => !config.optimizeDeps?.include?.includes(dep))
+    ...depsToInclude(options).filter((dep) => !config.optimizeDeps?.include?.includes(dep))
   ];
   config.build = config.build || {};
   config.build.rollupOptions = config.build.rollupOptions || {};
@@ -24309,6 +24333,7 @@ function normalizeDeviceApprovalBrand(value) {
 // src/plugin.ts
 function agentbuilder(options = {}) {
   const deviceApproval = normalizeDeviceApprovalBrand(options.deviceApproval);
+  const trustedDevHosts = normalizeTrustedDevHosts(options.trustedDevHosts);
   const toolsDir = options.toolsDir ? path9__default.resolve(process.cwd(), options.toolsDir) : path9__default.resolve(process.cwd(), "agents/tools");
   const hooksDir = options.hooksDir ? path9__default.resolve(process.cwd(), options.hooksDir) : path9__default.resolve(process.cwd(), "agents/hooks");
   const threadApiDir = options.apiDir ? path9__default.resolve(process.cwd(), options.apiDir) : path9__default.resolve(process.cwd(), "agents/api");
@@ -24413,7 +24438,8 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
     installedProviderPackageMap,
     hmr,
     sourceDirs,
-    regenerateTypes
+    regenerateTypes,
+    trustedDevHosts
   };
   const workerEntry = path9__default.relative(process.cwd(), generatedWorkerEntry).split(path9__default.sep).join("/");
   const corePlugin = {
@@ -24421,12 +24447,18 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
     enforce: "pre",
     config() {
       writeGeneratedWorkerEntry();
-      const viteConfig = createPluginViteConfig(import.meta.url);
+      const viteConfig = createPluginViteConfig(import.meta.url, {
+        isPackageInstalled: isProviderPackageInstalled,
+        trustedDevHosts
+      });
       return viteConfig;
     },
     // Apply exclusions and inclusions to ALL environments including Cloudflare worker
     configEnvironment(_name, config) {
-      applyPluginEnvironmentConfig(config);
+      applyPluginEnvironmentConfig(config, {
+        isPackageInstalled: isProviderPackageInstalled,
+        trustedDevHosts
+      });
     },
     resolveId(id) {
       if (id === VIRTUAL_TOOLS_ID) {
@@ -24471,6 +24503,7 @@ export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, ThreadWatchdog
     },
     buildStart() {
       writeGeneratedWorkerEntry();
+      warnLegacyRootAgentFiles(agentsDir);
       regenerateTypes();
       this.addWatchFile(toolsDir);
       this.addWatchFile(threadApiDir);
@@ -29242,12 +29275,9 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
             await parentThread.updateChildRegistryStatus(
               params.parent_thread_id,
               childThread.id,
-              childResult.terminal ? "terminated" : "idle"
+              "idle"
             );
           }
-          if (childResult.terminal && typeof childThreadStub.terminateThread === "function") {
-            await childThreadStub.terminateThread(childThread.id);
-          }
         } else if (typeof childThreadStub.terminateThread === "function") {
           await childThreadStub.terminateThread(childThread.id);
         }
@@ -31042,6 +31072,8 @@ var DurableThread = class _DurableThread extends DurableObject {
   // opened on and dies with it. Streams are in-memory only — they exist solely
   // while the client is attached and never park durably.
   clientStreams = /* @__PURE__ */ new Map();
+  proxyStreamReceivers = /* @__PURE__ */ new Map();
+  eventProxyStreams = /* @__PURE__ */ new Map();
   alarmQueue;
   runtimeSafety;
   alarmQueueRearmed = false;
@@ -31153,6 +31185,10 @@ var DurableThread = class _DurableThread extends DurableObject {
           clientName: typeof attachment.clientName === "string" ? attachment.clientName : null,
           clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null
         });
+        const interrupted = this.parseProxyStreamAttachments(attachment.proxyStreams);
+        if (interrupted.length > 0) {
+          this.recoverInterruptedProxyStreams(ws, interrupted);
+        }
       }
     }
   }
@@ -33243,11 +33279,13 @@ ${paths.join("\n")}`;
     try {
       const parentId = this.env.AGENT_BUILDER_THREAD.idFromName(parentThreadId);
       const parentStub = this.env.AGENT_BUILDER_THREAD.get(parentId);
-      const parentCommunication = await this.getParentCommunicationModeForChild(
+      const childRegistryEntry = await this.getParentRegistryEntryForChild(
         parentStub,
         parentThreadId,
         threadId
       );
+      const parentCommunication = childRegistryEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
+      const resumableChild = childRegistryEntry?.resumable === true;
       const copiedRefs = await this.copyAttachmentRefsToThread(
         refs,
         parentStub,
@@ -33270,10 +33308,11 @@ ${resultContent}${attachmentSummary}`;
         });
       }
       const terminalChildRun = sessionStopped || hasTerminalSessionTools;
+      const terminateChildThread = terminalChildRun && !resumableChild;
       await parentStub.updateChildRegistryStatus(
         parentThreadId,
         threadId,
-        terminalChildRun ? "terminated" : "idle"
+        terminateChildThread ? "terminated" : "idle"
       );
       if (parentCommunication !== "explicit") {
         await this.persistParentHandoffStatusMessage(
@@ -33281,23 +33320,22 @@ ${resultContent}${attachmentSummary}`;
           isErrorTerminal ? "failure" : "result"
         );
       }
-      if (terminalChildRun) {
+      if (terminateChildThread) {
         await this.terminateThread(threadId);
       }
     } catch (error) {
       console.error("[DurableThread] Failed to deliver subagent completion to parent:", error);
     }
   }
-  async getParentCommunicationModeForChild(parentStub, parentThreadId, childThreadId) {
+  async getParentRegistryEntryForChild(parentStub, parentThreadId, childThreadId) {
     if (typeof parentStub.getChildrenRegistry !== "function") {
-      return "implicit";
+      return void 0;
     }
     try {
       const entries = await parentStub.getChildrenRegistry(parentThreadId);
-      const childEntry = entries.find((entry) => entry.reference === childThreadId);
-      return childEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
+      return entries.find((entry) => entry.reference === childThreadId);
     } catch {
-      return "implicit";
+      return void 0;
     }
   }
   /**
@@ -34845,7 +34883,7 @@ ${resultContent}${attachmentSummary}`;
           void 0,
           INTERNAL_TOOL_DELIVERY
         );
-        if (delivered?.resume) sides.add(delivered.side);
+        if (delivered) sides.add(delivered.side);
       }
       if (threadId) {
         for (const side of sides) {
@@ -35147,17 +35185,14 @@ ${resultContent}${attachmentSummary}`;
   deliveredResultWaiters = /* @__PURE__ */ new Map();
   notifyDeliveredResultWaiters(toolCallId) {
     const waiters = this.deliveredResultWaiters?.get(toolCallId);
-    if (!waiters || waiters.size === 0) return false;
+    if (!waiters) return;
     this.deliveredResultWaiters.delete(toolCallId);
-    let notified = false;
     for (const wake of waiters) {
       try {
         wake();
-        notified = true;
       } catch {
       }
     }
-    return notified;
   }
   /**
    * Await a parked forwarded call's delivered result: one immediate read,
@@ -35302,46 +35337,37 @@ ${resultContent}${attachmentSummary}`;
     const side = pending.side === "b" ? "b" : "a";
     const content = ok ? result ?? "" : `Error: ${error ?? "tool failed"}`;
     const toolStatus = ok ? "success" : "error";
-    const resultMessageId = crypto.randomUUID();
-    const resultCreatedAt = Date.now() * TIMESTAMP_MULTIPLIER;
-    const accepted = this.ctx.storage.transactionSync(() => {
-      const claimed = this.ctx.storage.sql.exec(
-        `UPDATE pending_client_calls
-            SET status = 'resolved'
-          WHERE tool_call_id = ? AND status = 'pending'`,
+    await this.ctx.storage.sql.exec(
+      `UPDATE messages SET content = ?, tool_status = ? WHERE tool_call_id = ? AND role = 'tool'`,
+      content,
+      toolStatus,
+      toolCallId
+    );
+    const updated = await this.ctx.storage.sql.exec(
+      `SELECT COUNT(*) AS total FROM messages WHERE tool_call_id = ? AND role = 'tool'`,
+      toolCallId
+    );
+    if (Number(updated.toArray()[0]?.total ?? 0) === 0) {
+      const toolRow = await this.ctx.storage.sql.exec(
+        `SELECT tool FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
         toolCallId
       );
-      if (claimed.rowsWritten !== 1) return false;
-      this.ctx.storage.sql.exec(
-        `UPDATE messages SET content = ?, tool_status = ? WHERE tool_call_id = ? AND role = 'tool'`,
+      await this.ctx.storage.sql.exec(
+        `INSERT INTO messages (id, role, content, name, tool_call_id, tool_status, created_at, status, prompt)
+         VALUES (?, 'tool', ?, ?, ?, ?, ?, 'completed', NULL)`,
+        crypto.randomUUID(),
         content,
+        toolRow.toArray()[0]?.tool ?? null,
+        toolCallId,
         toolStatus,
-        toolCallId
+        Date.now() * TIMESTAMP_MULTIPLIER
       );
-      const updated = this.ctx.storage.sql.exec(
-        `SELECT COUNT(*) AS total FROM messages WHERE tool_call_id = ? AND role = 'tool'`,
-        toolCallId
-      );
-      if (Number(updated.toArray()[0]?.total ?? 0) === 0) {
-        const toolRow = this.ctx.storage.sql.exec(
-          `SELECT tool FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
-          toolCallId
-        );
-        this.ctx.storage.sql.exec(
-          `INSERT INTO messages (id, role, content, name, tool_call_id, tool_status, created_at, status, prompt)
-           VALUES (?, 'tool', ?, ?, ?, ?, ?, 'completed', NULL)`,
-          resultMessageId,
-          content,
-          toolRow.toArray()[0]?.tool ?? null,
-          toolCallId,
-          toolStatus,
-          resultCreatedAt
-        );
-      }
-      return true;
-    });
-    if (!accepted) return null;
-    const resumedInline = this.notifyDeliveredResultWaiters(toolCallId);
+    }
+    await this.ctx.storage.sql.exec(
+      `UPDATE pending_client_calls SET status = 'resolved' WHERE tool_call_id = ?`,
+      toolCallId
+    );
+    this.notifyDeliveredResultWaiters(toolCallId);
     try {
       const msgCursor = await this.ctx.storage.sql.exec(
         `SELECT id, role, content, name, tool_call_id, tool_status, created_at, depth
@@ -35352,7 +35378,7 @@ ${resultContent}${attachmentSummary}`;
       if (msg) this.broadcastMessage(msg);
     } catch {
     }
-    return { side, resume: !resumedInline };
+    return { side };
   }
   // ─── Runtime byte streams ──────────────────────────────────────────────────
   // The existing bridge frames carry opaque capability metadata and bytes
@@ -35418,8 +35444,138 @@ ${resultContent}${attachmentSummary}`;
       });
     }
   }
+  parseProxyStreamAttachments(value) {
+    if (!Array.isArray(value)) return [];
+    const parsed = [];
+    for (const item of value) {
+      if (!item || typeof item !== "object") continue;
+      const candidate = item;
+      if (typeof candidate.id === "string" && candidate.target && typeof candidate.target.threadId === "string" && typeof candidate.target.receiverId === "string") {
+        parsed.push({
+          id: candidate.id,
+          target: {
+            threadId: candidate.target.threadId,
+            receiverId: candidate.target.receiverId
+          }
+        });
+      }
+    }
+    return parsed;
+  }
+  /** Keep live proxy routes on the hibernating bridge socket for restart cleanup. */
+  updateBridgeProxyAttachment(socket) {
+    if (typeof socket.serializeAttachment !== "function") return;
+    let attachment = { type: "bridge" };
+    try {
+      const current = socket.deserializeAttachment();
+      if (current && typeof current === "object") {
+        attachment = { ...current };
+      }
+    } catch {
+    }
+    const proxyStreams = Array.from(this.clientStreams.entries()).filter(([, state]) => state.socket === socket && state.proxyTarget !== null).map(([id, state]) => ({ id, target: state.proxyTarget }));
+    try {
+      socket.serializeAttachment({ ...attachment, proxyStreams });
+    } catch {
+    }
+  }
+  async deliverProxyStreamFrame(target, frame) {
+    try {
+      const namespace = this.env.AGENT_BUILDER_THREAD;
+      const stub = namespace.get(namespace.idFromName(target.threadId));
+      return await stub.proxyStreamReceive(target.receiverId, frame);
+    } catch {
+      return false;
+    }
+  }
+  /** Abort live proxy routes restored without their in-memory stream state. */
+  recoverInterruptedProxyStreams(socket, streams) {
+    const error = "The stream ended because its runtime restarted.";
+    for (const stream of streams) {
+      try {
+        if (socket.readyState === WebSocket.OPEN) {
+          socket.send(JSON.stringify({ type: "stream_abort", id: stream.id, error }));
+        }
+      } catch {
+      }
+      this.ctx.waitUntil(
+        this.deliverProxyStreamFrame(stream.target, { type: "abort", error }).then(() => {
+        })
+      );
+    }
+    this.updateBridgeProxyAttachment(socket);
+  }
+  /** Register the child side before any ancestor opens an owner stream. */
+  createProxyStreamReceiver(onCancel) {
+    const id = crypto.randomUUID();
+    let controller = null;
+    let settleDone;
+    const done = new Promise((resolve3) => {
+      settleDone = resolve3;
+    });
+    const readable = new ReadableStream({
+      start(value) {
+        controller = value;
+      },
+      cancel: (reason) => {
+        const receiver2 = this.proxyStreamReceivers.get(id);
+        if (!receiver2 || receiver2.settled) return;
+        const error = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "The proxy stream reader was canceled.";
+        receiver2.settle({ ok: false, error });
+        receiver2.onCancel(error);
+      }
+    });
+    const receiver = {
+      controller,
+      settle: (result) => {
+        if (receiver.settled) return;
+        receiver.settled = true;
+        this.proxyStreamReceivers.delete(id);
+        settleDone(result);
+      },
+      onCancel,
+      settled: false
+    };
+    this.proxyStreamReceivers.set(id, receiver);
+    return { id, readable, done };
+  }
+  async proxyStreamReceiverExists(receiverId) {
+    return this.proxyStreamReceivers.has(receiverId);
+  }
+  async proxyStreamReceive(receiverId, frame) {
+    const receiver = this.proxyStreamReceivers.get(receiverId);
+    if (!receiver || receiver.settled) return false;
+    if (frame.type === "data") {
+      try {
+        receiver.controller?.enqueue(decodeStreamChunk(frame.data));
+      } catch (error2) {
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        try {
+          receiver.controller?.error(error2 instanceof Error ? error2 : new Error(message));
+        } catch {
+        }
+        receiver.settle({ ok: false, error: message });
+      }
+      return true;
+    }
+    if (frame.type === "end") {
+      try {
+        receiver.controller?.close();
+      } catch {
+      }
+      receiver.settle({ ok: true });
+      return true;
+    }
+    const error = frame.error ?? "The proxied client stream was aborted.";
+    try {
+      receiver.controller?.error(new Error(error));
+    } catch {
+    }
+    receiver.settle({ ok: false, error });
+    return true;
+  }
   /** Open a bidirectional byte stream to the connected owner client. */
-  async openClientStream(request) {
+  async openClientStream(request, proxyTarget = null) {
     const owner = await this.getExecutionOwner();
     let socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
     if (!socket && owner) {
@@ -35452,9 +35608,12 @@ ${resultContent}${attachmentSummary}`;
       opened: null,
       openTimer: null,
       settleDone,
-      settled: false
+      settled: false,
+      proxyTarget,
+      delivery: Promise.resolve()
     };
     this.clientStreams.set(id, state);
+    this.updateBridgeProxyAttachment(socket);
     this.bridgeLastSeen.set(socket, Date.now());
     const openResult = await new Promise((resolve3) => {
       state.opened = resolve3;
@@ -35490,6 +35649,7 @@ ${resultContent}${attachmentSummary}`;
     }
     if (!openResult.ok) {
       this.clientStreams.delete(id);
+      this.updateBridgeProxyAttachment(socket);
       state.settled = true;
       settleDone({ ok: false, error: openResult.error });
       return {
@@ -35531,14 +35691,28 @@ ${resultContent}${attachmentSummary}`;
     };
     return { ok: true, duplex };
   }
-  // ─── Subagent stream proxy-up (chunk-pull, no cross-DO ReadableStream) ─────
-  // A subagent (child thread, no bridge) proxies its whole stream request UP to
-  // this bridge-holding root. We open the client stream locally, then buffer
-  // incoming bytes so the child can drain them over plain request/response RPCs
-  // — sidestepping the unproven DO-to-DO ReadableStream return.
-  proxyStreams = /* @__PURE__ */ new Map();
-  async proxyStreamOpen(request) {
-    const opened = await this.openClientStream(request);
+  // ─── Event-driven subagent stream proxy ──────────────────────────────────
+  // A child registers a local receiver before the bridge-holding ancestor
+  // opens the client stream. The ancestor invokes that receiver only for real
+  // data/end/abort events; there is no pull loop or permanently outstanding
+  // cross-DO RPC while the stream is idle.
+  async proxyStreamOpen(request, target) {
+    const namespace = this.env.AGENT_BUILDER_THREAD;
+    let receiverExists = false;
+    try {
+      const destination = namespace.get(namespace.idFromName(target.threadId));
+      receiverExists = await destination.proxyStreamReceiverExists(target.receiverId);
+    } catch {
+      receiverExists = false;
+    }
+    if (!receiverExists) {
+      return {
+        ok: false,
+        error: "The destination stream receiver is unavailable.",
+        code: "unavailable"
+      };
+    }
+    const opened = await this.openClientStream(request, target);
     if (!opened.ok) {
       const failureData = opened.data;
       const noClient = failureData?.noClient === true;
@@ -35550,82 +35724,23 @@ ${resultContent}${attachmentSummary}`;
       };
     }
     const id = crypto.randomUUID();
-    const duplex = opened.duplex;
-    const reader = duplex.readable.getReader();
-    const writer = duplex.writable.getWriter();
-    const entry = {
-      writer,
-      reader,
-      buffer: [],
-      done: false,
-      error: void 0,
-      pump: Promise.resolve(),
-      close: (error) => duplex.close(error),
-      waiter: null,
-      notify: () => {
-        const waiter = entry.waiter;
-        entry.waiter = null;
-        waiter?.();
-      }
-    };
-    entry.pump = (async () => {
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          if (value) {
-            entry.buffer.push(value);
-            entry.notify();
-          }
-        }
-      } catch (error) {
-        entry.error = error instanceof Error ? error.message : String(error);
-      } finally {
-        entry.done = true;
-        entry.notify();
-      }
-    })();
-    void duplex.done.then((d) => {
-      entry.done = true;
-      if (!d.ok && !entry.error) entry.error = d.error;
-      entry.notify();
+    this.eventProxyStreams.set(id, {
+      writer: opened.duplex.writable.getWriter(),
+      close: (error) => opened.duplex.close(error),
+      target
     });
-    this.proxyStreams.set(id, entry);
-    return { ok: true, id, parkedPull: true };
+    return { ok: true, id, eventDriven: true };
   }
   async proxyStreamWrite(id, dataB64) {
-    const entry = this.proxyStreams.get(id);
+    const entry = this.eventProxyStreams.get(id);
     if (!entry) return;
     try {
       await entry.writer.write(decodeStreamChunk(dataB64));
     } catch {
     }
   }
-  async proxyStreamPull(id, maxWaitMs) {
-    const entry = this.proxyStreams.get(id);
-    if (!entry) return { chunks: [], done: true, error: "unknown proxy stream" };
-    if (entry.buffer.length === 0 && !entry.done) {
-      await new Promise((resolve3) => {
-        const deadline = typeof maxWaitMs === "number" && maxWaitMs > 0 ? setTimeout(() => {
-          if (entry.waiter === wake) entry.waiter = null;
-          resolve3();
-        }, maxWaitMs) : null;
-        const wake = () => {
-          if (deadline) clearTimeout(deadline);
-          resolve3();
-        };
-        entry.waiter = wake;
-      });
-    }
-    const chunks = entry.buffer.splice(0).map((b) => encodeStreamChunk(b));
-    if (entry.done && entry.buffer.length === 0) {
-      this.proxyStreams.delete(id);
-      return { chunks, done: true, error: entry.error };
-    }
-    return { chunks, done: false };
-  }
   async proxyStreamEnd(id) {
-    const entry = this.proxyStreams.get(id);
+    const entry = this.eventProxyStreams.get(id);
     if (!entry) return;
     try {
       await entry.writer.close();
@@ -35633,30 +35748,49 @@ ${resultContent}${attachmentSummary}`;
     }
   }
   async proxyStreamAbort(id) {
-    const entry = this.proxyStreams.get(id);
+    const entry = this.eventProxyStreams.get(id);
     if (!entry) return;
-    this.proxyStreams.delete(id);
-    entry.done = true;
-    if (!entry.error) entry.error = "aborted";
-    entry.notify();
+    this.eventProxyStreams.delete(id);
     try {
       entry.close("aborted");
     } catch {
     }
   }
+  forgetEventProxyStream(clientStreamId, target) {
+    const matchesTarget = (candidate) => candidate.threadId === target.threadId && candidate.receiverId === target.receiverId;
+    for (const [id, entry] of Array.from(this.eventProxyStreams.entries())) {
+      if (id !== clientStreamId && !matchesTarget(entry.target)) continue;
+      this.eventProxyStreams.delete(id);
+      try {
+        entry.writer.releaseLock();
+      } catch {
+      }
+    }
+  }
   /** Settle and remove a client stream exactly once. */
   settleClientStream(id, result, openCode) {
     const state = this.clientStreams.get(id);
     if (!state) return;
     this.clientStreams.delete(id);
+    this.updateBridgeProxyAttachment(state.socket);
     if (state.openTimer) clearTimeout(state.openTimer);
     if (state.opened) state.opened({ ok: false, error: result.error ?? "Stream closed.", code: openCode });
     if (!state.settled) {
       state.settled = true;
-      try {
-        if (result.ok) state.controller?.close();
-        else state.controller?.error(new Error(result.error ?? "Client stream aborted."));
-      } catch {
+      if (state.proxyTarget) {
+        const target = state.proxyTarget;
+        const frame = result.ok ? { type: "end" } : { type: "abort", error: result.error ?? "Client stream aborted." };
+        state.delivery = state.delivery.then(async () => {
+          await this.deliverProxyStreamFrame(target, frame);
+        });
+        this.ctx.waitUntil(state.delivery);
+        this.forgetEventProxyStream(id, target);
+      } else {
+        try {
+          if (result.ok) state.controller?.close();
+          else state.controller?.error(new Error(result.error ?? "Client stream aborted."));
+        } catch {
+        }
       }
       state.settleDone(result);
     }
@@ -35699,6 +35833,18 @@ ${resultContent}${attachmentSummary}`;
       }
       case "stream_data": {
         if (typeof parsed.data !== "string") return;
+        if (state.proxyTarget) {
+          const target = state.proxyTarget;
+          const frame = { type: "data", data: parsed.data };
+          state.delivery = state.delivery.then(async () => {
+            const delivered = await this.deliverProxyStreamFrame(target, frame);
+            if (!delivered && this.clientStreams.get(id) === state) {
+              this.abortClientStream(id, "The destination stream receiver is unavailable.");
+            }
+          });
+          this.ctx.waitUntil(state.delivery);
+          return;
+        }
         try {
           state.controller?.enqueue(decodeStreamChunk(parsed.data));
         } catch {
@@ -36526,11 +36672,12 @@ ${resultContent}${attachmentSummary}`;
       if (!parentThreadId) return;
       const parentId = this.env.AGENT_BUILDER_THREAD.idFromName(parentThreadId);
       const parentStub = this.env.AGENT_BUILDER_THREAD.get(parentId);
-      const parentCommunication = await this.getParentCommunicationModeForChild(
+      const childRegistryEntry = await this.getParentRegistryEntryForChild(
         parentStub,
         parentThreadId,
         threadId
       );
+      const parentCommunication = childRegistryEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
       if (parentCommunication !== "explicit") {
         await parentStub.queueMessage(parentThreadId, {
           role: "user",