@jeffreycao/copilot-api 2.1.4 → 2.1.6

package/dist/{token-_ZvkUtOA.js → token-DmNSTe37.js}

@@ -1,12 +1,12 @@
-import { c as setProviderConfig, j as PATHS, k as isResponsesApiWebSocketEnabled, n as getRawProviderConfig } from "./config-CoMdcHDW.js";
+import { A as isResponsesApiWebSocketEnabled, E as getResponsesTransportConfig, M as PATHS, c as setProviderConfig, n as getRawProviderConfig } from "./config-DMrKDHiF.js";
 import consola from "consola";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import fs, { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createServer } from "node:http";
-import { events } from "fetch-event-stream";
 import { getProxyForUrl } from "proxy-from-env";
 import { WebSocket } from "undici";
+import { events } from "fetch-event-stream";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { exec } from "node:child_process";
@@ -19,6 +19,10 @@ var HTTPError = class extends Error {
 	}
 };
 async function forwardError(c, error) {
+	if (c.req.raw.signal.aborted || isAbortError$1(error)) return new Response(null, {
+		status: 499,
+		statusText: "Client Closed Request"
+	});
 	consola.error("Error occurred:", error);
 	if (error instanceof HTTPError) {
 		if (error.response.status === 429) for (const [name, value] of error.response.headers) {
@@ -43,6 +47,7 @@ async function forwardError(c, error) {
 		type: "error"
 	} }, 500);
 }
+const isAbortError$1 = (error) => error instanceof Error && error.name === "AbortError";
 //#endregion
 //#region src/lib/state.ts
 const state = {
@@ -53,9 +58,72 @@ const state = {
 };
 //#endregion
 //#region src/services/responses-websocket.ts
-const DEFAULT_WEBSOCKET_IDLE_TIMEOUT_MS = 6e4;
 const websocketPool = /* @__PURE__ */ new Map();
 const websocketActiveRequests = /* @__PURE__ */ new Map();
+var ResponsesWebSocketOpenTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Responses websocket did not open within ${timeoutMs}ms`);
+		this.name = "ResponsesWebSocketOpenTimeoutError";
+	}
+};
+var ResponsesWebSocketInactivityTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Responses websocket stream was inactive for ${timeoutMs}ms`);
+		this.name = "ResponsesWebSocketInactivityTimeoutError";
+	}
+};
+var ResponsesWebSocketBufferOverflowError = class extends Error {
+	constructor(maxBufferedBytes, maxBufferedMessages) {
+		super(`Responses websocket buffer exceeded ${maxBufferedBytes} bytes or ${maxBufferedMessages} messages; downstream consumption is too slow`);
+		this.name = "ResponsesWebSocketBufferOverflowError";
+	}
+};
+var WebSocketMessageBuffer = class {
+	entries = [];
+	head = 0;
+	maxBufferedBytes;
+	maxBufferedMessages;
+	sizeBytes = 0;
+	constructor(maxBufferedBytes, maxBufferedMessages) {
+		this.maxBufferedBytes = maxBufferedBytes;
+		this.maxBufferedMessages = maxBufferedMessages;
+	}
+	get bufferedBytes() {
+		return this.sizeBytes;
+	}
+	get bufferedMessages() {
+		return this.entries.length - this.head;
+	}
+	enqueue(data) {
+		const size = getWebSocketMessageSize(data);
+		if (this.sizeBytes + size > this.maxBufferedBytes || this.bufferedMessages + 1 > this.maxBufferedMessages) return false;
+		this.entries.push({
+			data: normalizeWebSocketMessageData(data),
+			size
+		});
+		this.sizeBytes += size;
+		return true;
+	}
+	dequeue() {
+		const entry = this.entries[this.head];
+		if (!entry) return void 0;
+		this.entries[this.head] = void 0;
+		this.head += 1;
+		this.sizeBytes -= entry.size;
+		this.compactIfNeeded();
+		return entry.data;
+	}
+	clear() {
+		this.entries.length = 0;
+		this.head = 0;
+		this.sizeBytes = 0;
+	}
+	compactIfNeeded() {
+		if (this.head < 256 || this.head * 2 < this.entries.length) return;
+		this.entries.splice(0, this.head);
+		this.head = 0;
+	}
+};
 const createWebSocketUrl = (url) => {
 	const websocketUrl = new URL(url);
 	if (websocketUrl.protocol === "https:") websocketUrl.protocol = "wss:";
@@ -64,23 +132,34 @@ const createWebSocketUrl = (url) => {
 };
 const createPooledWebSocketStream = (request, options) => runPooledWebSocketRequest(request, options);
 const runPooledWebSocketRequest = async function* (request, options) {
+	throwIfAborted(request.signal);
 	const { entry, pooled } = getPooledWebSocketRequestTarget(request, options);
-	const release = acquirePooledWebSocketEntry(request.poolKey, entry, pooled, options);
+	const release = acquirePooledWebSocketEntry(request.poolKey, entry, pooled);
+	let messageStream = null;
+	let reusable = false;
 	try {
 		const websocket = await getReadyPooledWebSocket(request.poolKey, entry, pooled, options);
+		throwIfAborted(request.signal);
+		messageStream = createWebSocketMessageStream(websocket, request.signal, options);
+		messageStream.start();
 		websocket.send(JSON.stringify(request.payload));
-		for await (const data of createWebSocketMessageStream(websocket, options)) {
+		for await (const data of messageStream.iterable) {
 			const chunk = options.createChunk(data);
+			const isTerminal = options.isTerminalChunk(chunk);
+			if (isTerminal) {
+				messageStream.complete();
+				reusable = true;
+			}
 			yield chunk;
-			if (options.isTerminalChunk(chunk)) return;
+			if (isTerminal) return;
 		}
-		removePooledWebSocketEntry(request.poolKey, entry);
 		throw new Error(options.terminalChunkMissingMessage);
 	} catch (error) {
-		removePooledWebSocketEntry(request.poolKey, entry);
-		throw toError(error);
+		throw toError$1(error);
 	} finally {
-		release();
+		messageStream?.dispose();
+		if (!reusable) removePooledWebSocketEntry(request.poolKey, entry);
+		release(reusable);
 	}
 };
 const getPooledWebSocketRequestTarget = (request, options) => {
@@ -91,7 +170,7 @@ const getPooledWebSocketRequestTarget = (request, options) => {
 	const existing = websocketPool.get(request.poolKey);
 	if (existing && !existing.closed) {
 		consola.debug("websocket from pool");
-		clearPooledWebSocketIdleTimer(existing);
+		clearPooledWebSocketIdleState(existing);
 		return {
 			entry: existing,
 			pooled: true
@@ -105,17 +184,24 @@ const getPooledWebSocketRequestTarget = (request, options) => {
 	};
 };
 const createPooledWebSocketEntry = (request, options) => {
+	const websocketPromise = openWebSocket({
+		headers: request.headers,
+		openErrorMessage: options.openErrorMessage,
+		openTimeoutMs: options.openTimeoutMs,
+		signal: request.signal,
+		url: request.url
+	});
 	const entry = {
 		closed: false,
+		idleMessageListener: null,
 		idleTimer: null,
+		poolIdleTimeoutMs: options.poolIdleTimeoutMs,
 		requestCount: 0,
-		websocketPromise: openWebSocket({
-			headers: request.headers,
-			openErrorMessage: options.openErrorMessage,
-			url: request.url
-		})
+		websocket: null,
+		websocketPromise
 	};
 	entry.websocketPromise.then((websocket) => {
+		entry.websocket = websocket;
 		websocket.addEventListener("close", () => {
 			removePooledWebSocketEntry(request.poolKey, entry);
 		});
@@ -127,26 +213,30 @@ const createPooledWebSocketEntry = (request, options) => {
 	});
 	return entry;
 };
-const acquirePooledWebSocketEntry = (poolKey, entry, pooled, options) => {
-	clearPooledWebSocketIdleTimer(entry);
+const acquirePooledWebSocketEntry = (poolKey, entry, pooled) => {
+	clearPooledWebSocketIdleState(entry);
 	incrementPooledWebSocketActiveRequestCount(poolKey);
 	entry.requestCount += 1;
 	let released = false;
-	return () => {
+	return (reusable) => {
 		if (released) return;
 		released = true;
 		entry.requestCount -= 1;
 		decrementPooledWebSocketActiveRequestCount(poolKey);
+		if (!reusable) {
+			removePooledWebSocketEntry(poolKey, entry);
+			return;
+		}
 		if (entry.closed || entry.requestCount > 0) return;
 		if (pooled && websocketPool.get(poolKey) === entry) {
-			schedulePooledWebSocketIdleClose(poolKey, entry, options);
+			schedulePooledWebSocketIdleClose(poolKey, entry);
 			return;
 		}
 		removePooledWebSocketEntry(poolKey, entry);
 	};
 };
 const getReadyPooledWebSocket = async (poolKey, entry, pooled, options) => {
-	const unavailableErrorMessage = options?.unavailableErrorMessage ?? "Websocket connection became unavailable before the request started";
+	const unavailableErrorMessage = options.unavailableErrorMessage ?? "Websocket connection became unavailable before the request started";
 	if (entry.closed) throw new Error(unavailableErrorMessage);
 	const websocket = await entry.websocketPromise;
 	if (entry.closed || pooled && websocketPool.get(poolKey) !== entry) throw new Error(unavailableErrorMessage);
@@ -156,18 +246,31 @@ const getReadyPooledWebSocket = async (poolKey, entry, pooled, options) => {
 	}
 	return websocket;
 };
-const schedulePooledWebSocketIdleClose = (poolKey, entry, options) => {
-	clearPooledWebSocketIdleTimer(entry);
+const schedulePooledWebSocketIdleClose = (poolKey, entry) => {
+	clearPooledWebSocketIdleState(entry);
+	const websocket = entry.websocket;
+	if (!websocket || websocket.readyState !== WebSocket.OPEN) {
+		removePooledWebSocketEntry(poolKey, entry);
+		return;
+	}
+	entry.idleMessageListener = () => {
+		removePooledWebSocketEntry(poolKey, entry);
+	};
+	websocket.addEventListener("message", entry.idleMessageListener);
 	entry.idleTimer = setTimeout(() => {
 		removePooledWebSocketEntry(poolKey, entry);
-	}, options.idleTimeoutMs ?? DEFAULT_WEBSOCKET_IDLE_TIMEOUT_MS);
+	}, entry.poolIdleTimeoutMs);
 	unrefTimer(entry.idleTimer);
 };
-const clearPooledWebSocketIdleTimer = (entry) => {
+const clearPooledWebSocketIdleState = (entry) => {
 	if (entry.idleTimer) {
 		clearTimeout(entry.idleTimer);
 		entry.idleTimer = null;
 	}
+	if (entry.websocket && entry.idleMessageListener) {
+		entry.websocket.removeEventListener("message", entry.idleMessageListener);
+		entry.idleMessageListener = null;
+	}
 };
 const getPooledWebSocketActiveRequestCount = (poolKey) => websocketActiveRequests.get(poolKey) ?? 0;
 const incrementPooledWebSocketActiveRequestCount = (poolKey) => {
@@ -175,117 +278,193 @@ const incrementPooledWebSocketActiveRequestCount = (poolKey) => {
 };
 const decrementPooledWebSocketActiveRequestCount = (poolKey) => {
 	const nextCount = getPooledWebSocketActiveRequestCount(poolKey) - 1;
-	if (nextCount <= 0) {
-		websocketActiveRequests.delete(poolKey);
-		return;
-	}
-	websocketActiveRequests.set(poolKey, nextCount);
+	if (nextCount <= 0) websocketActiveRequests.delete(poolKey);
+	else websocketActiveRequests.set(poolKey, nextCount);
 };
 const removePooledWebSocketEntry = (poolKey, entry) => {
 	if (websocketPool.get(poolKey) === entry) websocketPool.delete(poolKey);
 	if (entry.closed) return;
 	entry.closed = true;
-	clearPooledWebSocketIdleTimer(entry);
+	clearPooledWebSocketIdleState(entry);
 	entry.websocketPromise.then(closeWebSocket).catch(() => {});
 };
-const unrefTimer = (timer) => {
-	if (typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") timer.unref();
-};
 const createWebSocketError = (message, event) => {
 	const reason = event?.error ?? event?.message;
 	if (reason === void 0 || reason === "") return new Error(message);
-	const cause = toError(reason);
+	const cause = toError$1(reason);
 	return new Error(`${message}: ${cause.message}`, { cause });
 };
-const openWebSocket = async ({ headers, openErrorMessage, url }) => await new Promise((resolve, reject) => {
+const openWebSocket = async ({ headers, openErrorMessage, openTimeoutMs, signal, url }) => await new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(toAbortReason$1(signal.reason));
+		return;
+	}
 	const proxy = typeof Bun === "undefined" ? void 0 : getProxyUrl(url);
 	const websocket = new WebSocket(url, {
 		headers,
 		...proxy ? { proxy } : {}
 	});
+	let settled = false;
+	const timer = setTimeout(() => {
+		fail(new ResponsesWebSocketOpenTimeoutError(openTimeoutMs));
+	}, openTimeoutMs);
 	const cleanup = () => {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", onAbort);
 		websocket.removeEventListener("open", onOpen);
+		websocket.removeEventListener("close", onClose);
 		websocket.removeEventListener("error", onError);
 	};
+	const fail = (error) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		closeWebSocket(websocket);
+		reject(error);
+	};
+	const onAbort = () => fail(toAbortReason$1(signal?.reason));
 	const onOpen = () => {
+		if (settled) return;
+		settled = true;
 		cleanup();
 		resolve(websocket);
 	};
+	const onClose = () => fail(new Error(openErrorMessage));
 	const onError = (event) => {
-		cleanup();
-		reject(createWebSocketError(openErrorMessage, event));
+		fail(createWebSocketError(openErrorMessage, event));
 	};
+	signal?.addEventListener("abort", onAbort, { once: true });
 	websocket.addEventListener("open", onOpen);
+	websocket.addEventListener("close", onClose);
 	websocket.addEventListener("error", onError);
 });
-const createWebSocketMessageStream = async function* (websocket, options) {
-	const queue = [];
+const createWebSocketMessageStream = (websocket, signal, options) => {
+	const buffer = new WebSocketMessageBuffer(options.maxBufferedBytes, options.maxBufferedMessages);
 	let closed = false;
+	let disposed = false;
 	let error = null;
+	let inactivityTimer = null;
 	let notify = null;
 	const wake = () => {
 		notify?.();
 		notify = null;
 	};
+	const clearInactivityTimer = () => {
+		if (!inactivityTimer) return;
+		clearTimeout(inactivityTimer);
+		inactivityTimer = null;
+	};
+	const fail = (nextError, close = true) => {
+		if (error || disposed) return;
+		error = nextError;
+		clearInactivityTimer();
+		buffer.clear();
+		if (close) closeWebSocket(websocket);
+		wake();
+	};
+	const resetInactivityTimer = () => {
+		clearInactivityTimer();
+		if (disposed || closed || error) return;
+		inactivityTimer = setTimeout(() => {
+			fail(new ResponsesWebSocketInactivityTimeoutError(options.streamInactivityTimeoutMs));
+		}, options.streamInactivityTimeoutMs);
+	};
 	const onMessage = (event) => {
-		queue.push(normalizeWebSocketMessageData(event.data));
+		resetInactivityTimer();
+		if (!buffer.enqueue(event.data)) {
+			fail(new ResponsesWebSocketBufferOverflowError(options.maxBufferedBytes, options.maxBufferedMessages));
+			return;
+		}
 		wake();
 	};
 	const onClose = () => {
 		consola.debug("WebSocket closed");
 		closed = true;
+		clearInactivityTimer();
 		wake();
 	};
 	const onError = (event) => {
 		consola.error("WebSocket error:", event, event.error);
-		error = createWebSocketError(options.streamErrorMessage, event);
-		wake();
+		fail(createWebSocketError(options.streamErrorMessage, event), false);
 	};
+	const onAbort = () => fail(toAbortReason$1(signal?.reason));
 	websocket.addEventListener("message", onMessage);
 	websocket.addEventListener("close", onClose);
 	websocket.addEventListener("error", onError);
-	try {
-		while (true) {
-			const item = queue.shift();
-			if (item) {
-				yield await item;
-				continue;
-			}
-			if (error) throw toError(error);
-			if (closed) break;
-			await new Promise((resolve) => {
-				notify = resolve;
-			});
-		}
-	} finally {
+	signal?.addEventListener("abort", onAbort, { once: true });
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		clearInactivityTimer();
+		buffer.clear();
 		websocket.removeEventListener("message", onMessage);
 		websocket.removeEventListener("close", onClose);
 		websocket.removeEventListener("error", onError);
-	}
+		signal?.removeEventListener("abort", onAbort);
+		wake();
+	};
+	return {
+		complete: clearInactivityTimer,
+		dispose,
+		iterable: (async function* () {
+			try {
+				while (true) {
+					const item = buffer.dequeue();
+					if (item) {
+						yield await item;
+						continue;
+					}
+					if (error) throw toError$1(error);
+					if (closed) return;
+					await new Promise((resolve) => {
+						notify = resolve;
+					});
+				}
+			} finally {
+				dispose();
+			}
+		})(),
+		start: resetInactivityTimer
+	};
 };
 const normalizeWebSocketMessageData = async (data) => {
 	if (typeof data === "string") return data;
 	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
-	if (ArrayBuffer.isView(data)) {
-		const view = data;
-		return new TextDecoder().decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
-	}
+	if (ArrayBuffer.isView(data)) return new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
 	if (isTextReadable(data)) return await data.text();
 	return String(data);
 };
-const isTextReadable = (value) => {
-	if (!value || typeof value !== "object" || !("text" in value)) return false;
-	return typeof value.text === "function";
-};
-const toError = (value) => {
+const getWebSocketMessageSize = (data) => {
+	if (typeof data === "string") return new TextEncoder().encode(data).byteLength;
+	if (data instanceof ArrayBuffer) return data.byteLength;
+	if (ArrayBuffer.isView(data)) return data.byteLength;
+	if (isSized(data)) return data.size;
+	return new TextEncoder().encode(String(data)).byteLength;
+};
+const isTextReadable = (value) => Boolean(value && typeof value === "object" && "text" in value && typeof value.text === "function");
+const isSized = (value) => Boolean(value && typeof value === "object" && "size" in value && typeof value.size === "number");
+const toAbortReason$1 = (reason) => {
+	if (reason instanceof Error) return reason;
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	return error;
+};
+const throwIfAborted = (signal) => {
+	if (signal?.aborted) throw toAbortReason$1(signal.reason);
+};
+const toError$1 = (value) => {
 	if (value instanceof Error) return value;
 	return new Error(String(value));
 };
 const closeWebSocket = (websocket) => {
-	if (websocket.readyState === WebSocket.CONNECTING || websocket.readyState === WebSocket.OPEN) websocket.close();
+	if (websocket.readyState !== WebSocket.CONNECTING && websocket.readyState !== WebSocket.OPEN) return;
+	try {
+		websocket.close();
+	} catch {}
 };
-const getProxyUrl = (url) => {
-	return getProxyForUrl(url.replace(/^wss:/, "https:").replace(/^ws:/, "http:"));
+const getProxyUrl = (url) => getProxyForUrl(url.replace(/^wss:/u, "https:").replace(/^ws:/u, "http:"));
+const unrefTimer = (timer) => {
+	if (typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") timer.unref();
 };
 //#endregion
 //#region src/services/responses-websocket-helpers.ts
@@ -316,13 +495,200 @@ const isTerminalResponsesStreamChunk = (chunk) => {
 		return false;
 	}
 };
-const createResponsesSafeStream = async function* (source) {
+const createResponsesSafeStream = async function* (source, options = {}) {
 	try {
 		yield* source;
 	} catch (error) {
+		if (options.signal?.aborted || isAbortError(error)) return;
 		yield createResponsesErrorServerSentEventChunk(getErrorMessage(error));
 	}
 };
+const isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+//#endregion
+//#region src/services/responses-http.ts
+var ResponsesHeadersTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Responses upstream did not return headers within ${timeoutMs}ms`);
+		this.name = "ResponsesHeadersTimeoutError";
+	}
+};
+var ResponsesStreamInactivityTimeoutError = class extends Error {
+	constructor(timeoutMs) {
+		super(`Responses upstream stream was inactive for ${timeoutMs}ms`);
+		this.name = "ResponsesStreamInactivityTimeoutError";
+	}
+};
+async function fetchResponsesWithLifecycle(input, init, options) {
+	const lifecycle = createRequestLifecycle(options);
+	try {
+		const response = await fetch(input, {
+			...init,
+			signal: lifecycle.signal
+		});
+		lifecycle.headersReceived();
+		return createManagedResponse(response, lifecycle, options);
+	} catch (error) {
+		throw lifecycle.finishWithError(error);
+	}
+}
+const createRequestLifecycle = (options) => {
+	const controller = new AbortController();
+	const downstreamSignal = options.signal;
+	let finished = false;
+	let headersTimer = null;
+	const abortFromDownstream = () => {
+		controller.abort(toAbortReason(downstreamSignal?.reason));
+	};
+	if (downstreamSignal?.aborted) abortFromDownstream();
+	else downstreamSignal?.addEventListener("abort", abortFromDownstream, { once: true });
+	if (!controller.signal.aborted) headersTimer = setTimeout(() => {
+		controller.abort(new ResponsesHeadersTimeoutError(options.headersTimeoutMs));
+	}, options.headersTimeoutMs);
+	const clearHeadersTimer = () => {
+		if (headersTimer === null) return;
+		clearTimeout(headersTimer);
+		headersTimer = null;
+	};
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		clearHeadersTimer();
+		downstreamSignal?.removeEventListener("abort", abortFromDownstream);
+	};
+	return {
+		abort: (reason) => {
+			if (!controller.signal.aborted) controller.abort(reason);
+		},
+		finish,
+		finishWithError: (error) => {
+			clearHeadersTimer();
+			const reason = controller.signal.reason;
+			finish();
+			return reason instanceof Error ? reason : toError(error);
+		},
+		headersReceived: clearHeadersTimer,
+		signal: controller.signal
+	};
+};
+const createManagedResponse = (response, lifecycle, options) => {
+	if (!response.body) {
+		lifecycle.finish();
+		return response;
+	}
+	const body = createManagedResponseBody(response.body, lifecycle, options);
+	return new Response(body, {
+		headers: response.headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+};
+const createManagedResponseBody = (body, lifecycle, options) => {
+	const reader = body.getReader();
+	let finished = false;
+	let readerReleased = false;
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		lifecycle.finish();
+	};
+	const releaseReader = () => {
+		if (readerReleased) return;
+		readerReleased = true;
+		reader.releaseLock();
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await readWithLifecycle(reader, lifecycle, options);
+				if (result.done) {
+					finish();
+					releaseReader();
+					controller.close();
+					return;
+				}
+				controller.enqueue(result.value);
+			} catch (error) {
+				const reason = lifecycle.finishWithError(error);
+				finish();
+				await reader.cancel(reason).catch(() => {});
+				releaseReader();
+				controller.error(reason);
+			}
+		},
+		async cancel(reason) {
+			const error = toAbortReason(reason);
+			lifecycle.abort(error);
+			finish();
+			await reader.cancel(error).catch(() => {});
+			releaseReader();
+		}
+	});
+};
+const createResponsesHttpEventStream = async function* (response, signal) {
+	const responseBody = response.body;
+	if (!responseBody) return;
+	const reader = responseBody.getReader();
+	const readerBackedBody = new ReadableStream({
+		async pull(controller) {
+			const result = await reader.read();
+			if (result.done) {
+				controller.close();
+				return;
+			}
+			controller.enqueue(result.value);
+		},
+		async cancel(reason) {
+			await reader.cancel(reason);
+		}
+	});
+	try {
+		yield* events(new Response(readerBackedBody), signal);
+	} finally {
+		try {
+			await reader.cancel();
+		} catch {} finally {
+			reader.releaseLock();
+		}
+	}
+};
+const readWithLifecycle = async (reader, lifecycle, options) => await new Promise((resolve, reject) => {
+	let settled = false;
+	const signal = lifecycle.signal;
+	const timer = setTimeout(() => {
+		const error = new ResponsesStreamInactivityTimeoutError(options.streamInactivityTimeoutMs);
+		lifecycle.abort(error);
+		settle(() => reject(error));
+	}, options.streamInactivityTimeoutMs);
+	const onAbort = () => {
+		settle(() => reject(toAbortReason(signal.reason)));
+	};
+	const cleanup = () => {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", onAbort);
+	};
+	const settle = (action) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		action();
+	};
+	if (signal.aborted) {
+		onAbort();
+		return;
+	}
+	signal.addEventListener("abort", onAbort, { once: true });
+	reader.read().then((result) => settle(() => resolve(result)), (error) => settle(() => reject(toError(error))));
+});
+const toAbortReason = (reason) => {
+	if (reason instanceof Error) return reason;
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	return error;
+};
+const toError = (value) => {
+	if (value instanceof Error) return value;
+	return new Error(String(value));
+};
 //#endregion
 //#region src/lib/request-context.ts
 const TRACE_ID_MAX_LENGTH = 64;
@@ -434,27 +800,33 @@ function buildCodexResponsesWebSocketPayload(payload) {
 function buildCodexResponsesWebSocketUrl(baseUrl = CODEX_API_BASE_URL) {
 	return createWebSocketUrl(resolveCodexResponsesUrl(baseUrl));
 }
-function prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl = CODEX_API_BASE_URL) {
+function prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl = CODEX_API_BASE_URL, signal) {
 	const headers = buildCodexResponsesWebSocketHeaders(requestHeaders);
 	return {
 		headers,
 		payload: buildCodexResponsesWebSocketPayload(payload),
 		poolKey: buildCodexResponsesWebSocketPoolKey(payload, headers, baseUrl),
+		signal,
 		url: buildCodexResponsesWebSocketUrl(baseUrl)
 	};
 }
 async function forwardCodexResponses(payload, requestHeaders, baseUrl = CODEX_API_BASE_URL, options = {}) {
 	consola.log(`<-- model: ${payload.model}`);
 	const transport = resolveCodexResponsesTransport(options.transport);
-	if (payload.stream && transport === "websocket") return forwardCodexResponsesOverWebSocket(payload, requestHeaders, baseUrl);
+	if (payload.stream && transport === "websocket") return forwardCodexResponsesOverWebSocket(payload, requestHeaders, baseUrl, options.signal);
 	const normalizedPayload = normalizeCodexResponsesPayload(payload);
-	const response = await fetch(resolveCodexResponsesUrl(baseUrl), {
+	const transportConfig = getResponsesTransportConfig();
+	const response = await fetchResponsesWithLifecycle(resolveCodexResponsesUrl(baseUrl), {
 		method: "POST",
 		headers: buildCodexResponsesHeaders(requestHeaders, { stream: normalizedPayload.stream }),
 		body: JSON.stringify(normalizedPayload)
+	}, {
+		headersTimeoutMs: transportConfig.headersTimeoutMs,
+		signal: options.signal,
+		streamInactivityTimeoutMs: transportConfig.streamInactivityTimeoutMs
 	});
 	if (!response.ok) throw new HTTPError("Failed to create codex responses", response);
-	if (normalizedPayload.stream) return events(response);
+	if (normalizedPayload.stream) return createResponsesSafeStream(createResponsesHttpEventStream(response, options.signal), { signal: options.signal });
 	return await response.json();
 }
 const normalizeCodexResponsesPayload = (payload) => {
@@ -520,16 +892,24 @@ const buildCodexResponsesWebSocketPoolKey = (payload, headers, baseUrl) => {
 		headerFingerprint
 	].map(encodePoolKeyPart).join("|");
 };
-const forwardCodexResponsesOverWebSocket = (payload, requestHeaders, baseUrl) => {
-	return createCodexResponsesWebSocketStream(prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl));
+const forwardCodexResponsesOverWebSocket = (payload, requestHeaders, baseUrl, signal) => {
+	return createCodexResponsesWebSocketStream(prepareCodexResponsesWebSocketRequest(payload, requestHeaders, baseUrl, signal));
+};
+const createCodexResponsesWebSocketStream = (request) => {
+	const transportConfig = getResponsesTransportConfig();
+	return createResponsesSafeStream(createPooledWebSocketStream(request, {
+		createChunk: createCodexResponsesWebSocketStreamChunk,
+		maxBufferedBytes: transportConfig.websocketMaxBufferedBytes,
+		maxBufferedMessages: transportConfig.websocketMaxBufferedMessages,
+		isTerminalChunk: isTerminalResponsesStreamChunk,
+		openErrorMessage: "Failed to create codex responses websocket",
+		openTimeoutMs: transportConfig.websocketOpenTimeoutMs,
+		poolIdleTimeoutMs: transportConfig.websocketPoolIdleTimeoutMs,
+		streamInactivityTimeoutMs: transportConfig.streamInactivityTimeoutMs,
+		streamErrorMessage: "Codex responses websocket stream error",
+		terminalChunkMissingMessage: "Codex responses websocket ended without a terminal response"
+	}), { signal: request.signal });
 };
-const createCodexResponsesWebSocketStream = (request) => createResponsesSafeStream(createPooledWebSocketStream(request, {
-	createChunk: createCodexResponsesWebSocketStreamChunk,
-	isTerminalChunk: isTerminalResponsesStreamChunk,
-	openErrorMessage: "Failed to create codex responses websocket",
-	streamErrorMessage: "Codex responses websocket stream error",
-	terminalChunkMissingMessage: "Codex responses websocket ended without a terminal response"
-}));
 const createCodexResponsesWebSocketStreamChunk = (data) => {
 	if (data === "[DONE]") return { data };
 	try {
@@ -1500,6 +1880,6 @@ async function logUser() {
 	state.tokenBasedBilling = copilotUser.token_based_billing;
 }
 //#endregion
-export { buildCodexRequestHeaders as A, state as B, compactAutoContinuePromptStarts as C, compactTextOnlyGuard as D, compactSystemPromptStarts as E, createResponsesSafeStream as F, forwardError as H, encodePoolKeyPart as I, isTerminalResponsesStreamChunk as L, generateTraceId as M, requestContext as N, loginCodex as O, resolveTraceId as P, createPooledWebSocketStream as R, initOpencodeVersion as S, compactSummaryPromptStart as T, HTTPError as V, copilotModelsHeaders as _, setupGitHubToken as a, prepareInteractionHeaders as b, getUUID as c, isResponsesStream as d, parseUserIdMetadata as f, copilotHeaders as g, copilotBaseUrl as h, setupCopilotToken as i, forwardCodexResponses as j, CODEX_API_BASE_URL as k, isAsyncIterable as l, readGitHubToken as m, persistCodexCredentials as n, generateRequestIdFromPayload as o, getCopilotUsage as p, setupCodexToken as r, getRootSessionId as s, logUser as t, isNullish as u, copilotWebSocketHeaders as v, compactMessageSections as w, prepareMessageProxyHeaders as x, prepareForCompact as y, createWebSocketUrl as z };
+export { buildCodexRequestHeaders as A, createPooledWebSocketStream as B, compactAutoContinuePromptStarts as C, compactTextOnlyGuard as D, compactSystemPromptStarts as E, createResponsesHttpEventStream as F, state as H, fetchResponsesWithLifecycle as I, createResponsesSafeStream as L, generateTraceId as M, requestContext as N, loginCodex as O, resolveTraceId as P, encodePoolKeyPart as R, initOpencodeVersion as S, compactSummaryPromptStart as T, HTTPError as U, createWebSocketUrl as V, forwardError as W, copilotModelsHeaders as _, setupGitHubToken as a, prepareInteractionHeaders as b, getUUID as c, isResponsesStream as d, parseUserIdMetadata as f, copilotHeaders as g, copilotBaseUrl as h, setupCopilotToken as i, forwardCodexResponses as j, CODEX_API_BASE_URL as k, isAsyncIterable as l, readGitHubToken as m, persistCodexCredentials as n, generateRequestIdFromPayload as o, getCopilotUsage as p, setupCodexToken as r, getRootSessionId as s, logUser as t, isNullish as u, copilotWebSocketHeaders as v, compactMessageSections as w, prepareMessageProxyHeaders as x, prepareForCompact as y, isTerminalResponsesStreamChunk as z };
 
-//# sourceMappingURL=token-_ZvkUtOA.js.map
+//# sourceMappingURL=token-DmNSTe37.js.map