@dianshuv/copilot-api 0.1.2 → 0.2.1

package/dist/main.mjs

@@ -1017,7 +1017,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.1.2";
+var version = "0.2.1";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -1832,6 +1832,15 @@ var ConsoleRenderer = class {
 		process.stdout.write(message + "\n");
 		this.renderFooter();
 	}
+	/**
+	* Format model display string, showing resolved model when different.
+	* e.g., "claude-opus-4-6 -> claude-opus-4.6-1m"
+	*/
+	formatModelDisplay(request) {
+		if (!request.model) return void 0;
+		if (request.resolvedModel) return `${request.model} -> ${request.resolvedModel}`;
+		return request.model;
+	}
 	onRequestStart(request) {
 		this.activeRequests.set(request.id, request);
 		if (this.showActive && consola.level >= 5) {
@@ -1840,7 +1849,7 @@ var ConsoleRenderer = class {
 				time: formatTime(),
 				method: request.method,
 				path: request.path,
-				model: request.model,
+				model: this.formatModelDisplay(request),
 				extra: request.queuePosition !== void 0 && request.queuePosition > 0 ? `[q#${request.queuePosition}]` : void 0,
 				isDim: true
 			});
@@ -1857,7 +1866,7 @@ var ConsoleRenderer = class {
 				time: formatTime(),
 				method: request.method,
 				path: request.path,
-				model: request.model,
+				model: this.formatModelDisplay(request),
 				extra: "streaming...",
 				isDim: true
 			});
@@ -1875,7 +1884,7 @@ var ConsoleRenderer = class {
 			time: formatTime(),
 			method: request.method,
 			path: request.path,
-			model: request.model,
+			model: this.formatModelDisplay(request),
 			status,
 			duration: formatDuration(request.durationMs ?? 0),
 			queueWait,
@@ -2790,10 +2799,18 @@ const createChatCompletions = async (payload, options) => {
 * Contains common functions used by both OpenAI and Anthropic message handlers.
 */
 /** Helper to update tracker model */
-function updateTrackerModel(trackingId, model) {
+function updateTrackerModel(trackingId, model, resolvedModel) {
 	if (!trackingId) return;
 	const request = requestTracker.getRequest(trackingId);
-	if (request) request.model = model;
+	if (!request) return;
+	request.model = model;
+	request.resolvedModel = resolvedModel ?? model;
+}
+/** Helper to update only the resolved (post-translation) model */
+function updateTrackerResolvedModel(trackingId, resolvedModel) {
+	if (!trackingId) return;
+	const request = requestTracker.getRequest(trackingId);
+	if (request) request.resolvedModel = resolvedModel;
 }
 /** Helper to update tracker status */
 function updateTrackerStatus(trackingId, status) {
@@ -4890,6 +4907,211 @@ async function checkNeedsCompactionAnthropic(payload, model, config = {}) {
 	};
 }
 
+//#endregion
+//#region src/services/copilot/create-anthropic-messages.ts
+/**
+* Direct Anthropic-style message API for Copilot.
+* Used when the model vendor is Anthropic and supports /v1/messages endpoint.
+*/
+/**
+* Fields that are supported by Copilot's Anthropic API endpoint.
+* Any other fields in the incoming request will be stripped.
+*/
+const COPILOT_SUPPORTED_FIELDS = new Set([
+	"model",
+	"messages",
+	"max_tokens",
+	"system",
+	"metadata",
+	"stop_sequences",
+	"stream",
+	"temperature",
+	"top_p",
+	"top_k",
+	"tools",
+	"tool_choice",
+	"thinking",
+	"service_tier"
+]);
+/**
+* Filter payload to only include fields supported by Copilot's Anthropic API.
+* This prevents errors like "Extra inputs are not permitted" for unsupported
+* fields like `output_config`.
+*
+* Also converts server-side tools (web_search, etc.) to custom tools.
+*/
+function filterPayloadForCopilot(payload) {
+	const filtered = {};
+	const unsupportedFields = [];
+	for (const [key, value] of Object.entries(payload)) if (COPILOT_SUPPORTED_FIELDS.has(key)) filtered[key] = value;
+	else unsupportedFields.push(key);
+	if (unsupportedFields.length > 0) consola.debug(`[DirectAnthropic] Filtered unsupported fields: ${unsupportedFields.join(", ")}`);
+	if (filtered.tools) filtered.tools = convertServerToolsToCustom(filtered.tools);
+	return filtered;
+}
+/**
+* Adjust max_tokens if thinking is enabled.
+* According to Anthropic docs, max_tokens must be greater than thinking.budget_tokens.
+* max_tokens = thinking_budget + response_tokens
+*/
+function adjustMaxTokensForThinking(payload) {
+	const thinking = payload.thinking;
+	if (!thinking) return payload;
+	const budgetTokens = thinking.budget_tokens;
+	if (!budgetTokens) return payload;
+	if (payload.max_tokens <= budgetTokens) {
+		const newMaxTokens = budgetTokens + Math.min(16384, budgetTokens);
+		consola.debug(`[DirectAnthropic] Adjusted max_tokens: ${payload.max_tokens} → ${newMaxTokens} (thinking.budget_tokens=${budgetTokens})`);
+		return {
+			...payload,
+			max_tokens: newMaxTokens
+		};
+	}
+	return payload;
+}
+/**
+* Create messages using Anthropic-style API directly.
+* This bypasses the OpenAI translation layer for Anthropic models.
+*/
+async function createAnthropicMessages(payload, options) {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	let filteredPayload = filterPayloadForCopilot(payload);
+	filteredPayload = adjustMaxTokensForThinking(filteredPayload);
+	const enableVision = filteredPayload.messages.some((msg) => {
+		if (typeof msg.content === "string") return false;
+		return msg.content.some((block) => block.type === "image");
+	});
+	const isAgentCall = filteredPayload.messages.some((msg) => msg.role === "assistant");
+	const headers = {
+		...copilotHeaders(state, enableVision),
+		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user"),
+		"anthropic-version": "2023-06-01"
+	};
+	consola.debug("Sending direct Anthropic request to Copilot /v1/messages");
+	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(filteredPayload)
+	});
+	if (!response.ok) {
+		consola.debug("Request failed:", {
+			model: filteredPayload.model,
+			max_tokens: filteredPayload.max_tokens,
+			stream: filteredPayload.stream,
+			tools: filteredPayload.tools?.map((t) => ({
+				name: t.name,
+				type: t.type
+			})),
+			thinking: filteredPayload.thinking,
+			messageCount: filteredPayload.messages.length
+		});
+		throw await HTTPError.fromResponse("Failed to create Anthropic messages", response, filteredPayload.model);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+}
+const SERVER_TOOL_CONFIGS = {
+	web_search: {
+		description: "Search the web for current information. Returns web search results that can help answer questions about recent events, current data, or information that may have changed since your knowledge cutoff.",
+		input_schema: {
+			type: "object",
+			properties: { query: {
+				type: "string",
+				description: "The search query"
+			} },
+			required: ["query"]
+		}
+	},
+	web_fetch: {
+		description: "Fetch content from a URL. NOTE: This is a client-side tool - the client must fetch the URL and return the content.",
+		input_schema: {
+			type: "object",
+			properties: { url: {
+				type: "string",
+				description: "The URL to fetch"
+			} },
+			required: ["url"]
+		}
+	},
+	code_execution: {
+		description: "Execute code in a sandbox. NOTE: This is a client-side tool - the client must execute the code.",
+		input_schema: {
+			type: "object",
+			properties: {
+				code: {
+					type: "string",
+					description: "The code to execute"
+				},
+				language: {
+					type: "string",
+					description: "The programming language"
+				}
+			},
+			required: ["code"]
+		}
+	},
+	computer: {
+		description: "Control computer desktop. NOTE: This is a client-side tool - the client must handle computer control.",
+		input_schema: {
+			type: "object",
+			properties: { action: {
+				type: "string",
+				description: "The action to perform"
+			} },
+			required: ["action"]
+		}
+	}
+};
+/**
+* Check if a tool is a server-side tool that needs conversion.
+*/
+function getServerToolPrefix(tool) {
+	if (tool.type) {
+		for (const prefix of Object.keys(SERVER_TOOL_CONFIGS)) if (tool.type.startsWith(prefix)) return prefix;
+	}
+	return null;
+}
+/**
+* Convert server-side tools to custom tools, or pass them through unchanged.
+* This allows them to be passed to the API and handled by the client.
+*
+* Note: Server-side tools are only converted if state.rewriteAnthropicTools is enabled.
+*/
+function convertServerToolsToCustom(tools) {
+	if (!tools) return;
+	const result = [];
+	for (const tool of tools) {
+		const serverToolPrefix = getServerToolPrefix(tool);
+		if (serverToolPrefix) {
+			const config = SERVER_TOOL_CONFIGS[serverToolPrefix];
+			if (!state.rewriteAnthropicTools) {
+				consola.debug(`[DirectAnthropic] Passing ${serverToolPrefix} through unchanged (use --rewrite-anthropic-tools to convert)`);
+				result.push(tool);
+				continue;
+			}
+			if (config.remove) {
+				consola.warn(`[DirectAnthropic] Removing unsupported server tool: ${tool.name}. Reason: ${config.removalReason}`);
+				continue;
+			}
+			consola.debug(`[DirectAnthropic] Converting server tool to custom: ${tool.name} (type: ${tool.type})`);
+			result.push({
+				name: tool.name,
+				description: config.description,
+				input_schema: config.input_schema
+			});
+		} else result.push(tool);
+	}
+	return result.length > 0 ? result : void 0;
+}
+/**
+* Check if a model supports direct Anthropic API.
+* Returns true if redirect is disabled (direct API is on) and the model is from Anthropic vendor.
+*/
+function supportsDirectAnthropicApi(modelId) {
+	if (state.redirectAnthropic) return false;
+	return (state.models?.data.find((m) => m.id === modelId))?.vendor === "Anthropic";
+}
+
 //#endregion
 //#region src/routes/messages/message-utils.ts
 function convertAnthropicMessages(messages) {
@@ -4959,48 +5181,103 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 }
 
 //#endregion
-//#region src/routes/messages/non-stream-translation.ts
-const OPENAI_TOOL_NAME_LIMIT = 64;
-/**
-* Ensure all tool_use blocks have corresponding tool_result responses.
-* This handles edge cases where conversation history may be incomplete:
-* - Session interruptions where tool execution was cut off
-* - Previous request failures
-* - Client sending truncated history
-*
-* Adding placeholder responses prevents API errors and maintains protocol compliance.
-*/
-function fixMessageSequence(messages) {
-	const fixedMessages = [];
-	for (let i = 0; i < messages.length; i++) {
-		const message = messages[i];
-		fixedMessages.push(message);
-		if (message.role === "assistant" && message.tool_calls && message.tool_calls.length > 0) {
-			const foundToolResponses = /* @__PURE__ */ new Set();
-			let j = i + 1;
-			while (j < messages.length && messages[j].role === "tool") {
-				const toolMessage = messages[j];
-				if (toolMessage.tool_call_id) foundToolResponses.add(toolMessage.tool_call_id);
-				j++;
-			}
-			for (const toolCall of message.tool_calls) if (!foundToolResponses.has(toolCall.id)) {
-				consola.debug(`Adding placeholder tool_result for ${toolCall.id}`);
-				fixedMessages.push({
-					role: "tool",
-					tool_call_id: toolCall.id,
-					content: "Tool execution was interrupted or failed."
-				});
-			}
-		}
-	}
-	return fixedMessages;
-}
-function translateToOpenAI(payload) {
-	const toolNameMapping = {
-		truncatedToOriginal: /* @__PURE__ */ new Map(),
-		originalToTruncated: /* @__PURE__ */ new Map()
-	};
-	const messages = translateAnthropicMessagesToOpenAI(payload.messages, payload.system, toolNameMapping);
+//#region src/routes/messages/stream-accumulator.ts
+function createAnthropicStreamAccumulator() {
+	return {
+		model: "",
+		inputTokens: 0,
+		outputTokens: 0,
+		stopReason: "",
+		content: "",
+		toolCalls: [],
+		currentToolCall: null
+	};
+}
+function processAnthropicEvent(event, acc) {
+	switch (event.type) {
+		case "content_block_delta":
+			handleContentBlockDelta(event.delta, acc);
+			break;
+		case "content_block_start":
+			handleContentBlockStart(event.content_block, acc);
+			break;
+		case "content_block_stop":
+			handleContentBlockStop(acc);
+			break;
+		case "message_delta":
+			handleMessageDelta(event.delta, event.usage, acc);
+			break;
+		default: break;
+	}
+}
+function handleContentBlockDelta(delta, acc) {
+	if (delta.type === "text_delta") acc.content += delta.text;
+	else if (delta.type === "input_json_delta" && acc.currentToolCall) acc.currentToolCall.input += delta.partial_json;
+}
+function handleContentBlockStart(block, acc) {
+	if (block.type === "tool_use") acc.currentToolCall = {
+		id: block.id,
+		name: block.name,
+		input: ""
+	};
+}
+function handleContentBlockStop(acc) {
+	if (acc.currentToolCall) {
+		acc.toolCalls.push(acc.currentToolCall);
+		acc.currentToolCall = null;
+	}
+}
+function handleMessageDelta(delta, usage, acc) {
+	if (delta.stop_reason) acc.stopReason = delta.stop_reason;
+	if (usage) {
+		acc.inputTokens = usage.input_tokens ?? 0;
+		acc.outputTokens = usage.output_tokens;
+	}
+}
+
+//#endregion
+//#region src/routes/messages/non-stream-translation.ts
+const OPENAI_TOOL_NAME_LIMIT = 64;
+/**
+* Ensure all tool_use blocks have corresponding tool_result responses.
+* This handles edge cases where conversation history may be incomplete:
+* - Session interruptions where tool execution was cut off
+* - Previous request failures
+* - Client sending truncated history
+*
+* Adding placeholder responses prevents API errors and maintains protocol compliance.
+*/
+function fixMessageSequence(messages) {
+	const fixedMessages = [];
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		fixedMessages.push(message);
+		if (message.role === "assistant" && message.tool_calls && message.tool_calls.length > 0) {
+			const foundToolResponses = /* @__PURE__ */ new Set();
+			let j = i + 1;
+			while (j < messages.length && messages[j].role === "tool") {
+				const toolMessage = messages[j];
+				if (toolMessage.tool_call_id) foundToolResponses.add(toolMessage.tool_call_id);
+				j++;
+			}
+			for (const toolCall of message.tool_calls) if (!foundToolResponses.has(toolCall.id)) {
+				consola.debug(`Adding placeholder tool_result for ${toolCall.id}`);
+				fixedMessages.push({
+					role: "tool",
+					tool_call_id: toolCall.id,
+					content: "Tool execution was interrupted or failed."
+				});
+			}
+		}
+	}
+	return fixedMessages;
+}
+function translateToOpenAI(payload) {
+	const toolNameMapping = {
+		truncatedToOriginal: /* @__PURE__ */ new Map(),
+		originalToTruncated: /* @__PURE__ */ new Map()
+	};
+	const messages = translateAnthropicMessagesToOpenAI(payload.messages, payload.system, toolNameMapping);
 	return {
 		payload: {
 			model: translateModelName(payload.model),
@@ -5056,7 +5333,8 @@ function translateModelName(model) {
 	}
 	if (/^claude-sonnet-4-5-\d+$/.test(model)) return "claude-sonnet-4.5";
 	if (/^claude-sonnet-4-\d+$/.test(model)) return "claude-sonnet-4";
-	if (/^claude-opus-4-6$/.test(model)) return "claude-opus-4.6-1m";
+	if (model === "claude-opus-4-6-1m") return "claude-opus-4.6-1m";
+	if (/^claude-opus-4-6$/.test(model)) return "claude-opus-4.6";
 	if (/^claude-opus-4-5-\d+$/.test(model)) return "claude-opus-4.5";
 	if (/^claude-opus-4-\d+$/.test(model)) return findLatestModel("claude-opus", "claude-opus-4.5");
 	if (/^claude-haiku-4-5-\d+$/.test(model)) return "claude-haiku-4.5";
@@ -5287,316 +5565,6 @@ function getAnthropicToolUseBlocks(toolCalls, toolNameMapping) {
 	});
 }
 
-//#endregion
-//#region src/routes/messages/count-tokens-handler.ts
-/**
-* Handles token counting for Anthropic messages.
-*
-* For Anthropic models (vendor === "Anthropic"), uses the official Anthropic tokenizer.
-* For other models, uses GPT tokenizers with appropriate buffers.
-*
-* When auto-truncate is enabled and the request would exceed limits,
-* returns an inflated token count to trigger Claude Code's auto-compact mechanism.
-*/
-async function handleCountTokens(c) {
-	try {
-		const anthropicBeta = c.req.header("anthropic-beta");
-		const anthropicPayload = await c.req.json();
-		const { payload: openAIPayload } = translateToOpenAI(anthropicPayload);
-		const selectedModel = state.models?.data.find((model) => model.id === openAIPayload.model);
-		if (!selectedModel) {
-			consola.warn("Model not found, returning default token count");
-			return c.json({ input_tokens: 1 });
-		}
-		if (state.autoTruncate) {
-			const truncateCheck = await checkNeedsCompactionAnthropic(anthropicPayload, selectedModel);
-			if (truncateCheck.needed) {
-				const contextWindow = selectedModel.capabilities?.limits?.max_context_window_tokens ?? 2e5;
-				const inflatedTokens = Math.floor(contextWindow * .95);
-				consola.debug(`[count_tokens] Would trigger auto-truncate: ${truncateCheck.currentTokens} tokens > ${truncateCheck.tokenLimit}, returning inflated count: ${inflatedTokens}`);
-				return c.json({ input_tokens: inflatedTokens });
-			}
-		}
-		const tokenizerName = selectedModel.capabilities?.tokenizer ?? "o200k_base";
-		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
-		if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
-			let mcpToolExist = false;
-			if (anthropicBeta?.startsWith("claude-code")) mcpToolExist = anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__"));
-			if (!mcpToolExist) {
-				if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
-				else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 480;
-			}
-		}
-		let finalTokenCount = tokenCount.input + tokenCount.output;
-		if (!(selectedModel.vendor === "Anthropic")) finalTokenCount = anthropicPayload.model.startsWith("grok") ? Math.round(finalTokenCount * 1.03) : Math.round(finalTokenCount * 1.05);
-		consola.debug(`Token count: ${finalTokenCount} (tokenizer: ${tokenizerName})`);
-		return c.json({ input_tokens: finalTokenCount });
-	} catch (error) {
-		consola.error("Error counting tokens:", error);
-		return c.json({ input_tokens: 1 });
-	}
-}
-
-//#endregion
-//#region src/services/copilot/create-anthropic-messages.ts
-/**
-* Direct Anthropic-style message API for Copilot.
-* Used when the model vendor is Anthropic and supports /v1/messages endpoint.
-*/
-/**
-* Fields that are supported by Copilot's Anthropic API endpoint.
-* Any other fields in the incoming request will be stripped.
-*/
-const COPILOT_SUPPORTED_FIELDS = new Set([
-	"model",
-	"messages",
-	"max_tokens",
-	"system",
-	"metadata",
-	"stop_sequences",
-	"stream",
-	"temperature",
-	"top_p",
-	"top_k",
-	"tools",
-	"tool_choice",
-	"thinking",
-	"service_tier"
-]);
-/**
-* Filter payload to only include fields supported by Copilot's Anthropic API.
-* This prevents errors like "Extra inputs are not permitted" for unsupported
-* fields like `output_config`.
-*
-* Also converts server-side tools (web_search, etc.) to custom tools.
-*/
-function filterPayloadForCopilot(payload) {
-	const filtered = {};
-	const unsupportedFields = [];
-	for (const [key, value] of Object.entries(payload)) if (COPILOT_SUPPORTED_FIELDS.has(key)) filtered[key] = value;
-	else unsupportedFields.push(key);
-	if (unsupportedFields.length > 0) consola.debug(`[DirectAnthropic] Filtered unsupported fields: ${unsupportedFields.join(", ")}`);
-	if (filtered.tools) filtered.tools = convertServerToolsToCustom(filtered.tools);
-	return filtered;
-}
-/**
-* Adjust max_tokens if thinking is enabled.
-* According to Anthropic docs, max_tokens must be greater than thinking.budget_tokens.
-* max_tokens = thinking_budget + response_tokens
-*/
-function adjustMaxTokensForThinking(payload) {
-	const thinking = payload.thinking;
-	if (!thinking) return payload;
-	const budgetTokens = thinking.budget_tokens;
-	if (!budgetTokens) return payload;
-	if (payload.max_tokens <= budgetTokens) {
-		const newMaxTokens = budgetTokens + Math.min(16384, budgetTokens);
-		consola.debug(`[DirectAnthropic] Adjusted max_tokens: ${payload.max_tokens} → ${newMaxTokens} (thinking.budget_tokens=${budgetTokens})`);
-		return {
-			...payload,
-			max_tokens: newMaxTokens
-		};
-	}
-	return payload;
-}
-/**
-* Create messages using Anthropic-style API directly.
-* This bypasses the OpenAI translation layer for Anthropic models.
-*/
-async function createAnthropicMessages(payload, options) {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	let filteredPayload = filterPayloadForCopilot(payload);
-	filteredPayload = adjustMaxTokensForThinking(filteredPayload);
-	const enableVision = filteredPayload.messages.some((msg) => {
-		if (typeof msg.content === "string") return false;
-		return msg.content.some((block) => block.type === "image");
-	});
-	const isAgentCall = filteredPayload.messages.some((msg) => msg.role === "assistant");
-	const headers = {
-		...copilotHeaders(state, enableVision),
-		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user"),
-		"anthropic-version": "2023-06-01"
-	};
-	consola.debug("Sending direct Anthropic request to Copilot /v1/messages");
-	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(filteredPayload)
-	});
-	if (!response.ok) {
-		consola.debug("Request failed:", {
-			model: filteredPayload.model,
-			max_tokens: filteredPayload.max_tokens,
-			stream: filteredPayload.stream,
-			tools: filteredPayload.tools?.map((t) => ({
-				name: t.name,
-				type: t.type
-			})),
-			thinking: filteredPayload.thinking,
-			messageCount: filteredPayload.messages.length
-		});
-		throw await HTTPError.fromResponse("Failed to create Anthropic messages", response, filteredPayload.model);
-	}
-	if (payload.stream) return events(response);
-	return await response.json();
-}
-const SERVER_TOOL_CONFIGS = {
-	web_search: {
-		description: "Search the web for current information. Returns web search results that can help answer questions about recent events, current data, or information that may have changed since your knowledge cutoff.",
-		input_schema: {
-			type: "object",
-			properties: { query: {
-				type: "string",
-				description: "The search query"
-			} },
-			required: ["query"]
-		}
-	},
-	web_fetch: {
-		description: "Fetch content from a URL. NOTE: This is a client-side tool - the client must fetch the URL and return the content.",
-		input_schema: {
-			type: "object",
-			properties: { url: {
-				type: "string",
-				description: "The URL to fetch"
-			} },
-			required: ["url"]
-		}
-	},
-	code_execution: {
-		description: "Execute code in a sandbox. NOTE: This is a client-side tool - the client must execute the code.",
-		input_schema: {
-			type: "object",
-			properties: {
-				code: {
-					type: "string",
-					description: "The code to execute"
-				},
-				language: {
-					type: "string",
-					description: "The programming language"
-				}
-			},
-			required: ["code"]
-		}
-	},
-	computer: {
-		description: "Control computer desktop. NOTE: This is a client-side tool - the client must handle computer control.",
-		input_schema: {
-			type: "object",
-			properties: { action: {
-				type: "string",
-				description: "The action to perform"
-			} },
-			required: ["action"]
-		}
-	}
-};
-/**
-* Check if a tool is a server-side tool that needs conversion.
-*/
-function getServerToolPrefix(tool) {
-	if (tool.type) {
-		for (const prefix of Object.keys(SERVER_TOOL_CONFIGS)) if (tool.type.startsWith(prefix)) return prefix;
-	}
-	return null;
-}
-/**
-* Convert server-side tools to custom tools, or pass them through unchanged.
-* This allows them to be passed to the API and handled by the client.
-*
-* Note: Server-side tools are only converted if state.rewriteAnthropicTools is enabled.
-*/
-function convertServerToolsToCustom(tools) {
-	if (!tools) return;
-	const result = [];
-	for (const tool of tools) {
-		const serverToolPrefix = getServerToolPrefix(tool);
-		if (serverToolPrefix) {
-			const config = SERVER_TOOL_CONFIGS[serverToolPrefix];
-			if (!state.rewriteAnthropicTools) {
-				consola.debug(`[DirectAnthropic] Passing ${serverToolPrefix} through unchanged (use --rewrite-anthropic-tools to convert)`);
-				result.push(tool);
-				continue;
-			}
-			if (config.remove) {
-				consola.warn(`[DirectAnthropic] Removing unsupported server tool: ${tool.name}. Reason: ${config.removalReason}`);
-				continue;
-			}
-			consola.debug(`[DirectAnthropic] Converting server tool to custom: ${tool.name} (type: ${tool.type})`);
-			result.push({
-				name: tool.name,
-				description: config.description,
-				input_schema: config.input_schema
-			});
-		} else result.push(tool);
-	}
-	return result.length > 0 ? result : void 0;
-}
-/**
-* Check if a model supports direct Anthropic API.
-* Returns true if redirect is disabled (direct API is on) and the model is from Anthropic vendor.
-*/
-function supportsDirectAnthropicApi(modelId) {
-	if (state.redirectAnthropic) return false;
-	return (state.models?.data.find((m) => m.id === modelId))?.vendor === "Anthropic";
-}
-
-//#endregion
-//#region src/routes/messages/stream-accumulator.ts
-function createAnthropicStreamAccumulator() {
-	return {
-		model: "",
-		inputTokens: 0,
-		outputTokens: 0,
-		stopReason: "",
-		content: "",
-		toolCalls: [],
-		currentToolCall: null
-	};
-}
-function processAnthropicEvent(event, acc) {
-	switch (event.type) {
-		case "content_block_delta":
-			handleContentBlockDelta(event.delta, acc);
-			break;
-		case "content_block_start":
-			handleContentBlockStart(event.content_block, acc);
-			break;
-		case "content_block_stop":
-			handleContentBlockStop(acc);
-			break;
-		case "message_delta":
-			handleMessageDelta(event.delta, event.usage, acc);
-			break;
-		default: break;
-	}
-}
-function handleContentBlockDelta(delta, acc) {
-	if (delta.type === "text_delta") acc.content += delta.text;
-	else if (delta.type === "input_json_delta" && acc.currentToolCall) acc.currentToolCall.input += delta.partial_json;
-}
-function handleContentBlockStart(block, acc) {
-	if (block.type === "tool_use") acc.currentToolCall = {
-		id: block.id,
-		name: block.name,
-		input: ""
-	};
-}
-function handleContentBlockStop(acc) {
-	if (acc.currentToolCall) {
-		acc.toolCalls.push(acc.currentToolCall);
-		acc.currentToolCall = null;
-	}
-}
-function handleMessageDelta(delta, usage, acc) {
-	if (delta.stop_reason) acc.stopReason = delta.stop_reason;
-	if (usage) {
-		acc.inputTokens = usage.input_tokens ?? 0;
-		acc.outputTokens = usage.output_tokens;
-	}
-}
-
 //#endregion
 //#region src/routes/messages/stream-translation.ts
 function isToolBlockOpen(state) {
@@ -5979,6 +5947,7 @@ const parseSubagentMarkerFromSystemReminder = (text) => {
 async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOverride) {
 	const { payload: translatedPayload, toolNameMapping } = translateToOpenAI(anthropicPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(translatedPayload));
+	updateTrackerResolvedModel(ctx.trackingId, translatedPayload.model);
 	const selectedModel = state.models?.data.find((model) => model.id === translatedPayload.model);
 	const { finalPayload: openAIPayload, truncateResult } = await buildFinalPayload(translatedPayload, selectedModel);
 	if (truncateResult) ctx.truncateResult = truncateResult;
@@ -6194,9 +6163,19 @@ function recordStreamingResponse(acc, fallbackModel, ctx) {
 
 //#endregion
 //#region src/routes/messages/handler.ts
+function resolveModelFromBetaHeader(model, betaHeader) {
+	if (!betaHeader || !/\bcontext-1m\b/.test(betaHeader)) return model;
+	if (!model.startsWith("claude-")) return model;
+	if (model.endsWith("-1m")) return model;
+	const resolved = `${model}-1m`;
+	consola.debug(`Detected context-1m in anthropic-beta header, resolving model: ${model} → ${resolved}`);
+	return resolved;
+}
 async function handleCompletion(c) {
 	const anthropicPayload = await c.req.json();
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+	const betaHeader = c.req.header("anthropic-beta");
+	anthropicPayload.model = resolveModelFromBetaHeader(anthropicPayload.model, betaHeader);
 	logToolInfo(anthropicPayload);
 	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
 	const initiatorOverride = subagentMarker ? "agent" : void 0;
@@ -6241,6 +6220,57 @@ function logToolInfo(anthropicPayload) {
 	}
 }
 
+//#endregion
+//#region src/routes/messages/count-tokens-handler.ts
+/**
+* Handles token counting for Anthropic messages.
+*
+* For Anthropic models (vendor === "Anthropic"), uses the official Anthropic tokenizer.
+* For other models, uses GPT tokenizers with appropriate buffers.
+*
+* When auto-truncate is enabled and the request would exceed limits,
+* returns an inflated token count to trigger Claude Code's auto-compact mechanism.
+*/
+async function handleCountTokens(c) {
+	try {
+		const anthropicBeta = c.req.header("anthropic-beta");
+		const anthropicPayload = await c.req.json();
+		anthropicPayload.model = resolveModelFromBetaHeader(anthropicPayload.model, anthropicBeta);
+		const { payload: openAIPayload } = translateToOpenAI(anthropicPayload);
+		const selectedModel = state.models?.data.find((model) => model.id === openAIPayload.model);
+		if (!selectedModel) {
+			consola.warn("Model not found, returning default token count");
+			return c.json({ input_tokens: 1 });
+		}
+		if (state.autoTruncate) {
+			const truncateCheck = await checkNeedsCompactionAnthropic(anthropicPayload, selectedModel);
+			if (truncateCheck.needed) {
+				const contextWindow = selectedModel.capabilities?.limits?.max_context_window_tokens ?? 2e5;
+				const inflatedTokens = Math.floor(contextWindow * .95);
+				consola.debug(`[count_tokens] Would trigger auto-truncate: ${truncateCheck.currentTokens} tokens > ${truncateCheck.tokenLimit}, returning inflated count: ${inflatedTokens}`);
+				return c.json({ input_tokens: inflatedTokens });
+			}
+		}
+		const tokenizerName = selectedModel.capabilities?.tokenizer ?? "o200k_base";
+		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+		if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
+			let mcpToolExist = false;
+			if (anthropicBeta?.startsWith("claude-code")) mcpToolExist = anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__"));
+			if (!mcpToolExist) {
+				if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
+				else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 480;
+			}
+		}
+		let finalTokenCount = tokenCount.input + tokenCount.output;
+		if (!(selectedModel.vendor === "Anthropic")) finalTokenCount = anthropicPayload.model.startsWith("grok") ? Math.round(finalTokenCount * 1.03) : Math.round(finalTokenCount * 1.05);
+		consola.debug(`Token count: ${finalTokenCount} (tokenizer: ${tokenizerName})`);
+		return c.json({ input_tokens: finalTokenCount });
+	} catch (error) {
+		consola.error("Error counting tokens:", error);
+		return c.json({ input_tokens: 1 });
+	}
+}
+
 //#endregion
 //#region src/routes/messages/route.ts
 const messageRoutes = new Hono();
@@ -6396,6 +6426,7 @@ const RESPONSES_ENDPOINT = "/responses";
 const handleResponses = async (c) => {
 	const payload = await c.req.json();
 	consola.debug("Responses request payload:", JSON.stringify(payload));
+	updateTrackerModel(c.get("trackingId"), payload.model);
 	useFunctionApplyPatch(payload);
 	removeWebSearchTool(payload);
 	if (!((state.models?.data.find((model) => model.id === payload.model))?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) return c.json({ error: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dianshuv/copilot-api",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!",
   "author": "dianshuv",
   "type": "module",