copilot-reverse 0.1.0 → 0.2.0

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
@@ -70,7 +71,7 @@ async function launchTui() {
     const registry = buildRegistry({ client, quit }, endpoint, {
         dashboardUrl: `http://${cfg.bindHost}:${cfg.supervisorPort}/`,
         reportRepo: cfg.reportRepo,
-        appVersion: "0.1.0",
+        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.
@@ -145,7 +146,7 @@ async function launchTui() {
     }));
 }
 const program = new Command();
-program.name("copilot-reverse").description("copilot-reverse: interactive Copilot proxy").version("0.1.0");
+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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-reverse",
-  "version": "0.1.0",
+  "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": {