@saadnvd1/agent-os 0.3.524 → 0.3.528

package/lib/chat/drivers/copilot-mapper.ts

@@ -0,0 +1,203 @@
+import type { ChatContext, DriverEvent, UsageTotals } from "../events";
+import { toolTitle } from "../tools";
+import { TurnItems, type ToolStart } from "./turn-items";
+
+type P = Record<string, unknown>;
+const str = (v: unknown) => (typeof v === "string" ? v : "");
+
+const TODO_STATUS = {
+  pending: "pending",
+  in_progress: "in_progress",
+  completed: "completed",
+} as const;
+
+// "*** Update File: f.txt" in an apply_patch the agent made.
+const patchFile = (patch: string) =>
+  patch.match(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/m)?.[1]?.trim();
+
+export function toolStart(update: P): ToolStart {
+  const raw = update.rawInput;
+  const input = (typeof raw === "object" && raw ? raw : {}) as P;
+  const file =
+    str(input.path) ||
+    str(input.fileName) ||
+    str((update.locations as P[] | undefined)?.[0]?.path) ||
+    (typeof raw === "string" ? patchFile(raw) : undefined) ||
+    "";
+  const title = str(update.title);
+  switch (str(update.kind)) {
+    case "execute": {
+      const command = str(input.command);
+      return {
+        name: "Bash",
+        title: toolTitle("Bash", { command, description: input.description }),
+        input: { command, description: input.description },
+      };
+    }
+    case "edit":
+    case "delete":
+    case "move":
+      return {
+        name: "Edit",
+        title: file ? toolTitle("Edit", { file_path: file }) : title,
+        input: { file_path: file },
+      };
+    case "read":
+      if (input.pattern)
+        return {
+          name: "Glob",
+          title: toolTitle("Glob", { pattern: input.pattern }),
+          input,
+        };
+      return {
+        name: "Read",
+        title: toolTitle("Read", { file_path: file }),
+        input: { file_path: file },
+      };
+    case "search":
+      return {
+        name: "Grep",
+        title: toolTitle("Grep", { pattern: input.pattern ?? input.query }),
+        input,
+      };
+    case "fetch":
+      return {
+        name: "WebFetch",
+        title: toolTitle("WebFetch", { url: input.url }),
+        input,
+      };
+    default:
+      return { name: title || "Tool", title: title || "Tool", input: raw };
+  }
+}
+
+function contentText(update: P): string {
+  const parts = (update.content as P[] | undefined) ?? [];
+  const text = parts
+    .map((c) => (c.type === "content" ? str((c.content as P)?.text) : ""))
+    .filter(Boolean)
+    .join("\n");
+  if (text) return text;
+  const raw = (update.rawOutput ?? {}) as P;
+  return str(raw.content);
+}
+
+// Copilot's session updates as chat items. One per conversation.
+export class CopilotMapper {
+  readonly items: TurnItems;
+  readonly totals: UsageTotals = {
+    costUsd: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+  };
+  // Text before and after a tool call are separate bubbles.
+  private block = 0;
+  // A resumed conversation replays its history before it's ready: not ours.
+  replaying = false;
+
+  constructor(private emit: (e: DriverEvent) => void) {
+    this.items = new TurnItems(emit);
+  }
+
+  map(update: P): void {
+    if (this.replaying) return;
+    const text = str((update.content as P | undefined)?.text);
+    switch (str(update.sessionUpdate)) {
+      case "agent_message_chunk":
+        this.items.startTurn();
+        return this.items.delta(`m${this.block}`, "assistant", text);
+      case "agent_thought_chunk":
+        this.items.startTurn();
+        return this.items.delta(`r${this.block}`, "reasoning", text);
+      case "tool_call":
+        return this.started(update);
+      case "tool_call_update":
+        return this.updated(update);
+      case "plan":
+        return this.items.todos(
+          ((update.entries as P[]) ?? []).map((e) => ({
+            text: str(e.content),
+            status:
+              TODO_STATUS[str(e.status) as keyof typeof TODO_STATUS] ??
+              "pending",
+          }))
+        );
+      case "usage_update":
+        return this.context(update);
+    }
+  }
+
+  private close(): void {
+    this.items.finishText(`m${this.block}`, "assistant");
+    this.items.finishText(`r${this.block}`, "reasoning");
+    this.block++;
+  }
+
+  private started(update: P): void {
+    this.items.startTurn();
+    this.close();
+    this.items.tool(str(update.toolCallId), toolStart(update));
+  }
+
+  private updated(update: P): void {
+    const id = str(update.toolCallId);
+    const status = str(update.status);
+    if (status !== "completed" && status !== "failed") return;
+    const start = toolStart(update);
+    if (!this.items.hasTool(id)) this.items.tool(id, start);
+    const diff = ((update.content as P[]) ?? []).find((c) => c.type === "diff");
+    const changed = diff
+      ? {
+          path: str(diff.path),
+          before: str(diff.oldText),
+          after: str(diff.newText),
+        }
+      : undefined;
+    this.items.toolDone(
+      id,
+      status === "failed" ? "error" : "done",
+      contentText(update),
+      changed
+        ? {
+            name: "Edit",
+            title: toolTitle("Edit", { file_path: changed.path }),
+            diff: changed,
+          }
+        : undefined
+    );
+  }
+
+  private context(update: P): void {
+    const used = Number(update.used);
+    const max = Number(update.size);
+    if (!max || !Number.isFinite(used)) return;
+    const context: ChatContext = {
+      usedTokens: used,
+      maxTokens: max,
+      percentage: Math.round((used / max) * 1000) / 10,
+      categories: [],
+      at: Date.now(),
+    };
+    this.emit({ type: "context", context });
+  }
+
+  // What a finished prompt spent. The CLI counts cached tokens in its input.
+  spent(usage: P | undefined): void {
+    if (!usage) return;
+    const read = Number(usage.cachedReadTokens) || 0;
+    const written = Number(usage.cachedWriteTokens) || 0;
+    const input = Number(usage.inputTokens) || 0;
+    this.totals.inputTokens += Math.max(0, input - read - written);
+    this.totals.outputTokens += Number(usage.outputTokens) || 0;
+    this.totals.cacheReadTokens += read;
+    this.totals.cacheWriteTokens += written;
+  }
+
+  endTurn(end: { interrupted?: boolean; error?: string }): void {
+    this.close();
+    this.emit({ type: "usage", totals: { ...this.totals } });
+    this.items.endTurn(end);
+  }
+}

package/lib/chat/drivers/copilot-rpc.ts

@@ -0,0 +1,126 @@
+import { AgentChild } from "./child";
+
+export interface AcpMessage {
+  id?: number | string;
+  method?: string;
+  params?: Record<string, unknown>;
+  result?: unknown;
+  error?: { code?: number; message?: string };
+}
+
+const REQUEST_MS = 60_000;
+
+// The GitHub Copilot CLI as an Agent Client Protocol server: JSON-RPC 2.0
+// over the stdio of `copilot --acp`. Its own requests to us (permission
+// prompts) count their ids separately from ours.
+export class CopilotRpc {
+  private child: AgentChild;
+  private nextId = 1;
+  private calls = new Map<
+    number,
+    { resolve: (r: unknown) => void; reject: (e: Error) => void }
+  >();
+
+  constructor(
+    args: string[],
+    options: { cwd: string; env: NodeJS.ProcessEnv },
+    handlers: {
+      notify: (method: string, params: Record<string, unknown>) => void;
+      request: (
+        id: number | string,
+        method: string,
+        params: Record<string, unknown>
+      ) => void;
+      exit: (error: string) => void;
+    }
+  ) {
+    this.child = new AgentChild(
+      "copilot",
+      ["--acp", "--no-auto-update", ...args],
+      {
+        ...options,
+        onRecord: (r) => {
+          const m = r as AcpMessage;
+          if (m.method && m.id !== undefined)
+            handlers.request(m.id, m.method, m.params ?? {});
+          else if (m.method) handlers.notify(m.method, m.params ?? {});
+          else if (typeof m.id === "number") this.settle(m);
+        },
+        onExit: (code, error) => {
+          const why =
+            error ??
+            `GitHub Copilot stopped (exit ${code ?? "signal"})${this.child.errorTail ? `: ${this.child.errorTail}` : ""}`;
+          for (const call of this.calls.values()) call.reject(new Error(why));
+          this.calls.clear();
+          handlers.exit(why);
+        },
+      }
+    );
+  }
+
+  private settle(m: AcpMessage): void {
+    const call = this.calls.get(m.id as number);
+    if (!call) return;
+    this.calls.delete(m.id as number);
+    if (m.error)
+      call.reject(new Error(m.error.message ?? "GitHub Copilot error"));
+    else call.resolve(m.result);
+  }
+
+  // A timeout of 0 waits as long as it takes (a prompt runs a whole turn).
+  request<T>(
+    method: string,
+    params: unknown = {},
+    timeoutMs = REQUEST_MS
+  ): Promise<T> {
+    const id = this.nextId++;
+    return new Promise<T>((resolve, reject) => {
+      const timer = timeoutMs
+        ? setTimeout(() => {
+            this.calls.delete(id);
+            reject(new Error(`GitHub Copilot didn't answer ${method}`));
+          }, timeoutMs)
+        : undefined;
+      this.calls.set(id, {
+        resolve: (r) => {
+          clearTimeout(timer);
+          resolve(r as T);
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          reject(e);
+        },
+      });
+      this.child.write({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+
+  notify(method: string, params?: unknown): void {
+    this.child.write({ jsonrpc: "2.0", method, params });
+  }
+
+  reply(id: number | string, result: unknown): void {
+    this.child.write({ jsonrpc: "2.0", id, result });
+  }
+
+  replyError(id: number | string, message: string): void {
+    this.child.write({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32601, message },
+    });
+  }
+
+  // No file or terminal access offered: the agent uses its own.
+  async initialize(): Promise<void> {
+    await this.request("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: {},
+      clientInfo: { name: "agentos", title: "AgentOS", version: "1.0.0" },
+    });
+  }
+
+  close(): void {
+    this.child.kill();
+  }
+}

package/lib/chat/drivers/copilot.ts

@@ -0,0 +1,174 @@
+import type { ChatConversation, ChatDriver, ChatStartOptions } from "../driver";
+import type { ChatImage, DriverEvent } from "../events";
+import { InputQueue } from "../queue";
+import { AGENT_DEFAULT_MODEL } from "../../providers/registry";
+import { CopilotApprovals } from "./copilot-approvals";
+import { CopilotMapper } from "./copilot-mapper";
+import { CopilotRpc } from "./copilot-rpc";
+
+type P = Record<string, unknown>;
+
+export function copilotArgs(o: ChatStartOptions): string[] {
+  const args: string[] = [];
+  if (o.model && o.model !== AGENT_DEFAULT_MODEL) args.push("--model", o.model);
+  return args;
+}
+
+export function copilotPrompt(text: string, images?: ChatImage[]) {
+  return [
+    { type: "text", text },
+    ...(images ?? []).map((i) => ({
+      type: "image",
+      data: i.data,
+      mimeType: i.mediaType,
+    })),
+  ];
+}
+
+// The GitHub Copilot CLI over the Agent Client Protocol (`copilot --acp`).
+// It has no system prompt to append to, so the instructions go ahead of the
+// first message of a new conversation.
+export const copilotDriver: ChatDriver = {
+  id: "copilot",
+  plan: false,
+  inProcessTools: false,
+  atRest: false,
+
+  // The ACP server lists no models or commands without a session; the agent
+  // picks its own model unless one is chosen.
+  async discover() {
+    return { commands: [], models: [] };
+  },
+
+  start(options): ChatConversation {
+    const out = new InputQueue<DriverEvent>();
+    const emit = (e: DriverEvent) => out.push(e);
+    const mapper = new CopilotMapper(emit);
+    const approvals = new CopilotApprovals(emit, options.access);
+    let sessionId: string | null = null;
+    let busy = false;
+    let intro = options.resumeId ? "" : (options.systemAppend ?? "").trim();
+    // Messages that can't join the running turn wait for it to end, in order.
+    const held: { text: string; images?: ChatImage[] }[] = [];
+    const rpc: CopilotRpc = new CopilotRpc(
+      copilotArgs(options),
+      { cwd: options.cwd, env: { ...process.env, ...options.env } },
+      {
+        notify(method, params) {
+          if (method === "session/update")
+            mapper.map((params.update ?? {}) as P);
+        },
+        request(id, method, params) {
+          if (method !== "session/request_permission")
+            return rpc.replyError(id, `${method} isn't supported`);
+          void approvals.handle(params).then((result) => rpc.reply(id, result));
+        },
+        exit(error) {
+          approvals.pending.expireAll();
+          mapper.endTurn({ error });
+          out.end();
+        },
+      }
+    );
+    emit({ type: "usage_start", totals: { ...mapper.totals } });
+
+    const ready = rpc.initialize().then(async () => {
+      const params = { cwd: options.cwd, mcpServers: [] };
+      if (options.resumeId) {
+        mapper.replaying = true;
+        try {
+          await rpc.request("session/load", {
+            ...params,
+            sessionId: options.resumeId,
+          });
+          sessionId = options.resumeId;
+        } catch {
+          mapper.items.error(
+            "That conversation is gone, so this one starts over"
+          );
+          intro = (options.systemAppend ?? "").trim();
+        } finally {
+          mapper.replaying = false;
+        }
+      }
+      if (!sessionId)
+        sessionId = (
+          await rpc.request<{ sessionId: string }>("session/new", params)
+        ).sessionId;
+      emit({ type: "resume_id", id: sessionId });
+    });
+    ready.catch((error: Error) => {
+      mapper.items.error(`GitHub Copilot couldn't start: ${error.message}`);
+      mapper.endTurn({});
+      out.end();
+      rpc.close();
+    });
+
+    async function run(text: string, images?: ChatImage[]) {
+      busy = true;
+      mapper.items.startTurn();
+      let end: { interrupted?: boolean; error?: string } = {};
+      try {
+        await ready;
+        const first = intro ? `${intro}\n\n${text}` : text;
+        intro = "";
+        const r = await rpc.request<P>(
+          "session/prompt",
+          { sessionId, prompt: copilotPrompt(first, images) },
+          0
+        );
+        mapper.spent(r.usage as P | undefined);
+        end = { interrupted: r.stopReason === "cancelled" };
+      } catch (error) {
+        end = { error: (error as Error).message };
+      }
+      busy = false;
+      mapper.endTurn(end);
+      const next = held.shift();
+      if (next) void run(next.text, next.images);
+    }
+
+    function stop() {
+      approvals.pending.expireAll();
+      if (busy && sessionId) rpc.notify("session/cancel", { sessionId });
+    }
+
+    return {
+      send(text, images, sendOptions) {
+        if (!busy) void run(text, images);
+        else {
+          held.push({ text, images });
+          if (sendOptions?.now) stop();
+        }
+        return undefined;
+      },
+      // Stops the turn only: a message already sent still goes after it.
+      async interrupt() {
+        stop();
+      },
+      // The model is chosen when the CLI starts.
+      async setModel() {},
+      async setAccess(next) {
+        approvals.access = next;
+      },
+      async setPlan() {},
+      respond(id, answer) {
+        approvals.pending.respond(id, answer);
+      },
+      async stopTask() {},
+      async undo() {
+        return {
+          canUndo: false,
+          error: "GitHub Copilot can't undo from chat",
+          files: [],
+        };
+      },
+      close() {
+        approvals.pending.expireAll();
+        rpc.close();
+        out.end();
+      },
+      events: out,
+    };
+  },
+};

package/lib/chat/drivers/index.ts

@@ -4,6 +4,7 @@ import { claudeDriver } from "./claude";
 import { codexDriver } from "./codex";
 import { openCodeDriver } from "./opencode";
 import { piDriver } from "./pi";
+import { copilotDriver } from "./copilot";
 import { demoDriver } from "./demo";
 import { demoMode } from "../../security/demo";
 
@@ -14,6 +15,7 @@ const DRIVERS: Record<(typeof CHAT_AGENT_TYPES)[number], ChatDriver> = {
   codex: codexDriver,
   pi: piDriver,
   opencode: openCodeDriver,
+  copilot: copilotDriver,
 };
 
 export function chatDriverFor(agentType: string): ChatDriver | null {

package/lib/chat/events.ts

@@ -81,6 +81,8 @@ export interface ChatOrigin {
   body?: string;
   // Lines of an event batch that are the reader's answers to asks.
   decided?: string[];
+  // The tasks it is about, by name, set where the event is delivered.
+  subjects?: { id: string; name: string }[];
   // Only Away mode's own lines: the turn it starts isn't anyone's activity
   // (lib/away/activity).
   away?: true;

package/lib/chat/find.ts

@@ -7,7 +7,12 @@
 
 import type { ChatItem } from "./events";
 import { lineDiff } from "./diff";
-import { groupTimeline, STANDALONE_TOOLS, type ToolItem } from "./group";
+import {
+  groupTimeline,
+  STANDALONE_TOOLS,
+  type GroupOptions,
+  type ToolItem,
+} from "./group";
 import { eventParts, originOf } from "./origin";
 
 export const MIN_QUERY = 2;
@@ -170,7 +175,11 @@ function rowKeys(item: ChatItem): string[] {
  * so it's on screen: a step inside its folded run, a message inside an undo.
  * Null when it isn't loaded (or the timeline never shows it).
  */
-export function locate(items: ChatItem[], id: string): Located | null {
+export function locate(
+  items: ChatItem[],
+  id: string,
+  opts: GroupOptions = {}
+): Located | null {
   const at = items.findIndex((i) => i.id === id);
   if (at === -1) return null;
   const inside = (
@@ -182,16 +191,28 @@ export function locate(items: ChatItem[], id: string): Located | null {
         return { open: [...open, ...rowKeys(b.item)] };
       if (b.type === "tools" && b.tools.some((t) => t.id === id))
         return { open: [...open, `steps:${b.id}`, `tool:${id}`] };
+      if (b.type === "events") {
+        const turn = b.turns.find(
+          (t) => t.id === id || t.replies.some((i) => i.id === id)
+        );
+        if (!turn) continue;
+        const opened = [...open, `events:${b.id}`, `eventturn:${turn.id}`];
+        if (turn.id === id) return { open: [...opened, ...rowKeys(turn.user)] };
+        return inside(groupTimeline(turn.replies), opened) ?? { open: opened };
+      }
       if (b.type === "undone" && b.items.some((i) => i.id === id))
         return (
-          inside(groupTimeline(b.items), [...open, `undone:${b.undo.id}`]) ?? {
+          inside(groupTimeline(b.items, opts), [
+            ...open,
+            `undone:${b.undo.id}`,
+          ]) ?? {
             open: [...open, `undone:${b.undo.id}`],
           }
         );
     }
     return null;
   };
-  const blocks = groupTimeline(items);
+  const blocks = groupTimeline(items, opts);
   const blockOf = (b: (typeof blocks)[number]) =>
     b.type === "item" ? b.item.id : b.id;
   for (const b of blocks) {

package/lib/chat/group.ts

@@ -1,4 +1,5 @@
 import type { ChatItem } from "./events";
+import { eventTurnAt, type EventTurn } from "./turns";
 
 export type ToolItem = Extract<ChatItem, { kind: "tool" }>;
 export type UndoItem = Extract<ChatItem, { kind: "undo" }>;
@@ -6,7 +7,14 @@ export type UndoItem = Extract<ChatItem, { kind: "undo" }>;
 export type TimelineBlock =
   | { type: "item"; item: ChatItem }
   | { type: "tools"; id: string; tools: ToolItem[] }
-  | { type: "undone"; id: string; undo: UndoItem; items: ChatItem[] };
+  | { type: "undone"; id: string; undo: UndoItem; items: ChatItem[] }
+  // Consecutive turns an event started, with the reply to each.
+  | { type: "events"; id: string; turns: EventTurn[] };
+
+export interface GroupOptions {
+  // Fold events and the replies to them (the orchestrator's chat).
+  foldEvents?: boolean;
+}
 
 // Tools worth seeing on their own rather than as one step among many.
 export const STANDALONE_TOOLS = new Set(["Skill", "Task", "Agent"]);
@@ -14,17 +22,45 @@ export const STANDALONE_TOOLS = new Set(["Skill", "Task", "Agent"]);
 // Consecutive tool calls (and the reasoning between them) fold into one
 // collapsible block, so a long turn reads as what was said, not every step.
 // Undone messages fold into one block behind the undo that took them back.
-export function groupTimeline(items: ChatItem[]): TimelineBlock[] {
+export function groupTimeline(
+  items: ChatItem[],
+  opts: GroupOptions = {}
+): TimelineBlock[] {
   const blocks: TimelineBlock[] = [];
   let tools: ToolItem[] = [];
   const flush = () => {
     if (tools.length) blocks.push({ type: "tools", id: tools[0].id, tools });
     tools = [];
   };
+  let turns: EventTurn[] = [];
+  const flushTurns = () => {
+    if (turns.length)
+      blocks.push({ type: "events", id: `ev-${turns[0].id}`, turns });
+    turns = [];
+  };
   const ends = undoneRanges(items);
+  // Where the next undone range starts: a turn stops short of it.
+  const starts = [...ends.keys()].sort((a, b) => a - b);
   for (let i = 0; i < items.length; i++) {
     const item = items[i];
     const end = ends.get(i);
+    if (opts.foldEvents && end === undefined && item.kind === "user") {
+      const limit = starts.find((s) => s > i) ?? items.length;
+      const found = eventTurnAt(items, i, limit);
+      if (found) {
+        flush();
+        turns.push(found.turn);
+        i = found.end - 1;
+        continue;
+      }
+    }
+    // What the timeline never shows doesn't break a run of events.
+    const hidden =
+      item.kind === "task" ||
+      (item.kind === "approval" &&
+        item.status !== "pending" &&
+        !(item.status === "answered" && item.questions));
+    if (!hidden) flushTurns();
     if (end !== undefined) {
       flush();
       blocks.push({
@@ -57,6 +93,7 @@ export function groupTimeline(items: ChatItem[]): TimelineBlock[] {
     }
   }
   flush();
+  flushTurns();
   return blocks;
 }
 
@@ -89,6 +126,17 @@ export function sameBlock(a: TimelineBlock, b: TimelineBlock): boolean {
     return sameItems(a.tools, b.tools);
   if (a.type === "undone" && b.type === "undone")
     return a.undo === b.undo && sameItems(a.items, b.items);
+  if (a.type === "events" && b.type === "events")
+    return (
+      a.id === b.id &&
+      a.turns.length === b.turns.length &&
+      a.turns.every(
+        (t, i) =>
+          t.user === b.turns[i].user &&
+          t.live === b.turns[i].live &&
+          sameItems(t.replies, b.turns[i].replies)
+      )
+    );
   return false;
 }