@jeffreycao/copilot-api 2.2.13 → 2.2.15

package/dist/main.js

@@ -30,7 +30,7 @@ if (isMcpFastPath(process.argv)) {
 	const { auth } = await import("./auth-C-RWNXGU.js");
 	const { debug } = await import("./debug-41w6Whae.js");
 	const { mcp } = await import("./mcp-fpSlKZxK.js");
-	const { start } = await import("./start-z_xmbJbc.js");
+	const { start } = await import("./start-Dk0QorqU.js");
 	await runMain(defineCommand({
 		meta: {
 			name: "copilot-api",

package/dist/{server-Bmd_z-tv.js → server-BRGh2SlD.js}

@@ -374,6 +374,21 @@ async function resolveProviderConfig(providerName) {
 	}
 	return getProviderConfig(normalizedProviderName);
 }
+/**
+* Returns the parsed "provider/model" alias only when that provider is
+* actually configured, otherwise null so the caller falls through to its
+* default flow. GitHub Copilot enterprise models can ship with namespaced ids
+* such as "org/family/model": without this check the first segment is
+* misrouted to a non-existent provider and surfaced as a 400/404.
+*/
+async function ensureConfiguredProviderModelAlias(alias, resolveConfig = resolveProviderConfig) {
+	if (!alias) return null;
+	return await resolveConfig(alias.provider) ? alias : null;
+}
+/** parseProviderModelAlias + ensureConfiguredProviderModelAlias. */
+async function resolveConfiguredProviderModelAlias(model, resolveConfig = resolveProviderConfig) {
+	return ensureConfiguredProviderModelAlias(parseProviderModelAlias(model), resolveConfig);
+}
 //#endregion
 //#region src/lib/event-bus.ts
 var EventBus = class {
@@ -2845,10 +2860,12 @@ async function handleAlphaSearchRequest(c, resolvedProviderConfig) {
 		}
 	}
 	const fallbackRequestedModel = messagesBackedModel ? payload.model : requestedModel;
-	if (providerModelAlias) return await alphaSearchRouteDependencies.handleAlphaSearchResponses(c, {
-		provider: providerModelAlias.provider,
-		request: payload
-	});
+	if (providerModelAlias) {
+		if (await ensureConfiguredProviderModelAlias(providerModelAlias, alphaSearchRouteDependencies.resolveProviderConfig)) return await alphaSearchRouteDependencies.handleAlphaSearchResponses(c, {
+			provider: providerModelAlias.provider,
+			request: payload
+		});
+	}
 	return await alphaSearchRouteDependencies.handleAlphaSearchResponses(c, { request: {
 		...payload,
 		model: fallbackRequestedModel
@@ -3127,7 +3144,7 @@ async function handleCompletion$1(c) {
 	const requestedModel = payload.model;
 	payload.model = resolveMappedModel(payload.model);
 	if (payload.model !== requestedModel) consola.debug(`Resolved model mapping: ${requestedModel} -> ${payload.model}`);
-	const providerModelAlias = parseProviderModelAlias(payload.model);
+	const providerModelAlias = await resolveConfiguredProviderModelAlias(payload.model);
 	if (providerModelAlias) {
 		payload.model = providerModelAlias.model;
 		return await handleProviderChatCompletionsForProvider(c, {
@@ -4419,7 +4436,7 @@ async function handleCountTokens(c) {
 	const anthropicPayload = await c.req.json();
 	anthropicPayload.model = resolveMappedModel(anthropicPayload.model);
 	normalizeSystemMessages(anthropicPayload);
-	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
+	const providerModelAlias = await resolveConfiguredProviderModelAlias(anthropicPayload.model);
 	if (providerModelAlias) {
 		anthropicPayload.model = providerModelAlias.model;
 		return await handleProviderCountTokensForProvider(c, {
@@ -4520,6 +4537,7 @@ function completePendingMessage(state, events, chunk) {
 	if (chunk?.usage) state.pendingMessageDelta.usage = getAnthropicUsageFromOpenAIChunk(chunk);
 	events.push(state.pendingMessageDelta, { type: "message_stop" });
 	state.pendingMessageDelta = void 0;
+	state.messageCompleted = true;
 }
 function handleFinish(choice, state, context) {
 	const { events, chunk } = context;
@@ -4797,6 +4815,15 @@ function closeThinkingBlockIfOpen(state, events) {
 		state.thinkingBlockOpen = false;
 	}
 }
+function translateErrorToAnthropicErrorEvent() {
+	return {
+		type: "error",
+		error: {
+			type: "api_error",
+			message: "An unexpected error occurred during streaming."
+		}
+	};
+}
 //#endregion
 //#region src/routes/messages/responses-translation.ts
 const MESSAGE_TYPE = "message";
@@ -6144,6 +6171,7 @@ const containsVisionContent = (value) => {
 //#region src/routes/messages/web-search/fulfill.ts
 const webSearchFlowDependencies = {
 	createResponses,
+	resolveProviderConfig,
 	createUsageRecorder: (payload, sessionId, webSearchModel) => createCopilotTokenUsageRecorder({
 		endpoint: "responses",
 		fallbackSessionId: sessionId,
@@ -6165,14 +6193,17 @@ const stripWebSearchServerTool = (payload) => {
 	if (!Array.isArray(payload.tools)) return;
 	payload.tools = payload.tools.filter((tool) => !isWebSearchServerTool(tool));
 };
-const resolveWebSearchRoute = (payload, options) => {
+const resolveWebSearchRoute = async (payload, options) => {
 	const { webSearchModel, responsesWebSearchEnabled } = options;
 	if (!webSearchModel || !isWebSearchOnlyRequest(payload)) return { kind: "strip" };
 	const alias = parseProviderModelAlias(webSearchModel);
-	if (alias) return {
-		kind: "provider",
-		alias
-	};
+	if (alias) {
+		const configuredAlias = await ensureConfiguredProviderModelAlias(alias, options.resolveProviderConfig ?? resolveProviderConfig);
+		return configuredAlias ? {
+			kind: "provider",
+			alias: configuredAlias
+		} : { kind: "strip" };
+	}
 	if (responsesWebSearchEnabled) return {
 		kind: "responses",
 		model: webSearchModel
@@ -6274,9 +6305,10 @@ const createUsageRecorder = (payload, sessionId, webSearchModel) => webSearchFlo
 const tryHandleWebSearch = async (c, payload, options) => {
 	if (!hasWebSearchServerTool(payload)) return null;
 	normalizeSystemMessages(payload);
-	const route = resolveWebSearchRoute(payload, {
+	const route = await resolveWebSearchRoute(payload, {
 		webSearchModel: getMessageApiWebSearchModel(),
-		responsesWebSearchEnabled: isResponsesApiWebSearchEnabled()
+		responsesWebSearchEnabled: isResponsesApiWebSearchEnabled(),
+		resolveProviderConfig: webSearchFlowDependencies.resolveProviderConfig
 	});
 	if (route.kind === "provider") {
 		payload.model = route.alias.model;
@@ -6916,35 +6948,54 @@ const streamProviderMessages = ({ c, modelConfig, payload, pricingCurrency, prov
 	const recordUsage = createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency, usageEndpoint);
 	return streamSSE(c, async (stream) => {
 		let usage = {};
+		let messageStopSeen = false;
+		let errorSeen = false;
 		const openRouterThinkingState = {
 			signedThinkingBlockIndexes: /* @__PURE__ */ new Set(),
 			thinkingBlockIndexes: /* @__PURE__ */ new Set()
 		};
-		for await (const chunk of events(upstreamResponse)) {
-			logger$10.debug("provider.messages.raw_stream_event:", chunk.data);
-			const eventName = chunk.event;
-			if (eventName === "ping") {
-				await stream.writeSSE({
-					event: "ping",
-					data: "{\"type\":\"ping\"}"
+		try {
+			for await (const chunk of events(upstreamResponse)) {
+				logger$10.debug("provider.messages.raw_stream_event:", chunk.data);
+				const eventName = chunk.event;
+				if (eventName === "ping") {
+					await stream.writeSSE({
+						event: "ping",
+						data: "{\"type\":\"ping\"}"
+					});
+					continue;
+				}
+				let data = chunk.data;
+				if (!data) continue;
+				if (chunk.data === "[DONE]") break;
+				const parsed = parseProviderStreamEvent(data);
+				if (parsed) {
+					usage = mergeAnthropicUsage(usage, parsed.usage);
+					data = parsed.data;
+					if (parsed.type === "message_stop") messageStopSeen = true;
+					else if (parsed.type === "error") errorSeen = true;
+				}
+				const streamEvents = provider === "openrouter" ? normalizeOpenRouterStreamEvents(eventName, data, openRouterThinkingState) : [{
+					data,
+					event: eventName
+				}];
+				for (const streamEvent of streamEvents) await stream.writeSSE({
+					event: streamEvent.event,
+					data: streamEvent.data
 				});
-				continue;
-			}
-			let data = chunk.data;
-			if (!data) continue;
-			if (chunk.data === "[DONE]") break;
-			const parsed = parseProviderStreamEvent(data);
-			if (parsed) {
-				usage = mergeAnthropicUsage(usage, parsed.usage);
-				data = parsed.data;
 			}
-			const streamEvents = provider === "openrouter" ? normalizeOpenRouterStreamEvents(eventName, data, openRouterThinkingState) : [{
-				data,
-				event: eventName
-			}];
-			for (const streamEvent of streamEvents) await stream.writeSSE({
-				event: streamEvent.event,
-				data: streamEvent.data
+		} catch (error) {
+			logger$10.warn("provider.messages.stream_interrupted:", {
+				error,
+				provider
+			});
+		}
+		if (!messageStopSeen && !errorSeen) {
+			logger$10.warn("provider.messages.stream_incomplete:", { provider });
+			const errorEvent = translateErrorToAnthropicErrorEvent();
+			await stream.writeSSE({
+				event: errorEvent.type,
+				data: JSON.stringify(errorEvent)
 			});
 		}
 		recordUsage(usage);
@@ -6957,36 +7008,44 @@ const streamOpenAICompatibleProviderMessages = ({ c, modelConfig, payload, prici
 		let usage = {};
 		const streamState = {
 			messageStartSent: false,
+			messageCompleted: false,
 			contentBlockIndex: 0,
 			contentBlockOpen: false,
 			toolCalls: {},
 			thinkingBlockOpen: false
 		};
-		for await (const chunk of events(upstreamResponse)) {
-			logger$10.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
-			if (chunk.event === "ping") {
-				await stream.writeSSE({
-					event: "ping",
-					data: "{\"type\":\"ping\"}"
-				});
-				continue;
-			}
-			if (!chunk.data || chunk.data === "[DONE]") {
-				if (chunk.data === "[DONE]") break;
-				continue;
-			}
-			const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
-			if (!parsed) continue;
-			if (parsed.usage) usage = normalizeOpenAIUsage(parsed.usage);
-			const events = translateChunkToAnthropicEvents(parsed, streamState);
-			for (const event of events) {
-				const eventData = JSON.stringify(event);
-				debugLazy(logger$10, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
-				await stream.writeSSE({
-					event: event.type,
-					data: eventData
-				});
+		try {
+			for await (const chunk of events(upstreamResponse)) {
+				logger$10.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
+				if (chunk.event === "ping") {
+					await stream.writeSSE({
+						event: "ping",
+						data: "{\"type\":\"ping\"}"
+					});
+					continue;
+				}
+				if (!chunk.data || chunk.data === "[DONE]") {
+					if (chunk.data === "[DONE]") break;
+					continue;
+				}
+				const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
+				if (!parsed) continue;
+				if (parsed.usage) usage = normalizeOpenAIUsage(parsed.usage);
+				const events = translateChunkToAnthropicEvents(parsed, streamState);
+				for (const event of events) {
+					const eventData = JSON.stringify(event);
+					debugLazy(logger$10, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+					await stream.writeSSE({
+						event: event.type,
+						data: eventData
+					});
+				}
 			}
+		} catch (error) {
+			logger$10.warn("provider.messages.openai_compatible.stream_interrupted:", {
+				error,
+				provider
+			});
 		}
 		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
 			const eventData = JSON.stringify(event);
@@ -6996,6 +7055,14 @@ const streamOpenAICompatibleProviderMessages = ({ c, modelConfig, payload, prici
 				data: eventData
 			});
 		}
+		if (!streamState.messageCompleted) {
+			logger$10.warn("provider.messages.openai_compatible.stream_incomplete:", { provider });
+			const errorEvent = translateErrorToAnthropicErrorEvent();
+			await stream.writeSSE({
+				event: errorEvent.type,
+				data: JSON.stringify(errorEvent)
+			});
+		}
 		recordUsage(usage);
 	});
 };
@@ -7072,14 +7139,17 @@ const parseProviderStreamEvent = (data) => {
 		if (parsed.type === "message_start") return {
 			data: JSON.stringify(parsed),
 			model: parsed.message.model,
+			type: parsed.type,
 			usage: normalizeAnthropicUsage(parsed.message.usage)
 		};
 		if (parsed.type === "message_delta") return {
 			data: JSON.stringify(parsed),
+			type: parsed.type,
 			usage: normalizeAnthropicUsage(parsed.usage)
 		};
 		return {
 			data: JSON.stringify(parsed),
+			type: parsed.type,
 			usage: {}
 		};
 	} catch (error) {
@@ -7283,29 +7353,34 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 		let usage = {};
 		const streamState = {
 			messageStartSent: false,
+			messageCompleted: false,
 			contentBlockIndex: 0,
 			contentBlockOpen: false,
 			toolCalls: {},
 			thinkingBlockOpen: false
 		};
-		for await (const rawEvent of response) {
-			debugJson(logger, "Copilot raw stream event:", rawEvent);
-			if (rawEvent.data === "[DONE]") break;
-			if (!rawEvent.data) continue;
-			const chunk = JSON.parse(rawEvent.data);
-			if (chunk.usage || chunk.copilot_usage) usage = {
-				...normalizeOpenAIUsage(chunk.usage),
-				total_nano_aiu: normalizeOptionalToken(chunk.copilot_usage?.total_nano_aiu)
-			};
-			const events = translateChunkToAnthropicEvents(chunk, streamState);
-			for (const event of events) {
-				const eventData = JSON.stringify(event);
-				debugLazy(logger, () => ["Translated Anthropic event:", eventData]);
-				await stream.writeSSE({
-					event: event.type,
-					data: eventData
-				});
+		try {
+			for await (const rawEvent of response) {
+				debugJson(logger, "Copilot raw stream event:", rawEvent);
+				if (rawEvent.data === "[DONE]") break;
+				if (!rawEvent.data) continue;
+				const chunk = JSON.parse(rawEvent.data);
+				if (chunk.usage || chunk.copilot_usage) usage = {
+					...normalizeOpenAIUsage(chunk.usage),
+					total_nano_aiu: normalizeOptionalToken(chunk.copilot_usage?.total_nano_aiu)
+				};
+				const events = translateChunkToAnthropicEvents(chunk, streamState);
+				for (const event of events) {
+					const eventData = JSON.stringify(event);
+					debugLazy(logger, () => ["Translated Anthropic event:", eventData]);
+					await stream.writeSSE({
+						event: event.type,
+						data: eventData
+					});
+				}
 			}
+		} catch (error) {
+			logger.warn("Chat completions stream interrupted:", error);
 		}
 		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
 			const eventData = JSON.stringify(event);
@@ -7315,6 +7390,14 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 				data: eventData
 			});
 		}
+		if (!streamState.messageCompleted) {
+			logger.warn("Chat completions stream ended without completion; sending error event");
+			const errorEvent = translateErrorToAnthropicErrorEvent();
+			await stream.writeSSE({
+				event: errorEvent.type,
+				data: JSON.stringify(errorEvent)
+			});
+		}
 		recordUsage(usage);
 	});
 };
@@ -7414,24 +7497,40 @@ const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 		logger.debug("Streaming response from Copilot (Messages API)");
 		return streamSSE(c, async (stream) => {
 			let usage = {};
-			for await (const event of response) {
-				const eventName = event.event;
-				const data = event.data ?? "";
-				if (data === "[DONE]") break;
-				if (!data) continue;
-				debugLazy(logger, () => ["Messages raw stream event:", data]);
-				const parsedEvent = parseAnthropicStreamEvent(data);
-				if (parsedEvent?.type === "message_start") usage = mergeAnthropicUsage(usage, {
-					...normalizeAnthropicUsage(parsedEvent.message.usage),
-					...normalizeCopilotUsage(parsedEvent.message.copilot_usage)
-				});
-				else if (parsedEvent?.type === "message_delta") usage = mergeAnthropicUsage(usage, {
-					...normalizeAnthropicUsage(parsedEvent.usage),
-					...normalizeCopilotUsage(parsedEvent.copilot_usage)
-				});
+			let messageStopSeen = false;
+			let errorSeen = false;
+			try {
+				for await (const event of response) {
+					const eventName = event.event;
+					const data = event.data ?? "";
+					if (data === "[DONE]") break;
+					if (!data) continue;
+					debugLazy(logger, () => ["Messages raw stream event:", data]);
+					const parsedEvent = parseAnthropicStreamEvent(data);
+					if (parsedEvent?.type === "message_start") usage = mergeAnthropicUsage(usage, {
+						...normalizeAnthropicUsage(parsedEvent.message.usage),
+						...normalizeCopilotUsage(parsedEvent.message.copilot_usage)
+					});
+					else if (parsedEvent?.type === "message_delta") usage = mergeAnthropicUsage(usage, {
+						...normalizeAnthropicUsage(parsedEvent.usage),
+						...normalizeCopilotUsage(parsedEvent.copilot_usage)
+					});
+					if (parsedEvent?.type === "message_stop" || eventName === "message_stop") messageStopSeen = true;
+					else if (parsedEvent?.type === "error" || eventName === "error") errorSeen = true;
+					await stream.writeSSE({
+						event: eventName,
+						data
+					});
+				}
+			} catch (error) {
+				logger.warn("Messages stream interrupted:", error);
+			}
+			if (!messageStopSeen && !errorSeen) {
+				logger.warn("Messages stream ended without completion; sending error event");
+				const errorEvent = translateErrorToAnthropicErrorEvent();
 				await stream.writeSSE({
-					event: eventName,
-					data
+					event: errorEvent.type,
+					data: JSON.stringify(errorEvent)
 				});
 			}
 			recordUsage(usage);
@@ -7560,7 +7659,7 @@ async function handleCompletionPayload(c, anthropicPayload, dispatchOptions = {}
 		consola.debug(`Claude auto model override: ${anthropicPayload.model} -> ${claudeAutoModel}`);
 		anthropicPayload.model = claudeAutoModel;
 	}
-	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
+	const providerModelAlias = await resolveConfiguredProviderModelAlias(anthropicPayload.model, providerMessagesHandlerDependencies.resolveProviderConfig);
 	if (providerModelAlias) {
 		anthropicPayload.model = providerModelAlias.model;
 		return await handleProviderMessagesForProvider(c, {
@@ -9148,12 +9247,14 @@ function appendUserBlock(messages, block) {
 	};
 	messages.push(message);
 }
-function parseFunctionArguments(value, path) {
+function parseFunctionArguments(value, _path) {
 	try {
 		const parsed = JSON.parse(value);
 		if (isRecord(parsed)) return parsed;
-	} catch {}
-	throw new ResponsesMessagesTranslationError(`${path} must be a JSON object string`);
+	} catch {
+		return {};
+	}
+	return {};
 }
 function parseDataUrl(value) {
 	const match = /^data:([^;,]+);base64,(.*)$/su.exec(value);
@@ -9394,12 +9495,7 @@ async function* translateMessagesStream(chunks, context) {
 			if (state.messageStopped) break;
 		}
 		if (!state.initialized) throw new ResponsesMessagesTranslationError("Messages API returned an empty stream", 502);
-		if (!state.messageStopped) {
-			for (const translated of closeAllBlocks(state)) yield translated;
-			for (const translated of finishCompaction(state)) yield translated;
-			state.messageStopped = true;
-			yield createTerminalEvent(state);
-		}
+		if (!state.messageStopped) throw new ResponsesMessagesTranslationError("Messages stream ended without a message_stop event", 502);
 	} catch (error) {
 		if (!state.initialized) throw error;
 		yield createErrorEvent(state, error);
@@ -10315,7 +10411,7 @@ const handleResponses = async (c) => {
 	const requestedModel = payload.model;
 	payload.model = responsesHandlerDependencies.resolveMappedModel(payload.model);
 	if (payload.model !== requestedModel) consola.debug(`Resolved model mapping: ${requestedModel} -> ${payload.model}`);
-	const providerModelAlias = parseProviderModelAlias(payload.model);
+	const providerModelAlias = await resolveConfiguredProviderModelAlias(payload.model, providerResponsesHandlerDependencies.resolveProviderConfig);
 	if (providerModelAlias) {
 		payload.model = providerModelAlias.model;
 		return await handleProviderResponsesForProvider(c, {
@@ -10622,4 +10718,4 @@ server.route("/:provider/images", providerImageRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-Bmd_z-tv.js.map
+//# sourceMappingURL=server-BRGh2SlD.js.map