@standardagents/builder 0.40.5 → 0.40.6

package/dist/runtime.d.ts

@@ -1,5 +1,5 @@
-import { j as AuthContext, e as ThreadEnv, w as Agent, y as ThreadMetadata, z as ToolResult, M as Message, o as ClientToolRequest, p as ClientToolResponse, q as ClientStreamRequest, t as ClientStreamResponse, H as FileRecord, V as SkillStorageScope, F as FlowState, N as FileStats, K as GrepResult, J as AttachmentRef, U as MessageContent, G as Env, x as ThreadInstance } from './index-0NI3m5DR.js';
-export { A as AuthUser, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, u as ClientDuplex, v as ClientForwarding, B as Controller, a as ControllerContext, D as FlowResult, P as ImageContentPart, I as ImageMetadata, L as LLMResponse, Q as MultimodalContent, R as RequestContext, S as StorageBackend, E as TelemetryEvent, O as TextContentPart, b as ThreadEndpointContext, T as ToolCall, 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';
+import { j as AuthContext, e as ThreadEnv, w as Agent, y as ThreadMetadata, z as ToolResult, M as Message, o as ClientToolRequest, p as ClientToolResponse, V as ProxyStreamReceiver, W as ProxyStreamFrame, q as ClientStreamRequest, X as ProxyStreamTarget, t as ClientStreamResponse, Y as ProxyStreamOpenResult, H as FileRecord, Z as SkillStorageScope, F as FlowState, N as FileStats, K as GrepResult, J as AttachmentRef, U as MessageContent, G as Env, x as ThreadInstance } from './index-DYhbT5Eq.js';
+export { A as AuthUser, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, u as ClientDuplex, v as ClientForwarding, B as Controller, a as ControllerContext, D as FlowResult, P as ImageContentPart, I as ImageMetadata, L as LLMResponse, Q as MultimodalContent, R as RequestContext, S as StorageBackend, E as TelemetryEvent, O as TextContentPart, b as ThreadEndpointContext, T as ToolCall, 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';
 import { CodeExecutionOptions, CodeExecutionResult, SubagentRegistryEntry, InjectMessageInput, QueueMessageInput, CredentialGrant, SkillMetadata, SkillFileInput, ModelDefinition as ModelDefinition$1, ToolArgs, PromptTextPart, PromptEnvPart, VariableDefinition, SubpromptConfig as SubpromptConfig$1, PromptToolConfig as PromptToolConfig$1, SubagentToolConfig as SubagentToolConfig$1, ReasoningConfig, SideConfig as SideConfig$1, ParentHookRequirement, LLMProviderInterface, ContentPart, TextPart, ImagePart, FilePart, ThreadState, NamespaceContext, DefinitionLoader } from '@standardagents/spec';
 export { AgentType, DefinitionLoader, GlobalNamespaceContext, HookExecutionContext, HookExecutionSource, HookSignatures, ImageContent, ModelCapabilities, ModelProvider, NamespaceContext, PackageSignature, PackedExports, PackedMeta, PackedMetadata, PackedNamespaceContext, ParentHookRequirement, ParentHookStage, PromptInput, PromptTextPart, ProviderAssistantMessage, ProviderError, ProviderErrorCode, ProviderFactory, ProviderFactoryConfig, ProviderFinishReason, ProviderGeneratedImage, ProviderMessage, ProviderMessageContent, ModelCapabilities as ProviderModelCapabilities, ProviderReasoningDetail, ProviderRequest, ProviderResponse, ProviderStreamChunk, 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';
 import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
@@ -234,6 +234,8 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
     private executionOwnerCache;
     private pendingClientCalls;
     private clientStreams;
+    private proxyStreamReceivers;
+    private eventProxyStreams;
     private alarmQueue;
     private runtimeSafety;
     private alarmQueueRearmed;
@@ -1256,25 +1258,23 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
      * match the CURRENT owner.
      */
     private awaitOwnerBridgeSocket;
+    private parseProxyStreamAttachments;
+    /** Keep live proxy routes on the hibernating bridge socket for restart cleanup. */
+    private updateBridgeProxyAttachment;
+    private deliverProxyStreamFrame;
+    /** Abort live proxy routes restored without their in-memory stream state. */
+    private recoverInterruptedProxyStreams;
+    /** Register the child side before any ancestor opens an owner stream. */
+    createProxyStreamReceiver(onCancel: (error?: string) => void): ProxyStreamReceiver;
+    proxyStreamReceiverExists(receiverId: string): Promise<boolean>;
+    proxyStreamReceive(receiverId: string, frame: ProxyStreamFrame): Promise<boolean>;
     /** Open a bidirectional byte stream to the connected owner client. */
-    openClientStream(request: ClientStreamRequest): Promise<ClientStreamResponse>;
-    private proxyStreams;
-    proxyStreamOpen(request: ClientStreamRequest): Promise<{
-        ok: boolean;
-        id?: string;
-        error?: string;
-        noClient?: boolean;
-        parkedPull?: boolean;
-        code?: 'unsupported' | 'unavailable' | 'refused' | 'timeout';
-    }>;
+    openClientStream(request: ClientStreamRequest, proxyTarget?: ProxyStreamTarget | null): Promise<ClientStreamResponse>;
+    proxyStreamOpen(request: ClientStreamRequest, target: ProxyStreamTarget): Promise<ProxyStreamOpenResult>;
     proxyStreamWrite(id: string, dataB64: string): Promise<void>;
-    proxyStreamPull(id: string, maxWaitMs?: number): Promise<{
-        chunks: string[];
-        done: boolean;
-        error?: string;
-    }>;
     proxyStreamEnd(id: string): Promise<void>;
     proxyStreamAbort(id: string): Promise<void>;
+    private forgetEventProxyStream;
     /** Settle and remove a client stream exactly once. */
     private settleClientStream;
     /** Abort a stream from the Worker side, telling the client to tear down. */

package/dist/runtime.js

@@ -14715,27 +14715,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,
@@ -14747,69 +14771,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));
@@ -14822,20 +14798,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) {
@@ -22266,6 +22242,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;
@@ -22377,6 +22355,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);
+        }
       }
     }
   }
@@ -26632,8 +26614,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((resolve) => {
+      settleDone = resolve;
+    });
+    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) {
@@ -26666,9 +26778,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((resolve) => {
       state.opened = resolve;
@@ -26704,6 +26819,7 @@ ${resultContent}${attachmentSummary}`;
     }
     if (!openResult.ok) {
       this.clientStreams.delete(id);
+      this.updateBridgeProxyAttachment(socket);
       state.settled = true;
       settleDone({ ok: false, error: openResult.error });
       return {
@@ -26745,14 +26861,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;
@@ -26764,82 +26894,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((resolve) => {
-        const deadline = typeof maxWaitMs === "number" && maxWaitMs > 0 ? setTimeout(() => {
-          if (entry.waiter === wake) entry.waiter = null;
-          resolve();
-        }, maxWaitMs) : null;
-        const wake = () => {
-          if (deadline) clearTimeout(deadline);
-          resolve();
-        };
-        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();
@@ -26847,30 +26918,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);
     }
@@ -26913,6 +27003,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 {