ACP: session/cancel is answered with stopReason "end_turn" instead of "cancelled" #4561

#!/usr/bin/env node
// Minimal reproduction: GitHub Copilot CLI in ACP mode answers session/prompt with
// stopReason "end_turn" after the client sends session/cancel, where ACP requires
// "cancelled".
//
//   node acp-cancel-repro.mjs            # cancel on the first tool_call
//   node acp-cancel-repro.mjs --control  # identical run, no cancel (baseline)
//
// Zero dependencies, Node >= 20. Requires a logged-in CLI (`copilot login`).

import { spawn } from "node:child_process";
import { createInterface } from "node:readline";
import { mkdtemp, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";

const CONTROL = process.argv.includes("--control");
const cwd = await mkdtemp(join(tmpdir(), "acp-cancel-repro-"));
// Three files to read, so the turn is long enough to interrupt.
for (const n of ["alpha.txt", "beta.txt", "gamma.txt"])
  await writeFile(join(cwd, n), `${n}: ` + "lorem ipsum ".repeat(40) + "\n");

const proc = spawn("copilot", ["--acp", "--stdio", "--no-color", "--allow-all-tools"], {
  cwd, stdio: ["pipe", "pipe", "inherit"],
});

const t0 = Date.now();
const ms = () => Date.now() - t0;
const pending = new Map();
let nextId = 1;
let cancelledAt = null;
let events = 0;

const send = (m) => proc.stdin.write(JSON.stringify(m) + "\n");
const request = (method, params) =>
  new Promise((resolve) => { const id = nextId++; pending.set(id, resolve); send({ jsonrpc: "2.0", id, method, params }); });

createInterface({ input: proc.stdout }).on("line", (line) => {
  if (!line.trim()) return;
  let msg; try { msg = JSON.parse(line); } catch { return; }

  if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
    pending.get(msg.id)?.(msg.result ?? { error: msg.error });
    pending.delete(msg.id);
    return;
  }
  if (msg.method === "session/update") {
    events++;
    const kind = msg.params?.update?.sessionUpdate;
    if (kind === "tool_call" && !cancelledAt && !CONTROL) {
      cancelledAt = ms();
      console.log(`[${cancelledAt}ms] first tool_call -> sending session/cancel`);
      send({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId } });
    }
    return;
  }
  // Answer anything else so the turn cannot stall on us.
  if (msg.id !== undefined) send({ jsonrpc: "2.0", id: msg.id, result: {} });
});

const init = await request("initialize", {
  protocolVersion: 1,
  clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: false },
  clientInfo: { name: "acp-cancel-repro", version: "1.0.0" },
});
console.log(`initialize: ${init.agentInfo?.name} ${init.agentInfo?.version} (protocol v${init.protocolVersion})`);

const { sessionId } = await request("session/new", { cwd, mcpServers: [] });

const prompt =
  "Read every file in this directory one at a time, and for each one write a two-sentence " +
  "summary. Work through them slowly and thoroughly, one file per step.";
console.log(`[${ms()}ms] session/prompt (${CONTROL ? "control: no cancel" : "will cancel on first tool_call"})`);
const res = await request("session/prompt", { sessionId, prompt: [{ type: "text", text: prompt }] });

console.log(`\nstopReason:        ${JSON.stringify(res.stopReason)}`);
console.log(`turn ended at:     ${ms()} ms`);
if (cancelledAt) console.log(`cancel -> answer:  ${ms() - cancelledAt} ms`);
console.log(`session/update events: ${events}`);
proc.stdin.end(); proc.kill();