@jeffreycao/copilot-api 1.11.1 → 1.11.3

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-t4js93GE.js");
 await runMain(defineCommand({
 	meta: {
 		name: "copilot-api",

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

@@ -2343,7 +2343,7 @@ const prepareMessagesApiPayload = (payload, selectedModel) => {
 		payload.thinking = { type: "adaptive" };
 		if (!hasThinking) payload.thinking.display = "summarized";
 		if (shouldSummarizeThinkingDisplayForModel(payload.model)) payload.thinking.display = "summarized";
-		let effort = getReasoningEffortForModel(payload.model);
+		let effort = payload.output_config?.effort ?? getReasoningEffortForModel(payload.model);
 		if (effort === "none" || effort === "minimal") effort = "low";
 		const reasoningEffort = selectedModel.capabilities.supports.reasoning_effort;
 		if (reasoningEffort && !reasoningEffort.includes(effort)) effort = reasoningEffort.at(-1);
@@ -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,
@@ -5625,34 +5791,54 @@ const createProviderResponsesUsageRecorder = (payload, provider) => {
 		sessionId: sessionAffinity ?? ""
 	});
 };
-const streamProviderResponses = (c, upstreamResponse, options) => {
+const streamProviderResponses = async (c, upstreamResponse, options) => {
+	const iterator = upstreamResponse[Symbol.asyncIterator]();
+	const firstResult = await iterator.next();
+	if (firstResult.done) throw new HTTPError(`Empty stream from ${options.provider} responses`, new Response("", { status: 502 }));
+	const firstChunk = firstResult.value;
+	if (firstChunk.data && firstChunk.data !== "[DONE]") {
+		const event = parseProviderResponsesStreamEvent(firstChunk.data, {
+			normalizeCodex: options.normalizeCodex,
+			provider: options.provider
+		});
+		if (event?.type === "error") {
+			const errorEvent = event;
+			const statusCode = errorEvent.status_code ?? 500;
+			return c.json({ error: {
+				message: errorEvent.message,
+				...errorEvent.error
+			} }, statusCode, errorEvent.headers ?? void 0);
+		}
+	}
 	return streamSSE(c, async (stream) => {
 		let usage = {};
-		try {
-			for await (const chunk of upstreamResponse) {
-				debugJson(logger$2, "Responses stream chunk:", chunk);
-				let responseChunk = chunk;
-				let event = null;
-				if (chunk.data && chunk.data !== "[DONE]") {
-					event = parseProviderResponsesStreamEvent(chunk.data, {
-						normalizeCodex: options.normalizeCodex,
-						provider: options.provider
-					});
-					if (event && options.normalizeCodex) responseChunk = {
-						...chunk,
-						data: JSON.stringify(event),
-						event: event.type
-					};
-				}
-				if (event) {
-					const nextUsage = getResponsesStreamEventUsage(event);
-					if (nextUsage) usage = nextUsage;
-				}
-				await stream.writeSSE({
-					data: responseChunk.data ?? "",
-					event: responseChunk.event
+		const writeChunk = async (chunk) => {
+			debugJson(logger$2, "Responses stream chunk:", chunk);
+			let responseChunk = chunk;
+			let event = null;
+			if (chunk.data && chunk.data !== "[DONE]") {
+				event = parseProviderResponsesStreamEvent(chunk.data, {
+					normalizeCodex: options.normalizeCodex,
+					provider: options.provider
 				});
+				if (event && options.normalizeCodex) responseChunk = {
+					...chunk,
+					data: JSON.stringify(event),
+					event: event.type
+				};
+			}
+			if (event) {
+				const nextUsage = getResponsesStreamEventUsage(event);
+				if (nextUsage) usage = nextUsage;
 			}
+			await stream.writeSSE({
+				data: responseChunk.data ?? "",
+				event: responseChunk.event
+			});
+		};
+		try {
+			await writeChunk(firstChunk);
+			for await (const chunk of { [Symbol.asyncIterator]: () => iterator }) await writeChunk(chunk);
 		} finally {
 			options.recordUsage(usage);
 		}
@@ -5970,4 +6156,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-BxCf-DN5.js.map
+//# sourceMappingURL=server-CSpOUSFF.js.map