Spaces:
Running
Running
| // Client-disconnect abort plumbing shared by the /chat/completions and | |
| // /v1/responses routes. When an agent presses Stop or closes the session, the | |
| // underlying socket tears down and the response `close` event fires BEFORE the | |
| // response has finished writing — that's the signal we use to abort the whole | |
| // retry/recovery loop and any in-flight upstream call. (#292) | |
| // | |
| // The hard part is telling a real disconnect apart from a normal completion: | |
| // the response `close` event ALSO fires after `res.end()` on a successful | |
| // response. We therefore check `res.writableEnded` inside the handler before | |
| // aborting — a close after the response is fully written is the normal | |
| // teardown, not a client stop. | |
| import { RequestAbortError } from '../providers/base.js'; | |
| /** Resolve the promise after `ms`, but reject early with `RequestAbortError` | |
| * if `signal` aborts first. Returns immediately (resolved) when the signal is | |
| * already aborted — the caller is expected to check `signal.aborted` at the | |
| * loop top too, but resolving early keeps the await from throwing on the | |
| * already-settled rejection. (#292) */ | |
| export function abortableSleep(ms: number, signal?: AbortSignal): Promise<void> { | |
| return new Promise<void>((resolve, reject) => { | |
| if (signal?.aborted) { | |
| reject(new RequestAbortError()); | |
| return; | |
| } | |
| if (ms <= 0) { | |
| resolve(); | |
| return; | |
| } | |
| const timer = setTimeout(() => { | |
| if (signal) signal.removeEventListener('abort', onAbort); | |
| resolve(); | |
| }, ms); | |
| const onAbort = () => { | |
| clearTimeout(timer); | |
| reject(new RequestAbortError()); | |
| }; | |
| signal?.addEventListener('abort', onAbort, { once: true }); | |
| }); | |
| } | |
| /** Attach a client-disconnect watcher to an Express response. | |
| * | |
| * Returns an `AbortController` whose `signal` should be threaded into every | |
| * provider call and `abortableSleep` in the retry loop. The controller is | |
| * aborted when the response's underlying socket closes BEFORE the response has | |
| * finished streaming/writing — i.e. a genuine client Stop/disconnect, not | |
| * normal completion. The handler removes itself in `detach()` for the | |
| * clean-completion path. (#292) | |
| * | |
| * We listen on the RESPONSE's `close` event, NOT the request's. The request | |
| * `close` fires as soon as the request BODY has been fully received — which | |
| * is long before the response is sent — so it cannot distinguish a real | |
| * disconnect from a normal in-progress request (it would abort every single | |
| * POST the moment the body finished uploading). The response `close` fires | |
| * when the socket tears down, and `res.writableEnded` tells us whether we | |
| * finished writing (normal completion) or not (client gone). */ | |
| export function attachClientAbort( | |
| res: { on: (e: 'close', fn: () => void) => void; removeListener: (e: 'close', fn: () => void) => void; writableEnded: boolean }, | |
| ): { controller: AbortController; detach: () => void } { | |
| const controller = new AbortController(); | |
| const onClose = () => { | |
| // Normal completion: the response was fully written before the socket | |
| // closed. This is the `close` that always fires after `res.end()`; do NOT | |
| // abort — there's nothing left to cancel and aborting would throw spurious | |
| // errors into a response that's already gone out. | |
| if (res.writableEnded) return; | |
| controller.abort(); | |
| }; | |
| res.on('close', onClose); | |
| const detach = () => { | |
| try { res.removeListener('close', onClose); } catch { /* already gone */ } | |
| }; | |
| return { controller, detach }; | |
| } | |
| /** True if `err` is any shape of abort — our `RequestAbortError` or a native | |
| * fetch `AbortError`. Re-exported here so routes can import everything | |
| * abort-related from one place. (#292) */ | |
| export { isAbortError } from '../providers/base.js'; | |