@jeffreycao/copilot-api 1.2.4 → 1.2.5

package/dist/{server-BPTBrSfO.js → server-C6P5thwB.js}

@@ -1,4 +1,4 @@
-import { HTTPError, PATHS, cacheModels, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, getConfig, getCopilotUsage, getExtraPromptForModel, getReasoningEffortForModel, getRootSessionId, getSmallModel, getUUID, isNullish, isResponsesApiContextManagementModel, shouldCompactUseSmallModel, sleep, state } from "./config-BD6sOCuT.js";
+import { HTTPError, PATHS, cacheModels, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, getConfig, getCopilotUsage, getExtraPromptForModel, getProviderConfig, getReasoningEffortForModel, getRootSessionId, getSmallModel, getUUID, isNullish, isResponsesApiContextManagementModel, prepareInteractionHeaders, shouldCompactUseSmallModel, sleep, state } from "./config-C4e-TaZM.js";
 import consola from "consola";
 import path from "node:path";
 import fs, { readFileSync } from "node:fs";
@@ -429,11 +429,7 @@ const createChatCompletions = async (payload, options) => {
 		...copilotHeaders(state, options.requestId, enableVision),
 		"x-initiator": isAgentCall ? "agent" : "user"
 	};
-	if (options.subagentMarker) {
-		headers["x-initiator"] = "agent";
-		headers["x-interaction-type"] = "conversation-subagent";
-	}
-	if (options.sessionId) headers["x-interaction-id"] = options.sessionId;
+	prepareInteractionHeaders(options.sessionId, Boolean(options.subagentMarker), headers);
 	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
 		method: "POST",
 		headers,
@@ -449,19 +445,19 @@ const createChatCompletions = async (payload, options) => {
 
 //#endregion
 //#region src/routes/chat-completions/handler.ts
-const logger$3 = createHandlerLogger("chat-completions-handler");
+const logger$6 = createHandlerLogger("chat-completions-handler");
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
 	let payload = await c.req.json();
-	logger$3.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	logger$6.debug("Request payload:", JSON.stringify(payload).slice(-400));
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
 		if (selectedModel) {
 			const tokenCount = await getTokenCount(payload, selectedModel);
-			logger$3.info("Current token count:", tokenCount);
-		} else logger$3.warn("No model selected, skipping token count calculation");
+			logger$6.info("Current token count:", tokenCount);
+		} else logger$6.warn("No model selected, skipping token count calculation");
 	} catch (error) {
-		logger$3.warn("Failed to calculate token count:", error);
+		logger$6.warn("Failed to calculate token count:", error);
 	}
 	if (state.manualApprove) await awaitApproval();
 	if (isNullish(payload.max_tokens)) {
@@ -469,24 +465,24 @@ async function handleCompletion$1(c) {
 			...payload,
 			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
 		};
-		logger$3.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
+		logger$6.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
 	const requestId = generateRequestIdFromPayload(payload);
-	logger$3.debug("Generated request ID:", requestId);
+	logger$6.debug("Generated request ID:", requestId);
 	const sessionId = getUUID(requestId);
-	logger$3.debug("Extracted session ID:", sessionId);
+	logger$6.debug("Extracted session ID:", sessionId);
 	const response = await createChatCompletions(payload, {
 		requestId,
 		sessionId
 	});
 	if (isNonStreaming$1(response)) {
-		logger$3.debug("Non-streaming response:", JSON.stringify(response));
+		logger$6.debug("Non-streaming response:", JSON.stringify(response));
 		return c.json(response);
 	}
-	logger$3.debug("Streaming response");
+	logger$6.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
 		for await (const chunk of response) {
-			logger$3.debug("Streaming chunk:", JSON.stringify(chunk));
+			logger$6.debug("Streaming chunk:", JSON.stringify(chunk));
 			await stream.writeSSE(chunk);
 		}
 	});
@@ -823,11 +819,7 @@ const createResponses = async (payload, { vision, initiator, subagentMarker, req
 		...copilotHeaders(state, requestId, vision),
 		"x-initiator": initiator
 	};
-	if (subagentMarker) {
-		headers["x-initiator"] = "agent";
-		headers["x-interaction-type"] = "conversation-subagent";
-	}
-	if (sessionId) headers["x-interaction-id"] = sessionId;
+	prepareInteractionHeaders(sessionId, Boolean(subagentMarker), headers);
 	payload.service_tier = null;
 	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
 		method: "POST",
@@ -1797,11 +1789,7 @@ const createMessages = async (payload, anthropicBetaHeader, options) => {
 		...copilotHeaders(state, options.requestId, enableVision),
 		"x-initiator": isInitiateRequest ? "user" : "agent"
 	};
-	if (options.subagentMarker) {
-		headers["x-initiator"] = "agent";
-		headers["x-interaction-type"] = "conversation-subagent";
-	}
-	if (options.sessionId) headers["x-interaction-id"] = options.sessionId;
+	prepareInteractionHeaders(options.sessionId, Boolean(options.subagentMarker), headers);
 	const anthropicBeta = buildAnthropicBetaHeader(anthropicBetaHeader, payload.thinking);
 	if (anthropicBeta) headers["anthropic-beta"] = anthropicBeta;
 	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
@@ -2114,27 +2102,27 @@ const parseSubagentMarkerFromSystemReminder = (text) => {
 
 //#endregion
 //#region src/routes/messages/handler.ts
-const logger$2 = createHandlerLogger("messages-handler");
+const logger$5 = createHandlerLogger("messages-handler");
 const compactSystemPromptStart = "You are a helpful AI assistant tasked with summarizing conversations";
 async function handleCompletion(c) {
 	await checkRateLimit(state);
 	const anthropicPayload = await c.req.json();
-	logger$2.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+	logger$5.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
-	if (subagentMarker) logger$2.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
+	if (subagentMarker) logger$5.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
 	const sessionId = getRootSessionId(anthropicPayload, c);
-	logger$2.debug("Extracted session ID:", sessionId);
+	logger$5.debug("Extracted session ID:", sessionId);
 	const isCompact = isCompactRequest(anthropicPayload);
 	const anthropicBeta = c.req.header("anthropic-beta");
-	logger$2.debug("Anthropic Beta header:", anthropicBeta);
+	logger$5.debug("Anthropic Beta header:", anthropicBeta);
 	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
 	if (anthropicBeta && noTools && !isCompact) anthropicPayload.model = getSmallModel();
 	if (isCompact) {
-		logger$2.debug("Is compact request:", isCompact);
+		logger$5.debug("Is compact request:", isCompact);
 		if (shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
 	} else mergeToolResultForClaude(anthropicPayload);
 	const requestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
-	logger$2.debug("Generated request ID:", requestId);
+	logger$5.debug("Generated request ID:", requestId);
 	if (state.manualApprove) await awaitApproval();
 	const selectedModel = state.models?.data.find((m) => m.id === anthropicPayload.model);
 	if (shouldUseMessagesApi(selectedModel)) return await handleWithMessagesApi(c, anthropicPayload, {
@@ -2161,19 +2149,19 @@ const MESSAGES_ENDPOINT = "/v1/messages";
 const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 	const { subagentMarker, requestId, sessionId } = options;
 	const openAIPayload = translateToOpenAI(anthropicPayload);
-	logger$2.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	logger$5.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	const response = await createChatCompletions(openAIPayload, {
 		subagentMarker,
 		requestId,
 		sessionId
 	});
 	if (isNonStreaming(response)) {
-		logger$2.debug("Non-streaming response from Copilot:", JSON.stringify(response));
+		logger$5.debug("Non-streaming response from Copilot:", JSON.stringify(response));
 		const anthropicResponse = translateToAnthropic(response);
-		logger$2.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+		logger$5.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 		return c.json(anthropicResponse);
 	}
-	logger$2.debug("Streaming response from Copilot");
+	logger$5.debug("Streaming response from Copilot");
 	return streamSSE(c, async (stream) => {
 		const streamState = {
 			messageStartSent: false,
@@ -2183,13 +2171,13 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 			thinkingBlockOpen: false
 		};
 		for await (const rawEvent of response) {
-			logger$2.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
+			logger$5.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
 			if (rawEvent.data === "[DONE]") break;
 			if (!rawEvent.data) continue;
 			const chunk = JSON.parse(rawEvent.data);
 			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events$1) {
-				logger$2.debug("Translated Anthropic event:", JSON.stringify(event));
+				logger$5.debug("Translated Anthropic event:", JSON.stringify(event));
 				await stream.writeSSE({
 					event: event.type,
 					data: JSON.stringify(event)
@@ -2203,7 +2191,7 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
 	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(responsesPayload);
-	logger$2.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
+	logger$5.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
 	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
 	const response = await createResponses(responsesPayload, {
 		vision,
@@ -2213,7 +2201,7 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 		sessionId
 	});
 	if (responsesPayload.stream && isAsyncIterable$1(response)) {
-		logger$2.debug("Streaming response from Copilot (Responses API)");
+		logger$5.debug("Streaming response from Copilot (Responses API)");
 		return streamSSE(c, async (stream) => {
 			const streamState = createResponsesStreamState();
 			for await (const chunk of response) {
@@ -2226,23 +2214,23 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 				}
 				const data = chunk.data;
 				if (!data) continue;
-				logger$2.debug("Responses raw stream event:", data);
+				logger$5.debug("Responses raw stream event:", data);
 				const events$1 = translateResponsesStreamEvent(JSON.parse(data), streamState);
 				for (const event of events$1) {
 					const eventData = JSON.stringify(event);
-					logger$2.debug("Translated Anthropic event:", eventData);
+					logger$5.debug("Translated Anthropic event:", eventData);
 					await stream.writeSSE({
 						event: event.type,
 						data: eventData
 					});
 				}
 				if (streamState.messageCompleted) {
-					logger$2.debug("Message completed, ending stream");
+					logger$5.debug("Message completed, ending stream");
 					break;
 				}
 			}
 			if (!streamState.messageCompleted) {
-				logger$2.warn("Responses stream ended without completion; sending error event");
+				logger$5.warn("Responses stream ended without completion; sending error event");
 				const errorEvent = buildErrorEvent("Responses stream ended without completion");
 				await stream.writeSSE({
 					event: errorEvent.type,
@@ -2251,9 +2239,9 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 			}
 		});
 	}
-	logger$2.debug("Non-streaming Responses result:", JSON.stringify(response).slice(-400));
+	logger$5.debug("Non-streaming Responses result:", JSON.stringify(response).slice(-400));
 	const anthropicResponse = translateResponsesResultToAnthropic(response);
-	logger$2.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+	logger$5.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 	return c.json(anthropicResponse);
 };
 const handleWithMessagesApi = async (c, anthropicPayload, options) => {
@@ -2268,19 +2256,19 @@ const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 		anthropicPayload.thinking = { type: "adaptive" };
 		anthropicPayload.output_config = { effort: getAnthropicEffortForModel(anthropicPayload.model) };
 	}
-	logger$2.debug("Translated Messages payload:", JSON.stringify(anthropicPayload));
+	logger$5.debug("Translated Messages payload:", JSON.stringify(anthropicPayload));
 	const response = await createMessages(anthropicPayload, anthropicBetaHeader, {
 		subagentMarker,
 		requestId,
 		sessionId
 	});
 	if (isAsyncIterable$1(response)) {
-		logger$2.debug("Streaming response from Copilot (Messages API)");
+		logger$5.debug("Streaming response from Copilot (Messages API)");
 		return streamSSE(c, async (stream) => {
 			for await (const event of response) {
 				const eventName = event.event;
 				const data = event.data ?? "";
-				logger$2.debug("Messages raw stream event:", data);
+				logger$5.debug("Messages raw stream event:", data);
 				await stream.writeSSE({
 					event: eventName,
 					data
@@ -2288,7 +2276,7 @@ const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 			}
 		});
 	}
-	logger$2.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
+	logger$5.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
 	return c.json(response);
 };
 const shouldUseResponsesApi = (selectedModel) => {
@@ -2399,6 +2387,182 @@ modelRoutes.get("/", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/routes/provider/messages/count-tokens-handler.ts
+const logger$4 = createHandlerLogger("provider-count-tokens-handler");
+const createFallbackModel = (modelId) => ({
+	capabilities: {
+		family: "provider",
+		limits: {},
+		object: "model_capabilities",
+		supports: {},
+		tokenizer: "o200k_base",
+		type: "chat"
+	},
+	id: modelId,
+	model_picker_enabled: false,
+	name: modelId,
+	object: "model",
+	preview: false,
+	vendor: "provider",
+	version: "unknown"
+});
+async function handleProviderCountTokens(c) {
+	const provider = c.req.param("provider");
+	try {
+		const anthropicPayload = await c.req.json();
+		const openAIPayload = translateToOpenAI(anthropicPayload);
+		const modelId = anthropicPayload.model.trim();
+		let selectedModel = state.models?.data.find((model) => model.id === modelId);
+		if (!selectedModel && modelId) selectedModel = createFallbackModel(modelId);
+		if (!selectedModel) {
+			logger$4.warn("provider.count_tokens.model_not_found", {
+				provider,
+				model: anthropicPayload.model
+			});
+			return c.json({ input_tokens: 1 });
+		}
+		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+		const finalTokenCount = tokenCount.input + tokenCount.output;
+		logger$4.debug("provider.count_tokens.success", {
+			provider,
+			model: anthropicPayload.model,
+			input_tokens: finalTokenCount
+		});
+		return c.json({ input_tokens: finalTokenCount });
+	} catch (error) {
+		logger$4.error("provider.count_tokens.error", {
+			provider,
+			error
+		});
+		return c.json({ input_tokens: 1 });
+	}
+}
+
+//#endregion
+//#region src/services/providers/anthropic-proxy.ts
+const FORWARDABLE_HEADERS = [
+	"anthropic-version",
+	"anthropic-beta",
+	"accept",
+	"user-agent"
+];
+function buildProviderUpstreamHeaders(providerConfig, requestHeaders) {
+	const headers = {
+		"content-type": "application/json",
+		accept: "application/json",
+		"x-api-key": providerConfig.apiKey
+	};
+	for (const headerName of FORWARDABLE_HEADERS) {
+		const headerValue = requestHeaders.get(headerName);
+		if (headerValue) headers[headerName] = headerValue;
+	}
+	return headers;
+}
+async function forwardProviderMessages(providerConfig, payload, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/messages`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderModels(providerConfig, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/models`, {
+		method: "GET",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders)
+	});
+}
+
+//#endregion
+//#region src/routes/provider/messages/handler.ts
+const logger$3 = createHandlerLogger("provider-messages-handler");
+async function handleProviderMessages(c) {
+	const provider = c.req.param("provider");
+	const providerConfig = getProviderConfig(provider);
+	if (!providerConfig) return c.json({ error: {
+		message: `Provider '${provider}' not found or disabled`,
+		type: "invalid_request_error"
+	} }, 404);
+	try {
+		const payload = await c.req.json();
+		payload.temperature ??= providerConfig.defaultTemperature;
+		payload.top_p ??= providerConfig.defaultTopP;
+		payload.top_k ??= providerConfig.defaultTopK;
+		logger$3.debug("provider.messages.request", JSON.stringify({
+			payload,
+			provider
+		}));
+		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
+		const contentType = upstreamResponse.headers.get("content-type") ?? "";
+		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) {
+			logger$3.debug("provider.messages.streaming");
+			return streamSSE(c, async (stream) => {
+				for await (const event of events(upstreamResponse)) {
+					const eventName = event.event;
+					const data = event.data ?? "";
+					logger$3.debug("provider.messages.raw_stream_event", data);
+					await stream.writeSSE({
+						event: eventName,
+						data
+					});
+				}
+			});
+		}
+		return upstreamResponse;
+	} catch (error) {
+		logger$3.error("provider.messages.error", {
+			provider,
+			error
+		});
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/routes/provider/messages/route.ts
+const providerMessageRoutes = new Hono();
+providerMessageRoutes.post("/", async (c) => {
+	try {
+		return await handleProviderMessages(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+providerMessageRoutes.post("/count_tokens", async (c) => {
+	try {
+		return await handleProviderCountTokens(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/provider/models/route.ts
+const logger$2 = createHandlerLogger("provider-models-handler");
+const providerModelRoutes = new Hono();
+providerModelRoutes.get("/", async (c) => {
+	const provider = c.req.param("provider") ?? "";
+	try {
+		const providerConfig = getProviderConfig(provider);
+		if (!providerConfig) return c.json({ error: {
+			message: `Provider '${provider}' not found or disabled`,
+			type: "invalid_request_error"
+		} }, 404);
+		const upstreamResponse = await forwardProviderModels(providerConfig, c.req.raw.headers);
+		logger$2.debug("provider.models.response", {
+			provider,
+			statusCode: upstreamResponse.status
+		});
+		return upstreamResponse;
+	} catch (error) {
+		logger$2.error("provider.models.error", {
+			provider,
+			error
+		});
+		return await forwardError(c, error);
+	}
+});
+
 //#endregion
 //#region src/routes/responses/stream-id-sync.ts
 const createStreamIdTracker = () => ({ outputItems: /* @__PURE__ */ new Map() });
@@ -2584,7 +2748,9 @@ server.route("/v1/models", modelRoutes);
 server.route("/v1/embeddings", embeddingRoutes);
 server.route("/v1/responses", responsesRoutes);
 server.route("/v1/messages", messageRoutes);
+server.route("/:provider/v1/messages", providerMessageRoutes);
+server.route("/:provider/v1/models", providerModelRoutes);
 
 //#endregion
 export { server };
-//# sourceMappingURL=server-BPTBrSfO.js.map
+//# sourceMappingURL=server-C6P5thwB.js.map