@frebreco/canvas 0.6.0-next.2 → 0.6.0-next.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frebreco/canvas",
-  "version": "0.6.0-next.2",
+  "version": "0.6.0-next.4",
   "description": "A multiplayer canvas for coding agents that run on your machine.",
   "license": "MIT",
   "type": "module",

package/src/server/agents.ts

@@ -45,6 +45,8 @@ import type {
   SessionMeta,
   SessionSnapshot,
 } from "../shared/protocol";
+import { PLAN_EVENT } from "../shared/protocol";
+import { todoPlan } from "./todo-plan";
 import { fromAcp, pendingChanges, settingsOf } from "./agent-config";
 import { SKILLS_DIR } from "./skills";
 import { trimEvent } from "./trim-event";
@@ -187,12 +189,18 @@ export class AgentManager {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`no session ${sessionId}`);
     const live = await this.connect(session);
-    const response = await live.acp.setSessionConfigOption({
-      sessionId: live.sessionId,
-      configId,
-      ...(typeof value === "boolean" ? { type: "boolean" as const, value } : { value }),
-    });
-    this.setOptions(session, response.configOptions);
+    try {
+      const response = await live.acp.setSessionConfigOption({
+        sessionId: live.sessionId,
+        configId,
+        ...(typeof value === "boolean" ? { type: "boolean" as const, value } : { value }),
+      });
+      // Sent even unchanged: it is the answer the browser waits for.
+      this.setOptions(session, response.configOptions, true);
+    } catch (cause) {
+      if (session.options) this.options.onOptions(session.meta.id, session.options);
+      throw cause;
+    }
     this.touch(session);
   }
 
@@ -264,6 +272,7 @@ export class AgentManager {
         labels: {
           sessionIdEvent: `${session.meta.agent}.session-id`,
           contentEvent: `${session.meta.agent}.message-content`,
+          planEvent: PLAN_EVENT,
         },
       });
       for await (const chunk of chunks) {
@@ -280,6 +289,7 @@ export class AgentManager {
     this.append(session, {
       kind: "turn-end",
       turnId,
+      at: Date.now(),
       ...(error !== undefined && !cancelled && { error }),
       ...(cancelled && { cancelled: true }),
     });
@@ -424,7 +434,19 @@ export class AgentManager {
   private onUpdate(session: Session, update: SessionUpdate): void {
     if (update.sessionUpdate === "config_option_update")
       return this.setOptions(session, update.configOptions);
+    if (update.sessionUpdate === "usage_update") {
+      const { used, size, cost } = update;
+      const usage = {
+        used,
+        size,
+        ...(cost && { cost: { amount: cost.amount, currency: cost.currency } }),
+      };
+      session.meta = { ...session.meta, usage };
+      return this.options.onMeta(session.meta);
+    }
     session.turn?.queue.push({ kind: "update", update: update as AcpSessionUpdate });
+    const plan = todoPlan(update);
+    if (plan) session.turn?.queue.push({ kind: "update", update: plan as AcpSessionUpdate });
   }
 
   /** Park the agent's ask until the host answers it in the browser. */
@@ -457,9 +479,13 @@ export class AgentManager {
     };
   }
 
-  private setOptions(session: Session, raw: ReadonlyArray<SessionConfigOption>): void {
+  private setOptions(
+    session: Session,
+    raw: ReadonlyArray<SessionConfigOption>,
+    always = false,
+  ): void {
     const options = fromAcp(raw);
-    if (JSON.stringify(options) !== JSON.stringify(session.options)) {
+    if (always || JSON.stringify(options) !== JSON.stringify(session.options)) {
       session.options = options;
       this.options.onOptions(session.meta.id, options);
     }

package/src/server/todo-plan.ts

@@ -0,0 +1,30 @@
+/**
+ * Agents that keep a todo list without sending ACP `plan` updates (opencode's
+ * `todowrite`) still have a plan: the list, in the tool call's input. This
+ * reads it as the plan update the agent would have sent, so a thread knows
+ * one kind of plan only.
+ */
+
+import type { PlanEntry, SessionUpdate } from "@agentclientprotocol/sdk";
+
+const STATUSES = new Set(["pending", "in_progress", "completed"]);
+
+export function todoPlan(update: SessionUpdate): SessionUpdate | null {
+  if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update")
+    return null;
+  const input = update.rawInput as { todos?: unknown } | null | undefined;
+  if (!Array.isArray(input?.todos)) return null;
+  const entries = input.todos.flatMap((todo: unknown): PlanEntry[] => {
+    const { content, status, priority } = (todo ?? {}) as Record<string, unknown>;
+    if (typeof content !== "string" || typeof status !== "string" || !STATUSES.has(status))
+      return [];
+    return [
+      {
+        content,
+        status: status as PlanEntry["status"],
+        priority: priority === "high" || priority === "low" ? priority : "medium",
+      },
+    ];
+  });
+  return entries.length ? { sessionUpdate: "plan", entries } : null;
+}

package/src/shared/protocol.ts

@@ -37,6 +37,17 @@ export interface SessionMeta {
    * shown while the agent is not connected, and re-applied when it reconnects.
    */
   readonly settings?: ReadonlyArray<AgentSetting>;
+  /** How full the agent's context is, as it last said (ACP `usage_update`); not every agent does. */
+  readonly usage?: ContextUsage;
+}
+
+export interface ContextUsage {
+  /** Tokens in the context now. */
+  readonly used: number;
+  /** The context window, in tokens. */
+  readonly size: number;
+  /** The session's cost so far, if the agent knows it. */
+  readonly cost?: { readonly amount: number; readonly currency: string };
 }
 
 export type AgentConfigValue = string | boolean;
@@ -115,10 +126,24 @@ export type AgentEvent =
   | {
       readonly kind: "turn-end";
       readonly turnId: string;
+      /** When it ended (absent in logs from before it was kept). */
+      readonly at?: number;
       readonly error?: string;
       readonly cancelled?: boolean;
     };
 
+/**
+ * The name of the AG-UI `CUSTOM` chunk that carries the agent's plan (an ACP
+ * `plan` update): `{ entries: PlanEntry[] }`, the whole plan each time.
+ */
+export const PLAN_EVENT = "plan";
+
+export interface PlanEntry {
+  readonly content: string;
+  readonly status: "pending" | "in_progress" | "completed";
+  readonly priority?: "high" | "medium" | "low";
+}
+
 export interface SessionSnapshot {
   readonly meta: SessionMeta;
   readonly events: ReadonlyArray<AgentEvent>;