@standardagents/builder 0.40.5 → 0.40.7

package/dist/client/index.html

@@ -26,7 +26,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <link rel="icon" type="image/svg+xml" href="/agents/assets/img/favicon-9uH1rb2F.svg">
     <title>AgentBuilder Admin</title>
-    <script type="module" crossorigin src="/agents/index-CKtIkI0N.js"></script>
+    <script type="module" crossorigin src="/agents/index-9HZDcx7i.js"></script>
     <link rel="modulepreload" crossorigin href="/agents/formkit-DJxUzqRQ.js">
     <link rel="modulepreload" crossorigin href="/agents/vendor-c_uwtQ-S.js">
     <link rel="modulepreload" crossorigin href="/agents/syntax-D68HCEYm.js">

package/dist/{index-0NI3m5DR.d.ts → index-DYhbT5Eq.d.ts}

@@ -164,6 +164,41 @@ interface ClientDuplex {
         error?: string;
     }>;
 }
+/** Builder-internal destination for an event-driven cross-thread stream. */
+interface ProxyStreamTarget {
+    /** Thread Durable Object that owns the receiver. */
+    threadId: string;
+    /** In-memory receiver registered before the ancestor opens the client stream. */
+    receiverId: string;
+}
+/** Builder-internal stream event delivered from an ancestor to a child thread. */
+type ProxyStreamFrame = {
+    type: "data";
+    data: string;
+} | {
+    type: "end";
+} | {
+    type: "abort";
+    error?: string;
+};
+/** Local handle returned when a child thread registers a proxy receiver. */
+interface ProxyStreamReceiver {
+    id: string;
+    readable: ReadableStream<Uint8Array>;
+    done: Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+}
+/** Result of asking an ancestor to open an event-driven proxy stream. */
+interface ProxyStreamOpenResult {
+    ok: boolean;
+    id?: string;
+    error?: string;
+    noClient?: boolean;
+    eventDriven?: boolean;
+    code?: "unsupported" | "unavailable" | "refused" | "timeout";
+}
 type ClientStreamResponse = {
     ok: true;
     duplex: ClientDuplex;
@@ -406,6 +441,8 @@ interface ThreadInstance {
         side: "a" | "b";
     }): Promise<ClientToolResponse>;
     openClientStream?(request: ClientStreamRequest): Promise<ClientStreamResponse>;
+    createProxyStreamReceiver?(onCancel: (error?: string) => void): ProxyStreamReceiver;
+    proxyStreamReceive?(receiverId: string, frame: ProxyStreamFrame): Promise<boolean>;
     dispatchClientTool?(request: ClientToolRequest, toolCallId: string, side: "a" | "b"): Promise<{
         dispatched: boolean;
     }>;
@@ -1363,6 +1400,12 @@ interface DurableThreadRpc {
         releaseForensicHold?: boolean;
     }): Promise<unknown>;
     getRuntimeSafetyStatus?(): Promise<unknown>;
+    proxyStreamReceiverExists(receiverId: string): Promise<boolean>;
+    proxyStreamReceive(receiverId: string, frame: ProxyStreamFrame): Promise<boolean>;
+    proxyStreamOpen(request: ClientStreamRequest, target: ProxyStreamTarget): Promise<ProxyStreamOpenResult>;
+    proxyStreamWrite(id: string, data: string): Promise<void>;
+    proxyStreamEnd(id: string): Promise<void>;
+    proxyStreamAbort(id: string): Promise<void>;
     /** Newest non-empty user message on the thread, for thread-list previews. */
     getLatestUserMessagePreview(): Promise<string | null>;
     executeBlocking?(threadId: string, agentId: string, initial_messages?: unknown[], data?: unknown): Promise<{
@@ -1934,4 +1977,4 @@ declare function defineController<Env extends ThreadEnv = ThreadEnv>(controller:
  */
 declare function createThreadEndpointHandler<Env extends ThreadEnv = ThreadEnv>(handler: ThreadEndpointHandler): BuilderController<Env>;
 
-export { type AuthUser as A, type BuilderController as B, CLIENT_STREAM_CHUNK_BYTES as C, type FlowResult as D, type TelemetryEvent as E, type FlowState as F, type Env as G, type FileRecord as H, type ImageMetadata as I, type AttachmentRef as J, type GrepResult as K, type LLMResponse as L, type Message as M, type FileStats as N, type TextContentPart as O, type ImageContentPart as P, type MultimodalContent as Q, type RequestContext as R, type StorageBackend as S, type ToolCall as T, type MessageContent as U, type SkillStorageScope as V, type BuilderControllerContext as a, type ThreadEndpointContext as b, createThreadEndpointHandler as c, defineController as d, type ThreadEnv as e, type BuilderThreadEndpointHandler as f, authenticate as g, requireAdmin as h, endpointCallerFromAuth as i, type AuthContext as j, callClient as k, callClientStream as l, encodeStreamChunk as m, decodeStreamChunk as n, type ClientToolRequest as o, type ClientToolResponse as p, type ClientStreamRequest as q, requireAuth as r, supportsClientForwarding as s, type ClientStreamResponse as t, type ClientDuplex as u, type ClientForwarding as v, type Agent as w, type ThreadInstance as x, type ThreadMetadata as y, type ToolResult as z };
+export { type AuthUser as A, type BuilderController as B, CLIENT_STREAM_CHUNK_BYTES as C, type FlowResult as D, type TelemetryEvent as E, type FlowState as F, type Env as G, type FileRecord as H, type ImageMetadata as I, type AttachmentRef as J, type GrepResult as K, type LLMResponse as L, type Message as M, type FileStats as N, type TextContentPart as O, type ImageContentPart as P, type MultimodalContent as Q, type RequestContext as R, type StorageBackend as S, type ToolCall as T, type MessageContent as U, type ProxyStreamReceiver as V, type ProxyStreamFrame as W, type ProxyStreamTarget as X, type ProxyStreamOpenResult as Y, type SkillStorageScope as Z, type BuilderControllerContext as a, type ThreadEndpointContext as b, createThreadEndpointHandler as c, defineController as d, type ThreadEnv as e, type BuilderThreadEndpointHandler as f, authenticate as g, requireAdmin as h, endpointCallerFromAuth as i, type AuthContext as j, callClient as k, callClientStream as l, encodeStreamChunk as m, decodeStreamChunk as n, type ClientToolRequest as o, type ClientToolResponse as p, type ClientStreamRequest as q, requireAuth as r, supportsClientForwarding as s, type ClientStreamResponse as t, type ClientDuplex as u, type ClientForwarding as v, type Agent as w, type ThreadInstance as x, type ThreadMetadata as y, type ToolResult as z };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { ModelDefinition, AgentDefinition } from './runtime.js';
 export { AgentBuilderEnv, AgentBuilderEvent, BroadcastOptions, CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, FlowStateWithSdk, HubClientInfo, ImageContextConfig, InjectMessageOptions, LLMProviderInterface, NamespaceResolutionError, PromptContent, PromptDefinition, PromptIncludePart, PromptPart, PromptToolConfig, Provider, ProviderContentPart, ProviderFilePart, ProviderImagePart, ProviderRegistry, ProviderTextPart, SessionToolBinding, SessionToolConfig, SideConfig, SubagentToolConfig, SubpromptConfig, ThreadEventPayload, ThreadRegistryEntry, ThreadWatchdog, ThreadWatchdogState, ToolConfig, UpdateThreadParams, User, WatchdogCheckin, WatchdogProbeResult, applyRuntimeCors, buildImageDescription, canAccessThread, cat, createNamespaceContext, emitThreadEvent, enhanceFlowState, exists, find, forceTurn, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isAdminOnlyApiRoute, isHostedInstance, isPublicApiRoute, isQualifiedName, isSameOriginBrowserRequest, isTrustedLocalDevelopmentRequest, linkFile, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, runtimeCorsHeaders, runtimePreflightResponse, stat, tail, unlink, updateThread, writeFile, writeImage } from './runtime.js';
 export { AgentPluginOptions, agentbuilder, builder } from './plugin.js';
-export { w as Agent, J as AttachmentRef, j as AuthContext, A as AuthUser, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, u as ClientDuplex, v as ClientForwarding, q as ClientStreamRequest, t as ClientStreamResponse, o as ClientToolRequest, p as ClientToolResponse, B as Controller, a as ControllerContext, G as Env, H as FileRecord, N as FileStats, D as FlowResult, F as FlowState, K as GrepResult, P as ImageContentPart, I as ImageMetadata, L as LLMResponse, M as Message, U as MessageContent, Q as MultimodalContent, R as RequestContext, S as StorageBackend, E as TelemetryEvent, O as TextContentPart, b as ThreadEndpointContext, e as ThreadEnv, x as ThreadInstance, y as ThreadMetadata, T as ToolCall, z as ToolResult, g as authenticate, k as callClient, l as callClientStream, c as createThreadEndpointHandler, n as decodeStreamChunk, d as defineController, m as encodeStreamChunk, i as endpointCallerFromAuth, h as requireAdmin, r as requireAuth, s as supportsClientForwarding } from './index-0NI3m5DR.js';
+export { w as Agent, J as AttachmentRef, j as AuthContext, A as AuthUser, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, u as ClientDuplex, v as ClientForwarding, q as ClientStreamRequest, t as ClientStreamResponse, o as ClientToolRequest, p as ClientToolResponse, B as Controller, a as ControllerContext, G as Env, H as FileRecord, N as FileStats, D as FlowResult, F as FlowState, K as GrepResult, P as ImageContentPart, I as ImageMetadata, L as LLMResponse, M as Message, U as MessageContent, Q as MultimodalContent, R as RequestContext, S as StorageBackend, E as TelemetryEvent, O as TextContentPart, b as ThreadEndpointContext, e as ThreadEnv, x as ThreadInstance, y as ThreadMetadata, T as ToolCall, z as ToolResult, g as authenticate, k as callClient, l as callClientStream, c as createThreadEndpointHandler, n as decodeStreamChunk, d as defineController, m as encodeStreamChunk, i as endpointCallerFromAuth, h as requireAdmin, r as requireAuth, s as supportsClientForwarding } from './index-DYhbT5Eq.js';
 export { AgentType, DefinitionLoader, GlobalNamespaceContext, HookExecutionContext, HookExecutionSource, HookSignatures, ImageContent, ModelCapabilities, ModelProvider, NamespaceContext, PackageSignature, PackedExports, PackedMeta, PackedMetadata, PackedNamespaceContext, ParentHookRequirement, ParentHookStage, PromptInput, PromptTextPart, ProviderAssistantMessage, ProviderConfigSlot, ProviderConfigSlots, ProviderConfigValueSource, ProviderDefinition, ProviderError, ProviderErrorCode, ProviderFactory, ProviderFactoryConfig, ProviderFinishReason, ProviderGeneratedImage, ProviderMessage, ProviderMessageContent, ProviderMethodOverrides, ModelCapabilities as ProviderModelCapabilities, ProviderOverride, ProviderOverrideContext, ProviderReasoningDetail, ProviderRequest, ProviderResponse, ProviderStreamChunk, ProviderSyncOverride, ProviderSystemMessage, ProviderTool, ProviderToolCallPart, ProviderToolMessage, ProviderToolResultContent, ProviderUsage, ProviderUserMessage, ReasoningConfig, StructuredPrompt, TextContent, ThreadHookName, Tool, ToolArgs, ToolArgsNode, ToolArgsRawShape, ToolContent, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineProvider, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue } from '@standardagents/spec';
 export { C as ConstituentItem, D as DiscoveredPackage, N as NamespacedRegistry, P as PackingAnalysis, a as PackingOptions, b as PackingResult, c as UnpackOptions, d as UnpackResult } from './types-BMnBYNwn.js';
 export { D as DiscoveryConfig, P as PackageDiscoveryService, d as discoverPackages } from './discovery-DZ7fv-b4.js';

package/dist/index.js

@@ -14722,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,
@@ -14754,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));
@@ -14829,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) {
@@ -31096,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;
@@ -31207,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);
+        }
       }
     }
   }
@@ -35462,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) {
@@ -35496,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;
@@ -35534,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 {
@@ -35575,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;
@@ -35594,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();
@@ -35677,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);
     }
@@ -35743,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 {