@tickernelz/paperclip-pro-server 2026.928.4 → 2026.928.6

package/node_modules/@agentclientprotocol/sdk/dist/connection.js

@@ -1,27 +1,74 @@
 import { isResponseMessage } from "./jsonrpc.js";
 import { messageIdKey, sessionIdFromMessageParams, sessionIdFromResponseResult, } from "./protocol.js";
+/** Default for {@link ConnectionLimits.maxBufferedBytes}: 64 MiB. */
+export const DEFAULT_MAX_BUFFERED_BYTES = 64 * 1024 * 1024;
+/** Default for {@link ConnectionLimits.maxOutputStallMs}: 60 seconds. */
+export const DEFAULT_MAX_OUTPUT_STALL_MS = 60_000;
+/** Default for {@link ConnectionLimits.maxBufferedSessionStreams}: 1024. */
+export const DEFAULT_MAX_BUFFERED_SESSION_STREAMS = 1024;
+/** Default for {@link ConnectionLimits.maxIdLength}: 1024. */
+export const DEFAULT_MAX_ID_LENGTH = 1024;
+/** The longest a timer can wait; timers fire at once past it. */
+const MAX_TIMER_MS = 2 ** 31 - 1;
+/** Raised when a client or agent exceeds a {@link ConnectionLimits} limit. */
+export class ConnectionLimitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConnectionLimitError";
+    }
+}
+/** Error for a connection that holds more than a limit allows. */
+export function connectionLimitExceeded(limit, limits) {
+    return new ConnectionLimitError(`Connection exceeds ${limit} (${limits[limit]})`);
+}
+/** Error for a connection whose client read none of its output in time. */
+export function connectionOutputStalled(limits) {
+    return new ConnectionLimitError(`Connection output stalled for maxOutputStallMs (${limits.maxOutputStallMs})`);
+}
+/** Raised when a message is sent to a connection that has shut down. */
+export class ConnectionClosedError extends Error {
+    constructor() {
+        super("ACP connection is closed");
+        this.name = "ConnectionClosedError";
+    }
+}
 export class OutboundMailbox {
     enabled;
+    onReceiverChange;
+    observer;
+    /** Queued messages start at `head`; see `dequeue`. */
     queue = [];
+    head = 0;
     activeLease;
     isFinished = false;
     isAborted = false;
-    constructor(enabled = true) {
+    abortError;
+    constructor(enabled = true, onReceiverChange, observer) {
         this.enabled = enabled;
+        this.onReceiverChange = onReceiverChange;
+        this.observer = observer;
     }
     push(message) {
         if (!this.enabled || this.isFinished) {
             return;
         }
         this.queue.push(message);
+        this.observer?.queued?.(message);
         this.activeLease?.wake();
     }
+    get hasReceiver() {
+        return this.activeLease !== undefined;
+    }
+    get hasQueuedMessages() {
+        return this.head < this.queue.length;
+    }
     tryAcquire() {
         if (!this.enabled || this.isAborted || this.activeLease) {
             return undefined;
         }
         const lease = new MailboxLease(this);
         this.activeLease = lease;
+        this.onReceiverChange?.();
         return lease;
     }
     finish() {
@@ -31,26 +78,36 @@ export class OutboundMailbox {
         this.isFinished = true;
         this.activeLease?.wake();
     }
-    abort() {
+    abort(error) {
         if (this.isAborted) {
             return;
         }
         this.isAborted = true;
+        this.abortError = error;
         this.isFinished = true;
-        this.queue.length = 0;
-        this.activeLease?.wake();
+        while (this.hasQueuedMessages) {
+            this.dequeue();
+        }
+        // Whatever still holds this stream, such as a stalled response body,
+        // must not keep its connection reachable.
+        this.observer = undefined;
+        this.onReceiverChange = undefined;
+        this.activeLease?.stop(error ?? new ConnectionClosedError());
     }
     /** @internal */
     async receive(lease) {
         for (;;) {
-            if (this.isAborted || lease.released || this.activeLease !== lease) {
+            if (lease.released || this.activeLease !== lease) {
                 return { done: true, value: undefined };
             }
-            if (this.queue.length > 0) {
-                return {
-                    done: false,
-                    value: this.queue.shift(),
-                };
+            if (this.isAborted) {
+                if (this.abortError !== undefined) {
+                    throw this.abortError;
+                }
+                return { done: true, value: undefined };
+            }
+            if (this.hasQueuedMessages) {
+                return { done: false, value: this.dequeue() };
             }
             if (this.isFinished) {
                 return { done: true, value: undefined };
@@ -65,47 +122,108 @@ export class OutboundMailbox {
         }
         this.activeLease = undefined;
         lease.markReleased();
+        this.onReceiverChange?.();
+    }
+    /**
+     * Takes the oldest queued message. `Array.prototype.shift` copies the rest
+     * of a large array, which would make draining a full queue quadratic, so
+     * this advances `head` instead and drops the taken prefix once the queue
+     * empties or is mostly taken.
+     */
+    dequeue() {
+        const message = this.queue[this.head];
+        this.queue[this.head] = undefined;
+        this.head += 1;
+        if (this.head === this.queue.length) {
+            this.queue = [];
+            this.head = 0;
+        }
+        else if (this.head >= 1024 && this.head * 2 >= this.queue.length) {
+            this.queue = this.queue.slice(this.head);
+            this.head = 0;
+        }
+        this.observer?.dequeued(message);
+        return message;
     }
 }
 export class ConnectionState {
     transport;
+    limits;
     connectionId;
     inboundTx;
     outboundRx;
+    /** Connection-level HTTP stream, queuing each message as JSON text. */
     connectionStream;
+    /** Every outbound message, for WebSocket connections. */
     allOutbound;
+    /** Session-level HTTP streams, queuing each message as JSON text. */
     sessionStreams = new Map();
     pendingRoutes = new Map();
     clientResponseRoutes = new Map();
     closed;
     agentConnection;
+    /** Length of the JSON text queued on HTTP streams; see `maxBufferedBytes`. */
+    bufferedBytes = 0;
+    streamObserver = {
+        queued: (json) => {
+            this.bufferedBytes += json.length;
+        },
+        dequeued: (json) => {
+            this.bufferedBytes -= json.length;
+            this.notifyOutboundProgress();
+        },
+    };
+    /** Session streams without a receiver; see `maxBufferedSessionStreams`. */
+    bufferedSessionStreams = 0;
+    /** Called when a client takes output, or the connection stops routing. */
+    progressWaiters = new Set();
     supportsBatches = false;
     hasStartedRouter = false;
+    hasAgentOutputEnded = false;
+    hasFinishedRouting = false;
+    hasStartedShutdown = false;
     inboundWriteChain = Promise.resolve();
     initialReader;
     outboundReader;
     routerPromise;
     shutdownPromise;
     hasResolvedClosed = false;
-    finishAgentOutbound = () => { };
+    abortAgentInbound = () => { };
+    endAgentOutbound = () => { };
     resolveClosed = () => { };
-    constructor(agent, transport = "http") {
+    constructor(agent, transport, limits) {
         this.transport = transport;
+        this.limits = limits;
         this.connectionId = globalThis.crypto.randomUUID();
-        this.connectionStream = new OutboundMailbox(transport === "http");
-        this.allOutbound = new OutboundMailbox(transport === "websocket");
+        this.connectionStream = new OutboundMailbox(transport === "http", undefined, this.streamObserver);
+        // WebSocket output waits here only until the socket pump takes it; the
+        // socket itself holds what the client has not read.
+        this.allOutbound = new OutboundMailbox(transport === "websocket", undefined, {
+            dequeued: () => {
+                this.notifyOutboundProgress();
+            },
+        });
         this.closed = new Promise((resolve) => {
             this.resolveClosed = resolve;
         });
-        const inbound = new TransformStream();
-        const outbound = createBufferedOutboundChannel((message) => {
+        const inbound = new TransformStream({
+            start: (controller) => {
+                this.abortAgentInbound = (error) => controller.error(error);
+            },
+        });
+        const outbound = createOutboundChannel((message) => {
             if (!this.supportsBatches && Array.isArray(message)) {
                 throw new TypeError("AcpServer transports do not support outbound JSON-RPC batch messages");
             }
+        }, () => {
+            // Nothing more will come from the agent, so let the router finish
+            // instead of waiting for clients to make room.
+            this.hasAgentOutputEnded = true;
+            this.notifyOutboundProgress();
         });
         this.inboundTx = inbound.writable;
         this.outboundRx = outbound.readable;
-        this.finishAgentOutbound = outbound.finish;
+        this.endAgentOutbound = outbound.end;
         const stream = {
             readable: inbound.readable,
             writable: outbound.writable,
@@ -167,33 +285,103 @@ export class ConnectionState {
     get batchesEnabled() {
         return this.supportsBatches;
     }
+    /** Whether shutdown has begun; a closed connection accepts no more work. */
+    get isClosed() {
+        return this.hasStartedShutdown;
+    }
+    /**
+     * Whether the connection takes no more agent output for now. HTTP
+     * connections hold up to `maxBufferedBytes` in their streams. WebSocket
+     * connections hand each message to the socket pump, which waits while the
+     * socket holds `maxBufferedBytes`, so they wait until the pump takes it.
+     */
+    get hasOutboundBacklog() {
+        return this.transport === "http"
+            ? this.bufferedBytes >= this.limits.maxBufferedBytes
+            : this.allOutbound.hasQueuedMessages;
+    }
+    /** Throws `ConnectionLimitError` for a session ID over `maxIdLength`. */
+    validateSessionId(sessionId) {
+        this.validateIdLength("Session ID", sessionId);
+    }
+    /** Throws `ConnectionLimitError` for a request ID over `maxIdLength`. */
+    validateRequestId(id) {
+        if (typeof id === "string") {
+            this.validateIdLength("Request ID", id);
+        }
+    }
+    /**
+     * Resolves once the connection can take more agent output, or has stopped,
+     * and rejects if `signal` aborts first. Client requests wait on this, so a
+     * client that is not reading cannot make the agent produce more.
+     */
+    async waitForOutboundCapacity(signal) {
+        await this.waitForRoom(() => this.hasFinishedRouting, signal);
+    }
+    /**
+     * Returns the stream that delivers messages for a session, creating one
+     * that buffers them until a receiver attaches. Throws
+     * `ConnectionLimitError` for an over-long ID or when no further session
+     * may buffer.
+     */
     ensureSession(sessionId) {
+        this.validateSessionId(sessionId);
+        // WebSocket connections deliver every message over the socket.
+        if (this.transport === "websocket") {
+            return this.connectionStream;
+        }
         const existing = this.sessionStreams.get(sessionId);
         if (existing) {
             return existing;
         }
-        const stream = new OutboundMailbox(this.transport === "http");
-        this.sessionStreams.set(sessionId, stream);
-        return stream;
+        // A new stream has no receiver yet, so its messages are buffered.
+        if (this.bufferedSessionStreams >= this.limits.maxBufferedSessionStreams) {
+            throw connectionLimitExceeded("maxBufferedSessionStreams", this.limits);
+        }
+        return this.createSessionStream(sessionId);
+    }
+    /**
+     * Attaches a receiver to a session's stream, or returns `undefined` if the
+     * stream cannot take one. The open request backing the receiver bounds it,
+     * so this is not limited by `maxBufferedSessionStreams`. Throws
+     * `ConnectionLimitError` for an over-long ID, and `ConnectionClosedError`
+     * for a new stream once the connection can no longer route output to it.
+     */
+    acquireSessionStream(sessionId) {
+        this.validateSessionId(sessionId);
+        if (this.transport === "websocket") {
+            return undefined;
+        }
+        const existing = this.sessionStreams.get(sessionId);
+        if (existing) {
+            return existing.tryAcquire();
+        }
+        if (this.isClosed || this.hasFinishedRouting) {
+            throw new ConnectionClosedError();
+        }
+        return this.createSessionStream(sessionId).tryAcquire();
     }
-    async shutdown() {
+    async shutdown(error) {
         if (!this.shutdownPromise) {
-            this.shutdownPromise = this.runShutdown();
+            this.shutdownPromise = this.runShutdown(error);
         }
         return this.shutdownPromise;
     }
-    async runShutdown() {
+    async runShutdown(error) {
         try {
-            this.connectionStream.abort();
-            this.allOutbound.abort();
+            this.hasStartedShutdown = true;
+            this.notifyOutboundProgress();
+            this.connectionStream.abort(error);
+            this.allOutbound.abort(error);
             for (const stream of this.sessionStreams.values()) {
-                stream.abort();
+                stream.abort(error);
             }
             this.sessionStreams.clear();
+            this.bufferedSessionStreams = 0;
             this.pendingRoutes.clear();
             this.clientResponseRoutes.clear();
             await Promise.allSettled([
-                this.inboundTx.close(),
+                this.closeInbound(error),
                 this.cancelOutboundReader(),
             ]);
         }
@@ -213,7 +401,7 @@ export class ConnectionState {
                 await this.shutdown();
                 return;
             }
-            this.finishAgentOutbound();
+            this.endAgentOutbound();
             await this.routerPromise;
         });
     }
@@ -224,11 +412,30 @@ export class ConnectionState {
         }
         return this.outboundRx.cancel();
     }
+    closeInbound(error) {
+        if (error !== undefined || this.inboundTx.locked) {
+            this.abortAgentInbound(error ?? new ConnectionClosedError());
+            return Promise.resolve();
+        }
+        return this.inboundTx.close();
+    }
     async writeInboundMessage(message) {
+        // Once routing has finished, the agent can no longer answer, such as a
+        // request that waited for room while the agent exited.
+        if (this.isClosed || this.hasFinishedRouting) {
+            throw new ConnectionClosedError();
+        }
         const writer = this.inboundTx.getWriter();
         try {
             await writer.write(message);
         }
+        catch (error) {
+            // Shutdown aborts a write that was still waiting on the agent.
+            if (this.isClosed) {
+                throw new ConnectionClosedError();
+            }
+            throw error;
+        }
         finally {
             writer.releaseLock();
         }
@@ -239,16 +446,30 @@ export class ConnectionState {
         try {
             while (true) {
                 const result = await reader.read();
-                if (result.done) {
+                if (result.done || this.isClosed) {
                     return;
                 }
                 this.routeOutbound(result.value);
+                // Take no more output, which makes the agent's sends wait, until
+                // clients read what is queued. Once the agent's output has ended,
+                // nothing waits on the router, so it routes what is left.
+                await this.waitForRoom(() => this.hasAgentOutputEnded);
             }
         }
         catch (error) {
-            console.error("ACP connection router stopped unexpectedly:", error);
+            // Output can no longer be routed, so close the connection rather than
+            // leave the agent and its client waiting on it.
+            if (error instanceof ConnectionLimitError) {
+                this.closeForLimit(error);
+            }
+            else {
+                console.error(`ACP connection ${this.connectionId} router stopped unexpectedly:`, error);
+                void this.shutdown(error);
+            }
         }
         finally {
+            this.hasFinishedRouting = true;
+            this.notifyOutboundProgress();
             if (this.outboundReader === reader) {
                 this.outboundReader = undefined;
             }
@@ -268,15 +489,74 @@ export class ConnectionState {
         this.hasResolvedClosed = true;
         this.resolveClosed();
     }
+    /**
+     * Waits while the connection holds `maxBufferedBytes` of output, until
+     * `stopWaiting()` holds or the connection closes, and rejects if `signal`
+     * aborts first. An HTTP client that takes none of the output for
+     * `maxOutputStallMs`, having stopped reading or never opened the stream it
+     * is for, is not coming back for it, so the connection closes rather than
+     * keep the agent or the client's own requests waiting. A WebSocket session
+     * times out its socket itself, where it can see each byte the client reads.
+     */
+    async waitForRoom(stopWaiting, signal) {
+        while (!this.isClosed && !stopWaiting() && this.hasOutboundBacklog) {
+            if (!(await this.waitForProgress(signal))) {
+                this.closeForLimit(connectionOutputStalled(this.limits));
+                return;
+            }
+        }
+    }
+    /**
+     * Resolves `true` the next time a client takes output or the connection
+     * stops routing, or on HTTP, `false` if `maxOutputStallMs` passes first.
+     * Rejects if `signal` aborts first, leaving nothing behind.
+     */
+    waitForProgress(signal) {
+        const timeoutMs = this.transport === "http" ? this.limits.maxOutputStallMs : undefined;
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(signal.reason);
+                return;
+            }
+            let timer;
+            const settle = () => {
+                this.progressWaiters.delete(onProgress);
+                signal?.removeEventListener("abort", onAbort);
+                clearTimeout(timer);
+            };
+            const onProgress = () => {
+                settle();
+                resolve(true);
+            };
+            const onAbort = () => {
+                settle();
+                reject(signal?.reason);
+            };
+            this.progressWaiters.add(onProgress);
+            signal?.addEventListener("abort", onAbort, { once: true });
+            if (timeoutMs !== undefined) {
+                timer = setTimeout(() => {
+                    settle();
+                    resolve(false);
+                }, timeoutMs);
+            }
+        });
+    }
+    notifyOutboundProgress() {
+        for (const onProgress of [...this.progressWaiters]) {
+            onProgress();
+        }
+    }
     routeOutbound(message) {
-        this.allOutbound.push(message);
         if (Array.isArray(message)) {
             for (const item of message) {
                 this.routeOutboundMessage(item);
             }
-            return;
         }
-        this.routeOutboundMessage(message);
+        else {
+            this.routeOutboundMessage(message);
+        }
+        this.allOutbound.push(message);
     }
     routeOutboundMessage(message) {
         if (isResponseMessage(message)) {
@@ -290,22 +570,66 @@ export class ConnectionState {
         const route = key ? this.pendingRoutes.get(key) : undefined;
         const sessionId = sessionIdFromResponseResult(message);
         if (sessionId) {
-            this.ensureSession(sessionId);
+            // Never hand out a session ID this connection would refuse to route.
+            this.validateSessionId(sessionId);
         }
         if (key) {
             this.pendingRoutes.delete(key);
         }
         this.pushToRoute(route ?? "connection", message);
     }
+    createSessionStream(sessionId) {
+        const stream = new OutboundMailbox(true, () => {
+            this.onSessionReceiverChange(sessionId, stream);
+        }, this.streamObserver);
+        this.sessionStreams.set(sessionId, stream);
+        this.bufferedSessionStreams += 1;
+        return stream;
+    }
+    /**
+     * Keeps `bufferedSessionStreams` in step as receivers attach and leave. A
+     * stream a receiver leaves is kept only while messages still wait on it.
+     */
+    onSessionReceiverChange(sessionId, stream) {
+        // Shutdown discards every stream and resets the count itself.
+        if (this.isClosed) {
+            return;
+        }
+        if (stream.hasReceiver) {
+            this.bufferedSessionStreams -= 1;
+            return;
+        }
+        if (!stream.hasQueuedMessages) {
+            this.sessionStreams.delete(sessionId);
+            stream.abort();
+            return;
+        }
+        this.bufferedSessionStreams += 1;
+        // Once routing has finished, nothing more can be buffered.
+        if (!this.hasFinishedRouting &&
+            this.bufferedSessionStreams > this.limits.maxBufferedSessionStreams) {
+            this.closeForLimit(connectionLimitExceeded("maxBufferedSessionStreams", this.limits));
+        }
+    }
+    closeForLimit(error) {
+        console.warn(`Closing ACP connection ${this.connectionId}:`, error.message);
+        void this.shutdown(error);
+    }
+    validateIdLength(label, id) {
+        if (id.length > this.limits.maxIdLength) {
+            throw new ConnectionLimitError(`${label} exceeds maxIdLength (${this.limits.maxIdLength})`);
+        }
+    }
     routeOutboundRequestOrNotification(message) {
         const sessionId = sessionIdFromMessageParams(message);
         if (sessionId) {
+            const stream = this.ensureSession(sessionId);
             this.trackClientResponseRoute(message, { session: sessionId });
-            this.ensureSession(sessionId).push(message);
+            this.deliver(stream, message);
             return;
         }
         this.trackClientResponseRoute(message, "connection");
-        this.connectionStream.push(message);
+        this.deliver(this.connectionStream, message);
     }
     trackClientResponseRoute(message, route) {
         if (!("id" in message) || !("method" in message)) {
@@ -318,23 +642,37 @@ export class ConnectionState {
     }
     pushToRoute(route, message) {
         if (route === "connection") {
-            this.connectionStream.push(message);
+            this.deliver(this.connectionStream, message);
             return;
         }
-        this.ensureSession(route.session).push(message);
+        this.deliver(this.ensureSession(route.session), message);
+    }
+    /**
+     * Queues a message on an HTTP stream as JSON text, which is all a stream
+     * delivers and all `maxBufferedBytes` needs to count. WebSocket
+     * connections deliver through `allOutbound` instead.
+     */
+    deliver(stream, message) {
+        if (this.transport === "http") {
+            stream.push(JSON.stringify(message));
+        }
     }
 }
 export class ConnectionRegistry {
+    limits;
     connections = new Map();
     pendingConnections = new Map();
+    constructor(options = {}) {
+        this.limits = resolveConnectionLimits(options);
+    }
     createConnection(agent, transport = "http") {
-        const connection = new ConnectionState(agent, transport);
+        const connection = new ConnectionState(agent, transport, this.limits);
         this.connections.set(connection.connectionId, connection);
         this.trackConnectionClose(connection);
         return connection;
     }
     createPendingConnection(agent, transport = "websocket") {
-        const connection = new ConnectionState(agent, transport);
+        const connection = new ConnectionState(agent, transport, this.limits);
         this.pendingConnections.set(connection.connectionId, connection);
         this.trackConnectionClose(connection);
         return connection;
@@ -344,10 +682,13 @@ export class ConnectionRegistry {
         this.connections.set(connection.connectionId, connection);
     }
     get(connectionId) {
-        return this.connections.get(connectionId);
+        const connection = this.connections.get(connectionId);
+        return connection?.isClosed ? undefined : connection;
     }
     remove(connectionId) {
-        const connection = this.get(connectionId);
+        // Unlike `get`, include a connection that is already shutting down, so
+        // DELETE still succeeds until its shutdown completes.
+        const connection = this.connections.get(connectionId);
         if (!connection) {
             return undefined;
         }
@@ -386,15 +727,36 @@ export class ConnectionRegistry {
         });
     }
 }
+function resolveConnectionLimits(options) {
+    const limits = {
+        maxBufferedBytes: options.maxBufferedBytes ?? DEFAULT_MAX_BUFFERED_BYTES,
+        maxOutputStallMs: options.maxOutputStallMs ?? DEFAULT_MAX_OUTPUT_STALL_MS,
+        maxBufferedSessionStreams: options.maxBufferedSessionStreams ?? DEFAULT_MAX_BUFFERED_SESSION_STREAMS,
+        maxIdLength: options.maxIdLength ?? DEFAULT_MAX_ID_LENGTH,
+    };
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            throw new RangeError(`${name} must be a positive safe integer`);
+        }
+    }
+    if (limits.maxOutputStallMs > MAX_TIMER_MS) {
+        throw new RangeError(`maxOutputStallMs must be at most ${MAX_TIMER_MS}`);
+    }
+    return limits;
+}
 class MailboxLease {
     mailbox;
     released = false;
+    stoppedController = new AbortController();
     receiving = false;
     wakePromise;
     resolveWake;
     constructor(mailbox) {
         this.mailbox = mailbox;
     }
+    get stopped() {
+        return this.stoppedController.signal;
+    }
     async receive() {
         if (this.receiving) {
             throw new Error("ACP outbound mailbox lease already has a pending receive");
@@ -427,10 +789,27 @@ class MailboxLease {
         this.released = true;
         this.wake();
     }
+    stop(reason) {
+        this.stoppedController.abort(reason);
+        this.wake();
+    }
 }
-function createBufferedOutboundChannel(validate) {
+/**
+ * Carries the agent's output to the router. A write resolves at once if the
+ * router is waiting for a message, and otherwise once the router takes it
+ * and asks for the next one, so an agent that awaits its sends goes no
+ * faster than the router, which pauses while clients are behind.
+ */
+function createOutboundChannel(validate, onEnd) {
     let controller;
     let isFinished = false;
+    let isEnding = false;
+    let resumeWriter;
+    const resume = () => {
+        const resolve = resumeWriter;
+        resumeWriter = undefined;
+        resolve?.();
+    };
     const finish = () => {
         if (isFinished) {
             return;
@@ -442,6 +821,8 @@ function createBufferedOutboundChannel(validate) {
         catch {
             // The router may already have cancelled the readable side.
         }
+        resume();
+        onEnd();
     };
     const fail = (error) => {
         if (isFinished) {
@@ -454,18 +835,39 @@ function createBufferedOutboundChannel(validate) {
         catch {
             // The router may already have cancelled the readable side.
         }
+        resume();
+        onEnd();
+    };
+    /**
+     * Ends the channel for an agent that closed without closing its stream, as
+     * a connector whose `closed` resolves on its own may. Writes it made before
+     * closing can still be queued in the writable stream, which hands them
+     * over one per microtask, so they stop waiting for the router and the
+     * channel finishes after them.
+     */
+    const end = () => {
+        if (isFinished || isEnding) {
+            return;
+        }
+        isEnding = true;
+        resume();
+        setTimeout(finish, 0);
     };
     return {
         readable: new ReadableStream({
             start(readableController) {
                 controller = readableController;
             },
+            // With no high-water mark, this runs only once the router is waiting
+            // on an empty queue, which means it took the last message.
+            pull: resume,
             cancel() {
                 isFinished = true;
+                resume();
             },
-        }),
+        }, { highWaterMark: 0 }),
         writable: new WritableStream({
-            write(message) {
+            async write(message) {
                 if (isFinished) {
                     throw new Error("ACP outbound channel is closed");
                 }
@@ -477,11 +879,17 @@ function createBufferedOutboundChannel(validate) {
                     fail(error);
                     throw error;
                 }
+                // The message went straight to a waiting router unless it is queued.
+                if (!isFinished && !isEnding && (controller?.desiredSize ?? 0) < 0) {
+                    await new Promise((resolve) => {
+                        resumeWriter = resolve;
+                    });
+                }
             },
             close: finish,
             abort: fail,
         }),
-        finish,
+        end,
     };
 }
 function isMatchingResponse(msg, id) {