@jeffreycao/copilot-api 1.11.1 → 1.11.2

package/dist/main.js

@@ -43,7 +43,7 @@ const { auth } = await import("./auth-D3ta3JW0.js");
 const { checkUsage } = await import("./check-usage-Dh0WqiLC.js");
 const { debug } = await import("./debug-BiX0ewij.js");
 const { mcp } = await import("./mcp-DZgcvqQY.js");
-const { start } = await import("./start-CFeefs3X.js");
+const { start } = await import("./start-CUCHCtOg.js");
 await runMain(defineCommand({
 	meta: {
 		name: "copilot-api",

package/dist/{server-BxCf-DN5.js → server--yUElsYz.js}

@@ -4351,7 +4351,7 @@ const prepareWebSearchResponsesPayload = (payload, options = {}) => {
 		...payload,
 		model: options.model ?? payload.model,
 		tools: [],
-		stream: false
+		stream: true
 	}, options.subagentAgentId);
 	responsesPayload.tools = [buildResponsesWebSearchTool(config)];
 	responsesPayload.tool_choice = void 0;
@@ -4377,6 +4377,143 @@ const reconstructWebSearchResponse = (payload, result, options) => {
 		}
 	};
 };
+const collectWebSearchResponsesStreamResult = async ({ errorMessagePrefix = "Web search responses stream", parseEvent = parseWebSearchResponsesStreamEvent, upstreamResponse, logger }) => {
+	const state = createWebSearchResponsesStreamCollection();
+	for await (const chunk of upstreamResponse) {
+		debugJson(logger, "Received web search responses stream chunk:", chunk.data);
+		if (chunk.event === "ping") continue;
+		if (!chunk.data || chunk.data === "[DONE]") continue;
+		const parsed = parseEvent(chunk.data);
+		if (!parsed) continue;
+		collectWebSearchResponsesStreamEvent(parsed, state);
+		if (parsed.type === "error") throw new Error(getStreamErrorMessage(parsed) ?? `${errorMessagePrefix} failed`);
+		if (isResponsesTerminalEvent(parsed)) return buildWebSearchResponsesStreamResult(state);
+	}
+	throw new Error(`${errorMessagePrefix} ended without a terminal event`);
+};
+const parseWebSearchResponsesStreamEvent = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+};
+const isWebSearchResponsesStream = (value) => {
+	return Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
+};
+const isResponsesTerminalEvent = (event) => (event.type === "response.completed" || event.type === "response.failed" || event.type === "response.incomplete") && getResponsesResult(event.response) !== void 0;
+const createWebSearchResponsesStreamCollection = () => ({
+	outputItemsByIndex: /* @__PURE__ */ new Map(),
+	textPartsByKey: /* @__PURE__ */ new Map()
+});
+const collectWebSearchResponsesStreamEvent = (event, state) => {
+	if (event.type === "response.created") {
+		state.createdResponse = getResponsesResult(event.response);
+		return;
+	}
+	if (isResponsesTerminalEvent(event)) {
+		state.terminalResponse = event.response;
+		return;
+	}
+	if (event.type === "response.output_item.added" || event.type === "response.output_item.done") {
+		const outputIndex = getNumber(event.output_index);
+		const item = getRecord(event.item);
+		if (outputIndex !== void 0 && item) state.outputItemsByIndex.set(outputIndex, item);
+		return;
+	}
+	if (event.type === "response.output_text.delta") {
+		const part = getOrCreateOutputTextPart(event, state);
+		const delta = getString(event.delta);
+		if (part && delta) part.text += delta;
+		return;
+	}
+	if (event.type === "response.output_text.done") {
+		const part = getOrCreateOutputTextPart(event, state);
+		const text = getString(event.text);
+		if (part && text !== void 0) part.text = text;
+		return;
+	}
+	if (event.type === "response.output_text.annotation.added") {
+		const part = getOrCreateOutputTextPart(event, state);
+		const annotation = event.annotation;
+		if (part && annotation !== void 0) part.annotations.push(annotation);
+		return;
+	}
+	if (event.type === "response.content_part.done") collectDoneContentPart(event, state);
+};
+const buildWebSearchResponsesStreamResult = (state) => {
+	const response = state.terminalResponse ?? state.createdResponse;
+	if (!response) throw new Error("Web search responses stream ended without a response");
+	const output = buildCollectedWebSearchOutput(state);
+	return {
+		...response,
+		output: output.length > 0 ? output : response.output
+	};
+};
+const buildCollectedWebSearchOutput = (state) => [...state.outputItemsByIndex.entries()].sort(([leftIndex], [rightIndex]) => leftIndex - rightIndex).map(([outputIndex, item]) => mergeOutputItemWithCollectedText(outputIndex, item, state));
+const mergeOutputItemWithCollectedText = (outputIndex, item, state) => {
+	if (item.type !== "message") return item;
+	const collectedParts = getCollectedTextParts(outputIndex, state);
+	if (collectedParts.length === 0) return item;
+	const content = getArray(item.content);
+	for (const part of collectedParts) {
+		const existingPart = getRecord(content[part.contentIndex]);
+		content[part.contentIndex] = {
+			...existingPart,
+			type: "output_text",
+			text: part.text,
+			annotations: mergeAnnotations(existingPart?.annotations, part.annotations)
+		};
+	}
+	return {
+		...item,
+		content
+	};
+};
+const collectDoneContentPart = (event, state) => {
+	const partRecord = getRecord(getRecord(event)?.part);
+	if (partRecord?.type !== "output_text") return;
+	const part = getOrCreateOutputTextPart(event, state);
+	if (!part) return;
+	const text = getString(partRecord.text);
+	if (text !== void 0) part.text = text;
+	const annotations = getArray(partRecord.annotations);
+	if (annotations.length > 0) part.annotations.push(...annotations);
+};
+const getOrCreateOutputTextPart = (event, state) => {
+	const eventRecord = getRecord(event);
+	const outputIndex = getNumber(eventRecord?.output_index);
+	const contentIndex = getNumber(eventRecord?.content_index);
+	if (outputIndex === void 0 || contentIndex === void 0) return;
+	const key = `${outputIndex}:${contentIndex}`;
+	let part = state.textPartsByKey.get(key);
+	if (!part) {
+		part = {
+			annotations: [],
+			contentIndex,
+			itemId: getString(eventRecord?.item_id),
+			outputIndex,
+			text: ""
+		};
+		state.textPartsByKey.set(key, part);
+	}
+	return part;
+};
+const getCollectedTextParts = (outputIndex, state) => [...state.textPartsByKey.values()].filter((part) => part.outputIndex === outputIndex).sort((left, right) => left.contentIndex - right.contentIndex || (left.itemId ?? "").localeCompare(right.itemId ?? ""));
+const mergeAnnotations = (existingAnnotations, collectedAnnotations) => {
+	const annotations = getArray(existingAnnotations);
+	annotations.push(...collectedAnnotations);
+	return annotations;
+};
+const getResponsesResult = (value) => getRecord(value);
+const getRecord = (value) => value && typeof value === "object" ? value : void 0;
+const getArray = (value) => Array.isArray(value) ? Array.from(value) : [];
+const getStreamErrorMessage = (event) => {
+	const eventRecord = getRecord(event);
+	return getString(getRecord(eventRecord?.error)?.message) ?? getString(eventRecord?.message);
+};
+const getNumber = (value) => typeof value === "number" ? value : void 0;
+const getString = (value) => typeof value === "string" ? value : void 0;
 const createUsageRecorder = (payload, sessionId, webSearchModel) => webSearchFlowDependencies.createUsageRecorder(payload, sessionId, webSearchModel);
 /**
 * Entry point for web-search detection and routing on /v1/messages.
@@ -4432,8 +4569,8 @@ const handleWebSearchViaResponses = async (c, payload, options) => {
 	const selectedModel = findEndpointModel(webSearchModel);
 	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
 	const transport = getResponsesTransportForModel(selectedModel, { compactType: options.compactType }) ?? "http";
-	logger.debug(`Switching web search request to model: ${webSearchModel} ${JSON.stringify(responsesPayload)}`);
-	const result = await webSearchFlowDependencies.createResponses(responsesPayload, {
+	debugJson(logger, `Switching web search request to model: ${webSearchModel}`, responsesPayload);
+	const upstreamResult = await webSearchFlowDependencies.createResponses(responsesPayload, {
 		vision,
 		initiator,
 		transport,
@@ -4442,8 +4579,13 @@ const handleWebSearchViaResponses = async (c, payload, options) => {
 		sessionId: options.sessionId,
 		compactType: options.compactType
 	});
+	const result = isWebSearchResponsesStream(upstreamResult) ? await collectWebSearchResponsesStreamResult({
+		errorMessagePrefix: "Web search responses stream",
+		upstreamResponse: upstreamResult,
+		logger
+	}) : upstreamResult;
 	const { extract, response } = reconstructWebSearchResponse(payload, result, { requestId: options.requestId });
-	logger.debug(`Web search via responses: ${extract.queries.length} quer(y/ies), ${extract.sources.length} source(s), ${JSON.stringify(result)}`);
+	debugJson(logger, `Web search via responses: ${extract.queries.length} quer(y/ies), ${extract.sources.length} source(s)`, result);
 	createUsageRecorder(payload, options.sessionId, webSearchModel)(normalizeResponsesUsage(result.usage));
 	if (!wantsStream) return c.json(response);
 	return streamSSE(c, async (stream) => {
@@ -4701,17 +4843,31 @@ const handleOpenAIResponsesProviderWebSearchMessages = async (c, options) => {
 	const { payload, provider, providerConfig } = options;
 	const selectedModel = providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0;
 	const responsesPayload = prepareWebSearchResponsesPayload(payload);
+	responsesPayload.stream = true;
 	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(responsesPayload);
 	debugJson(logger$5, "provider.messages.responses.web_search.request", {
 		payload: responsesPayload,
 		provider
 	});
-	if (providerConfig.name === "codex") return respondWebSearchProviderMessagesJson(c, {
-		body: await forwardCodexResponses(responsesPayload, c.req.raw.headers, providerConfig.baseUrl),
-		payload,
-		provider
-	});
+	if (providerConfig.name === "codex") {
+		const upstreamResponse = await forwardCodexResponses(responsesPayload, c.req.raw.headers, providerConfig.baseUrl);
+		if (isResponsesStream$1(upstreamResponse)) return respondWebSearchProviderMessagesJson(c, {
+			body: await collectWebSearchResponsesStreamResult({
+				errorMessagePrefix: `${provider} web search responses stream`,
+				parseEvent: (data) => parseResponsesProviderStreamChunk(data, providerConfig),
+				upstreamResponse,
+				logger: logger$5
+			}),
+			payload,
+			provider
+		});
+		return respondWebSearchProviderMessagesJson(c, {
+			body: upstreamResponse,
+			payload,
+			provider
+		});
+	}
 	const upstreamResponse = await forwardProviderResponses(providerConfig, responsesPayload, c.req.raw.headers);
 	if (!upstreamResponse.ok) {
 		logger$5.error("Failed to create provider web search responses", {
@@ -4720,6 +4876,16 @@ const handleOpenAIResponsesProviderWebSearchMessages = async (c, options) => {
 		});
 		throw new HTTPError("Failed to create provider web search responses", upstreamResponse);
 	}
+	if ((upstreamResponse.headers.get("content-type") ?? "").includes("text/event-stream")) return respondWebSearchProviderMessagesJson(c, {
+		body: await collectWebSearchResponsesStreamResult({
+			errorMessagePrefix: `${provider} web search responses stream`,
+			parseEvent: (data) => parseResponsesProviderStreamChunk(data, providerConfig),
+			upstreamResponse: events(upstreamResponse),
+			logger: logger$5
+		}),
+		payload,
+		provider
+	});
 	return respondWebSearchProviderMessagesJson(c, {
 		body: await upstreamResponse.json(),
 		payload,
@@ -5970,4 +6136,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-BxCf-DN5.js.map
+//# sourceMappingURL=server--yUElsYz.js.map