ada-agent 0.4.0 → 0.6.0

package/docs/integrations.md

@@ -24,8 +24,14 @@ language, over plain HTTP + Server-Sent Events:
 ```
 GET  /v1/sessions                        → { sessions: [{ file, title, mtime, parent? }, …] }
 POST /v1/sessions {"resume"?: "latest"|"<file>"} → { sessionId, model, file, resumed }
-POST /v1/sessions/:id/prompt {"text":…}  → SSE stream of events (see below), until "done"
+POST /v1/sessions/:id/prompt {"text":…, "images"?: [dataURL|https…]}
+                                         → SSE stream of events (see below), until "done"
+                                           (409 if a turn is already running on this session)
 POST /v1/sessions/:id/approve {"id":…, "decision":"yes"|"all"|"no"}
+POST /v1/sessions/:id/abort              → cancel the running turn ("stop generating"); also
+                                           denies any approval it was parked on
+POST /v1/sessions/:id/steer {"text":…}   → queue a mid-turn user message (409 when idle)
+PATCH /v1/sessions/:id {"mode":"ask"|"plan"|"auto"} → switch the permission mode live
 DELETE /v1/sessions/:id                  → free the session (does not delete the transcript)
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ada-agent",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "A from-zero terminal coding agent with a Cursor-style routing backend, ~285 skills, MCP connectors, and ask/plan/auto modes",
   "type": "module",
   "license": "MIT",

package/src/client/agent-server.ts

@@ -39,6 +39,14 @@ export class ApprovalRegistry {
     return true;
   }
 
+  /** Deny every pending approval — an aborted turn must not stay parked on an unanswered prompt. */
+  abortAll(): number {
+    const n = this.pending.size;
+    for (const resolve of this.pending.values()) resolve("no");
+    this.pending.clear();
+    return n;
+  }
+
   get size(): number {
     return this.pending.size;
   }

package/src/client/agent.ts

@@ -19,8 +19,8 @@ type Msg = OpenAI.Chat.Completions.ChatCompletionMessageParam;
  *  When `onEvent` is set on SendCtrl, `send()` emits these instead of writing to stdout. */
 export type AgentEvent =
   | { type: "text"; delta: string }
-  | { type: "tool_call"; name: string; detail: string }
-  | { type: "tool_result"; name: string; output: string; isError: boolean }
+  | { type: "tool_call"; callId: string; name: string; detail: string }
+  | { type: "tool_result"; callId: string; name: string; output: string; isError: boolean }
   | { type: "done"; text: string; usage: string };
 type SendCtrl = { signal?: AbortSignal; steer?: string[]; quiet?: boolean; images?: string[]; onReplyStart?: () => void; onEvent?: (e: AgentEvent) => void };
 type ToolCall = { id: string; name: string; args: string };
@@ -50,7 +50,7 @@ function systemPrompt(includeProject: boolean): string {
       "You are ada, a minimal coding agent running in a terminal, in the spirit of pi, Codex, and Cursor.",
       `Working directory: ${process.cwd()}`,
       `Platform: ${process.platform}`,
-      "Tools: read_file, write_file, edit_file, bash, ls, grep, glob, web_fetch, web_search, lsp_diagnostics. Use grep/glob/ls to explore the codebase; read a file before editing it; prefer edit_file for changes to existing files; web_fetch to read a URL, web_search to find one; lsp_diagnostics to check a file for errors after editing; apply_patch for multi-file changes; ask_user only when genuinely blocked.",
+      "Tools: read_file, write_file, edit_file, bash, ls, grep, glob, codebase_search, web_fetch, web_search, lsp_diagnostics. Use grep/glob/ls to explore the codebase — or codebase_search when you're looking for code by MEANING rather than an exact string; read a file before editing it; prefer edit_file for changes to existing files; web_fetch to read a URL, web_search to find one; lsp_diagnostics to check a file for errors after editing; apply_patch for multi-file changes; ask_user only when genuinely blocked.",
       "Specialized skills are available: call list_skills to browse them (by category or filter), then use_skill to load one before a specialized task.",
       "Be concise. Don't narrate routine actions or pad with preamble. When you have enough information to act, act. Ask only when genuinely blocked or before destructive, irreversible actions.",
     ].join("\n") + (includeProject ? projectContext() : "")
@@ -654,6 +654,7 @@ export class Agent {
               calls[tc.index] = entry;
             }
             if (tc.id) entry.id = tc.id;
+            else if (!entry.id) entry.id = `call_${tc.index}`; // some backends omit streamed ids — consumers key events on callId
             if (tc.function?.name) entry.name += tc.function.name;
             if (tc.function?.arguments) entry.args += tc.function.arguments;
           }
@@ -699,14 +700,14 @@ export class Agent {
    *  append one tool message per call. */
   private async execTools(toolCalls: ToolCall[], ctrl: SendCtrl | undefined, say: (s: string) => void): Promise<void> {
     const signal = ctrl?.signal;
-    const printCall = (name: string, args: Record<string, unknown>): void => {
+    const printCall = (callId: string, name: string, args: Record<string, unknown>): void => {
       const d = describeCall(name, args);
       const detail = d.detail ? ` ${d.detail.length > 100 ? `${d.detail.slice(0, 99)}…` : d.detail}` : "";
-      ctrl?.onEvent?.({ type: "tool_call", name, detail: d.detail });
+      ctrl?.onEvent?.({ type: "tool_call", callId, name, detail: d.detail });
       say(`\n\x1b[2m• ${name}${detail}\x1b[0m\n`);
     };
-    const printResult = (name: string, r: ToolResult): void => {
-      ctrl?.onEvent?.({ type: "tool_result", name, output: r.output, isError: !!r.isError });
+    const printResult = (callId: string, name: string, r: ToolResult): void => {
+      ctrl?.onEvent?.({ type: "tool_result", callId, name, output: r.output, isError: !!r.isError });
       if (r.display) say(`${r.display}\n`);
       else if (r.isError) say(`\x1b[31m  ${r.output.split("\n")[0]}\x1b[0m\n`);
     };
@@ -734,15 +735,15 @@ export class Agent {
         continue;
       }
       if (!tool) {
-        printCall(c.name, args);
+        printCall(c.id, c.name, args);
         results[i] = { output: `Unknown tool: ${c.name}`, isError: true };
         continue;
       }
       const perm = permissionFor(c.name, summarize(args)); // configured allow/ask/deny rule, if any
       if (perm === "deny") {
-        printCall(c.name, args);
+        printCall(c.id, c.name, args);
         results[i] = { output: "Denied by permission policy.", isError: true };
-        printResult(c.name, results[i]!);
+        printResult(c.id, c.name, results[i]!);
         continue;
       }
       if (!tool.needsApproval && perm !== "ask") {
@@ -750,10 +751,10 @@ export class Agent {
         continue;
       }
       // gated tool (or a rule forces "ask") → sequential (so prompts and same-file writes don't race)
-      printCall(c.name, args);
+      printCall(c.id, c.name, args);
       if (this.planMode && tool.needsApproval) {
         results[i] = { output: "Plan mode: not executing — finish the plan; the user approves with /run." };
-        printResult(c.name, results[i]!);
+        printResult(c.id, c.name, results[i]!);
         continue;
       }
       const forceConfirm = c.name === "bash" && isDestructive(String(args.command ?? ""));
@@ -771,15 +772,15 @@ export class Agent {
           results[i] = await runTool(tool, c.name, args);
         }
       }
-      printResult(c.name, results[i]!);
+      printResult(c.id, c.name, results[i]!);
     }
     await Promise.all(
       parallel.map(async (i) => {
         const c = toolCalls[i]!;
         const args = argsOf(c.args);
-        printCall(c.name, args);
+        printCall(c.id, c.name, args);
         results[i] = await runTool(toolByName.get(c.name)!, c.name, args);
-        printResult(c.name, results[i]!);
+        printResult(c.id, c.name, results[i]!);
       }),
     );
     for (let i = 0; i < toolCalls.length; i++) {

package/src/client/cli.ts

@@ -502,6 +502,11 @@ const NO_BACKEND = new Set(["mcp", "skill", "worktree", "wt", "catalog", "share"
 
 async function main(): Promise<void> {
   const sub = process.argv[2];
+  if (sub === "--version" || sub === "-v" || sub === "version") {
+    // Before anything else — must not auto-start a backend just to print a version.
+    console.log(`ada ${adaVersion()}`);
+    return;
+  }
   if (sub === "login" || sub === "logout") {
     await authCommand(sub, process.argv[3]);
     return;
@@ -643,9 +648,10 @@ async function main(): Promise<void> {
     return;
   }
   if (sub === "acp") {
-    // Minimal Agent Client Protocol bridge over stdio (JSON-RPC 2.0, newline-delimited). Scaffold:
-    // handles initialize + prompt so an ACP-aware editor can drive ada. Extend method names/framing
-    // to match your client's ACP version.
+    // Agent Client Protocol bridge over stdio (JSON-RPC 2.0, newline-delimited). Handles
+    // initialize / session/new / session/prompt, and streams session/update notifications
+    // (agent_message_chunk + tool_call/tool_call_update) while a turn runs — the shape ACP editors
+    // like Zed render live. Still experimental until exercised against a real ACP client.
     const trusted = isTrusted(process.cwd());
     const settings = loadSettings(trusted);
     await loadExtensions(trusted);
@@ -662,6 +668,9 @@ async function main(): Promise<void> {
     }
     const agent = new Agent({ client, model, session: Session.create(), onApprove: async (): Promise<ApprovalDecision> => "yes", autoApprove: true, project: trusted, compactAt: settings.compactAt });
     const send = (msg: object): void => void stdout.write(`${JSON.stringify(msg)}\n`);
+    const ACP_SESSION = newId("acp");
+    const update = (update: object): void => send({ jsonrpc: "2.0", method: "session/update", params: { sessionId: ACP_SESSION, update } });
+    let acpCtrl: AbortController | null = null; // the in-flight prompt's abort handle (session/cancel)
     let buf = "";
     stdin.on("data", async (d) => {
       buf += d.toString("utf8");
@@ -677,16 +686,29 @@ async function main(): Promise<void> {
           continue;
         }
         if (msg.method === "initialize") send({ jsonrpc: "2.0", id: msg.id, result: { protocolVersion: 1, agentCapabilities: { promptCapabilities: {} } } });
-        else if (msg.method === "session/new" || msg.method === "newSession") send({ jsonrpc: "2.0", id: msg.id, result: { sessionId: "ada" } });
-        else if (msg.method === "session/prompt" || msg.method === "prompt") {
+        else if (msg.method === "session/new" || msg.method === "newSession") send({ jsonrpc: "2.0", id: msg.id, result: { sessionId: ACP_SESSION } });
+        else if (msg.method === "session/cancel" || msg.method === "cancel") {
+          acpCtrl?.abort();
+          if (msg.id != null) send({ jsonrpc: "2.0", id: msg.id, result: {} });
+        } else if (msg.method === "session/prompt" || msg.method === "prompt") {
           const p = msg.params ?? {};
           const blocks = (p.prompt ?? p.text) as unknown;
           const text = Array.isArray(blocks) ? blocks.map((b) => (b as { text?: string }).text ?? "").join("") : String(blocks ?? "");
+          acpCtrl = new AbortController();
           try {
-            const out = await agent.send(text, { quiet: true });
-            send({ jsonrpc: "2.0", id: msg.id, result: { stopReason: "end_turn", content: [{ type: "text", text: out }] } });
+            await agent.send(text, {
+              signal: acpCtrl.signal,
+              onEvent: (e: AgentEvent) => {
+                if (e.type === "text") update({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: e.delta } });
+                else if (e.type === "tool_call") update({ sessionUpdate: "tool_call", toolCallId: e.callId, title: `${e.name} ${e.detail}`.trim(), status: "in_progress" });
+                else if (e.type === "tool_result") update({ sessionUpdate: "tool_call_update", toolCallId: e.callId, status: e.isError ? "failed" : "completed" });
+              },
+            });
+            send({ jsonrpc: "2.0", id: msg.id, result: { stopReason: acpCtrl.signal.aborted ? "cancelled" : "end_turn" } });
           } catch (e) {
             send({ jsonrpc: "2.0", id: msg.id, error: { code: -32000, message: e instanceof Error ? e.message : String(e) } });
+          } finally {
+            acpCtrl = null;
           }
         } else if (msg.id != null) send({ jsonrpc: "2.0", id: msg.id, result: {} });
       }
@@ -736,6 +758,9 @@ async function main(): Promise<void> {
       registry: ApprovalRegistry;
       emit: ((frame: string) => void) | null; // set only while a /prompt request's SSE stream is open
       file: string; // the on-disk transcript — survives an `ada serve` restart; resume with it
+      ctrl: AbortController | null; // set while a turn runs — doubles as the busy flag
+      steer: string[]; // queued mid-turn user messages, drained by the agent between steps
+      mode: "ask" | "plan" | "auto";
     }
     const sessions = new Map<string, AgentSession>();
     // `resumeFile` reattaches to an existing on-disk transcript (e.g. after `ada serve` restarted) —
@@ -743,7 +768,7 @@ async function main(): Promise<void> {
     const makeSession = (m: string, resumeFile?: string): { id: string; rec: AgentSession } => {
       const session = resumeFile ? Session.open(resumeFile) : Session.create();
       const history = resumeFile ? (session.load() as unknown as Msg[]) : undefined;
-      const rec: AgentSession = { agent: undefined as unknown as Agent, registry: new ApprovalRegistry(), emit: null, file: session.file };
+      const rec: AgentSession = { agent: undefined as unknown as Agent, registry: new ApprovalRegistry(), emit: null, file: session.file, ctrl: null, steer: [], mode: "ask" };
       rec.agent = new Agent({
         client,
         model: m,
@@ -810,6 +835,16 @@ async function main(): Promise<void> {
           } catch {
             /* ignore, use default model + no resume */
           }
+          if (resume) {
+            // A live in-memory session may still be appending to that transcript (e.g. the IDE lost
+            // its SSE stream and *assumed* a restart) — two Agents on one JSONL interleave twin
+            // conversations. Point the caller at the live session instead of forking the file.
+            const live = [...sessions.entries()].find(([, r]) => r.file === resume);
+            if (live) {
+              res.writeHead(409, { "content-type": "application/json" }).end(JSON.stringify({ error: "that transcript belongs to a live session — reuse it (or DELETE it first)", sessionId: live[0], busy: !!live[1].ctrl }));
+              return;
+            }
+          }
           const { id, rec } = makeSession(m, resume);
           res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ sessionId: id, model: m, file: rec.file, resumed: !!resume }));
         });
@@ -822,28 +857,121 @@ async function main(): Promise<void> {
           res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "unknown session" }));
           return;
         }
+        if (rec.ctrl) {
+          // One turn at a time per session — two interleaved prompts would corrupt one conversation.
+          res.writeHead(409, { "content-type": "application/json" }).end(JSON.stringify({ error: "a turn is already running on this session — abort it or wait for done" }));
+          return;
+        }
+        rec.ctrl = new AbortController(); // claim the session before any await, so a racing second prompt sees busy
+        // If the client dies MID-BODY (e.g. a dropped multi-MB image upload), 'end' never fires and
+        // the claim above would brick the session with a permanent 409 — release it on 'close'.
+        req.on("close", () => {
+          if (!req.complete) {
+            rec.ctrl = null;
+            rec.steer.length = 0;
+          }
+        });
         let body = "";
         req.on("data", (c) => (body += c));
         req.on("end", async () => {
           let text = "";
+          let images: string[] | undefined;
           try {
-            text = String((JSON.parse(body || "{}") as { text?: string }).text ?? "");
+            const j = JSON.parse(body || "{}") as { text?: string; images?: string[] };
+            text = String(j.text ?? "");
+            if (Array.isArray(j.images) && j.images.length) images = j.images.map(String);
           } catch {
             /* empty prompt */
           }
           res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+          // If the client drops the SSE stream mid-turn (IDE reload/crash), abort the turn — else it
+          // runs headless, and in ask mode parks forever on an approval no one can see or answer.
+          res.on("close", () => {
+            if (!res.writableEnded) {
+              rec.ctrl?.abort();
+              rec.registry.abortAll();
+            }
+          });
           rec.emit = (frame) => res.write(frame);
           try {
-            await rec.agent.send(text, { onEvent: (e: AgentEvent) => res.write(sseFrame(e)) });
+            await rec.agent.send(text, { signal: rec.ctrl!.signal, steer: rec.steer, images, onEvent: (e: AgentEvent) => res.write(sseFrame(e)) });
           } catch (e) {
             res.write(sseFrame({ type: "error", message: e instanceof Error ? e.message : String(e) }));
           } finally {
             rec.emit = null;
+            rec.ctrl = null;
+            rec.steer.length = 0;
             res.end();
           }
         });
         return;
       }
+      const abortMatch = req.method === "POST" && url.pathname.match(/^\/v1\/sessions\/([^/]+)\/abort$/);
+      if (abortMatch) {
+        const rec = sessions.get(abortMatch[1]!);
+        if (!rec) {
+          res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "unknown session" }));
+          return;
+        }
+        const wasRunning = !!rec.ctrl;
+        rec.ctrl?.abort();
+        rec.registry.abortAll(); // a turn parked on an unanswered approval must not stay stuck
+        res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true, wasRunning }));
+        return;
+      }
+      const steerMatch = req.method === "POST" && url.pathname.match(/^\/v1\/sessions\/([^/]+)\/steer$/);
+      if (steerMatch) {
+        const rec = sessions.get(steerMatch[1]!);
+        if (!rec) {
+          res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "unknown session" }));
+          return;
+        }
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", () => {
+          let text = "";
+          try {
+            text = String((JSON.parse(body || "{}") as { text?: string }).text ?? "");
+          } catch {
+            /* stays empty */
+          }
+          if (!text || !rec.ctrl) {
+            // steering only makes sense mid-turn; when idle, just send the next prompt instead
+            res.writeHead(409, { "content-type": "application/json" }).end(JSON.stringify({ ok: false, error: rec.ctrl ? "empty text" : "no turn running — send a prompt instead" }));
+            return;
+          }
+          rec.steer.push(text);
+          res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true }));
+        });
+        return;
+      }
+      const modeMatch = req.method === "PATCH" && url.pathname.match(/^\/v1\/sessions\/([^/]+)$/);
+      if (modeMatch) {
+        const rec = sessions.get(modeMatch[1]!);
+        if (!rec) {
+          res.writeHead(404, { "content-type": "application/json" }).end(JSON.stringify({ error: "unknown session" }));
+          return;
+        }
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", () => {
+          let mode: string | undefined;
+          try {
+            mode = (JSON.parse(body || "{}") as { mode?: string }).mode;
+          } catch {
+            /* stays undefined */
+          }
+          if (mode !== "ask" && mode !== "plan" && mode !== "auto") {
+            res.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ error: 'mode must be "ask" | "plan" | "auto"' }));
+            return;
+          }
+          rec.mode = mode;
+          rec.agent.setPlanMode(mode === "plan");
+          rec.agent.setAutoApprove(mode === "auto");
+          res.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({ ok: true, mode }));
+        });
+        return;
+      }
       const approveMatch = req.method === "POST" && url.pathname.match(/^\/v1\/sessions\/([^/]+)\/approve$/);
       if (approveMatch) {
         const rec = sessions.get(approveMatch[1]!);
@@ -867,6 +995,9 @@ async function main(): Promise<void> {
       }
       const delMatch = req.method === "DELETE" && url.pathname.match(/^\/v1\/sessions\/([^/]+)$/);
       if (delMatch) {
+        const rec = sessions.get(delMatch[1]!);
+        rec?.ctrl?.abort(); // don't orphan a running turn
+        rec?.registry.abortAll();
         const existed = sessions.delete(delMatch[1]!);
         res.writeHead(existed ? 200 : 404, { "content-type": "application/json" }).end(JSON.stringify({ ok: existed }));
         return;
@@ -876,9 +1007,10 @@ async function main(): Promise<void> {
       console.log(
         `ada HTTP API on http://localhost:${port}  ·  model ${model || "(none — set one)"}\n` +
           `  one-shot:    POST /v1/prompt {"text":"…"}\n` +
-          `  interactive: POST /v1/sessions → {sessionId}\n` +
-          `               POST /v1/sessions/:id/prompt {"text":"…"}  (SSE: text/tool_call/tool_result/approval_request/done)\n` +
-          `               POST /v1/sessions/:id/approve {"id":"…","decision":"yes"|"all"|"no"}`,
+          `  interactive: POST /v1/sessions → {sessionId}   (GET lists resumable transcripts)\n` +
+          `               POST /v1/sessions/:id/prompt {"text":"…","images"?:[…]}  (SSE: text/tool_call/tool_result/approval_request/done)\n` +
+          `               POST /v1/sessions/:id/approve {"id":"…","decision":"yes"|"all"|"no"}\n` +
+          `               POST /v1/sessions/:id/abort · /steer {"text":"…"} · PATCH /v1/sessions/:id {"mode":"ask"|"plan"|"auto"}`,
       ),
     );
     await new Promise(() => {}); // keep the process alive for the server

package/src/client/embed-index.ts

@@ -0,0 +1,198 @@
+// @codebase semantic search. Chunks the working tree, embeds chunks through the backend's
+// /v1/embeddings (which forwards to Ollama — `ollama pull nomic-embed-text`, or set
+// ADA_EMBED_MODEL), caches vectors in .ada/index.json keyed by content hash, and answers queries
+// by cosine similarity. Exposed to the model as the read-only `codebase_search` tool.
+//
+// ponytail: brute-force cosine over a JSON cache — fine to ~50k chunks; an ANN index and a binary
+// vector format are the upgrade path if repos outgrow it.
+
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+
+const EMBED_MODEL = process.env.ADA_EMBED_MODEL ?? "nomic-embed-text";
+const BACKEND = process.env.ADA_BACKEND_URL ?? "http://localhost:8787/v1";
+const SKIP = new Set(["node_modules", ".git", "dist", ".ada", ".next", "build", "coverage"]);
+const TEXT_EXT = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|rb|php|cs|c|h|cpp|hpp|md|txt|json|yaml|yml|toml|css|scss|html|sql|sh|svelte|vue)$/i;
+const CHUNK_LINES = 80;
+const MAX_FILE_BYTES = 200_000;
+
+export interface Chunk {
+  start: number; // 1-based first line
+  end: number;
+  text: string;
+}
+interface IndexedFile {
+  hash: string;
+  chunks: Array<{ start: number; end: number; vec: number[] }>;
+}
+interface Index {
+  model: string;
+  files: Record<string, IndexedFile>;
+}
+
+/** Split file text into fixed-size line windows, char-capped so minified/long-line files can't
+ *  blow the embedding model's context window. */
+export function chunkText(text: string, lines = CHUNK_LINES): Chunk[] {
+  const all = text.split("\n");
+  const out: Chunk[] = [];
+  for (let i = 0; i < all.length; i += lines) {
+    const slice = all.slice(i, i + lines).join("\n");
+    if (slice.trim()) out.push({ start: i + 1, end: Math.min(i + lines, all.length), text: slice.slice(0, 6000) });
+  }
+  return out;
+}
+
+export function cosine(a: number[], b: number[]): number {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i]! * b[i]!;
+    na += a[i]! * a[i]!;
+    nb += b[i]! * b[i]!;
+  }
+  const d = Math.sqrt(na) * Math.sqrt(nb);
+  return d ? dot / d : 0;
+}
+
+function sha1(s: string): string {
+  return createHash("sha1").update(s).digest("hex");
+}
+
+/** Indexable text files under root (relative paths), matching the tool suite's skip list. */
+export function walkFiles(root: string, dir = root, out: string[] = []): string[] {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    if (e.name.startsWith(".") && e.name !== ".github") continue;
+    if (SKIP.has(e.name)) continue;
+    const p = join(dir, e.name);
+    if (e.isDirectory()) walkFiles(root, p, out);
+    else if (TEXT_EXT.test(e.name)) {
+      try {
+        if (statSync(p).size <= MAX_FILE_BYTES) out.push(relative(root, p).replace(/\\/g, "/"));
+      } catch {
+        /* unreadable — skip */
+      }
+    }
+  }
+  return out;
+}
+
+async function embed(texts: string[], kind: "document" | "query" = "document"): Promise<number[][]> {
+  // nomic-embed models are trained asymmetric: prefixing queries/documents differently measurably
+  // improves retrieval (code stops losing to prose). Other models get the raw text.
+  const input = EMBED_MODEL.includes("nomic") ? texts.map((t) => `search_${kind}: ${t}`) : texts;
+  const res = await fetch(`${BACKEND}/embeddings`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${process.env.ADA_CLIENT_KEY ?? "dev"}` },
+    body: JSON.stringify({ model: EMBED_MODEL, input }),
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!res.ok) throw new Error(`embeddings HTTP ${res.status}: ${(await res.text().catch(() => "")).slice(0, 200)} — is the backend up, and is "${EMBED_MODEL}" pulled in Ollama? (ollama pull nomic-embed-text, or set ADA_EMBED_MODEL)`);
+  const j = (await res.json()) as { data?: Array<{ index: number; embedding: number[] }> };
+  if (!j.data?.length) throw new Error("embeddings response had no data");
+  return [...j.data].sort((a, b) => a.index - b.index).map((d) => d.embedding);
+}
+
+function indexPath(root: string): string {
+  return resolve(root, ".ada", "index.json");
+}
+
+// Cache key includes an embedding-scheme tag: changing the model OR how text is prefixed makes old
+// vectors incomparable, and both must force a rebuild.
+const SCHEME = EMBED_MODEL.includes("nomic") ? `${EMBED_MODEL}#affix1` : EMBED_MODEL;
+
+function loadIndex(root: string): Index {
+  try {
+    const idx = JSON.parse(readFileSync(indexPath(root), "utf8")) as Index;
+    if (idx.model === SCHEME) return idx; // scheme changed → vectors incomparable, rebuild
+  } catch {
+    /* no cache yet */
+  }
+  return { model: SCHEME, files: {} };
+}
+
+function saveIndex(root: string, idx: Index): void {
+  try {
+    mkdirSync(resolve(root, ".ada"), { recursive: true });
+    writeFileSync(indexPath(root), JSON.stringify(idx));
+  } catch {
+    /* cache is best-effort */
+  }
+}
+
+/** Bring the index up to date (embed new/changed files, drop deleted ones). Returns chunk count. */
+export async function refreshIndex(root = process.cwd(), onProgress?: (msg: string) => void): Promise<number> {
+  const idx = loadIndex(root);
+  const files = walkFiles(root);
+  const live = new Set(files);
+  for (const known of Object.keys(idx.files)) if (!live.has(known)) delete idx.files[known];
+
+  const stale: Array<{ rel: string; hash: string; chunks: Chunk[] }> = [];
+  for (const rel of files) {
+    let text: string;
+    try {
+      text = readFileSync(resolve(root, rel), "utf8");
+    } catch {
+      continue;
+    }
+    const hash = sha1(text);
+    if (idx.files[rel]?.hash === hash) continue;
+    stale.push({ rel, hash, chunks: chunkText(text) });
+  }
+
+  let done = 0;
+  for (const f of stale) {
+    const vecs: number[][] = [];
+    for (let i = 0; i < f.chunks.length; i += 32) {
+      const batch = f.chunks.slice(i, i + 32);
+      vecs.push(...(await embed(batch.map((c) => c.text))));
+    }
+    idx.files[f.rel] = { hash: f.hash, chunks: f.chunks.map((c, i) => ({ start: c.start, end: c.end, vec: vecs[i]! })) };
+    done++;
+    if (onProgress && done % 20 === 0) onProgress(`indexed ${done}/${stale.length} changed files…`);
+  }
+  if (stale.length) saveIndex(root, idx);
+  return Object.values(idx.files).reduce((n, f) => n + f.chunks.length, 0);
+}
+
+export interface Hit {
+  file: string;
+  start: number;
+  end: number;
+  score: number;
+  snippet: string;
+}
+
+/** Top-k chunks most similar to the query. Refreshes the index first (incremental). */
+export async function searchCodebase(query: string, k = 6, root = process.cwd()): Promise<Hit[]> {
+  await refreshIndex(root);
+  const idx = loadIndex(root);
+  const [qvec] = await embed([query], "query");
+  const hits: Hit[] = [];
+  for (const [rel, f] of Object.entries(idx.files)) {
+    for (const c of f.chunks) {
+      hits.push({ file: rel, start: c.start, end: c.end, score: cosine(qvec!, c.vec), snippet: "" });
+    }
+  }
+  hits.sort((a, b) => b.score - a.score);
+  const top = hits.slice(0, k);
+  for (const h of top) {
+    try {
+      h.snippet = readFileSync(resolve(root, h.file), "utf8")
+        .split("\n")
+        .slice(h.start - 1, h.end)
+        .join("\n")
+        .slice(0, 1200);
+    } catch {
+      h.snippet = "(file changed since indexing)";
+    }
+  }
+  return top;
+}

package/src/client/skill-router.ts

@@ -64,16 +64,28 @@ export function rankSkills(query: string, items: RankItem[], n = 5): { name: str
 
 /**
  * The single clearly-dominant skill for a query, or null when the match is weak/ambiguous.
- * Three gates, all required: a score floor, dominance over the runner-up, and — crucially — an
- * EXACT whole-token overlap with the skill NAME. That last gate is the precision guard against
- * lexical false positives: "make a powerpoint" prefix-matches "low-power" and even dominates, but
- * "powerpoint" never equals the name token "power", so it's correctly rejected.
+ * Four gates, all required:
+ *  1. a score floor;
+ *  2. dominance over the runner-up;
+ *  3. an EXACT whole-token overlap with the skill NAME — the guard against prefix false positives
+ *     ("make a powerpoint" prefix-matches "low-power" and even dominates, but "powerpoint" never
+ *     equals the name token "power", so it's rejected);
+ *  4. query COVERAGE — strictly more than a third of the query's content tokens must EXACTLY match
+ *     the skill's tokens. A conversational sentence that merely *contains* one skill-y keyword
+ *     ("remember this: the secret word is X" → secret-scan, observed live) is about something else;
+ *     a short task-like command ("describe the project" → project-overview) matches nearly all its
+ *     tokens. Exact equality here on purpose — matches()'s 4-char prefixing is right for recall in
+ *     rankSkills but inflates coverage ("remember" prefix-matches "remediate"), re-opening the leak.
  */
 export function confidentSkill(query: string, items: RankItem[]): string | null {
   const ranked = rankSkills(query, items, 2);
   const top = ranked[0];
   if (!top || top.score < 4) return null;
-  if (ranked[1] && top.score < ranked[1].score * 1.3) return null; // reject ties/near-ties; the name-exact gate below is the real precision guard
-  const q = new Set(tokenize(query));
-  return tokenize(top.name).some((t) => q.has(t)) ? top.name : null;
+  if (ranked[1] && top.score < ranked[1].score * 1.3) return null; // reject ties/near-ties
+  const q = [...new Set(tokenize(query))];
+  if (!tokenize(top.name).some((t) => q.includes(t))) return null;
+  const item = items.find((it) => it.name === top.name);
+  const doc = new Set(tokenize(`${top.name} ${item?.description ?? ""} ${item?.category ?? ""}`));
+  const covered = q.filter((qt) => doc.has(qt)).length;
+  return covered / q.length > 1 / 3 ? top.name : null;
 }

package/src/client/tools.ts

@@ -533,6 +533,31 @@ export const tools: Tool[] = [
       return { output: (matches.join("\n") || "(no matches)") + more };
     },
   },
+  {
+    name: "codebase_search",
+    description:
+      "Semantic (meaning-based) search over the codebase — finds code by what it DOES, not by exact strings. Use when grep's literal matching won't work (\"where do we handle auth?\", \"how are sessions persisted?\"). First call indexes the repo (needs an Ollama embedding model, e.g. nomic-embed-text); later calls are incremental.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "What you're looking for, in plain words." },
+        k: { type: "number", description: "How many results (default 6)." },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    },
+    needsApproval: false,
+    async run(args) {
+      try {
+        const { searchCodebase } = await import("./embed-index.ts"); // lazy — only pay for it when used
+        const hits = await searchCodebase(String(args.query), Math.min(Number(args.k) || 6, 20));
+        if (!hits.length) return { output: "No indexed content matched. Is the repo empty, or all files skipped?" };
+        return { output: hits.map((h) => `${h.file}:${h.start}-${h.end}  (score ${h.score.toFixed(3)})\n${h.snippet}`).join("\n\n---\n\n") };
+      } catch (e) {
+        return { output: String(e instanceof Error ? e.message : e), isError: true };
+      }
+    },
+  },
   {
     name: "web_fetch",
     description: "Fetch an http(s) URL and return its content as readable text (HTML is stripped to text). Use to read docs, articles, changelogs, or JSON APIs.",

package/src/sdk/index.ts

@@ -23,8 +23,8 @@ export interface PromptResult {
 /** One event from an interactive session's prompt stream. */
 export type SessionEvent =
   | { type: "text"; delta: string }
-  | { type: "tool_call"; name: string; detail: string }
-  | { type: "tool_result"; name: string; output: string; isError: boolean }
+  | { type: "tool_call"; callId: string; name: string; detail: string }
+  | { type: "tool_result"; callId: string; name: string; output: string; isError: boolean }
   | { type: "approval_request"; id: string; name: string; summary: string }
   | { type: "done"; text: string; usage: string }
   | { type: "error"; message: string };
@@ -36,10 +36,17 @@ export interface AdaSession {
   readonly file: string;
   /** True if this session's history was seeded from an existing transcript. */
   readonly resumed: boolean;
-  /** Send a prompt; `onEvent` fires for every event as the turn streams. Resolves once it's done. */
-  prompt(text: string, onEvent: (e: SessionEvent) => void): Promise<void>;
+  /** Send a prompt; `onEvent` fires for every event as the turn streams. Resolves once it's done.
+   *  `images` are data: or https: URLs attached to the message. 409s if a turn is already running. */
+  prompt(text: string, onEvent: (e: SessionEvent) => void, opts?: { images?: string[] }): Promise<void>;
   /** Answer a pending `approval_request` event by its id. */
   approve(id: string, decision: "yes" | "all" | "no"): Promise<void>;
+  /** Cancel the currently-running turn (the "stop generating" button). Safe when idle. */
+  abort(): Promise<void>;
+  /** Queue a mid-turn user message — the agent folds it in between steps (the "steer" box). */
+  steer(text: string): Promise<void>;
+  /** Switch the session's permission mode: ask (gate every edit), plan (read-only), auto (run freely). */
+  setMode(mode: "ask" | "plan" | "auto"): Promise<void>;
   /** Free the session's resources server-side. (Does not delete the on-disk transcript.) */
   close(): Promise<void>;
 }
@@ -110,11 +117,11 @@ export function createClient(baseUrl = "http://localhost:8788"): AdaClient {
         id: sessionId,
         file,
         resumed,
-        async prompt(text, onEvent) {
+        async prompt(text, onEvent, opts) {
           const r = await fetch(`${url}/v1/sessions/${sessionId}/prompt`, {
             method: "POST",
             headers: { "content-type": "application/json" },
-            body: JSON.stringify({ text }),
+            body: JSON.stringify({ text, images: opts?.images }),
           });
           await streamSse(r, onEvent);
         },
@@ -126,6 +133,26 @@ export function createClient(baseUrl = "http://localhost:8788"): AdaClient {
           });
           if (!r.ok) throw new Error(`ada ${r.status}: could not settle approval ${id}`);
         },
+        async abort() {
+          const r = await fetch(`${url}/v1/sessions/${sessionId}/abort`, { method: "POST" });
+          if (!r.ok) throw new Error(`ada ${r.status}: abort failed`);
+        },
+        async steer(text) {
+          const r = await fetch(`${url}/v1/sessions/${sessionId}/steer`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ text }),
+          });
+          if (!r.ok) throw new Error(`ada ${r.status}: steer failed (is a turn running?)`);
+        },
+        async setMode(mode) {
+          const r = await fetch(`${url}/v1/sessions/${sessionId}`, {
+            method: "PATCH",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ mode }),
+          });
+          if (!r.ok) throw new Error(`ada ${r.status}: could not set mode`);
+        },
         async close() {
           await fetch(`${url}/v1/sessions/${sessionId}`, { method: "DELETE" });
         },

package/src/selfcheck.ts

@@ -293,6 +293,37 @@ async function main(): Promise<void> {
     assert.equal(route("anything-else"), "openrouter", "unmatched → openrouter");
   }
 
+  // --- @codebase semantic search: pure parts (no network / no embedding model needed) ---
+  {
+    const { chunkText, cosine, walkFiles } = await import("./client/embed-index.ts");
+    const chunks = chunkText(Array.from({ length: 200 }, (_, i) => `line ${i + 1}`).join("\n"));
+    assert.equal(chunks.length, 3, "200 lines → 3 chunks of 80");
+    assert.equal(chunks[0]!.start, 1);
+    assert.equal(chunks[1]!.start, 81);
+    assert.equal(chunks[2]!.end, 200, "last chunk ends at the last line");
+    assert.equal(chunkText("   \n \n").length, 0, "whitespace-only text → no chunks");
+    assert.ok(chunkText(`x${"y".repeat(50_000)}`)[0]!.text.length <= 6000, "long-line chunks are char-capped");
+    assert.ok(Math.abs(cosine([1, 0], [1, 0]) - 1) < 1e-9, "cosine identical = 1");
+    assert.equal(cosine([1, 0], [0, 1]), 0, "cosine orthogonal = 0");
+    assert.equal(cosine([0, 0], [1, 1]), 0, "zero vector → 0, not NaN");
+    const walked = walkFiles(process.cwd());
+    assert.ok(walked.includes("src/selfcheck.ts"), "walkFiles finds source files");
+    assert.ok(!walked.some((f) => f.includes("node_modules")), "walkFiles skips node_modules");
+    // Offline: the tool must fail with a clear message, not hang or throw
+    const r = await toolByName.get("codebase_search")!.run({ query: "x" });
+    assert.ok(typeof r.output === "string", "codebase_search returns cleanly even when embeddings are unavailable");
+  }
+
+  // --- `ada --version` prints the version and exits WITHOUT auto-starting a backend ---
+  {
+    const { spawnSync } = await import("node:child_process");
+    const { fileURLToPath } = await import("node:url");
+    const bin = fileURLToPath(new URL("../bin/ada.mjs", import.meta.url));
+    const r = spawnSync(process.execPath, [bin, "--version"], { encoding: "utf8", timeout: 30_000 });
+    assert.match(r.stdout, /^ada \d+\.\d+\.\d+/, `--version prints the version (got: ${JSON.stringify(r.stdout)} / ${JSON.stringify(r.stderr?.slice(0, 120))})`);
+    assert.ok(!/starting ada-server/.test(r.stderr ?? ""), "--version must not auto-start the backend");
+  }
+
   // --- autostart helpers: URL classification + /health derivation ---
   {
     const { isLocalBackend, healthUrl } = await import("./client/autostart.ts");
@@ -327,6 +358,14 @@ async function main(): Promise<void> {
     assert.equal(await promise, "yes", "the waiting promise resolves with the decision");
     assert.equal(registry.size, 0, "settle() clears the pending entry");
     assert.equal(registry.settle("nope", "no"), false, "settle() on an unknown id returns false");
+
+    // abortAll: an aborted turn must not stay parked on unanswered approvals
+    const a1 = registry.wait();
+    const a2 = registry.wait();
+    assert.equal(registry.abortAll(), 2, "abortAll reports how many were pending");
+    assert.equal(await a1.promise, "no", "aborted approvals resolve to 'no'");
+    assert.equal(await a2.promise, "no", "all of them");
+    assert.equal(registry.size, 0, "abortAll clears the registry");
   }
   assert.equal((await toolByName.get("web_fetch")!.run({ url: "http://127.0.0.1/x" })).isError, true, "web_fetch blocks loopback (SSRF guard)");
 
@@ -381,6 +420,18 @@ async function main(): Promise<void> {
   assert.equal(confidentSkill("draw an architecture diagram of this project", allSkills), "architecture-diagram", "confident: → architecture-diagram");
   assert.equal(confidentSkill("make a powerpoint about Q3 results", allSkills), null, "precision guard: 'powerpoint' must NOT auto-apply 'low-power'");
   assert.equal(confidentSkill("what is 2 + 2", allSkills), null, "ambiguous query → no auto-apply");
+  // Coverage gate — a long sentence merely CONTAINING a skill-y keyword must not auto-apply
+  // (observed live: this exact prompt pulled in secret-scan and derailed a small model).
+  assert.equal(
+    confidentSkill("Remember this fact for later: the secret word is PINEAPPLE97. Just confirm you will remember it, do not do anything else.", allSkills),
+    null,
+    "coverage gate: incidental 'secret' must NOT auto-apply secret-scan",
+  );
+  assert.equal(confidentSkill("I was talking to my friend about docker yesterday and she mentioned kubernetes", allSkills), null, "coverage gate: conversational mention of docker");
+  // Short rephrasings of the same incident — prefix-matching must not inflate coverage
+  // ("remember" prefix-matches "remediate"), and 1/3 exactly must not pass the strict gate.
+  assert.equal(confidentSkill("remember this: the secret word is X", allSkills), null, "coverage gate: short secret-word phrasing");
+  assert.equal(confidentSkill("remember the secret word", allSkills), null, "coverage gate: shortest secret-word phrasing");
   // LOADED was set by registerSkillTool(allSkills) above, so routeConfident/skillBody resolve a body.
   const applied = routeConfident("describe the project");
   assert.ok(applied?.name === "project-overview" && /purpose/i.test(applied.body), "routeConfident returns the skill body to inject");

package/src/server/config.ts

@@ -23,9 +23,9 @@ export const PROVIDERS: Record<ProviderName, ProviderDef> = {
     baseURL: process.env.DASHSCOPE_BASE_URL ?? "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
     keyEnv: "DASHSCOPE_API_KEY",
   },
-  // GitHub Copilot — OpenAI-compatible chat endpoint. COPILOT_API_KEY must be a Copilot *bearer*
-  // token (exchanged from a GitHub OAuth token at /copilot_internal/v2/token — that exchange is not
-  // implemented here; it needs a Copilot subscription). Required headers are added in the adapter.
+  // GitHub Copilot — OpenAI-compatible chat endpoint. Set COPILOT_API_KEY (a Copilot bearer you
+  // already have) OR COPILOT_GITHUB_TOKEN (a GitHub token with Copilot access — the adapter runs
+  // the /copilot_internal/v2/token exchange and caches/refreshes the bearer; see copilot-token.ts).
   copilot: { baseURL: process.env.COPILOT_BASE_URL ?? "https://api.githubcopilot.com", keyEnv: "COPILOT_API_KEY" },
   // Cloudflare Workers AI / AI Gateway — OpenAI-compatible. Workers AI: set CLOUDFLARE_ACCOUNT_ID +
   // CLOUDFLARE_API_TOKEN (default URL). AI Gateway: point CLOUDFLARE_BASE_URL at the gateway URL.
@@ -57,6 +57,8 @@ export function providerKey(p: ProviderName): string | undefined {
 
 /** A provider is usable if it's keyless, its key env var is set, or a credential is stored. */
 export function isConfigured(p: ProviderName): boolean {
+  // Copilot has a second way in: a GitHub token the adapter exchanges for a bearer (copilot-token.ts).
+  if (p === "copilot" && process.env.COPILOT_GITHUB_TOKEN) return true;
   return PROVIDERS[p].keyEnv === "" || !!process.env[PROVIDERS[p].keyEnv] || !!getCredential(p);
 }
 

package/src/server/index.ts

@@ -72,6 +72,25 @@ async function handleChat(req: IncomingMessage, res: ServerResponse): Promise<vo
   await adapterFor(provider).chat({ provider, model, body, res });
 }
 
+/** Embeddings for @codebase semantic search — forwarded to the ollama provider's
+ *  OpenAI-compatible endpoint (embedding models only live there for now). */
+async function handleEmbeddings(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const raw = await readBody(req);
+  try {
+    JSON.parse(raw);
+  } catch {
+    return json(res, 400, { error: { message: "invalid JSON body" } });
+  }
+  const upstream = await fetch(`${PROVIDERS.ollama.baseURL}/embeddings`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: raw,
+  });
+  const text = await upstream.text();
+  res.writeHead(upstream.status, { "content-type": "application/json" });
+  res.end(text);
+}
+
 const server = createServer(async (req, res) => {
   try {
     const url = new URL(req.url ?? "/", "http://localhost");
@@ -91,6 +110,10 @@ const server = createServer(async (req, res) => {
       if (!(await authorized(req))) return json(res, 401, { error: { message: "unauthorized — invalid client key or login" } });
       return await handleChat(req, res);
     }
+    if (req.method === "POST" && url.pathname === "/v1/embeddings") {
+      if (!(await authorized(req))) return json(res, 401, { error: { message: "unauthorized — invalid client key or login" } });
+      return await handleEmbeddings(req, res);
+    }
     return json(res, 404, { error: { message: "not found" } });
   } catch (err) {
     if (!res.headersSent) json(res, 500, { error: { message: err instanceof Error ? err.message : String(err) } });

package/src/server/providers/copilot-token.ts

@@ -0,0 +1,35 @@
+// GitHub Copilot bearer-token exchange. Copilot's endpoint doesn't take a GitHub token directly —
+// you exchange one at /copilot_internal/v2/token for a short-lived bearer. Ways in, in order:
+//   COPILOT_API_KEY      — you already have a bearer (pasted from another tool); used as-is.
+//   COPILOT_GITHUB_TOKEN — a GitHub OAuth token with Copilot access; exchanged + cached here,
+//                          refreshed automatically before expiry.
+//   stored credential    — whatever `ada login`-style credential storage holds for copilot.
+// Untested against a live subscription (needs one) — the exchange shape matches the documented
+// flow used by editor integrations; failures surface as a normal upstream error to the client.
+
+import { providerKey } from "../config.ts";
+
+let cached: { token: string; expiresAt: number } | null = null;
+
+/** Drop the cached bearer (e.g. after an upstream 401 — revoked token or clock skew). */
+export function invalidateCopilotBearer(): void {
+  cached = null;
+}
+
+/** The bearer to send to api.githubcopilot.com, or "" if no Copilot credentials are configured. */
+export async function copilotBearer(): Promise<string> {
+  const direct = process.env.COPILOT_API_KEY;
+  if (direct) return direct;
+  const gh = process.env.COPILOT_GITHUB_TOKEN;
+  if (!gh) return providerKey("copilot") ?? ""; // stored credential, or unconfigured
+  if (cached && Date.now() < cached.expiresAt - 60_000) return cached.token;
+  const res = await fetch("https://api.github.com/copilot_internal/v2/token", {
+    headers: { authorization: `token ${gh}`, "user-agent": "ada" },
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!res.ok) throw new Error(`Copilot token exchange failed: HTTP ${res.status} — is COPILOT_GITHUB_TOKEN a GitHub token on an account with a Copilot subscription?`);
+  const j = (await res.json()) as { token?: string; expires_at?: number };
+  if (!j.token) throw new Error("Copilot token exchange returned no token");
+  cached = { token: j.token, expiresAt: (j.expires_at ?? Math.floor(Date.now() / 1000) + 600) * 1000 };
+  return cached.token;
+}

package/src/server/providers/openai-compat.ts

@@ -4,17 +4,35 @@
 // that format, this adapter just swaps in the upstream base URL + key and streams the
 // response straight back — no translation needed.
 
+import { readFileSync } from "node:fs";
 import type { ProviderName } from "../../shared/types.ts";
 import { PROVIDERS, providerKey } from "../config.ts";
 import { SSE_HEADERS } from "../sse.ts";
 import type { Adapter, ChatRequest } from "./adapter.ts";
+import { copilotBearer, invalidateCopilotBearer } from "./copilot-token.ts";
 
-function authHeaders(provider: ProviderName): Record<string, string> {
+const ADA_VERSION = (() => {
+  try {
+    return (JSON.parse(readFileSync(new URL("../../../package.json", import.meta.url), "utf8")) as { version?: string }).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+})();
+
+async function authHeaders(provider: ProviderName): Promise<Record<string, string>> {
+  // GitHub Copilot: bearer comes from the token exchange (or COPILOT_API_KEY), plus the
+  // editor-identification headers its endpoint requires.
+  if (provider === "copilot") {
+    const bearer = await copilotBearer();
+    return {
+      ...(bearer ? { authorization: `Bearer ${bearer}` } : {}),
+      "Copilot-Integration-Id": "vscode-chat",
+      "Editor-Version": `ada/${ADA_VERSION}`,
+      "Editor-Plugin-Version": `ada/${ADA_VERSION}`,
+    };
+  }
   const key = providerKey(provider);
-  const base: Record<string, string> = key ? { authorization: `Bearer ${key}` } : {};
-  // GitHub Copilot's endpoint requires these editor-identification headers.
-  if (provider === "copilot") return { ...base, "Copilot-Integration-Id": "vscode-chat", "Editor-Version": "ada/0.0.1", "Editor-Plugin-Version": "ada/0.0.1" };
-  return base;
+  return key ? { authorization: `Bearer ${key}` } : {};
 }
 
 export const openAICompatAdapter: Adapter = {
@@ -28,7 +46,7 @@ export const openAICompatAdapter: Adapter = {
     try {
       upstream = await fetch(`${def.baseURL}/chat/completions`, {
         method: "POST",
-        headers: { "content-type": "application/json", ...authHeaders(provider) },
+        headers: { "content-type": "application/json", ...(await authHeaders(provider)) },
         body: JSON.stringify(outBody),
       });
     } catch (e) {
@@ -42,6 +60,8 @@ export const openAICompatAdapter: Adapter = {
     }
 
     if (!upstream.ok || !upstream.body) {
+      // A dead exchanged bearer (revoked / clock skew) would otherwise be reused until local expiry.
+      if (provider === "copilot" && upstream.status === 401) invalidateCopilotBearer();
       const text = await upstream.text().catch(() => "");
       res.writeHead(upstream.status || 502, { "content-type": "application/json" });
       res.end(text || JSON.stringify({ error: { message: `upstream error ${upstream.status}` } }));
@@ -67,7 +87,7 @@ export const openAICompatAdapter: Adapter = {
   async listModels(provider: ProviderName): Promise<string[]> {
     const def = PROVIDERS[provider];
     try {
-      const r = await fetch(`${def.baseURL}/models`, { headers: authHeaders(provider) });
+      const r = await fetch(`${def.baseURL}/models`, { headers: await authHeaders(provider) });
       if (!r.ok) return [];
       const j = (await r.json()) as { data?: Array<{ id?: unknown }> };
       return (j.data ?? []).map((m) => m.id).filter((x): x is string => typeof x === "string");