Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
fix(cliproxyapi): Anthropic-shape body routing and gate compatibility (#2165)
Anton704f686396f3
diff --git a/open-sse/executors/cliproxyapi.ts b/open-sse/executors/cliproxyapi.tsindex 69e2f05bb8..601d100e03 100644--- a/open-sse/executors/cliproxyapi.ts+++ b/open-sse/executors/cliproxyapi.ts@@ -27,6 +27,91 @@ const DEFAULT_PORT = 8317;const DEFAULT_HOST = "127.0.0.1";const HEALTH_CHECK_TIMEOUT_MS = 5000;+// Anthropic's reserved tool-name namespace: ^mcp_[^_].* triggers their+// server-side MCP connector billing gate, returning a misleading+// "out of extra usage" 400. Two-underscore (mcp__X) and capitalized+// (Mcp_X) variants pass cleanly.+const MCP_RESERVED_PREFIX_RE = /^mcp_(?=[^_])/;++function rewriteMcpToolName(name: string): string | null {+ if (typeof name !== "string" || !MCP_RESERVED_PREFIX_RE.test(name)) return null;+ return "M" + name.slice(1); // mcp_call → Mcp_call+}++/**+ * Rewrite ^mcp_[^_] tool names on a body destined for Anthropic's+ * /v1/messages. Returns a reverse map (rewritten → original) that the SSE+ * response stream uses to restore the client's original names on tool_use+ * blocks coming back.+ *+ * Non-mutating: replaces nested array elements with cloned objects rather+ * than mutating in place, so the caller's input body is not affected. The+ * outer `body` reference itself is the cloned `transformed` object from+ * `transformRequest` — we mutate its top-level `tools`, `messages`, and+ * `tool_choice` properties to point at the new clones.+ */+function applyMcpToolNameRewrite(body: Record<string, unknown>): Map<string, string> {+ const reverseMap = new Map<string, string>();+ const remember = (original: string, rewritten: string) => {+ reverseMap.set(rewritten, original);+ };++ const tools = body.tools;+ if (Array.isArray(tools)) {+ body.tools = tools.map((tool) => {+ if (!tool || typeof tool !== "object") return tool;+ const t = tool as Record<string, unknown>;+ const original = typeof t.name === "string" ? t.name : "";+ const rewritten = rewriteMcpToolName(original);+ if (rewritten) {+ remember(original, rewritten);+ return { ...t, name: rewritten };+ }+ return tool;+ });+ }++ const messages = body.messages;+ if (Array.isArray(messages)) {+ body.messages = messages.map((msg) => {+ if (!msg || typeof msg !== "object") return msg;+ const m = msg as Record<string, unknown>;+ const content = m.content;+ if (!Array.isArray(content)) return msg;+ let mutated = false;+ const newContent = content.map((block) => {+ if (!block || typeof block !== "object") return block;+ const b = block as Record<string, unknown>;+ if (b.type !== "tool_use") return block;+ const original = typeof b.name === "string" ? b.name : "";+ const rewritten = rewriteMcpToolName(original);+ if (rewritten) {+ mutated = true;+ remember(original, rewritten);+ return { ...b, name: rewritten };+ }+ return block;+ });+ return mutated ? { ...m, content: newContent } : msg;+ });+ }++ const toolChoice = body.tool_choice;+ if (toolChoice && typeof toolChoice === "object") {+ const tc = toolChoice as Record<string, unknown>;+ if (tc.type === "tool" && typeof tc.name === "string") {+ const rewritten = rewriteMcpToolName(tc.name);+ if (rewritten) {+ const original = tc.name;+ body.tool_choice = { ...tc, name: rewritten };+ remember(original, rewritten);+ }+ }+ }++ return reverseMap;+}+function resolveCliproxyapiBaseUrl(): string {const host = process.env.CLIPROXYAPI_HOST || DEFAULT_HOST;const port = parseInt(process.env.CLIPROXYAPI_PORT || String(DEFAULT_PORT), 10);@@ -64,11 +149,48 @@ export class CliproxyapiExecutor extends BaseExecutor {_urlIndex = 0,_credentials: ProviderCredentials | null = null): string {- // Always OpenAI-compatible. CLIProxyAPI detects Claude models internally- // and applies full emulation (CCH, billing header, system prompt, uTLS).+ // Default endpoint when called without body context (kept for back-compat).+ // execute() picks the right endpoint from the body shape; see selectEndpoint().return `${this.upstreamBaseUrl}/v1/chat/completions`;}+ /**+ * Returns true when the body matches the Anthropic Messages wire shape.+ *+ * chatCore detects target=claude when the request comes from a Claude-source+ * client (`/v1/messages`, Anthropic-version header, claude/* model). In that+ * case no openai translation is applied and the executor sees the original+ * Anthropic body: top-level `system` as an array of content blocks, and+ * `messages[].content` as arrays. Routing those bodies to CPA's+ * /v1/chat/completions causes CPA to emit OpenAI-style SSE chunks, which+ * Anthropic SDK clients (Capy, claude-cli, etc.) cannot parse — the result+ * looks like a 200 server-side with "0 chunks received" client-side.+ *+ * CPA exposes /v1/messages natively (claude executor with uTLS spoof,+ * billing header, CCH signing, etc.) and emits proper Anthropic SSE:+ * `event: message_start`, `content_block_delta`, etc.+ */+ private isAnthropicShape(body: unknown): boolean {+ if (!body || typeof body !== "object") return false;+ const b = body as Record<string, unknown>;+ // Strong signal: top-level `system` field is unique to the Anthropic+ // Messages API. OpenAI Chat Completions encodes system as a role:"system"+ // entry inside messages[], not at body level. Accept both string and+ // array-of-content-blocks forms (Anthropic supports both per the docs).+ if (b.system !== undefined) return true;+ // Strong signal: messages[0].content is an array of Anthropic content blocks+ const msgs = b.messages;+ if (Array.isArray(msgs) && msgs.length > 0) {+ const first = msgs[0] as Record<string, unknown>;+ if (Array.isArray(first?.content)) return true;+ }+ return false;+ }++ private selectEndpoint(body: unknown): string {+ return this.isAnthropicShape(body) ? "/v1/messages" : "/v1/chat/completions";+ }+buildHeaders(credentials: ProviderCredentials | null, stream = true): Record<string, string> {const key = credentials?.apiKey || credentials?.accessToken;@@ -99,6 +221,59 @@ export class CliproxyapiExecutor extends BaseExecutor {transformed.model = model;}+ // For Anthropic-shape bodies routed to CPA's /v1/messages, strip the+ // Capy/Anthropic-SDK premium extras that Anthropic gates with+ // "Extra usage is required" / "out of extra usage" (400). CPA does its+ // own Claude Code wire-image cloak (CCH, billing header, uTLS, metadata+ // user_id, system sentinel) downstream — but it forwards client extras+ // like output_config.effort=xhigh which trigger the extras-billing gate.+ //+ // Mirrors the runtime "Patch I2/I4" effect previously applied via patch.mjs.+ // Strips are no-op when fields are absent (OpenAI-shape passthrough).+ if (this.isAnthropicShape(transformed)) {+ delete transformed.output_config;+ delete transformed.context_management;+ delete transformed.client_info;+ delete transformed.prompt_cache_key;+ delete transformed.safety_identifier;+ delete transformed.metadata;++ // Conditional thinking strip: preserve Anthropic-valid shapes+ // ({type:"enabled"|"disabled", budget_tokens:N}) that applyThinkingBudget+ // already normalized. Strip non-Anthropic shapes (e.g. Capy's+ // {type:"adaptive", display:"summarized"}) which trigger Anthropic 400+ // "Extra usage required" / "out of extra usage". The `display` field is+ // a Capy-specific hint Anthropic doesn't accept.+ const thinking = transformed.thinking;+ if (thinking && typeof thinking === "object") {+ const t = thinking as Record<string, unknown>;+ const validType = t.type === "enabled" || t.type === "disabled";+ const hasValidBudget = typeof t.budget_tokens === "number" && t.budget_tokens >= 0;+ const hasInvalidExtras = "display" in t;+ if (!validType || !hasValidBudget || hasInvalidExtras) {+ delete transformed.thinking;+ }+ }++ // Rewrite tool names matching Anthropic's reserved ^mcp_[^_] namespace.+ // Anthropic returns "out of extra usage" / "Extra usage required" 400+ // when a client-declared tool name collides with their server-side MCP+ // connector tools. Bisected character-by-character against the real+ // Anthropic API via CPA (uTLS spoof, Claude OAuth):+ // mcp_call, mcp_query, mcp_x, mcp_test → 400 (gate hit)+ // Mcp_call, _mcp_call, mcp__call, mcp-call, mcpcall, my_mcp_call → 200+ // The "Mcp_" capitalization is the smallest stable rewrite that+ // preserves readability. The reverse map below is propagated to+ // chatCore via body._toolNameMap, which the SSE passthrough stream+ // uses (utils/stream.ts:restoreClaudePassthroughToolUseName) to+ // rewrite tool_use.name back to the client's original namespace on+ // the response side. Capy sees mcp_call back in tool_use blocks.+ const toolNameMap = applyMcpToolNameRewrite(transformed);+ if (toolNameMap.size > 0) {+ transformed._toolNameMap = toolNameMap;+ }+ }+return transformed;}@@ -111,7 +286,9 @@ export class CliproxyapiExecutor extends BaseExecutor {log?: any;upstreamExtraHeaders?: Record<string, string> | null;}) {- const url = this.buildUrl(input.model, input.stream, 0, input.credentials);+ const endpoint = this.selectEndpoint(input.body);+ const url = `${this.upstreamBaseUrl}${endpoint}`;+ const shape = endpoint === "/v1/messages" ? "anthropic" : "openai";const headers = this.buildHeaders(input.credentials, input.stream);const transformedBody = this.transformRequest(input.model,@@ -126,12 +303,21 @@ export class CliproxyapiExecutor extends BaseExecutor {? mergeAbortSignals(input.signal, timeoutSignal): timeoutSignal;- input.log?.info?.("CPA", `CLIProxyAPI → ${url} (model: ${input.model})`);+ input.log?.info?.("CPA", `CLIProxyAPI → ${url} (model: ${input.model}, shape: ${shape})`);++ // _toolNameMap is an in-memory channel to chatCore for response-side+ // tool name restoration; never send it over the wire.+ const wireBody =+ transformedBody && typeof transformedBody === "object"+ ? JSON.stringify(transformedBody, (key, value) =>+ key === "_toolNameMap" ? undefined : value+ )+ : JSON.stringify(transformedBody);const response = await fetch(url, {method: "POST",headers,- body: JSON.stringify(transformedBody),+ body: wireBody,signal: combinedSignal,});diff --git a/tests/unit/cliproxyapi-executor.test.ts b/tests/unit/cliproxyapi-executor.test.tsindex cc37ccb8a3..0d65bf2431 100644--- a/tests/unit/cliproxyapi-executor.test.ts+++ b/tests/unit/cliproxyapi-executor.test.ts@@ -129,6 +129,65 @@ describe("CliproxyapiExecutor", () => {const result = exec.transformRequest("model", null, true, {});assert.equal(result, null);});++ it("preserves Anthropic-valid thinking shape on /v1/messages routing", () => {+ const exec = new CliproxyapiExecutor();+ const body = {+ model: "claude-opus-4-7",+ system: [{ type: "text", text: "Be helpful" }],+ messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],+ thinking: { type: "enabled", budget_tokens: 10240 },+ };+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ assert.deepEqual(result.thinking, { type: "enabled", budget_tokens: 10240 });+ });++ it("preserves disabled thinking shape on /v1/messages routing", () => {+ const exec = new CliproxyapiExecutor();+ const body = {+ model: "claude-opus-4-7",+ system: [{ type: "text", text: "x" }],+ messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],+ thinking: { type: "disabled", budget_tokens: 0 },+ };+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ assert.deepEqual(result.thinking, { type: "disabled", budget_tokens: 0 });+ });++ it("strips Capy-style adaptive thinking on /v1/messages routing", () => {+ const exec = new CliproxyapiExecutor();+ const body = {+ model: "claude-opus-4-7",+ system: [{ type: "text", text: "x" }],+ messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],+ thinking: { type: "adaptive", display: "summarized" },+ };+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ assert.equal(result.thinking, undefined);+ });++ it("strips thinking carrying display field even with enabled type", () => {+ const exec = new CliproxyapiExecutor();+ const body = {+ model: "claude-opus-4-7",+ system: [{ type: "text", text: "x" }],+ messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],+ thinking: { type: "enabled", budget_tokens: 10240, display: "summarized" },+ };+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ assert.equal(result.thinking, undefined);+ });++ it("does not touch thinking on OpenAI-shape bodies", () => {+ const exec = new CliproxyapiExecutor();+ const body = {+ model: "gpt-5.5",+ messages: [{ role: "user", content: "hi" }],+ thinking: { type: "adaptive", display: "summarized" },+ };+ const result = exec.transformRequest("gpt-5.5", body, true, {});+ assert.deepEqual(result.thinking, { type: "adaptive", display: "summarized" });+ });});describe("execute", () => {@@ -229,4 +288,183 @@ describe("CliproxyapiExecutor", () => {assert.ok(result.transformedBody);});});++ describe("Anthropic-shape detection", () => {+ it("detects Anthropic-shape when top-level system field present", () => {+ const exec = new CliproxyapiExecutor();+ const body = {+ model: "claude-opus-4-7",+ system: [{ type: "text", text: "You are helpful" }],+ messages: [{ role: "user", content: "hi" }],+ };+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ // Anthropic-shape: system field stripped (Capy extras behavior) vs preserved+ // The key assertion is that it does NOT try to send to /v1/chat/completions path+ // (verified by output_config being stripped when present)+ assert.equal(result.system !== undefined || result.messages !== undefined, true);+ });++ it("detects Anthropic-shape when messages[0].content is an array (no system field)", () => {+ const exec = new CliproxyapiExecutor();+ const body = {+ model: "claude-opus-4-7",+ messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],+ output_config: { effort: "max" },+ };+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ assert.equal(+ result.output_config,+ undefined,+ "output_config should be stripped for Anthropic-shape"+ );+ });++ it("treats OpenAI-shape (string content, no system) as non-Anthropic passthrough", () => {+ const exec = new CliproxyapiExecutor();+ const body = {+ model: "gpt-5.5",+ messages: [{ role: "user", content: "hi" }],+ output_config: { effort: "max" },+ };+ const result = exec.transformRequest("gpt-5.5", body, true, {});+ assert.deepEqual(+ result.output_config,+ { effort: "max" },+ "output_config preserved for OpenAI-shape"+ );+ });+ });++ describe("Capy extras strip on Anthropic-shape bodies", () => {+ function anthropicBody(extras: Record<string, unknown>) {+ return {+ model: "claude-opus-4-7",+ system: [{ type: "text", text: "x" }],+ messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],+ ...extras,+ };+ }++ it("strips output_config", () => {+ const exec = new CliproxyapiExecutor();+ const result = exec.transformRequest(+ "claude-opus-4-7",+ anthropicBody({ output_config: { effort: "max" } }),+ true,+ {}+ );+ assert.equal(result.output_config, undefined);+ });++ it("strips metadata", () => {+ const exec = new CliproxyapiExecutor();+ const result = exec.transformRequest(+ "claude-opus-4-7",+ anthropicBody({ metadata: { user_id: "abc" } }),+ true,+ {}+ );+ assert.equal(result.metadata, undefined);+ });++ it("strips client_info", () => {+ const exec = new CliproxyapiExecutor();+ const result = exec.transformRequest(+ "claude-opus-4-7",+ anthropicBody({ client_info: { name: "Capy" } }),+ true,+ {}+ );+ assert.equal(result.client_info, undefined);+ });++ it("strips prompt_cache_key", () => {+ const exec = new CliproxyapiExecutor();+ const result = exec.transformRequest(+ "claude-opus-4-7",+ anthropicBody({ prompt_cache_key: "key123" }),+ true,+ {}+ );+ assert.equal(result.prompt_cache_key, undefined);+ });++ it("strips safety_identifier", () => {+ const exec = new CliproxyapiExecutor();+ const result = exec.transformRequest(+ "claude-opus-4-7",+ anthropicBody({ safety_identifier: "sid" }),+ true,+ {}+ );+ assert.equal(result.safety_identifier, undefined);+ });+ });++ describe("mcp_ tool name rewrite on Anthropic-shape bodies", () => {+ function anthropicBodyWithTools(tools: unknown[], messages: unknown[] = []) {+ return {+ model: "claude-opus-4-7",+ system: [{ type: "text", text: "x" }],+ tools,+ messages:+ messages.length > 0+ ? messages+ : [{ role: "user", content: [{ type: "text", text: "hi" }] }],+ };+ }++ it("rewrites mcp_* tool definition names (tool defs)", () => {+ const exec = new CliproxyapiExecutor();+ const body = anthropicBodyWithTools([+ { name: "mcp_filesystem_read", description: "Read file", input_schema: {} },+ ]);+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ const toolName = (result.tools as Array<{ name: string }>)[0].name;+ assert.notEqual(toolName, "mcp_filesystem_read", "mcp_ tool name should be rewritten");+ assert.match(+ toolName,+ /^[A-Z]/,+ "rewritten name should start with uppercase or differ from mcp_"+ );+ });++ it("does not rewrite non-mcp_ tool names", () => {+ const exec = new CliproxyapiExecutor();+ const body = anthropicBodyWithTools([+ { name: "my_tool", description: "My tool", input_schema: {} },+ ]);+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ const toolName = (result.tools as Array<{ name: string }>)[0].name;+ assert.equal(toolName, "my_tool");+ });++ it("rewrites mcp_* tool_use names in assistant message history", () => {+ const exec = new CliproxyapiExecutor();+ const body = anthropicBodyWithTools(+ [{ name: "mcp_github_create_issue", description: "d", input_schema: {} }],+ [+ {+ role: "assistant",+ content: [{ type: "tool_use", id: "tu_1", name: "mcp_github_create_issue", input: {} }],+ },+ { role: "user", content: [{ type: "tool_result", tool_use_id: "tu_1", content: "ok" }] },+ ]+ );+ const result = exec.transformRequest("claude-opus-4-7", body, true, {});+ const assistantMsg = (result.messages as Array<{ role: string; content: unknown[] }>).find(+ (m) => m.role === "assistant"+ );+ const toolUseBlock = assistantMsg?.content.find(+ (b): b is { type: string; name: string } =>+ typeof b === "object" && b !== null && (b as Record<string, unknown>).type === "tool_use"+ );+ assert.ok(toolUseBlock, "tool_use block should exist in assistant message");+ assert.notEqual(+ toolUseBlock.name,+ "mcp_github_create_issue",+ "tool_use name should be rewritten"+ );+ });+ });});