copilot-reverse 0.5.2 → 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/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.2";
+export const APP_VERSION = "0.5.3";

package/package.json

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