@nick3/copilot-api 1.2.4 → 1.3.1

package/dist/{server-Cxlbm6kJ.js → server-D3A61KAx.js}

@@ -1,4 +1,4 @@
-import { HTTPError, PATHS, accountFromState, accountsManager, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, getAliasTargetSet, getConfig, getCopilotUsage, getExtraPromptForModel, getModelAliases, getModelAliasesInfo, getModelRefreshIntervalMs, getReasoningEffortForModel, getRootSessionId, getSmallModel, getUUID, isForceAgentEnabled, isFreeModelLoadBalancingEnabled, isMessageStartInputTokensFallbackEnabled, isNullish, isResponsesApiContextManagementModel, listAccountsFromRegistry, mergeConfigWithDefaults, shouldCompactUseSmallModel, sleep, state } from "./accounts-manager-eec8Wj3_.js";
+import { HTTPError, PATHS, accountFromState, accountsManager, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, getAliasTargetSet, getConfig, getCopilotUsage, getExtraPromptForModel, getModelAliases, getModelAliasesInfo, getModelRefreshIntervalMs, getProviderConfig, getReasoningEffortForModel, getRootSessionId, getSmallModel, getUUID, isForceAgentEnabled, isFreeModelLoadBalancingEnabled, isMessageStartInputTokensFallbackEnabled, isNullish, isResponsesApiContextManagementModel, listAccountsFromRegistry, mergeConfigWithDefaults, prepareInteractionHeaders, shouldCompactUseSmallModel, sleep, state } from "./accounts-manager-BeKvbv0T.js";
 import consola from "consola";
 import fs, { readFile } from "node:fs/promises";
 import * as path$1 from "node:path";
@@ -2234,11 +2234,7 @@ const createResponses = async (payload, { vision, initiator, upstreamRequestId,
 		...copilotHeaders(ctx, vision, upstreamRequestId),
 		"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(ctx)}/responses`, {
 		method: "POST",
@@ -2718,8 +2714,7 @@ const createChatCompletions = async (payload, account, options) => {
 		...copilotHeaders(ctx, enableVision, options?.upstreamRequestId),
 		"x-initiator": options?.subagentMarker ? "agent" : initiator
 	};
-	if (options?.subagentMarker) headers["x-interaction-type"] = "conversation-subagent";
-	if (options?.sessionId) headers["x-interaction-id"] = options.sessionId;
+	prepareInteractionHeaders(options?.sessionId, Boolean(options?.subagentMarker), headers);
 	const upstreamPayload = applyDefaultReasoningEffort(payload);
 	const response = await fetch(`${copilotBaseUrl(ctx)}/chat/completions`, {
 		method: "POST",
@@ -2736,7 +2731,7 @@ const createChatCompletions = async (payload, account, options) => {
 
 //#endregion
 //#region src/routes/chat-completions/handler.ts
-const logger$3 = createHandlerLogger("chat-completions-handler");
+const logger$6 = createHandlerLogger("chat-completions-handler");
 const CHAT_COMPLETIONS_ENDPOINT$1 = "/chat/completions";
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
@@ -2766,7 +2761,7 @@ async function handleCompletion$1(c) {
 			reason: "MODEL_NOT_SUPPORTED"
 		});
 	}
-	logger$3.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	logger$6.debug("Request payload:", JSON.stringify(payload).slice(-400));
 	const selection = await accountsManager.selectAccountForRequest([{
 		modelId: clientModel,
 		endpoint: CHAT_COMPLETIONS_ENDPOINT$1
@@ -2885,9 +2880,9 @@ function selectionFailureResponse$2(c, params) {
 async function logTokenCountForRequest(params) {
 	try {
 		const tokenCount = await getTokenCount(params.payload, params.selectedModel);
-		logger$3.info("Current token count:", tokenCount);
+		logger$6.info("Current token count:", tokenCount);
 	} catch (error) {
-		logger$3.warn("Failed to calculate token count:", error);
+		logger$6.warn("Failed to calculate token count:", error);
 	}
 }
 function applyDefaultMaxTokens(payload, selectedModel) {
@@ -2896,7 +2891,7 @@ function applyDefaultMaxTokens(payload, selectedModel) {
 		...payload,
 		max_tokens: selectedModel.capabilities.limits.max_output_tokens
 	};
-	logger$3.debug("Set max_tokens to:", JSON.stringify(updated.max_tokens));
+	logger$6.debug("Set max_tokens to:", JSON.stringify(updated.max_tokens));
 	return updated;
 }
 async function handleStreamingRequest(params) {
@@ -2928,7 +2923,7 @@ async function handleStreamingRequest(params) {
 		premiumUnlimitedBefore,
 		response
 	});
-	logger$3.debug("Streaming response");
+	logger$6.debug("Streaming response");
 	return streamSSE(c, (stream) => streamChatCompletionsAndLog$1({
 		stream,
 		response,
@@ -2981,7 +2976,7 @@ async function handleNonStreamingUpstreamResponse(params) {
 	let errorMessage;
 	const finishedAtMs = Date.now();
 	try {
-		logger$3.debug("Non-streaming response:", JSON.stringify(response));
+		logger$6.debug("Non-streaming response:", JSON.stringify(response));
 		return c.json(response);
 	} catch (error) {
 		const details = extractErrorDetails(error);
@@ -3031,7 +3026,7 @@ async function streamChatCompletionsAndLog$1(params) {
 			if (ttfbMs === void 0) ttfbMs = Date.now() - request.startedAtMs;
 			const usage = await extractUsageFromChunk(chunk);
 			if (usage) lastUsage = usage;
-			logger$3.debug("Streaming chunk:", JSON.stringify(chunk));
+			logger$6.debug("Streaming chunk:", JSON.stringify(chunk));
 			await stream.writeSSE(chunk);
 		}
 	} catch (error) {
@@ -3039,7 +3034,7 @@ async function streamChatCompletionsAndLog$1(params) {
 		errorName = details.errorName;
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
-		logger$3.warn("Streaming error:", error);
+		logger$6.warn("Streaming error:", error);
 	} finally {
 		const finishedAtMs = Date.now();
 		await accountsManager.finalizeQuota(account, reservation);
@@ -3096,13 +3091,13 @@ async function handleNonStreamingRequest(params) {
 		});
 		finishedAtMs = Date.now();
 		if (!isNonStreaming$1(response)) {
-			logger$3.debug("Unexpected streaming response");
+			logger$6.debug("Unexpected streaming response");
 			return streamSSE(c, async (stream) => {
 				for await (const chunk of response) await stream.writeSSE(chunk);
 			});
 		}
 		usage = normalizeChatCompletionsUsage(response.usage);
-		logger$3.debug("Non-streaming response:", JSON.stringify(response));
+		logger$6.debug("Non-streaming response:", JSON.stringify(response));
 		return c.json(response);
 	} catch (error) {
 		finishedAtMs = Date.now();
@@ -3319,6 +3314,57 @@ async function runEmbeddingsWithAccount({ c, store, ctx, payload, clientModel, s
 	}
 }
 
+//#endregion
+//#region src/lib/models.ts
+const findEndpointModel = (sdkModelId) => {
+	const models = state.models?.data ?? [];
+	const exactMatch = models.find((m) => m.id === sdkModelId);
+	if (exactMatch) return exactMatch;
+	const normalized = _normalizeSdkModelId(sdkModelId);
+	if (!normalized) return;
+	const modelName = `claude-${normalized.family}-${normalized.version}`;
+	const model = models.find((m) => m.id === modelName);
+	if (model) return model;
+};
+/**
+* Normalizes an SDK model ID to extract the model family and version.
+* this method from github copilot extension
+* Examples:
+* - "claude-opus-4-5-20251101" -> { family: "opus", version: "4.5" }
+* - "claude-3-5-sonnet-20241022" -> { family: "sonnet", version: "3.5" }
+* - "claude-sonnet-4-20250514" -> { family: "sonnet", version: "4" }
+* - "claude-haiku-3-5-20250514" -> { family: "haiku", version: "3.5" }
+* - "claude-haiku-4.5" -> { family: "haiku", version: "4.5" }
+*/
+const _normalizeSdkModelId = (sdkModelId) => {
+	const withoutDate = sdkModelId.toLowerCase().replace(/-\d{8}$/, "");
+	const pattern1 = withoutDate.match(/^claude-(\w+)-(\d+)-(\d+)$/);
+	if (pattern1) return {
+		family: pattern1[1],
+		version: `${pattern1[2]}.${pattern1[3]}`
+	};
+	const pattern2 = withoutDate.match(/^claude-(\d+)-(\d+)-(\w+)$/);
+	if (pattern2) return {
+		family: pattern2[3],
+		version: `${pattern2[1]}.${pattern2[2]}`
+	};
+	const pattern3 = withoutDate.match(/^claude-(\w+)-(\d+)\.(\d+)$/);
+	if (pattern3) return {
+		family: pattern3[1],
+		version: `${pattern3[2]}.${pattern3[3]}`
+	};
+	const pattern4 = withoutDate.match(/^claude-(\w+)-(\d+)$/);
+	if (pattern4) return {
+		family: pattern4[1],
+		version: pattern4[2]
+	};
+	const pattern5 = withoutDate.match(/^claude-(\d+)-(\w+)$/);
+	if (pattern5) return {
+		family: pattern5[2],
+		version: pattern5[1]
+	};
+};
+
 //#endregion
 //#region src/routes/messages/utils.ts
 function mapOpenAIStopReasonToAnthropic(finishReason) {
@@ -3374,11 +3420,11 @@ const mergeToolResultForClaude = (anthropicPayload) => {
 		msg.content = mergeToolResult(toolResults, textBlocks);
 	}
 };
-const estimateInputTokens = async (payload, selectedModel, logger$4) => {
+const estimateInputTokens = async (payload, selectedModel, logger$7) => {
 	try {
 		return (await getTokenCount(payload, selectedModel)).input;
 	} catch (error) {
-		logger$4.warn("Failed to estimate input tokens for message_start", error);
+		logger$7.warn("Failed to estimate input tokens for message_start", error);
 		return;
 	}
 };
@@ -3443,7 +3489,7 @@ const maybeBlockOriginalModelName = (context) => {
 //#region src/routes/messages/non-stream-translation.ts
 const THINKING_TEXT = "Thinking...";
 function translateToOpenAI(payload) {
-	const modelId = translateModelName(payload.model);
+	const modelId = payload.model;
 	const model = state.models?.data.find((m) => m.id === modelId);
 	const thinkingBudget = getThinkingBudget(payload, model);
 	return {
@@ -3464,56 +3510,27 @@ function getThinkingBudget(payload, model) {
 	const thinking = payload.thinking;
 	if (model && thinking) {
 		const maxThinkingBudget = Math.min(model.capabilities.supports.max_thinking_budget ?? 0, (model.capabilities.limits.max_output_tokens ?? 0) - 1);
-		if (maxThinkingBudget > 0 && thinking.budget_tokens !== void 0) {
+		thinking.budget_tokens ??= maxThinkingBudget;
+		if (maxThinkingBudget > 0) {
 			const budgetTokens = Math.min(thinking.budget_tokens, maxThinkingBudget);
 			return Math.max(budgetTokens, model.capabilities.supports.min_thinking_budget ?? 1024);
 		}
 	}
 }
-function translateModelName(model) {
-	if (model.startsWith("claude-sonnet-4-")) return model.replace(/^claude-sonnet-4-.*/, "claude-sonnet-4");
-	else if (model.startsWith("claude-opus-4-")) return model.replace(/^claude-opus-4-.*/, "claude-opus-4");
-	return model;
-}
-function translateAnthropicMessagesToOpenAI(payload, modelId, thinkingBudget) {
-	const systemMessages = handleSystemPrompt(payload.system, modelId, thinkingBudget);
+function translateAnthropicMessagesToOpenAI(payload, modelId, _thinkingBudget) {
+	const systemMessages = handleSystemPrompt(payload.system);
 	const otherMessages = payload.messages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, modelId));
-	if (modelId.startsWith("claude") && thinkingBudget) {
-		const reminder = "<system-reminder>you MUST follow interleaved_thinking_protocol</system-reminder>";
-		const firstUserIndex = otherMessages.findIndex((m) => m.role === "user");
-		if (firstUserIndex !== -1) {
-			const userMessage = otherMessages[firstUserIndex];
-			if (typeof userMessage.content === "string") userMessage.content = reminder + "\n\n" + userMessage.content;
-			else if (Array.isArray(userMessage.content)) userMessage.content = [{
-				type: "text",
-				text: reminder
-			}, ...userMessage.content];
-		}
-	}
 	return [...systemMessages, ...otherMessages];
 }
-function handleSystemPrompt(system, modelId, thinkingBudget) {
+function handleSystemPrompt(system) {
 	if (!system) return [];
-	let extraPrompt = "";
-	if (modelId.startsWith("claude") && thinkingBudget) extraPrompt = `
-<interleaved_thinking_protocol>
-ABSOLUTE REQUIREMENT - NON-NEGOTIABLE:
-The current thinking_mode is interleaved, Whenever you have the result of a function call, think carefully , MUST output a thinking block
-RULES:
-Tool result → thinking block (ALWAYS, no exceptions)
-This is NOT optional - it is a hard requirement
-The thinking block must contain substantive reasoning (minimum 3-5 sentences)
-Think about: what the results mean, what to do next, how to answer the user
-NEVER skip this step, even if the result seems simple or obvious
-</interleaved_thinking_protocol>`;
 	if (typeof system === "string") return [{
 		role: "system",
-		content: system + extraPrompt
+		content: system
 	}];
 	else return [{
 		role: "system",
-		content: system.map((block, index) => {
-			if (index === 0) return block.text + extraPrompt;
+		content: system.map((block) => {
 			return block.text;
 		}).join("\n\n")
 	}];
@@ -3685,7 +3702,8 @@ async function handleCountTokens(c) {
 		const anthropicBeta = c.req.header("anthropic-beta");
 		const anthropicPayload = await c.req.json();
 		const openAIPayload = translateToOpenAI(anthropicPayload);
-		const selectedModel = state.models?.data.find((model) => model.id === anthropicPayload.model);
+		const selectedModel = findEndpointModel(anthropicPayload.model);
+		anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
 		if (!selectedModel) {
 			consola.warn("Model not found, returning default token count");
 			return c.json({ input_tokens: 1 });
@@ -4246,8 +4264,7 @@ const createMessages = async (payload, account, options) => {
 		...copilotHeaders(ctx, enableVision, options?.upstreamRequestId),
 		"x-initiator": options?.subagentMarker ? "agent" : initiator
 	};
-	if (options?.subagentMarker) 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(options?.anthropicBetaHeader, payload.thinking);
 	if (anthropicBeta) headers["anthropic-beta"] = anthropicBeta;
 	const response = await fetch(`${copilotBaseUrl(ctx)}/v1/messages`, {
@@ -4567,7 +4584,7 @@ const parseSubagentMarkerFromSystemReminder = (text) => {
 
 //#endregion
 //#region src/routes/messages/handler.ts
-const logger$2 = createHandlerLogger("messages-handler");
+const logger$5 = createHandlerLogger("messages-handler");
 const CHAT_COMPLETIONS_ENDPOINT = "/chat/completions";
 const RESPONSES_ENDPOINT$1 = "/responses";
 const MESSAGES_ENDPOINT = "/v1/messages";
@@ -4582,21 +4599,21 @@ async function handleCompletion(c) {
 	const { ip: clientIp, source: clientIpSource } = getClientIpInfo(c);
 	const userAgent = c.req.header("user-agent") ?? void 0;
 	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);
 	const initiatorOverride = subagentMarker ? "agent" : void 0;
-	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 anthropicBeta = c.req.header("anthropic-beta");
 	const isCompact = isCompactRequest(anthropicPayload);
 	if (anthropicBeta && isWarmupProbeRequest(anthropicPayload)) 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 upstreamRequestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
-	logger$2.debug("Generated request ID:", upstreamRequestId);
+	logger$5.debug("Generated request ID:", upstreamRequestId);
 	const clientModel = anthropicPayload.model;
 	const streamRequested = Boolean(anthropicPayload.stream);
 	const rawUserId = anthropicPayload.metadata?.user_id;
@@ -4624,17 +4641,19 @@ async function handleCompletion(c) {
 	if (blockedResponse) return blockedResponse;
 	const openAIPayload = translateToOpenAI(anthropicPayload);
 	const fallbackInitiator = initiatorOverride ?? getChatInitiator(openAIPayload.messages);
+	const endpointModel = findEndpointModel(clientModel);
+	const resolvedClientModel = endpointModel?.id ?? clientModel;
 	const selection = await accountsManager.selectAccountForRequest([
 		{
-			modelId: clientModel,
+			modelId: resolvedClientModel,
 			endpoint: MESSAGES_ENDPOINT
 		},
 		{
-			modelId: clientModel,
+			modelId: resolvedClientModel,
 			endpoint: RESPONSES_ENDPOINT$1
 		},
 		{
-			modelId: openAIPayload.model,
+			modelId: endpointModel?.id ?? openAIPayload.model,
 			endpoint: CHAT_COMPLETIONS_ENDPOINT
 		}
 	]);
@@ -4716,7 +4735,7 @@ async function handleCompletion(c) {
 }
 const handleWithChatCompletions = async (params) => {
 	const { c, openAIPayload, initiatorOverride, subagentMarker, sessionId, selectedModel, instr } = params;
-	logger$2.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	logger$5.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	const ctx = toAccountContext(instr.account);
 	const initiator = initiatorOverride ?? getChatInitiator(openAIPayload.messages);
 	instr.initiator = initiator;
@@ -4740,9 +4759,9 @@ const handleWithChatCompletions = async (params) => {
 		response,
 		instr
 	});
-	logger$2.debug("Streaming response from Copilot");
+	logger$5.debug("Streaming response from Copilot");
 	const fallbackEnabled = isMessageStartInputTokensFallbackEnabled();
-	const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$2) : void 0;
+	const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$5) : void 0;
 	const historicalUsage = fallbackEnabled && instr.promptCacheKey && instr.safetyIdentifier ? instr.store.getLastCompletedUsageBySession({
 		promptCacheKey: instr.promptCacheKey,
 		safetyIdentifier: instr.safetyIdentifier,
@@ -4761,7 +4780,7 @@ const handleWithResponsesApi = async (params) => {
 	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload, selectedModel.id);
 	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 resolvedInitiator = initiatorOverride ?? initiator;
 	const ctx = toAccountContext(instr.account);
@@ -4783,9 +4802,9 @@ const handleWithResponsesApi = async (params) => {
 		});
 	}
 	if (responsesPayload.stream && isAsyncIterable$1(response)) {
-		logger$2.debug("Streaming response from Copilot (Responses API)");
+		logger$5.debug("Streaming response from Copilot (Responses API)");
 		const fallbackEnabled = isMessageStartInputTokensFallbackEnabled();
-		const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$2) : void 0;
+		const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$5) : void 0;
 		const historicalUsage = fallbackEnabled && instr.promptCacheKey && instr.safetyIdentifier ? instr.store.getLastCompletedUsageBySession({
 			promptCacheKey: instr.promptCacheKey,
 			safetyIdentifier: instr.safetyIdentifier,
@@ -4870,9 +4889,9 @@ async function handleChatCompletionsNonStreaming(params) {
 	let errorMessage;
 	const finishedAtMs = Date.now();
 	try {
-		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);
 	} catch (error) {
 		const details = extractErrorDetails(error);
@@ -4920,7 +4939,7 @@ async function streamChatCompletionsAndLog(params) {
 	try {
 		for await (const rawEvent of response) {
 			if (ttfbMs === void 0) ttfbMs = Date.now() - instr.startedAtMs;
-			logger$2.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
+			logger$5.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
 			const { data: rawData } = rawEvent;
 			const data = typeof rawData === "string" ? rawData : await rawData;
 			if (data === "[DONE]") break;
@@ -4929,7 +4948,7 @@ async function streamChatCompletionsAndLog(params) {
 			if (chunk.usage) lastUsage = normalizeChatCompletionsUsage(chunk.usage);
 			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)
@@ -4941,7 +4960,7 @@ async function streamChatCompletionsAndLog(params) {
 		errorName = details.errorName;
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
-		logger$2.warn("Streaming error:", error);
+		logger$5.warn("Streaming error:", error);
 		if (details.unauthorized) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 	} finally {
 		const finishedAtMs = Date.now();
@@ -4992,9 +5011,9 @@ async function handleResponsesNonStreaming(params) {
 	const finishedAtMs = Date.now();
 	try {
 		usage = extractResponsesUsageFromResult(result);
-		logger$2.debug("Non-streaming Responses result:", JSON.stringify(result).slice(-400));
+		logger$5.debug("Non-streaming Responses result:", JSON.stringify(result).slice(-400));
 		const anthropicResponse = translateResponsesResultToAnthropic(result);
-		logger$2.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+		logger$5.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 		return c.json(anthropicResponse);
 	} catch (error) {
 		const details = extractErrorDetails(error);
@@ -5024,7 +5043,7 @@ async function handleResponsesNonStreaming(params) {
 async function ensureResponsesStreamCompleted(params) {
 	const { stream, streamState, setStreamError } = params;
 	if (streamState.messageCompleted) return;
-	logger$2.warn("Responses stream ended without completion; sending error event");
+	logger$5.warn("Responses stream ended without completion; sending error event");
 	const msg = "Responses stream ended without completion";
 	const errorEvent = buildErrorEvent(msg);
 	setStreamError("StreamIncomplete", msg);
@@ -5057,21 +5076,21 @@ async function streamResponsesAndLog$1(params) {
 			}
 			const data = chunk.data;
 			if (!data) continue;
-			logger$2.debug("Responses raw stream event:", data);
+			logger$5.debug("Responses raw stream event:", data);
 			const parsed = JSON.parse(data);
 			const u = extractResponsesUsageFromStreamEvent(parsed);
 			if (u.usageJson) lastUsage = u;
 			const events$1 = translateResponsesStreamEvent(parsed, 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;
 			}
 		}
@@ -5088,7 +5107,7 @@ async function streamResponsesAndLog$1(params) {
 		errorName = details.errorName;
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
-		logger$2.warn("Streaming error:", error);
+		logger$5.warn("Streaming error:", error);
 		if (details.unauthorized) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 	} finally {
 		const finishedAtMs = Date.now();
@@ -5138,7 +5157,7 @@ async function handleMessagesNonStreaming(params) {
 	let errorMessage;
 	const finishedAtMs = Date.now();
 	try {
-		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);
 	} catch (error) {
 		const details = extractErrorDetails(error);
@@ -5172,7 +5191,7 @@ const parseMessagesStreamUsage = (data) => {
 		if (parsed.type !== "message_delta" || !parsed.usage) return null;
 		return normalizeMessagesUsage(parsed.usage);
 	} catch (error) {
-		logger$2.warn("Failed to parse messages stream event", error);
+		logger$5.warn("Failed to parse messages stream event", error);
 		return null;
 	}
 };
@@ -5189,7 +5208,7 @@ async function streamMessagesAndLog(params) {
 			const eventNameRaw = rawEvent.event;
 			const eventName = typeof eventNameRaw === "string" && eventNameRaw.length > 0 ? eventNameRaw : "message";
 			const data = rawEvent.data ?? "";
-			logger$2.debug("Messages raw stream event:", data);
+			logger$5.debug("Messages raw stream event:", data);
 			const usage = parseMessagesStreamUsage(data);
 			if (usage) lastUsage = usage;
 			await stream.writeSSE({
@@ -5202,7 +5221,7 @@ async function streamMessagesAndLog(params) {
 		errorName = details.errorName;
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
-		logger$2.warn("Streaming error:", error);
+		logger$5.warn("Streaming error:", error);
 		if (details.unauthorized) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 	} finally {
 		const finishedAtMs = Date.now();
@@ -5237,7 +5256,7 @@ const handleWithMessagesApi = async (params) => {
 		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 ctx = toAccountContext(instr.account);
 	const initiator = initiatorOverride ?? getMessagesInitiator(anthropicPayload);
 	instr.initiator = initiator;
@@ -5258,7 +5277,7 @@ const handleWithMessagesApi = async (params) => {
 		});
 	}
 	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, (stream) => streamMessagesAndLog({
 			stream,
 			response,
@@ -5342,6 +5361,204 @@ 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"
+];
+const STRIPPED_RESPONSE_HEADERS = [
+	"connection",
+	"content-encoding",
+	"content-length",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+];
+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;
+}
+function createProviderProxyResponse(upstreamResponse) {
+	const headers = new Headers(upstreamResponse.headers);
+	for (const headerName of STRIPPED_RESPONSE_HEADERS) headers.delete(headerName);
+	return new Response(upstreamResponse.body, {
+		headers,
+		status: upstreamResponse.status,
+		statusText: upstreamResponse.statusText
+	});
+}
+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();
+		const modelConfig = providerConfig.models?.[payload.model];
+		payload.temperature ??= modelConfig?.temperature;
+		payload.top_p ??= modelConfig?.topP;
+		payload.top_k ??= modelConfig?.topK;
+		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 createProviderProxyResponse(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 createProviderProxyResponse(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() });
@@ -5922,7 +6139,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-Cxlbm6kJ.js.map
+//# sourceMappingURL=server-D3A61KAx.js.map