copilot-reverse 0.5.1 → 0.5.3

package/dist/providers/copilot/adapter.js

@@ -86,13 +86,26 @@ export class CopilotAdapter {
         const data = (await res.json());
         const choice = data.choices[0];
         const content = [];
-        if (choice.message.content)
-            content.push({ type: "text", text: choice.message.content });
+        // Recover inline-XML tool calls in non-stream replies too (same reason as the stream path).
+        let xmlTool = false;
+        if (choice.message.content) {
+            const ex = new ToolCallExtractor();
+            for (const ev of [...ex.feed(choice.message.content), ...ex.flush()]) {
+                if (ev.kind === "text") {
+                    if (ev.text)
+                        content.push({ type: "text", text: ev.text });
+                }
+                else {
+                    xmlTool = true;
+                    content.push({ type: "tool_use", id: ev.tool.id, name: ev.tool.name, input: ev.tool.input });
+                }
+            }
+        }
         for (const tc of choice.message.tool_calls ?? [])
             content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input: safeJson(tc.function.arguments) });
         return {
             id: data.id ?? `cmpl-${randomUUID().replace(/-/g, "")}`, model: req.model, content,
-            finishReason: choice.finish_reason === "tool_calls" ? "tool_use" : choice.finish_reason === "length" ? "length" : "stop",
+            finishReason: choice.finish_reason === "tool_calls" || xmlTool ? "tool_use" : choice.finish_reason === "length" ? "length" : "stop",
             usage: { promptTokens: data.usage?.prompt_tokens ?? 0, completionTokens: data.usage?.completion_tokens ?? 0 },
         };
     }
@@ -134,9 +147,11 @@ export class CopilotAdapter {
         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;
+        // long/tool-heavy turns) — and they do it even when THIS request declared no tools (a follow-up
+        // turn, or a model that ignores the tools field). Always run assistant text through the extractor;
+        // it only captures on the distinctive `<invoke>`/`<function_calls>` sentinel and flushes anything
+        // unparseable back as text, so plain prose is unaffected.
+        const extractor = new ToolCallExtractor();
         let extractedTool = false;
         let extIdx = 100; // separate index space so recovered tools never collide with native tool_calls
         const toChunks = (events) => {

package/dist/providers/copilot/responses-upstream.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { ToolCallExtractor } from "../../core/tool-xml.js";
 // Outbound translation to GitHub Copilot's OpenAI Responses API. Newer Copilot models (e.g. gpt-5.5)
 // are served ONLY on /responses — their `supported_endpoints` omits /chat/completions — so the adapter
 // routes them here instead of the chat path. This is the mirror image of core/responses-inbound.ts
@@ -68,8 +69,20 @@ export function parseResponsesResult(data) {
     for (const item of data.output ?? []) {
         if (item.type === "message") {
             const text = (item.content ?? []).filter((p) => p.type === "output_text").map((p) => p.text ?? "").join("");
-            if (text)
-                content.push({ type: "text", text });
+            if (text) {
+                // Recover inline-XML tool calls here too (some models emit them as output_text).
+                const ex = new ToolCallExtractor();
+                for (const ev of [...ex.feed(text), ...ex.flush()]) {
+                    if (ev.kind === "text") {
+                        if (ev.text)
+                            content.push({ type: "text", text: ev.text });
+                    }
+                    else {
+                        sawTool = true;
+                        content.push({ type: "tool_use", id: ev.tool.id, name: ev.tool.name, input: ev.tool.input });
+                    }
+                }
+            }
         }
         else if (item.type === "function_call") {
             sawTool = true;
@@ -99,6 +112,25 @@ export async function* streamResponses(res) {
     let usage;
     const toolByOutputIndex = new Map(); // responses output_index -> canonical tool index
     let nextToolIndex = 0;
+    // Some models stream a tool call as inline XML text instead of a function_call item; recover it.
+    // Extracted tools use a high index space so they never collide with native function_call indices.
+    const extractor = new ToolCallExtractor();
+    let extIdx = 100, extractedTool = false;
+    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;
+    };
     const usageOf = (u) => u ? { promptTokens: u.input_tokens ?? 0, completionTokens: u.output_tokens ?? 0, cachedTokens: u.input_tokens_details?.cached_tokens ?? 0 } : undefined;
     for (;;) {
         const { value, done } = await reader.read();
@@ -133,7 +165,8 @@ export async function* streamResponses(res) {
                 }
                 case "response.output_text.delta":
                     if (ev.delta)
-                        yield { kind: "text", delta: ev.delta, done: false };
+                        for (const ch of toChunks(extractor.feed(ev.delta)))
+                            yield ch;
                     break;
                 case "response.function_call_arguments.delta": {
                     const idx = toolByOutputIndex.get(ev.output_index);
@@ -142,7 +175,7 @@ export async function* streamResponses(res) {
                     break;
                 }
                 case "response.completed":
-                    if (toolByOutputIndex.size)
+                    if (toolByOutputIndex.size || extractedTool)
                         finishReason = "tool_use";
                     usage = usageOf(ev.response?.usage) ?? usage;
                     break;
@@ -157,5 +190,9 @@ export async function* streamResponses(res) {
             }
         }
     }
+    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/shared/config.js

@@ -3,7 +3,7 @@ export function defaultConfig() {
         bindHost: "127.0.0.1",
         supervisorPort: 7890,
         workerPort: 7891,
-        restart: { maxCrashes: 5, windowMs: 60_000, baseBackoffMs: 500, maxBackoffMs: 8_000 },
+        restart: { maxCrashes: 5, windowMs: 60_000, baseBackoffMs: 500, maxBackoffMs: 8_000, unhealthyCooldownMs: 30_000 },
         // Empty = pass the requested model straight through to Copilot. Add entries (or "*") to remap.
         modelMap: {},
         // Set MAESTRO_REPORT_REPO=owner/repo to override where /report files diagnostics issues.

package/dist/supervisor/index.js

@@ -10,6 +10,7 @@ import { dataDir, dbPath } from "../shared/paths.js";
 import { readGhToken } from "../shared/creds.js";
 import { probeGithubAuth } from "../providers/copilot/token.js";
 import { GithubHeartbeat, SIGNED_OUT_DETAIL } from "./github-heartbeat.js";
+import { appendCrashLog } from "../shared/crash-log.js";
 export function startSupervisor() {
     const config = defaultConfig();
     mkdirSync(dataDir(), { recursive: true });
@@ -21,6 +22,9 @@ export function startSupervisor() {
         onStateChange: (s) => { state = s; bus.emit("state", { state: s }); },
         onCrash: (d, exitCode, stderrTail) => {
             recordRestart(db, { ts: Date.now(), reason: d.markedUnhealthy ? "unhealthy" : "crash", exitCode, stderrTail, backoffMs: d.backoffMs, markedUnhealthy: d.markedUnhealthy ? 1 : 0 });
+            // Also persist to crash.log so a worker crash is diagnosable post-mortem — the DB stderrTail can
+            // be empty if the worker died before flushing; this keeps whatever it did emit.
+            appendCrashLog("worker-crash", `exit=${exitCode} unhealthy=${d.markedUnhealthy} backoff=${d.backoffMs}ms\n${stderrTail || "(no stderr captured)"}`);
             bus.emit("crash", { exitCode, ...d });
         },
         onWorkerMessage: (m) => {

package/dist/supervisor/monitor.js

@@ -16,7 +16,7 @@ export class RestartController {
         const backoffMs = Math.min(this.policy.baseBackoffMs * 2 ** (this.consecutive - 1), this.policy.maxBackoffMs);
         return { backoffMs, markedUnhealthy: this.crashTimes.length >= this.policy.maxCrashes, crashesInWindow: this.crashTimes.length };
     }
-    reset() { this.consecutive = 0; }
+    reset() { this.consecutive = 0; this.crashTimes = []; }
 }
 export class WorkerMonitor {
     config;
@@ -58,7 +58,14 @@ export class WorkerMonitor {
             const d = this.controller.onCrash();
             this.hooks.onCrash(d, code, this.stderrTail);
             if (d.markedUnhealthy) {
+                // Don't give up forever: a transient crash burst (token rotation, a flaky upstream) shouldn't
+                // leave the daemon permanently dead. Mark unhealthy, then after a cooldown reset the window and
+                // try once more — recovering on its own if the cause has passed.
                 this.set("unhealthy");
+                setTimeout(() => { if (!this.stopped) {
+                    this.controller.reset();
+                    this.spawn();
+                } }, this.config.restart.unhealthyCooldownMs);
                 return;
             }
             this.set("crashed");

package/dist/version.js

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

package/dist/worker/index.js

@@ -9,8 +9,13 @@ import { makeGatewayRunner } from "../core/server-tools.js";
 import { borrowSearch } from "../providers/copilot/borrow-search.js";
 import { dataDir } from "../shared/paths.js";
 import { defaultConfig } from "../shared/config.js";
-function send(msg) { if (process.send)
-    process.send(msg); }
+// Sending after the parent tore down the IPC channel throws ERR_IPC_CHANNEL_CLOSED; guard it so a
+// crash-time report can't itself become a second, masking crash.
+function send(msg) { try {
+    if (process.connected)
+        process.send?.(msg);
+}
+catch { /* channel gone */ } }
 const cfg = defaultConfig();
 const port = Number(process.env.WORKER_PORT ?? cfg.workerPort);
 const host = process.env.BIND_HOST ?? cfg.bindHost;
@@ -47,4 +52,18 @@ process.on("message", (m) => { if (m?.type === "shutdown") {
     clearInterval(hb);
     server.close(() => process.exit(0));
 } });
-process.on("uncaughtException", (e) => { send({ type: "error", message: e.message, stack: e.stack }); process.exit(1); });
+// Crash diagnostics: write to STDERR FIRST so the supervisor's stderr capture (and crash.log) records
+// the reason even when the IPC channel is already gone; the IPC send is a best-effort extra. Without
+// the unhandledRejection handler, a stray floating rejection silently kills the worker on Node ≥15 —
+// the exact "exit 1, empty stderr" crash loop we kept seeing.
+function fatal(kind, e) {
+    const detail = e instanceof Error ? `${e.message}\n${e.stack ?? ""}` : String(e);
+    try {
+        process.stderr.write(`worker ${kind}: ${detail}\n`);
+    }
+    catch { /* nothing more we can do */ }
+    send({ type: "error", message: e instanceof Error ? e.message : String(e), stack: e instanceof Error ? e.stack : undefined });
+    process.exit(1);
+}
+process.on("uncaughtException", (e) => fatal("uncaughtException", e));
+process.on("unhandledRejection", (e) => fatal("unhandledRejection", e));

package/package.json

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