@dianshuv/copilot-api 0.2.0 → 0.2.1

package/dist/main.mjs

@@ -1017,7 +1017,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.2.0";
+var version = "0.2.1";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -4907,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) {
@@ -4976,56 +5181,111 @@ 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 {
-		payload: {
-			model: translateModelName(payload.model),
-			messages: fixMessageSequence(messages),
-			max_tokens: payload.max_tokens,
-			stop: payload.stop_sequences,
-			stream: payload.stream,
-			temperature: payload.temperature,
+		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),
+			messages: fixMessageSequence(messages),
+			max_tokens: payload.max_tokens,
+			stop: payload.stop_sequences,
+			stream: payload.stream,
+			temperature: payload.temperature,
 			top_p: payload.top_p,
 			user: payload.metadata?.user_id,
 			tools: translateAnthropicToolsToOpenAI(payload.tools, toolNameMapping),
@@ -5073,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 findLatestModel("claude-opus-4.6", "claude-opus-4.6");
+	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";
@@ -5144,474 +5405,164 @@ function handleAssistantMessage(message, toolNameMapping) {
 		content: allTextContent || null,
 		tool_calls: toolUseBlocks.map((toolUse) => ({
 			id: toolUse.id,
-			type: "function",
-			function: {
-				name: getTruncatedToolName(toolUse.name, toolNameMapping),
-				arguments: JSON.stringify(toolUse.input)
-			}
-		}))
-	}] : [{
-		role: "assistant",
-		content: mapContent(message.content)
-	}];
-}
-function mapContent(content) {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return null;
-	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text" || block.type === "thinking").map((block) => block.type === "text" ? block.text : block.thinking).join("\n\n");
-	const contentParts = [];
-	for (const block of content) switch (block.type) {
-		case "text":
-			contentParts.push({
-				type: "text",
-				text: block.text
-			});
-			break;
-		case "thinking":
-			contentParts.push({
-				type: "text",
-				text: block.thinking
-			});
-			break;
-		case "image":
-			contentParts.push({
-				type: "image_url",
-				image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
-			});
-			break;
-	}
-	return contentParts;
-}
-function getTruncatedToolName(originalName, toolNameMapping) {
-	if (originalName.length <= OPENAI_TOOL_NAME_LIMIT) return originalName;
-	const existingTruncated = toolNameMapping.originalToTruncated.get(originalName);
-	if (existingTruncated) return existingTruncated;
-	let hash = 0;
-	for (let i = 0; i < originalName.length; i++) {
-		const char = originalName.codePointAt(i) ?? 0;
-		hash = (hash << 5) - hash + char;
-		hash = Math.trunc(hash);
-	}
-	const hashSuffix = Math.abs(hash).toString(36).slice(0, 8);
-	const truncatedName = originalName.slice(0, OPENAI_TOOL_NAME_LIMIT - 9) + "_" + hashSuffix;
-	toolNameMapping.truncatedToOriginal.set(truncatedName, originalName);
-	toolNameMapping.originalToTruncated.set(originalName, truncatedName);
-	consola.debug(`Truncated tool name: "${originalName}" -> "${truncatedName}"`);
-	return truncatedName;
-}
-function translateAnthropicToolsToOpenAI(anthropicTools, toolNameMapping) {
-	if (!anthropicTools) return;
-	return anthropicTools.map((tool) => ({
-		type: "function",
-		function: {
-			name: getTruncatedToolName(tool.name, toolNameMapping),
-			description: tool.description,
-			parameters: tool.input_schema ?? {}
-		}
-	}));
-}
-function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice, toolNameMapping) {
-	if (!anthropicToolChoice) return;
-	switch (anthropicToolChoice.type) {
-		case "auto": return "auto";
-		case "any": return "required";
-		case "tool":
-			if (anthropicToolChoice.name) return {
-				type: "function",
-				function: { name: getTruncatedToolName(anthropicToolChoice.name, toolNameMapping) }
-			};
-			return;
-		case "none": return "none";
-		default: return;
-	}
-}
-/** Create empty response for edge case of no choices */
-function createEmptyResponse(response) {
-	return {
-		id: response.id,
-		type: "message",
-		role: "assistant",
-		model: response.model,
-		content: [],
-		stop_reason: "end_turn",
-		stop_sequence: null,
-		usage: {
-			input_tokens: response.usage?.prompt_tokens ?? 0,
-			output_tokens: response.usage?.completion_tokens ?? 0
-		}
-	};
-}
-/** Build usage object from response */
-function buildUsageObject(response) {
-	const cachedTokens = response.usage?.prompt_tokens_details?.cached_tokens;
-	return {
-		input_tokens: (response.usage?.prompt_tokens ?? 0) - (cachedTokens ?? 0),
-		output_tokens: response.usage?.completion_tokens ?? 0,
-		...cachedTokens !== void 0 && { cache_read_input_tokens: cachedTokens }
-	};
-}
-function translateToAnthropic(response, toolNameMapping) {
-	if (response.choices.length === 0) return createEmptyResponse(response);
-	const allTextBlocks = [];
-	const allToolUseBlocks = [];
-	let stopReason = null;
-	stopReason = response.choices[0]?.finish_reason ?? stopReason;
-	for (const choice of response.choices) {
-		const textBlocks = getAnthropicTextBlocks(choice.message.content);
-		const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls, toolNameMapping);
-		allTextBlocks.push(...textBlocks);
-		allToolUseBlocks.push(...toolUseBlocks);
-		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
-	}
-	return {
-		id: response.id,
-		type: "message",
-		role: "assistant",
-		model: response.model,
-		content: [...allTextBlocks, ...allToolUseBlocks],
-		stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
-		stop_sequence: null,
-		usage: buildUsageObject(response)
-	};
-}
-function getAnthropicTextBlocks(messageContent) {
-	if (typeof messageContent === "string") return [{
-		type: "text",
-		text: messageContent
-	}];
-	if (Array.isArray(messageContent)) return messageContent.filter((part) => part.type === "text").map((part) => ({
-		type: "text",
-		text: part.text
-	}));
-	return [];
-}
-function getAnthropicToolUseBlocks(toolCalls, toolNameMapping) {
-	if (!toolCalls) return [];
-	return toolCalls.map((toolCall) => {
-		let input = {};
-		try {
-			input = JSON.parse(toolCall.function.arguments);
-		} catch (error) {
-			consola.warn(`Failed to parse tool call arguments for ${toolCall.function.name}:`, error);
-		}
-		const originalName = toolNameMapping?.truncatedToOriginal.get(toolCall.function.name) ?? toolCall.function.name;
-		return {
-			type: "tool_use",
-			id: toolCall.id,
-			name: originalName,
-			input
-		};
-	});
-}
-
-//#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;
+			type: "function",
+			function: {
+				name: getTruncatedToolName(toolUse.name, toolNameMapping),
+				arguments: JSON.stringify(toolUse.input)
 			}
-			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
+		}))
+	}] : [{
+		role: "assistant",
+		content: mapContent(message.content)
+	}];
+}
+function mapContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return null;
+	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text" || block.type === "thinking").map((block) => block.type === "text" ? block.text : block.thinking).join("\n\n");
+	const contentParts = [];
+	for (const block of content) switch (block.type) {
+		case "text":
+			contentParts.push({
+				type: "text",
+				text: block.text
 			});
-		} else result.push(tool);
+			break;
+		case "thinking":
+			contentParts.push({
+				type: "text",
+				text: block.thinking
+			});
+			break;
+		case "image":
+			contentParts.push({
+				type: "image_url",
+				image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+			});
+			break;
 	}
-	return result.length > 0 ? result : void 0;
+	return contentParts;
 }
-/**
-* 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";
+function getTruncatedToolName(originalName, toolNameMapping) {
+	if (originalName.length <= OPENAI_TOOL_NAME_LIMIT) return originalName;
+	const existingTruncated = toolNameMapping.originalToTruncated.get(originalName);
+	if (existingTruncated) return existingTruncated;
+	let hash = 0;
+	for (let i = 0; i < originalName.length; i++) {
+		const char = originalName.codePointAt(i) ?? 0;
+		hash = (hash << 5) - hash + char;
+		hash = Math.trunc(hash);
+	}
+	const hashSuffix = Math.abs(hash).toString(36).slice(0, 8);
+	const truncatedName = originalName.slice(0, OPENAI_TOOL_NAME_LIMIT - 9) + "_" + hashSuffix;
+	toolNameMapping.truncatedToOriginal.set(truncatedName, originalName);
+	toolNameMapping.originalToTruncated.set(originalName, truncatedName);
+	consola.debug(`Truncated tool name: "${originalName}" -> "${truncatedName}"`);
+	return truncatedName;
 }
-
-//#endregion
-//#region src/routes/messages/stream-accumulator.ts
-function createAnthropicStreamAccumulator() {
-	return {
-		model: "",
-		inputTokens: 0,
-		outputTokens: 0,
-		stopReason: "",
-		content: "",
-		toolCalls: [],
-		currentToolCall: null
-	};
+function translateAnthropicToolsToOpenAI(anthropicTools, toolNameMapping) {
+	if (!anthropicTools) return;
+	return anthropicTools.map((tool) => ({
+		type: "function",
+		function: {
+			name: getTruncatedToolName(tool.name, toolNameMapping),
+			description: tool.description,
+			parameters: tool.input_schema ?? {}
+		}
+	}));
 }
-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 translateAnthropicToolChoiceToOpenAI(anthropicToolChoice, toolNameMapping) {
+	if (!anthropicToolChoice) return;
+	switch (anthropicToolChoice.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "tool":
+			if (anthropicToolChoice.name) return {
+				type: "function",
+				function: { name: getTruncatedToolName(anthropicToolChoice.name, toolNameMapping) }
+			};
+			return;
+		case "none": return "none";
+		default: return;
 	}
 }
-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;
+/** Create empty response for edge case of no choices */
+function createEmptyResponse(response) {
+	return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content: [],
+		stop_reason: "end_turn",
+		stop_sequence: null,
+		usage: {
+			input_tokens: response.usage?.prompt_tokens ?? 0,
+			output_tokens: response.usage?.completion_tokens ?? 0
+		}
+	};
 }
-function handleContentBlockStart(block, acc) {
-	if (block.type === "tool_use") acc.currentToolCall = {
-		id: block.id,
-		name: block.name,
-		input: ""
+/** Build usage object from response */
+function buildUsageObject(response) {
+	const cachedTokens = response.usage?.prompt_tokens_details?.cached_tokens;
+	return {
+		input_tokens: (response.usage?.prompt_tokens ?? 0) - (cachedTokens ?? 0),
+		output_tokens: response.usage?.completion_tokens ?? 0,
+		...cachedTokens !== void 0 && { cache_read_input_tokens: cachedTokens }
 	};
 }
-function handleContentBlockStop(acc) {
-	if (acc.currentToolCall) {
-		acc.toolCalls.push(acc.currentToolCall);
-		acc.currentToolCall = null;
+function translateToAnthropic(response, toolNameMapping) {
+	if (response.choices.length === 0) return createEmptyResponse(response);
+	const allTextBlocks = [];
+	const allToolUseBlocks = [];
+	let stopReason = null;
+	stopReason = response.choices[0]?.finish_reason ?? stopReason;
+	for (const choice of response.choices) {
+		const textBlocks = getAnthropicTextBlocks(choice.message.content);
+		const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls, toolNameMapping);
+		allTextBlocks.push(...textBlocks);
+		allToolUseBlocks.push(...toolUseBlocks);
+		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
 	}
+	return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content: [...allTextBlocks, ...allToolUseBlocks],
+		stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
+		stop_sequence: null,
+		usage: buildUsageObject(response)
+	};
 }
-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;
-	}
+function getAnthropicTextBlocks(messageContent) {
+	if (typeof messageContent === "string") return [{
+		type: "text",
+		text: messageContent
+	}];
+	if (Array.isArray(messageContent)) return messageContent.filter((part) => part.type === "text").map((part) => ({
+		type: "text",
+		text: part.text
+	}));
+	return [];
+}
+function getAnthropicToolUseBlocks(toolCalls, toolNameMapping) {
+	if (!toolCalls) return [];
+	return toolCalls.map((toolCall) => {
+		let input = {};
+		try {
+			input = JSON.parse(toolCall.function.arguments);
+		} catch (error) {
+			consola.warn(`Failed to parse tool call arguments for ${toolCall.function.name}:`, error);
+		}
+		const originalName = toolNameMapping?.truncatedToOriginal.get(toolCall.function.name) ?? toolCall.function.name;
+		return {
+			type: "tool_use",
+			id: toolCall.id,
+			name: originalName,
+			input
+		};
+	});
 }
 
 //#endregion
@@ -6212,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;
@@ -6259,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();

package/package.json

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