Skip to content

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

fix(cliproxyapi): Anthropic-shape body routing and gate compatibility (#2165)

Anton704f686396f3
diff --git a/open-sse/executors/cliproxyapi.ts b/open-sse/executors/cliproxyapi.ts
index 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.ts
index 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"
+ );
+ });
+ });
});