copilot-reverse 0.0.2 → 0.2.0

package/README.md

@@ -87,13 +87,13 @@ health, request volume, and (most useful) recent **errors with their real messag
 
 Already have something that speaks OpenAI or Anthropic? Point it here:
 
-- **OpenAI-compatible:** `http://127.0.0.1:7891/v1`
-- **Anthropic-compatible:** `http://127.0.0.1:7891`
+- **OpenAI-compatible:** `http://127.0.0.1:7891/openai`
+- **Anthropic-compatible:** `http://127.0.0.1:7891/anthropic`
 
 Any API key value works locally (it's your machine). Example:
 
 ```bash
-export ANTHROPIC_BASE_URL=http://127.0.0.1:7891
+export ANTHROPIC_BASE_URL=http://127.0.0.1:7891/anthropic
 export ANTHROPIC_API_KEY=local
 claude
 ```
@@ -159,8 +159,8 @@ Three processes, one terminal app:
 - **TUI** (Ink) — the `copilot-reverse` process: REPL + slash commands + a claude-agent-sdk
   assistant (which dogfoods copilot-reverse's own Anthropic endpoint).
 - **Supervisor** (:7890) — control API + SQLite + self-healing worker supervision.
-- **Worker** (:7891) — OpenAI `/v1/chat/completions` + Anthropic `/v1/messages` → Copilot,
-  with tool-use translation both ways.
+- **Worker** (:7891) — OpenAI `/openai/chat/completions` + Anthropic `/anthropic/v1/messages` → Copilot,
+  with tool-use translation both ways. Each protocol also serves a `…/models` discovery endpoint.
 
 ## Development
 

package/dist/cli/index.js

@@ -21,6 +21,7 @@ import { applyCodexToml } from "../tui/setup/codex-toml.js";
 import { claudeCopilotReverseEnv } from "../tui/setup/clients.js";
 import { dataDir } from "../shared/paths.js";
 import { defaultConfig } from "../shared/config.js";
+import { APP_VERSION } from "../version.js";
 const delay = (ms) => new Promise((r) => setTimeout(r, ms));
 const DEFAULT_MODEL = "gpt-4o"; // a valid Copilot model id; pass-through routing uses it as-is
 // Conservative context budget that drives the assistant's auto-compaction. Sized below the
@@ -49,6 +50,10 @@ async function launchTui() {
     const base = `http://${cfg.bindHost}:${cfg.supervisorPort}`;
     const client = new DaemonClient(base);
     const workerBase = `http://${cfg.bindHost}:${cfg.workerPort}`;
+    // Per-protocol base URLs the worker now serves under: OpenAI clients -> /openai/*,
+    // Anthropic clients (and the assistant's own dogfood SDK) -> /anthropic/*.
+    const openaiBase = `${workerBase}/openai`;
+    const anthropicBase = `${workerBase}/anthropic`;
     const endpoint = { host: cfg.bindHost, port: cfg.workerPort, apiKey: "copilot-reverse-local" };
     let app;
     const quit = () => { stopSupervisor?.(); app?.unmount(); process.exit(0); };
@@ -66,7 +71,7 @@ async function launchTui() {
     const registry = buildRegistry({ client, quit }, endpoint, {
         dashboardUrl: `http://${cfg.bindHost}:${cfg.supervisorPort}/`,
         reportRepo: cfg.reportRepo,
-        appVersion: "0.0.2",
+        appVersion: APP_VERSION,
         platform: `${process.platform} node-${process.version}`,
         resetClient,
         // Re-run device-code login, then restart the worker so it picks up the new token.
@@ -102,18 +107,18 @@ async function launchTui() {
     // model's context window) so either Codex setup style works.
     const applyClient = (clientKind, scope, model) => {
         if (clientKind === "claude") {
-            const r = applyClaude(scope, claudeCopilotReverseEnv(workerBase, "copilot-reverse-local", model, modelLimits[model]));
+            const r = applyClaude(scope, claudeCopilotReverseEnv(anthropicBase, "copilot-reverse-local", model, modelLimits[model]));
             writeClientSetup(dataDir(), { ...readClientSetup(dataDir()), claude: true });
             return r;
         }
-        const r = applyCodex(scope, { OPENAI_BASE_URL: `${workerBase}/v1`, OPENAI_API_KEY: "copilot-reverse-local", OPENAI_MODEL: model });
-        applyCodexToml({ baseUrl: `${workerBase}/v1`, model, contextWindow: modelLimits[model] });
+        const r = applyCodex(scope, { OPENAI_BASE_URL: openaiBase, OPENAI_API_KEY: "copilot-reverse-local", OPENAI_MODEL: model });
+        applyCodexToml({ baseUrl: openaiBase, model, contextWindow: modelLimits[model] });
         writeClientSetup(dataDir(), { ...readClientSetup(dataDir()), codex: true });
         return r;
     };
     const setup = { apply: async (clientKind, scope, model) => applyClient(clientKind, scope, model) };
     const onChat = makeOnChat({
-        client, workerBaseUrl: workerBase, apiKey: "copilot-reverse-local", model: DEFAULT_MODEL,
+        client, workerBaseUrl: anthropicBase, apiKey: "copilot-reverse-local", model: DEFAULT_MODEL,
         maxInputTokens: DEFAULT_MAX_INPUT_TOKENS, modelLimits,
         listModels: loadModels,
         setupClient: async (c, s, m) => applyClient(c, s, m),
@@ -130,8 +135,8 @@ async function launchTui() {
         loadModels,
         setup,
         info: {
-            openai: `${workerBase}/v1`,
-            anthropic: workerBase,
+            openai: openaiBase,
+            anthropic: anthropicBase,
             supervisorPort: cfg.supervisorPort,
             workerPort: cfg.workerPort,
             dataDir: dataDir(),
@@ -141,7 +146,7 @@ async function launchTui() {
     }));
 }
 const program = new Command();
-program.name("copilot-reverse").description("copilot-reverse: interactive Copilot proxy").version("0.0.2");
+program.name("copilot-reverse").description("copilot-reverse: interactive Copilot proxy").version(APP_VERSION);
 program.command("login").description("GitHub device-code login").action(() => runDeviceLogin(dataDir()));
 program.action(() => { void launchTui(); });
 program.parseAsync(process.argv);

package/dist/core/tool-xml.js

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+// Opening sentinels that switch the parser into capture mode. The `antml:` namespaced variants are
+// the un-stripped originals; the bare forms are what survives when the namespace prefix is dropped.
+const TRIGGER_RE = /<(?:antml:)?(?:function_calls>|invoke\b)/;
+// Longest suffix of `s` that is a proper prefix of a trigger token — text we must hold back because
+// it might be the front of a sentinel split across chunk boundaries (e.g. "…<inv" then "oke name=").
+const PREFIX_TOKENS = ["<function_calls>", "<function_calls>", "<invoke", "<invoke"];
+function heldBackLen(s) {
+    let max = 0;
+    for (const t of PREFIX_TOKENS) {
+        for (let k = Math.min(s.length, t.length - 1); k > 0; k--) {
+            if (s.endsWith(t.slice(0, k))) {
+                if (k > max)
+                    max = k;
+                break;
+            }
+        }
+    }
+    return max;
+}
+// Index just past a `</tag>` (or `</tag>`) close, or -1 if not yet present in `s`.
+function closeIndex(s, tag) {
+    const m = new RegExp(`</(?:antml:)?${tag}>`).exec(s);
+    return m ? m.index + m[0].length : -1;
+}
+// A scalar parameter value is raw text in the XML; recover its intended type by trying JSON, so
+// `42`/`true`/`{"a":1}` become real values while a bare command string stays a string.
+function coerce(raw) {
+    const v = raw.replace(/^\n/, "").replace(/\n$/, "");
+    try {
+        return JSON.parse(v);
+    }
+    catch {
+        return v;
+    }
+}
+function parseInvokes(block) {
+    const tools = [];
+    const invokeRe = /<(?:antml:)?invoke\s+name="([^"]+)"\s*>([\s\S]*?)<\/(?:antml:)?invoke>/g;
+    for (let m = invokeRe.exec(block); m; m = invokeRe.exec(block)) {
+        const [, name, body] = m;
+        const input = {};
+        const paramRe = /<(?:antml:)?parameter\s+name="([^"]+)"\s*>([\s\S]*?)<\/(?:antml:)?parameter>/g;
+        for (let p = paramRe.exec(body); p; p = paramRe.exec(body))
+            input[p[1]] = coerce(p[2]);
+        tools.push({ id: `call_${randomUUID().replace(/-/g, "").slice(0, 24)}`, name, input });
+    }
+    return tools;
+}
+export class ToolCallExtractor {
+    buf = "";
+    capturing = false;
+    feed(chunk) {
+        this.buf += chunk;
+        const events = [];
+        for (;;) {
+            if (!this.capturing) {
+                const m = TRIGGER_RE.exec(this.buf);
+                if (!m) {
+                    // No trigger; emit everything except a possible partial-sentinel tail.
+                    const keep = heldBackLen(this.buf);
+                    const emit = this.buf.slice(0, this.buf.length - keep);
+                    if (emit)
+                        events.push({ kind: "text", text: emit });
+                    this.buf = keep ? this.buf.slice(this.buf.length - keep) : "";
+                    return events;
+                }
+                if (m.index > 0)
+                    events.push({ kind: "text", text: this.buf.slice(0, m.index) });
+                this.buf = this.buf.slice(m.index);
+                this.capturing = true;
+            }
+            const isWrapper = /^<(?:antml:)?function_calls>/.test(this.buf);
+            const end = closeIndex(this.buf, isWrapper ? "function_calls" : "invoke");
+            if (end < 0)
+                return events; // incomplete block — wait for more data
+            const block = this.buf.slice(0, end);
+            for (const tool of parseInvokes(block))
+                events.push({ kind: "tool", tool });
+            this.buf = this.buf.slice(end);
+            this.capturing = false; // a following <invoke> re-triggers via the passthrough branch
+        }
+    }
+    // Stream ended. Anything still buffered is an incomplete block we couldn't parse — emit it as
+    // text so nothing is silently dropped.
+    flush() {
+        const out = this.buf ? [{ kind: "text", text: this.buf }] : [];
+        this.buf = "";
+        this.capturing = false;
+        return out;
+    }
+}

package/dist/providers/copilot/adapter.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { ToolCallExtractor } from "../../core/tool-xml.js";
 const CHAT_URL = "https://api.githubcopilot.com/chat/completions";
 // Canonical messages -> OpenAI wire messages (Copilot is OpenAI-shaped).
 function toWireMessages(messages) {
@@ -88,6 +89,27 @@ export class CopilotAdapter {
         let finishReason = "stop";
         let usage;
         const mapFinish = (f) => f === "tool_calls" ? "tool_use" : f === "length" ? "length" : "stop";
+        // Some models emit a tool call as inline XML text instead of native tool_calls (more likely on
+        // long/tool-heavy turns). When the request has tools, route assistant text through an extractor
+        // that recovers those blocks into structured tool calls; otherwise text passes straight through.
+        const extractor = req.tools?.length ? new ToolCallExtractor() : undefined;
+        let extractedTool = false;
+        let extIdx = 100; // separate index space so recovered tools never collide with native tool_calls
+        const toChunks = (events) => {
+            const out = [];
+            for (const ev of events) {
+                if (ev.kind === "text") {
+                    if (ev.text)
+                        out.push({ kind: "text", delta: ev.text, done: false });
+                    continue;
+                }
+                const index = extIdx++;
+                extractedTool = true;
+                out.push({ kind: "tool_use_start", index, id: ev.tool.id, name: ev.tool.name, done: false });
+                out.push({ kind: "tool_use_delta", index, argsDelta: JSON.stringify(ev.tool.input), done: false });
+            }
+            return out;
+        };
         for (;;) {
             const { value, done } = await reader.read();
             if (done)
@@ -101,6 +123,11 @@ export class CopilotAdapter {
                     continue;
                 const payload = line.slice(6).trim();
                 if (payload === "[DONE]") {
+                    if (extractor)
+                        for (const ch of toChunks(extractor.flush()))
+                            yield ch;
+                    if (extractedTool && finishReason === "stop")
+                        finishReason = "tool_use";
                     yield { kind: "done", done: true, finishReason, usage };
                     return;
                 }
@@ -122,8 +149,14 @@ export class CopilotAdapter {
                 const delta = choice.delta;
                 if (!delta)
                     continue;
-                if (delta.content)
-                    yield { kind: "text", delta: delta.content, done: false };
+                if (delta.content) {
+                    if (extractor) {
+                        for (const ch of toChunks(extractor.feed(delta.content)))
+                            yield ch;
+                    }
+                    else
+                        yield { kind: "text", delta: delta.content, done: false };
+                }
                 for (const tc of delta.tool_calls ?? []) {
                     const idx = tc.index ?? 0;
                     if (!startedTools.has(idx) && tc.function?.name) {
@@ -135,6 +168,11 @@ export class CopilotAdapter {
                 }
             }
         }
+        if (extractor)
+            for (const ch of toChunks(extractor.flush()))
+                yield ch;
+        if (extractedTool && finishReason === "stop")
+            finishReason = "tool_use";
         yield { kind: "done", done: true, finishReason, usage };
     }
 }

package/dist/providers/copilot/models.js

@@ -1,6 +1,6 @@
 // Live model list from Copilot. Falls back to a curated list if the endpoint is unavailable.
 const MODELS_URL = "https://api.githubcopilot.com/models";
-const FALLBACK = ["gpt-4o", "gpt-4o-mini", "claude-sonnet-4-6", "claude-opus-4-8", "o3-mini"];
+export const FALLBACK_MODELS = ["gpt-4o", "gpt-4o-mini", "claude-sonnet-4-6", "claude-opus-4-8", "o3-mini"];
 const HEADERS = (token) => ({
     authorization: `Bearer ${token}`,
     "content-type": "application/json",
@@ -28,9 +28,9 @@ async function getModels(token, fetchFn, timeoutMs) {
 export async function fetchCopilotModels(token, fetchFn = fetch, timeoutMs = DEFAULT_TIMEOUT_MS) {
     const data = await getModels(token, fetchFn, timeoutMs);
     if (!data)
-        return FALLBACK;
+        return FALLBACK_MODELS;
     const ids = [...new Set(data.map((m) => m.id).filter((x) => Boolean(x)))];
-    return ids.length ? ids : FALLBACK;
+    return ids.length ? ids : FALLBACK_MODELS;
 }
 // Map of model id -> its real input/context window, used to size auto-compaction per model and
 // to show the window in the picker. Returns {} on failure/timeout so callers fall back gracefully.

package/dist/tui/setup/clients.js

@@ -1,5 +1,5 @@
 export function claudeCodeConfig(e) {
-    const base = `http://${e.host}:${e.port}`;
+    const base = `http://${e.host}:${e.port}/anthropic`;
     return {
         env: { ANTHROPIC_BASE_URL: base, ANTHROPIC_API_KEY: e.apiKey },
         instructions: `Set these env vars for Claude Code:\n  ANTHROPIC_BASE_URL=${base}\n  ANTHROPIC_API_KEY=${e.apiKey}`,
@@ -30,7 +30,7 @@ export function claudeCopilotReverseEnv(base, apiKey, model, contextWindow) {
     };
 }
 export function codexConfig(e) {
-    const base = `http://${e.host}:${e.port}/v1`;
+    const base = `http://${e.host}:${e.port}/openai`;
     return {
         env: { OPENAI_BASE_URL: base, OPENAI_API_KEY: e.apiKey },
         instructions: `Set these env vars for Codex / OpenAI clients:\n  OPENAI_BASE_URL=${base}\n  OPENAI_API_KEY=${e.apiKey}`,

package/dist/tui/slash/commands.js

@@ -39,7 +39,7 @@ export function buildRegistry(ctx, endpoint, opts = {}) {
         } });
     reg.add({ name: "/setup-claude", describe: "print Claude Code config", run: async () => claudeCodeConfig(endpoint).instructions.split("\n") });
     reg.add({ name: "/setup-codex", describe: "print Codex/OpenAI config", run: async () => codexConfig(endpoint).instructions.split("\n") });
-    reg.add({ name: "/setup-status", describe: "show configured endpoints", run: async () => [`OpenAI: http://${endpoint.host}:${endpoint.port}/v1`, `Anthropic: http://${endpoint.host}:${endpoint.port}`] });
+    reg.add({ name: "/setup-status", describe: "show configured endpoints", run: async () => [`OpenAI: http://${endpoint.host}:${endpoint.port}/openai`, `Anthropic: http://${endpoint.host}:${endpoint.port}/anthropic`] });
     reg.add({ name: "/reset-claude", describe: "restore Claude Code config (remove copilot-reverse's keys)", run: async () => opts.resetClient ? opts.resetClient("claude") : ["reset not available"] });
     reg.add({ name: "/reset-codex", describe: "restore Codex/OpenAI config (remove copilot-reverse's keys)", run: async () => opts.resetClient ? opts.resetClient("codex") : ["reset not available"] });
     reg.add({ name: "/login", describe: "sign in to GitHub (device-code)", run: async () => opts.login ? opts.login() : ["login not available"] });

package/dist/version.js

@@ -0,0 +1,2 @@
+// AUTO-GENERATED by scripts/gen-version.mjs from package.json — do not edit.
+export const APP_VERSION = "0.2.0";

package/dist/worker/anthropic-server.js

@@ -5,16 +5,21 @@ import { errorHint } from "./errors.js";
 import { CopilotAuthError } from "../providers/copilot/token.js";
 const frame = (event, data) => `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
 export function mountAnthropic(app, router, onMetric) {
+    // Model discovery — Anthropic list shape. Claude Desktop / Anthropic-protocol clients GET this
+    // before chatting; without it they 404 on the connection test.
+    app.get("/anthropic/v1/models", (_req, res) => {
+        res.json({ data: router.listModels().map((id) => ({ type: "model", id, display_name: id })), has_more: false });
+    });
     // Anthropic clients (Claude Code) call this to size the prompt and decide when to auto-compact.
-    app.post("/v1/messages/count_tokens", (req, res) => {
+    app.post("/anthropic/v1/messages/count_tokens", (req, res) => {
         res.json({ input_tokens: estimateTokens(anthropicRequestToCanonical(req.body)) });
     });
-    app.post("/v1/messages", async (req, res) => {
+    app.post("/anthropic/v1/messages", async (req, res) => {
         const start = Date.now();
         const canon = anthropicRequestToCanonical(req.body);
         canon.model = router.resolveModel(canon.model);
         const provider = router.pick(canon.model);
-        const metric = (status, error) => onMetric({ endpoint: "/v1/messages", model: canon.model, status, latencyMs: Date.now() - start, error });
+        const metric = (status, error) => onMetric({ endpoint: "/anthropic/v1/messages", model: canon.model, status, latencyMs: Date.now() - start, error });
         try {
             if (canon.stream) {
                 res.setHeader("content-type", "text/event-stream");

package/dist/worker/openai-server.js

@@ -3,12 +3,17 @@ import { openaiRequestToCanonical, canonicalToOpenAIResponse, canonicalChunkToOp
 import { errorHint } from "./errors.js";
 import { CopilotAuthError } from "../providers/copilot/token.js";
 export function mountOpenAI(app, router, onMetric) {
-    app.post("/v1/chat/completions", async (req, res) => {
+    // Model discovery — OpenAI list shape. Clients (LiteLLM-style gateways, "test connection" probes)
+    // GET this before chatting; without it they 404 and refuse to connect.
+    app.get("/openai/models", (_req, res) => {
+        res.json({ object: "list", data: router.listModels().map((id) => ({ id, object: "model", owned_by: "copilot-reverse" })) });
+    });
+    app.post("/openai/chat/completions", async (req, res) => {
         const start = Date.now();
         const canon = openaiRequestToCanonical(req.body);
         canon.model = router.resolveModel(canon.model);
         const provider = router.pick(canon.model);
-        const metric = (status, error) => onMetric({ endpoint: "/v1/chat/completions", model: canon.model, status, latencyMs: Date.now() - start, error });
+        const metric = (status, error) => onMetric({ endpoint: "/openai/chat/completions", model: canon.model, status, latencyMs: Date.now() - start, error });
         try {
             if (canon.stream) {
                 res.setHeader("content-type", "text/event-stream");

package/dist/worker/router.js

@@ -1,4 +1,5 @@
 import { bestModelMatch } from "../core/fuzzy.js";
+import { FALLBACK_MODELS } from "../providers/copilot/models.js";
 // M1: single provider. Model name is remapped to the provider's actual id.
 export class Router {
     providers;
@@ -10,6 +11,9 @@ export class Router {
     }
     // The live Copilot model list, used for fuzzy matching (set once fetched at worker startup).
     setAvailableModels(ids) { this.available = ids; }
+    // Model ids to advertise from the /models discovery endpoints. Falls back to a curated list
+    // until the live fetch resolves, so discovery never returns an empty list.
+    listModels() { return this.available.length ? this.available : FALLBACK_MODELS; }
     resolveModel(requested) {
         // Claude Code appends [1m] to signal its 1M context window; Copilot doesn't know that id, so
         // strip it back to the real model before mapping/forwarding.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-reverse",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "description": "Interactive terminal app that exposes your GitHub Copilot subscription as local OpenAI- and Anthropic-compatible endpoints, with a self-healing daemon and a built-in assistant.",
   "type": "module",
   "license": "MIT",
@@ -32,12 +32,14 @@
     "llm"
   ],
   "scripts": {
+    "prebuild": "node scripts/gen-version.mjs",
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:e2e": "vitest run e2e/copilot-reverse.e2e.test.ts tests/e2e",
     "test:integration": "vitest run --config vitest.integration.config.ts",
     "dev": "tsx src/cli/index.ts",
+    "changeset": "node scripts/changesets.mjs new",
     "prepublishOnly": "npm run build && npm run test"
   },
   "engines": {