copilot-reverse 0.0.2 → 0.1.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

@@ -49,6 +49,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 +70,7 @@ async function launchTui() {
     const registry = buildRegistry({ client, quit }, endpoint, {
         dashboardUrl: `http://${cfg.bindHost}:${cfg.supervisorPort}/`,
         reportRepo: cfg.reportRepo,
-        appVersion: "0.0.2",
+        appVersion: "0.1.0",
         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 +106,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 +134,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 +145,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("0.1.0");
 program.command("login").description("GitHub device-code login").action(() => runDeviceLogin(dataDir()));
 program.action(() => { void launchTui(); });
 program.parseAsync(process.argv);

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/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.1.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",