@jeffreycao/copilot-api 1.10.2 → 1.10.4

package/dist/main.js

@@ -42,7 +42,7 @@ bindElectronFetch();
 const { auth } = await import("./auth-BHa2OHXf.js");
 const { checkUsage } = await import("./check-usage-BdXGp1Wr.js");
 const { debug } = await import("./debug-C_TBkyUw.js");
-const { start } = await import("./start-BVraN8xz.js");
+const { start } = await import("./start-CNhCFSlB.js");
 await runMain(defineCommand({
 	meta: {
 		name: "copilot-api",

package/dist/{server-csGHkK-m.js → server-D2zjqsEM.js}

@@ -2705,7 +2705,7 @@ const buildResponsesWebSocketPoolKey = (payload, { requestId, subagentMarker })
 const getResponsesWebSocketInitiator = (preparedHeaders) => {
 	return getHeaderValue(preparedHeaders, "x-initiator")?.toLowerCase() === "agent" ? "agent" : "user";
 };
-const createPooledResponsesWebSocketStream = (request) => runResponsesWebSocketPoolRequest(request);
+const createPooledResponsesWebSocketStream = (request) => runResponsesWebSocketRequest(request);
 const buildResponsesWebSocketPayload = (payload, initiator) => {
 	const websocketPayload = {
 		...payload,
@@ -2724,11 +2724,12 @@ const buildResponsesWebSocketUrl = (baseUrl) => {
 	return url.toString();
 };
 const responsesWebSocketPool = /* @__PURE__ */ new Map();
-const runResponsesWebSocketPoolRequest = async function* (request) {
-	const entry = getResponsesWebSocketPoolEntry(request);
-	const release = await acquireResponsesWebSocketPoolEntry(request.poolKey, entry);
+const responsesWebSocketActiveRequests = /* @__PURE__ */ new Map();
+const runResponsesWebSocketRequest = async function* (request) {
+	const { entry, pooled } = getResponsesWebSocketRequestTarget(request);
+	const release = acquireResponsesWebSocketEntry(request.poolKey, entry, pooled);
 	try {
-		const websocket = await entry.websocketPromise;
+		const websocket = await getReadyResponsesWebSocket(request.poolKey, entry, pooled);
 		websocket.send(JSON.stringify(request.payload));
 		for await (const data of createWebSocketMessageStream(websocket)) {
 			const chunk = createResponsesWebSocketStreamChunk(data);
@@ -2744,21 +2745,31 @@ const runResponsesWebSocketPoolRequest = async function* (request) {
 		release();
 	}
 };
-const getResponsesWebSocketPoolEntry = (request) => {
+const getResponsesWebSocketRequestTarget = (request) => {
+	if (getResponsesWebSocketActiveRequestCount(request.poolKey) > 0) return {
+		entry: createResponsesWebSocketEntry(request),
+		pooled: false
+	};
 	const existing = responsesWebSocketPool.get(request.poolKey);
 	if (existing && !existing.closed) {
 		clearResponsesWebSocketIdleTimer(existing);
-		return existing;
+		return {
+			entry: existing,
+			pooled: true
+		};
 	}
-	const entry = createResponsesWebSocketPoolEntry(request);
+	const entry = createResponsesWebSocketEntry(request);
 	responsesWebSocketPool.set(request.poolKey, entry);
-	return entry;
+	return {
+		entry,
+		pooled: true
+	};
 };
-const createResponsesWebSocketPoolEntry = (request) => {
+const createResponsesWebSocketEntry = (request) => {
 	const entry = {
 		closed: false,
 		idleTimer: null,
-		lock: Promise.resolve(),
+		requestCount: 0,
 		websocketPromise: openResponsesWebSocket({
 			headers: request.headers,
 			url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
@@ -2776,23 +2787,34 @@ const createResponsesWebSocketPoolEntry = (request) => {
 	});
 	return entry;
 };
-const acquireResponsesWebSocketPoolEntry = async (poolKey, entry) => {
-	clearResponsesWebSocketIdleTimer(entry);
-	let releaseCurrent;
-	const previousLock = entry.lock;
-	entry.lock = new Promise((resolve) => {
-		releaseCurrent = resolve;
-	});
-	await previousLock;
+const acquireResponsesWebSocketEntry = (poolKey, entry, pooled) => {
 	clearResponsesWebSocketIdleTimer(entry);
+	incrementResponsesWebSocketActiveRequestCount(poolKey);
+	entry.requestCount += 1;
 	let released = false;
 	return () => {
 		if (released) return;
 		released = true;
-		releaseCurrent();
-		if (!entry.closed) scheduleResponsesWebSocketIdleClose(poolKey, entry);
+		entry.requestCount -= 1;
+		decrementResponsesWebSocketActiveRequestCount(poolKey);
+		if (entry.closed || entry.requestCount > 0) return;
+		if (pooled && responsesWebSocketPool.get(poolKey) === entry) {
+			scheduleResponsesWebSocketIdleClose(poolKey, entry);
+			return;
+		}
+		removeResponsesWebSocketPoolEntry(poolKey, entry);
 	};
 };
+const getReadyResponsesWebSocket = async (poolKey, entry, pooled) => {
+	if (entry.closed) throw new Error("Responses websocket became unavailable before the request started");
+	const websocket = await entry.websocketPromise;
+	if (entry.closed || pooled && responsesWebSocketPool.get(poolKey) !== entry) throw new Error("Responses websocket became unavailable before the request started");
+	if (websocket.readyState !== WebSocket.OPEN) {
+		removeResponsesWebSocketPoolEntry(poolKey, entry);
+		throw new Error("Responses websocket became unavailable before the request started");
+	}
+	return websocket;
+};
 const scheduleResponsesWebSocketIdleClose = (poolKey, entry) => {
 	clearResponsesWebSocketIdleTimer(entry);
 	entry.idleTimer = setTimeout(() => {
@@ -2806,9 +2828,21 @@ const clearResponsesWebSocketIdleTimer = (entry) => {
 		entry.idleTimer = null;
 	}
 };
+const getResponsesWebSocketActiveRequestCount = (poolKey) => responsesWebSocketActiveRequests.get(poolKey) ?? 0;
+const incrementResponsesWebSocketActiveRequestCount = (poolKey) => {
+	responsesWebSocketActiveRequests.set(poolKey, getResponsesWebSocketActiveRequestCount(poolKey) + 1);
+};
+const decrementResponsesWebSocketActiveRequestCount = (poolKey) => {
+	const nextCount = getResponsesWebSocketActiveRequestCount(poolKey) - 1;
+	if (nextCount <= 0) {
+		responsesWebSocketActiveRequests.delete(poolKey);
+		return;
+	}
+	responsesWebSocketActiveRequests.set(poolKey, nextCount);
+};
 const removeResponsesWebSocketPoolEntry = (poolKey, entry) => {
-	if (responsesWebSocketPool.get(poolKey) !== entry) return;
-	responsesWebSocketPool.delete(poolKey);
+	if (responsesWebSocketPool.get(poolKey) === entry) responsesWebSocketPool.delete(poolKey);
+	if (entry.closed) return;
 	entry.closed = true;
 	clearResponsesWebSocketIdleTimer(entry);
 	entry.websocketPromise.then(closeResponsesWebSocket).catch(() => {});
@@ -2816,6 +2850,12 @@ const removeResponsesWebSocketPoolEntry = (poolKey, entry) => {
 const unrefTimer = (timer) => {
 	if (typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") timer.unref();
 };
+const createResponsesWebSocketError = (message, event) => {
+	const reason = event?.error ?? event?.message;
+	if (reason === void 0 || reason === "") return new Error(message);
+	const cause = toError(reason);
+	return new Error(`${message}: ${cause.message}`, { cause });
+};
 const openResponsesWebSocket = async ({ headers, url }) => await new Promise((resolve, reject) => {
 	const dispatcher = getProxyEnvDispatcher();
 	const websocket = new WebSocket(url, dispatcher ? {
@@ -2830,9 +2870,9 @@ const openResponsesWebSocket = async ({ headers, url }) => await new Promise((re
 		cleanup();
 		resolve(websocket);
 	};
-	const onError = () => {
+	const onError = (event) => {
 		cleanup();
-		reject(/* @__PURE__ */ new Error("Failed to create responses websocket"));
+		reject(createResponsesWebSocketError("Failed to create responses websocket", event));
 	};
 	websocket.addEventListener("open", onOpen);
 	websocket.addEventListener("error", onError);
@@ -2854,8 +2894,8 @@ const createWebSocketMessageStream = async function* (websocket) {
 		closed = true;
 		wake();
 	};
-	const onError = () => {
-		error = /* @__PURE__ */ new Error("Responses websocket stream error");
+	const onError = (event) => {
+		error = createResponsesWebSocketError("Responses websocket stream error", event);
 		wake();
 	};
 	websocket.addEventListener("message", onMessage);
@@ -4796,4 +4836,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-csGHkK-m.js.map
+//# sourceMappingURL=server-D2zjqsEM.js.map