@dondetir/ccmux 0.1.0

package/src/translate-request.ts

@@ -0,0 +1,142 @@
+import { mapModel, clampMaxTokens, resolveEffort } from "./models.js";
+import type { AnthropicBody, AnthropicMessage, TranslateFlags } from "./types.js";
+
+// Collapse an Anthropic system prompt (string | text-block[]) to a plain string.
+export function extractSystemText(system: AnthropicBody["system"]): string {
+  if (typeof system === "string") return system;
+  return (system ?? []).map((b: any) => b.text ?? "").join("\n");
+}
+
+// Last message carries a tool_result -> agent-initiated turn. Copilot accounts
+// these differently (X-Initiator header); shared by both request translators.
+export function isAgentTurn(messages: AnthropicMessage[] | undefined): boolean {
+  const last = messages?.[messages.length - 1];
+  return Array.isArray(last?.content) && last.content.some((b: any) => b.type === "tool_result");
+}
+
+// Anthropic Messages body -> OpenAI Chat Completions body.
+// Anthropic-only fields (cache_control, thinking, metadata, betas) are stripped
+// by construction: only known fields are copied onto fresh objects.
+export function anthropicToOpenAI(body: AnthropicBody): { payload: any; flags: TranslateFlags } {
+  const messages: any[] = [];
+  const flags: TranslateFlags = { vision: false, agent: false };
+
+  if (body.system) {
+    const sys = extractSystemText(body.system);
+    if (sys) messages.push({ role: "system", content: sys });
+  }
+
+  for (const msg of body.messages ?? []) {
+    if (typeof msg.content === "string") {
+      if (msg.content) messages.push({ role: msg.role, content: msg.content });
+      continue;
+    }
+    if (!Array.isArray(msg.content) || msg.content.length === 0) continue;
+
+    const parts: any[] = []; // text / image_url content parts
+    const toolCalls: any[] = [];
+    const toolMsgs: any[] = [];
+
+    for (const block of msg.content) {
+      switch (block.type) {
+        case "text":
+          parts.push({ type: "text", text: block.text });
+          break;
+        case "image":
+          flags.vision = true;
+          parts.push({
+            type: "image_url",
+            image_url: { url: `data:${block.source?.media_type};base64,${block.source?.data}` },
+          });
+          break;
+        case "tool_use":
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: { name: block.name, arguments: JSON.stringify(block.input ?? {}) },
+          });
+          break;
+        case "tool_result": {
+          const content = Array.isArray(block.content)
+            ? block.content
+                .filter((p: any) => p.type === "text")
+                .map((p: any) => p.text)
+                .join("\n")
+            : (block.content ?? "");
+          if (Array.isArray(block.content) && block.content.some((p: any) => p.type === "image"))
+            console.warn("tool_result image dropped (no OpenAI tool-message equivalent)");
+          toolMsgs.push({ role: "tool", tool_call_id: block.tool_use_id, content });
+          break;
+        }
+        default:
+          break; // thinking / redacted_thinking / unknown: drop
+      }
+    }
+
+    // OpenAI tool messages must directly follow the assistant tool_calls message.
+    messages.push(...toolMsgs);
+
+    const text = parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+    const hasImage = parts.some((p) => p.type === "image_url");
+    if (msg.role === "assistant") {
+      if (text || toolCalls.length) {
+        const m: any = { role: "assistant", content: text || null }; // null, not "" per OpenAI spec
+        if (toolCalls.length) m.tool_calls = toolCalls;
+        messages.push(m);
+      }
+    } else if (hasImage) {
+      messages.push({ role: msg.role, content: parts });
+    } else if (text) {
+      messages.push({ role: msg.role, content: text });
+    }
+  }
+
+  flags.agent = isAgentTurn(body.messages);
+
+  const model = mapModel(body.model ?? "");
+  const payload: any = {
+    model,
+    messages,
+    max_tokens: clampMaxTokens(model, body.max_tokens ?? 4096),
+  };
+  if (body.temperature !== undefined) payload.temperature = body.temperature;
+  if (body.stream) {
+    payload.stream = true;
+    payload.stream_options = { include_usage: true }; // omitting this leaves output_tokens at 0
+  }
+  if (body.stop_sequences?.length) payload.stop = body.stop_sequences;
+
+  // Keep only client tools; server tools (web_search_20250305, etc.) have no input_schema and 400 upstream.
+  const allTools = body.tools ?? [];
+  let tools = allTools.filter((t: any) => !t.type || t.type === "custom");
+  if (tools.length !== allTools.length)
+    console.warn(`dropped ${allTools.length - tools.length} server tool(s)`);
+  if (tools.length > 128) {
+    // OpenAI-format endpoint hard-caps tools at 128; Claude Code lists built-ins before MCP tools.
+    console.warn(`tool list capped at 128 (was ${tools.length}) for OpenAI-format upstream`);
+    tools = tools.slice(0, 128);
+  }
+  if (tools.length) {
+    payload.tools = tools.map((t: any) => ({
+      type: "function",
+      function: { name: t.name, description: t.description, parameters: t.input_schema },
+    }));
+  }
+
+  // Only forward reasoning_effort when the catalog confirms support; some Copilot
+  // endpoints 400 on unknown fields, and catalog absence means we can't confirm.
+  const effort = resolveEffort(model, body.output_config?.effort);
+  if (effort !== undefined) payload.reasoning_effort = effort;
+
+  if (body.tool_choice && tools.length) {
+    const tc = body.tool_choice;
+    payload.tool_choice =
+      tc.type === "any"
+        ? "required"
+        : tc.type === "tool"
+          ? { type: "function", function: { name: tc.name } }
+          : "auto";
+  }
+
+  return { payload, flags };
+}

package/src/translate-response.ts

@@ -0,0 +1,39 @@
+import { mapStopReason, THINKING_SIG } from "./models.js";
+
+// OpenAI Chat Completions response -> Anthropic Messages response (non-streaming).
+export function openAIToAnthropic(data: any) {
+  const choice = data.choices?.[0] ?? { message: {} };
+  const content: any[] = [];
+  // Ollama thinking models return chain-of-thought in message.reasoning; map to
+  // an Anthropic thinking block with a placeholder signature, ahead of the text.
+  if (choice.message?.reasoning)
+    content.push({ type: "thinking", thinking: choice.message.reasoning, signature: THINKING_SIG });
+  if (choice.message?.content) content.push({ type: "text", text: choice.message.content });
+  for (const tc of choice.message?.tool_calls ?? []) {
+    let parsedInput: any = {};
+    try {
+      parsedInput = JSON.parse(tc.function.arguments || "{}");
+    } catch {
+      console.warn(`ccmux: failed to parse tool_call arguments for ${tc.function?.name}; using {}`);
+    }
+    content.push({
+      type: "tool_use",
+      id: tc.id,
+      name: tc.function.name,
+      input: parsedInput,
+    });
+  }
+  return {
+    id: data.id ?? "msg_unknown",
+    type: "message",
+    role: "assistant",
+    model: data.model ?? "",
+    content,
+    stop_reason: mapStopReason(choice.finish_reason ?? null),
+    stop_sequence: null,
+    usage: {
+      input_tokens: data.usage?.prompt_tokens ?? 0,
+      output_tokens: data.usage?.completion_tokens ?? 0,
+    },
+  };
+}

package/src/translate-responses.ts

@@ -0,0 +1,252 @@
+import { mapModel, clampMaxTokens, resolveEffort } from "./models.js";
+import { extractSystemText } from "./translate-request.js";
+import type { AnthropicBody } from "./types.js";
+
+// Thrown for fields that have no /responses equivalent and must not be silently dropped. Caller returns HTTP 400.
+export class ResponsesApiUnsupported extends Error {
+  constructor(msg: string) {
+    super(msg);
+    this.name = "ResponsesApiUnsupported";
+  }
+}
+
+// Anthropic Messages body -> OpenAI Responses API body (POST .../responses).
+// Key differences from Chat Completions: input[] not messages[], instructions not
+// system, max_output_tokens, flat tool schema, tool_result -> function_call_output,
+// reasoning.effort not reasoning_effort.
+export function anthropicToResponses(body: AnthropicBody): any {
+  if (body.stop_sequences?.length) {
+    throw new ResponsesApiUnsupported(
+      "stop_sequences is not supported by /responses models; remove it or use a different model",
+    );
+  }
+
+  if ((body as any).top_k !== undefined) {
+    console.warn("ccmux: top_k has no /responses equivalent and will be dropped");
+  }
+
+  const model = mapModel(body.model ?? "");
+  const input: any[] = [];
+
+  const systemText = extractSystemText(body.system);
+
+  // Consecutive text blocks from the same role merge into one input item;
+  // function_call and function_call_output are standalone items (Responses API
+  // infers role from item type for those).
+  for (const msg of body.messages ?? []) {
+    if (typeof msg.content === "string") {
+      if (msg.content) input.push({ role: msg.role, content: msg.content });
+      continue;
+    }
+    if (!Array.isArray(msg.content) || msg.content.length === 0) continue;
+
+    let pendingText = ""; // accumulated text for the current role
+
+    const flushText = () => {
+      if (pendingText) {
+        input.push({ role: msg.role, content: pendingText });
+        pendingText = "";
+      }
+    };
+
+    for (const block of msg.content) {
+      switch (block.type) {
+        case "text":
+          pendingText += block.text ?? "";
+          break;
+
+        case "tool_use":
+          flushText();
+          // id = item id for streaming delta routing; call_id = the Anthropic tool_use id.
+          // Responses API preserves whatever call_id you provide, including toolu_* ids.
+          input.push({
+            type: "function_call",
+            id: block.id,
+            call_id: block.id,
+            name: block.name,
+            arguments: JSON.stringify(block.input ?? {}),
+          });
+          break;
+
+        case "tool_result":
+          flushText();
+          // call_id maps 1:1 to tool_use_id; Responses API is stateless and never reassigns call_ids.
+          {
+            let outputText: string;
+            if (Array.isArray(block.content)) {
+              let hasImage = false;
+              const parts: string[] = [];
+              for (const p of block.content) {
+                if (p.type === "text") parts.push(p.text ?? "");
+                else if (p.type === "image") hasImage = true;
+              }
+              if (hasImage)
+                console.warn(
+                  "ccmux: tool_result image content dropped; function_call_output only accepts string output",
+                );
+              outputText = parts.join("\n");
+            } else {
+              outputText = block.content ?? "";
+            }
+            if (block.is_error) outputText = "[tool_error] " + outputText;
+            input.push({
+              type: "function_call_output",
+              call_id: block.tool_use_id,
+              output: outputText,
+            });
+          }
+          break;
+
+        case "image": {
+          flushText(); // flush before image so it appears in its own input item
+          const src = block.source;
+          if (src?.type === "url") {
+            input.push({ role: msg.role, content: [{ type: "input_image", image_url: src.url }] });
+          } else if (src?.type === "base64") {
+            const dataUrl = `data:${src.media_type};base64,${src.data}`;
+            input.push({ role: msg.role, content: [{ type: "input_image", image_url: dataUrl }] });
+          } else {
+            console.warn("ccmux: unsupported image source type; image block dropped");
+          }
+          break;
+        }
+
+        case "thinking":
+        case "redacted_thinking":
+          break; // no /responses equivalent; drop
+
+        default:
+          break;
+      }
+    }
+
+    flushText();
+  }
+
+  const payload: any = {
+    model,
+    input,
+    max_output_tokens: clampMaxTokens(model, body.max_tokens ?? 4096),
+  };
+
+  if (systemText) payload.instructions = systemText;
+  if (body.stream) payload.stream = true;
+  if (body.temperature !== undefined) payload.temperature = body.temperature;
+  if ((body as any).top_p !== undefined) payload.top_p = (body as any).top_p;
+
+  // Tool schema is flat (no function wrapper); parameters renamed from input_schema.
+  const allTools = body.tools ?? [];
+  const tools = allTools.filter((t: any) => !t.type || t.type === "custom");
+  if (tools.length !== allTools.length) {
+    console.warn(
+      `ccmux: dropped ${allTools.length - tools.length} server tool(s) for /responses`,
+    );
+  }
+  if (tools.length) {
+    payload.tools = tools.map((t: any) => ({
+      type: "function",
+      name: t.name,
+      description: t.description,
+      parameters: t.input_schema,
+    }));
+  }
+
+  // tool_choice: Anthropic {type:"auto"|"any"|"tool",name?} -> Responses API "auto"|"required"|{type:"function",name}.
+  const tc = (body as any).tool_choice;
+  if (tc) {
+    if (tc.type === "auto") {
+      payload.tool_choice = "auto";
+    } else if (tc.type === "any") {
+      payload.tool_choice = "required";
+    } else if (tc.type === "tool" && tc.name) {
+      payload.tool_choice = { type: "function", name: tc.name };
+    } else if (tc.type === "none") {
+      payload.tool_choice = "none";
+    }
+  }
+
+  // Effort maps to reasoning.effort (nested object, unlike Chat Completions reasoning_effort).
+  const effort = resolveEffort(model, body.output_config?.effort);
+  if (effort !== undefined) payload.reasoning = { effort };
+
+  return payload;
+}
+
+// Maps Responses API status + incomplete_details to an Anthropic stop_reason.
+export function responsesStatusToStopReason(
+  status: string | undefined,
+  incompleteDetails?: { reason?: string },
+): string {
+  if (incompleteDetails?.reason === "max_output_tokens") return "max_tokens";
+  // "failed" maps to "end_turn" because "error" is not a valid Anthropic stop_reason;
+  // upstream sends failed status in-band, not as an HTTP error.
+  const map: Record<string, string> = { completed: "end_turn", incomplete: "max_tokens", failed: "end_turn" };
+  return map[status ?? ""] ?? "end_turn";
+}
+
+// Non-streaming: OpenAI Responses API response -> Anthropic Messages response.
+export function translateResponsesResponse(res: any): any {
+  const content: any[] = [];
+
+  for (const item of res.output ?? []) {
+    switch (item.type) {
+      case "message":
+        for (const part of item.content ?? []) {
+          if (part.type === "output_text") {
+            content.push({ type: "text", text: part.text });
+          } else if (part.type === "refusal") {
+            content.push({ type: "text", text: part.refusal });
+          }
+        }
+        break;
+
+      case "function_call":
+        {
+          let parsedInput: any = {};
+          try {
+            parsedInput = JSON.parse(item.arguments ?? "{}");
+          } catch {
+            console.warn(
+              `ccmux: failed to parse function_call arguments for ${item.name}; using {}`,
+            );
+          }
+          content.push({
+            type: "tool_use",
+            id: item.call_id,
+            name: item.name,
+            input: parsedInput,
+          });
+        }
+        break;
+
+      case "reasoning":
+        break; // no Anthropic equivalent; drop
+
+      default:
+        break;
+    }
+  }
+
+  let stopReason = responsesStatusToStopReason(res.status, res.incomplete_details);
+  // Override to "tool_use" so Claude Code enters the tool-execution loop.
+  if (
+    res.status === "completed" &&
+    !res.incomplete_details &&
+    content.some((b: any) => b.type === "tool_use")
+  ) {
+    stopReason = "tool_use";
+  }
+
+  return {
+    id: res.id ?? "msg_" + Date.now(),
+    type: "message",
+    role: "assistant",
+    content,
+    stop_reason: stopReason,
+    stop_sequence: null,
+    usage: {
+      input_tokens: res.usage?.input_tokens ?? 0, // Responses API already uses Anthropic-compatible field names
+      output_tokens: res.usage?.output_tokens ?? 0,
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,30 @@
+// Shared types. Kept loose on purpose: the proxy passes through fields it
+// doesn't understand and strips the ones upstream rejects (allowed-field rule).
+
+export interface AnthropicContentBlock {
+  type: string; // text | image | tool_use | tool_result | thinking | redacted_thinking
+  [key: string]: any;
+}
+
+export interface AnthropicMessage {
+  role: "user" | "assistant";
+  content: string | AnthropicContentBlock[];
+}
+
+export interface AnthropicBody {
+  model: string;
+  max_tokens: number;
+  messages: AnthropicMessage[];
+  system?: string | AnthropicContentBlock[];
+  tools?: any[];
+  tool_choice?: { type: string; name?: string };
+  stop_sequences?: string[];
+  temperature?: number;
+  stream?: boolean;
+  [key: string]: any;
+}
+
+export interface TranslateFlags {
+  vision: boolean; // any image block present -> Copilot-Vision-Request header
+  agent: boolean;  // last message contains a tool_result -> X-Initiator: agent
+}

package/src/upstream.ts

@@ -0,0 +1,107 @@
+import "./env.js"; // load .env BEFORE any env reads below
+import { getCopilotToken } from "./token.js";
+import type { TranslateFlags } from "./types.js";
+
+export const PORT = Number(process.env.PORT ?? 4141);
+
+// Set USE_NATIVE=1 to use Path A (native pass-through). Default uses translation.
+export const USE_NATIVE = process.env.USE_NATIVE === "1";
+
+// ⚠️ UNOFFICIAL — not in GitHub's public API docs. Community defaults.
+// Env-overridable so tests can point at a mock upstream.
+export const TOKEN_EXCHANGE_URL =
+  process.env.TOKEN_EXCHANGE_URL ?? "https://api.github.com/copilot_internal/v2/token";
+// Live plan/quota snapshot (token_based_billing, quota_snapshots, reset date).
+export const COPILOT_USER_URL =
+  process.env.COPILOT_USER_URL ?? "https://api.github.com/copilot_internal/user";
+export const COPILOT_BASE = process.env.COPILOT_BASE ?? "https://api.githubcopilot.com";
+
+// Ollama Cloud: OpenAI-compatible backend, static API key (no exchange/expiry).
+// Empty key = Ollama disabled.
+export const OLLAMA_BASE = process.env.OLLAMA_BASE ?? "https://ollama.com/v1";
+// Lazy read so a key saved by `ccmux login` is picked up without a module reload.
+export const ollamaKey = (): string => process.env.OLLAMA_API_KEY ?? "";
+
+// Client-identity headers Copilot's backend expects. Versions drift; if you get
+// a 4xx that mentions editor/version, bump these.
+export const COPILOT_HEADERS: Record<string, string> = {
+  "Copilot-Integration-Id": "vscode-chat",
+  "Editor-Version": "vscode/1.99.0",
+  "Editor-Plugin-Version": "copilot-chat/0.26.0",
+  "User-Agent": "GitHubCopilotChat/0.26.0",
+  "Openai-Intent": "conversation-panel",
+  "Content-Type": "application/json",
+};
+
+// Path B: send an OpenAI-format body to the chat endpoint.
+export async function callCopilot(
+  openaiBody: unknown,
+  flags: Partial<TranslateFlags> = {},
+  provider: "copilot" | "ollama" = "copilot",
+): Promise<Response> {
+  // Strip the `ollama/` namespace prefix before sending on the wire.
+  if (provider === "ollama") {
+    const body = openaiBody as any;
+    const wire = { ...body, model: String(body.model ?? "").replace(/^ollama\//, "") };
+    return fetch(`${OLLAMA_BASE}/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${ollamaKey()}` },
+      body: JSON.stringify(wire),
+    });
+  }
+  const bearer = await getCopilotToken();
+  const headers: Record<string, string> = { ...COPILOT_HEADERS, Authorization: `Bearer ${bearer}` };
+  headers["X-Initiator"] = flags.agent ? "agent" : "user";
+  if (flags.vision) headers["Copilot-Vision-Request"] = "true";
+  return fetch(`${COPILOT_BASE}/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(openaiBody),
+  });
+}
+
+// Path A: forward the Anthropic body unchanged to Copilot's native endpoint.
+export async function callCopilotNative(anthropicBody: unknown): Promise<Response> {
+  const bearer = await getCopilotToken();
+  return fetch(`${COPILOT_BASE}/v1/messages`, {
+    method: "POST",
+    headers: {
+      ...COPILOT_HEADERS,
+      Authorization: `Bearer ${bearer}`,
+      "anthropic-version": "2023-06-01",
+    },
+    body: JSON.stringify(anthropicBody),
+  });
+}
+
+// Path C: Responses API. Endpoint is /responses (no /v1 prefix); returns 400
+// model_not_supported on free tier, not 404.
+export async function callCopilotResponses(responsesBody: unknown): Promise<Response> {
+  const bearer = await getCopilotToken();
+  return fetch(`${COPILOT_BASE}/responses`, {
+    method: "POST",
+    headers: { ...COPILOT_HEADERS, Authorization: `Bearer ${bearer}` },
+    body: JSON.stringify(responsesBody),
+  });
+}
+
+// Proxy to the native count endpoint; returns null so the caller uses a local
+// estimate. The route must never 404.
+export async function countTokensUpstream(anthropicBody: unknown): Promise<number | null> {
+  try {
+    const bearer = await getCopilotToken();
+    const res = await fetch(`${COPILOT_BASE}/v1/messages/count_tokens`, {
+      method: "POST",
+      headers: {
+        ...COPILOT_HEADERS,
+        Authorization: `Bearer ${bearer}`,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify(anthropicBody),
+    });
+    if (res.ok) return ((await res.json()) as any).input_tokens ?? null;
+  } catch {
+    /* fall through to local estimate */
+  }
+  return null;
+}