betahi-copilot-bridge 0.1.6 → 0.1.8

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">copilot-bridge</h1>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/betahi-copilot-bridge"><img src="https://img.shields.io/npm/v/betahi-copilot-bridge.svg?v=0.1.6" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/betahi-copilot-bridge"><img src="https://img.shields.io/npm/v/betahi-copilot-bridge.svg?v=0.1.8" alt="npm version"></a>
   <a href="https://github.com/betahi/copilot-bridge/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/betahi-copilot-bridge.svg" alt="license"></a>
 </p>
 

package/dist/main.js

@@ -4,7 +4,7 @@ import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
@@ -1442,6 +1442,84 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 	}[finishReason];
 }
 
+//#endregion
+//#region src/bridges/claude/tool-names.ts
+const STRICT_TOOL_NAME_CHARS_PATTERN = /^[A-Za-z0-9_-]+$/;
+const DOTTED_TOOL_NAME_CHARS_PATTERN = /^[A-Za-z0-9_.-]+$/;
+const DEFAULT_TOOL_NAME_MAX_LENGTH = 64;
+const EXTENDED_TOOL_NAME_MAX_LENGTH = 128;
+const HASH_LENGTH = 10;
+const getToolNameMapperOptionsForModel = (modelId) => {
+	const normalized = modelId.trim().toLowerCase().replace(/\[1m\]$/, "-1m").replace(/[._]/g, "-");
+	if (/^claude-opus-4-(?:6|7)(?:$|-)/.test(normalized)) return {
+		allowDots: false,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	if (/^claude-sonnet-4(?:$|-\d{8}$)/.test(normalized)) return {
+		allowDots: false,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	if (normalized.startsWith("gemini-")) return {
+		allowDots: true,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	if (/^gpt-5-(?:2|4)(?:$|-)/.test(normalized) || /^gpt-5-(?:2|3)-codex(?:$|-)/.test(normalized) || /^gpt-5-4-mini(?:$|-)/.test(normalized) || /^gpt-5-mini(?:$|-)/.test(normalized) || /^gpt-5-5(?:$|-)/.test(normalized)) return {
+		allowDots: false,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	if (normalized.startsWith("gpt-")) return {
+		allowDots: true,
+		maxNameLength: EXTENDED_TOOL_NAME_MAX_LENGTH
+	};
+	return {
+		allowDots: false,
+		maxNameLength: DEFAULT_TOOL_NAME_MAX_LENGTH
+	};
+};
+const makeHash = (value) => createHash("sha1").update(value).digest("hex").slice(0, HASH_LENGTH);
+const getAllowedNamePattern = (allowDots) => allowDots ? DOTTED_TOOL_NAME_CHARS_PATTERN : STRICT_TOOL_NAME_CHARS_PATTERN;
+const cleanToolName = (name, allowDots) => {
+	const invalidCharsPattern = allowDots ? /[^A-Za-z0-9_.-]/g : /[^A-Za-z0-9_-]/g;
+	return name.replace(invalidCharsPattern, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "") || "tool";
+};
+const isValidToolName = (name, maxNameLength, allowDots) => name.length > 0 && name.length <= maxNameLength && getAllowedNamePattern(allowDots).test(name);
+const makeValidToolName = (name, maxNameLength, allowDots) => {
+	if (isValidToolName(name, maxNameLength, allowDots)) return name;
+	const cleaned = cleanToolName(name, allowDots);
+	if (cleaned.length <= maxNameLength) return cleaned;
+	const hash = makeHash(name);
+	const prefixLength = maxNameLength - hash.length - 1;
+	return `${cleaned.slice(0, prefixLength)}_${hash}`;
+};
+const makeUniqueToolName = (name, used, maxNameLength, allowDots) => {
+	const candidate = makeValidToolName(name, maxNameLength, allowDots);
+	if (!used.has(candidate)) return candidate;
+	for (let index = 2;; index++) {
+		const suffix = `_${makeHash(`${name}:${index}`)}`;
+		const prefixLength = maxNameLength - suffix.length;
+		const next = `${cleanToolName(name, allowDots).slice(0, prefixLength)}${suffix}`;
+		if (!used.has(next)) return next;
+	}
+};
+const createAnthropicToolNameMapper = (tools, options = {}) => {
+	const maxNameLength = options.maxNameLength ?? DEFAULT_TOOL_NAME_MAX_LENGTH;
+	const allowDots = options.allowDots ?? false;
+	const anthropicToOpenAI = /* @__PURE__ */ new Map();
+	const openAIToAnthropic = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	for (const tool of tools ?? []) {
+		if (anthropicToOpenAI.has(tool.name)) continue;
+		const openAIName = makeUniqueToolName(tool.name, used, maxNameLength, allowDots);
+		used.add(openAIName);
+		anthropicToOpenAI.set(tool.name, openAIName);
+		openAIToAnthropic.set(openAIName, tool.name);
+	}
+	return {
+		toAnthropic: (name) => openAIToAnthropic.get(name) ?? name,
+		toOpenAI: (name) => anthropicToOpenAI.get(name) ?? makeValidToolName(name, maxNameLength, allowDots)
+	};
+};
+
 //#endregion
 //#region src/bridges/claude/non-stream-translation.ts
 const normalizeClaudeModelAlias = (model) => {
@@ -1537,12 +1615,13 @@ function translateReasoningEffort(payload, settings) {
 	if (budgetTokens <= 24576) return sanitizeReasoningEffortForModel(modelId, "high");
 	return sanitizeReasoningEffortForModel(modelId, "xhigh");
 }
-function translateToOpenAI(payload, settings) {
+function translateToOpenAI(payload, settings, toolNameMapper) {
 	const model = translateModelName(payload.model, settings);
-	const tools = translateAnthropicToolsToOpenAI(payload.tools);
+	const mapper = toolNameMapper ?? createAnthropicToolNameMapper(payload.tools, { ...getToolNameMapperOptionsForModel(model) });
+	const tools = translateAnthropicToolsToOpenAI(payload.tools, mapper);
 	return {
 		model,
-		messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
+		messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system, mapper),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
 		stream: payload.stream,
@@ -1553,12 +1632,12 @@ function translateToOpenAI(payload, settings) {
 		reasoning_effort: translateReasoningEffort(payload, settings),
 		user: payload.metadata?.user_id,
 		tools,
-		tool_choice: tools && tools.length > 0 ? translateAnthropicToolChoiceToOpenAI(payload.tool_choice) : void 0
+		tool_choice: tools && tools.length > 0 ? translateAnthropicToolChoiceToOpenAI(payload.tool_choice, mapper) : void 0
 	};
 }
-function translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
+function translateAnthropicMessagesToOpenAI(anthropicMessages, system, toolNameMapper) {
 	const systemMessages = handleSystemPrompt(system);
-	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message));
+	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, toolNameMapper));
 	return [...systemMessages, ...otherMessages];
 }
 function handleSystemPrompt(system) {
@@ -1592,7 +1671,7 @@ function handleUserMessage(message) {
 	});
 	return newMessages;
 }
-function handleAssistantMessage(message) {
+function handleAssistantMessage(message, toolNameMapper) {
 	if (!Array.isArray(message.content)) return [{
 		role: "assistant",
 		content: mapContent(message.content)
@@ -1608,7 +1687,7 @@ function handleAssistantMessage(message) {
 			id: toolUse.id,
 			type: "function",
 			function: {
-				name: toolUse.name,
+				name: toolNameMapper.toOpenAI(toolUse.name),
 				arguments: JSON.stringify(toolUse.input)
 			}
 		}))
@@ -1644,18 +1723,18 @@ function mapContent(content) {
 	}
 	return contentParts;
 }
-function translateAnthropicToolsToOpenAI(anthropicTools) {
+function translateAnthropicToolsToOpenAI(anthropicTools, toolNameMapper) {
 	if (!anthropicTools || anthropicTools.length === 0) return;
 	return anthropicTools.map((tool) => ({
 		type: "function",
 		function: {
-			name: tool.name,
+			name: toolNameMapper.toOpenAI(tool.name),
 			description: tool.description,
 			parameters: tool.input_schema
 		}
 	}));
 }
-function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
+function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice, toolNameMapper) {
 	if (!anthropicToolChoice) return;
 	switch (anthropicToolChoice.type) {
 		case "auto": return "auto";
@@ -1663,21 +1742,21 @@ function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
 		case "tool":
 			if (anthropicToolChoice.name) return {
 				type: "function",
-				function: { name: anthropicToolChoice.name }
+				function: { name: toolNameMapper.toOpenAI(anthropicToolChoice.name) }
 			};
 			return;
 		case "none": return "none";
 		default: return;
 	}
 }
-function translateToAnthropic(response) {
+function translateToAnthropic(response, toolNameMapper = createAnthropicToolNameMapper(void 0)) {
 	const allTextBlocks = [];
 	const allToolUseBlocks = [];
 	let stopReason = null;
 	stopReason = response.choices[0]?.finish_reason ?? stopReason;
 	for (const choice of response.choices) {
 		allTextBlocks.push(...getAnthropicTextBlocks(choice.message.content));
-		allToolUseBlocks.push(...getAnthropicToolUseBlocks(choice.message.tool_calls));
+		allToolUseBlocks.push(...getAnthropicToolUseBlocks(choice.message.tool_calls, toolNameMapper));
 		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
 	}
 	return {
@@ -1706,12 +1785,12 @@ function getAnthropicTextBlocks(messageContent) {
 	}));
 	return [];
 }
-function getAnthropicToolUseBlocks(toolCalls) {
+function getAnthropicToolUseBlocks(toolCalls, toolNameMapper) {
 	if (!toolCalls) return [];
 	return toolCalls.map((toolCall) => ({
 		type: "tool_use",
 		id: toolCall.id,
-		name: toolCall.function.name,
+		name: toolNameMapper.toAnthropic(toolCall.function.name),
 		input: safeJsonParse(toolCall.function.arguments)
 	}));
 }
@@ -1729,7 +1808,7 @@ function isToolBlockOpen(state) {
 	if (!state.contentBlockOpen) return false;
 	return Object.values(state.toolCalls).some((tc) => tc.anthropicBlockIndex === state.contentBlockIndex);
 }
-function translateChunkToAnthropicEvents(chunk, state) {
+function translateChunkToAnthropicEvents(chunk, state, toolNameMapper = createAnthropicToolNameMapper(void 0)) {
 	const events$1 = [];
 	if (chunk.choices.length === 0) return events$1;
 	const choice = chunk.choices[0];
@@ -1793,10 +1872,11 @@ function translateChunkToAnthropicEvents(chunk, state) {
 				state.contentBlockIndex++;
 				state.contentBlockOpen = false;
 			}
+			const toolName = toolNameMapper.toAnthropic(toolCall.function.name);
 			const anthropicBlockIndex = state.contentBlockIndex;
 			state.toolCalls[toolCall.index] = {
 				id: toolCall.id,
-				name: toolCall.function.name,
+				name: toolName,
 				anthropicBlockIndex
 			};
 			events$1.push({
@@ -1805,7 +1885,7 @@ function translateChunkToAnthropicEvents(chunk, state) {
 				content_block: {
 					type: "tool_use",
 					id: toolCall.id,
-					name: toolCall.function.name,
+					name: toolName,
 					input: {}
 				}
 			});
@@ -2023,10 +2103,14 @@ messageRoutes.post("/", async (c) => {
 		if (error instanceof RateLimitError) return c.json({ error: { message: error.message } }, 429);
 		throw error;
 	}
-	const openAIPayload = translateToOpenAI(await c.req.json(), await getClaudeSettings());
+	const anthropicPayload = await c.req.json();
+	const claudeSettings = await getClaudeSettings();
+	const upstreamModel = translateModelName(anthropicPayload.model, claudeSettings);
+	const toolNameMapper = createAnthropicToolNameMapper(anthropicPayload.tools, { ...getToolNameMapperOptionsForModel(upstreamModel) });
+	const openAIPayload = translateToOpenAI(anthropicPayload, claudeSettings, toolNameMapper);
 	try {
 		const response = await createChatCompletions(config, openAIPayload, { client: "claude" });
-		if (isNonStreamingResponse(response)) return c.json(translateToAnthropic(response));
+		if (isNonStreamingResponse(response)) return c.json(translateToAnthropic(response, toolNameMapper));
 		return streamSSE(c, async (stream) => {
 			const streamState = {
 				messageStartSent: false,
@@ -2044,7 +2128,7 @@ messageRoutes.post("/", async (c) => {
 					} catch {
 						continue;
 					}
-					const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
+					const events$1 = translateChunkToAnthropicEvents(chunk, streamState, toolNameMapper);
 					for (const event of events$1) await stream.writeSSE({
 						event: event.type,
 						data: JSON.stringify(event)