@saadnvd1/agent-os 0.3.744 → 0.3.749

package/components/Settings/NoApprovalsSection.test.ts

@@ -38,6 +38,7 @@ vi.mock("@/data/approvals", () => ({
   }),
 }));
 
+const { TooltipProvider } = await import("@/components/ui/tooltip");
 const { NoApprovalsSection } = await import("./NoApprovalsSection");
 const { NoApprovalsBadge } =
   await import("@/components/Approvals/NoApprovalsBadge");
@@ -112,10 +113,12 @@ describe("the No approvals toggle", () => {
 
 describe("the badge", () => {
   it("shows only while the mode is on", () => {
-    render(createElement(NoApprovalsBadge));
+    const badge = () =>
+      createElement(TooltipProvider, null, createElement(NoApprovalsBadge));
+    render(badge());
     expect(host.textContent).toBe("");
     state.on = true;
-    render(createElement(NoApprovalsBadge));
+    render(badge());
     expect(host.textContent).toContain("No approvals");
   });
 });

package/lib/chat/demo.ts

@@ -11,6 +11,7 @@ import type {
   ChatClientMessage,
   ChatServerMessage,
   ChatState,
+  Compacting,
   ModelWait,
 } from "./events";
 import { demoConversation } from "./drivers/demo";
@@ -31,7 +32,10 @@ const sends = new Map<string, number>();
 
 // What a demo chat is doing, for a watcher that connects mid-turn (the stored
 // items alone would show a running step as stopped).
-const live = new Map<string, { state: ChatState; wait: ModelWait | null }>();
+const live = new Map<
+  string,
+  { state: ChatState; wait: ModelWait | null; compacting: Compacting | null }
+>();
 
 /** The demo chat's running turn, or null with none. */
 export function demoLive(sessionId: string) {
@@ -46,6 +50,18 @@ function conversation(sessionId: string): ChatConversation {
   let tracker = new ModelWaitTracker();
   void (async () => {
     for await (const e of c.events) {
+      if (e.type === "compacting") {
+        // The tokens before are the scripted prompt's (drivers/demo-script).
+        const compacting = e.active
+          ? { since: Date.now(), before: 48_200 }
+          : null;
+        const state = live.get(sessionId);
+        if (state) state.compacting = compacting;
+        tracker.on({ type: "compacting", compacting } as WorkerEvent);
+        emit(sessionId, { type: "compacting", compacting });
+        emit(sessionId, { type: "model_wait", wait: tracker.wait });
+        continue;
+      }
       // Each turn follows its own waits, whatever the last one left.
       if (e.type === "state" && e.state === "running")
         tracker = new ModelWaitTracker();
@@ -53,7 +69,12 @@ function conversation(sessionId: string): ChatConversation {
         emit(sessionId, { type: "model_wait", wait: tracker.wait });
       if (e.type === "state") {
         if (e.state === "idle") live.delete(sessionId);
-        else live.set(sessionId, { state: e.state, wait: tracker.wait });
+        else
+          live.set(sessionId, {
+            state: e.state,
+            wait: tracker.wait,
+            compacting: null,
+          });
       }
       const state = live.get(sessionId);
       if (state) state.wait = tracker.wait;

package/lib/chat/drivers/demo-script.ts

@@ -4,12 +4,17 @@
  * model, a retry) for a set time, then finishes. Demo only: the demo driver
  * is the one place that reads it (AGENTOS_DEMO=1; no real session gets here).
  *
- *     demo: running turn [step|wait|retry] [hold=<seconds>]
+ *     demo: running turn [step|wait|retry|compact|stalled|empty] [hold=<seconds>]
+ *
+ * compact holds a compaction; stalled and empty end the turn the way a stalled
+ * model request and an empty reply after compaction do (with a Retry).
  */
 
-import type { DriverEvent } from "../events";
+import type { DriverEvent, TurnEndReason } from "../events";
+import { COMPACTION_EMPTY_NOTICE, stalledNotice } from "./turn-outcome";
 
-export type DemoPhase = "step" | "wait" | "retry";
+export type DemoPhase =
+  "step" | "wait" | "retry" | "compact" | "stalled" | "empty";
 
 export interface DemoScript {
   // Hold only this state; none runs all three, one after the other.
@@ -19,7 +24,8 @@ export interface DemoScript {
 
 export const DEFAULT_HOLD_S = 30;
 export const MAX_HOLD_S = 120;
-const TRIGGER = /^demo: running turn(?: (step|wait|retry))?(?: hold=(\d+))?$/;
+const TRIGGER =
+  /^demo: running turn(?: (step|wait|retry|compact|stalled|empty))?(?: hold=(\d+))?$/;
 
 export function parseDemoScript(text: string): DemoScript | null {
   const m = TRIGGER.exec(text.trim());
@@ -99,6 +105,13 @@ async function runningStep(run: ScriptRun, id: string, holdMs: number) {
   });
 }
 
+// A compaction of a big context, held, then done.
+async function compacting(run: ScriptRun, holdMs: number) {
+  run.push({ type: "compacting", active: true });
+  await hold(run, holdMs);
+  run.push({ type: "compacting", active: false });
+}
+
 export async function runDemoScript(
   script: DemoScript,
   run: ScriptRun,
@@ -108,6 +121,13 @@ export async function runDemoScript(
   const phases: DemoPhase[] = script.phase
     ? [script.phase]
     : ["step", "wait", "retry"];
+  // The end of a turn that stopped short, after one finished step.
+  const ending: { reason: TurnEndReason; notice: string } | undefined =
+    script.phase === "stalled"
+      ? { reason: "stalled", notice: stalledNotice(22 * 60_000, false) }
+      : script.phase === "empty"
+        ? { reason: "compaction_empty", notice: COMPACTION_EMPTY_NOTICE }
+        : undefined;
   run.push({ type: "state", state: "running" });
   run.push({ type: "turn_start" });
   run.push({
@@ -124,6 +144,11 @@ export async function runDemoScript(
     if (run.stopped()) break;
     if (phase === "step")
       await runningStep(run, `demo-t-${runId}`, script.holdMs);
+    else if (phase === "stalled" || phase === "empty") {
+      await runningStep(run, `demo-t-${runId}`, 0);
+      if (phase === "empty") await compacting(run, script.holdMs);
+      else await hold(run, script.holdMs);
+    } else if (phase === "compact") await compacting(run, script.holdMs);
     else {
       if (phase === "retry")
         run.push({
@@ -141,6 +166,7 @@ export async function runDemoScript(
       kind: "turn_end",
       durationMs: Date.now() - started,
       interrupted: run.stopped() || undefined,
+      ended: run.stopped() ? undefined : ending,
       createdAt: Date.now(),
     },
   });

package/lib/chat/drivers/opencode-config.ts

@@ -13,6 +13,11 @@ type P = Record<string, unknown>;
 // that never answers still ends the request.
 export const HEADER_TIMEOUT_MS = 1_200_000;
 
+// How long a turn may wait on the model with no sign of life before AgentOS
+// stops it. Just past one header timeout: OpenCode would retry the same
+// stall up to five more times, hours on a local model.
+export const STALL_MS = HEADER_TIMEOUT_MS + 120_000;
+
 const isObject = (v: unknown): v is P =>
   !!v && typeof v === "object" && !Array.isArray(v);
 

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

@@ -2,7 +2,13 @@ import { randomUUID } from "crypto";
 import type { DriverEvent, UsageTotals } from "../events";
 import { openCodeTool } from "./opencode-rules";
 import { TurnItems } from "./turn-items";
-import { logTurnEnd, needsSummary, turnOutcome } from "./turn-outcome";
+import {
+  logTurnEnd,
+  needsSummary,
+  stalledNotice,
+  turnOutcome,
+  type TurnEnded,
+} from "./turn-outcome";
 import { retryNotice, TurnRetry, type RetryDecision } from "./transient-retry";
 
 type P = Record<string, unknown>;
@@ -12,6 +18,9 @@ const num = (v: unknown) => Number(v) || 0;
 // A prompt this big (tokens) is worth compacting before the last retry.
 const HEAVY_TOKENS = 16_000;
 
+// Events that show the session is alive; a retry notice is not one.
+const PROGRESS = /^(message\.|session\.(status|compacted|error)|todo\.)/;
+
 const TODO = new Set(["pending", "in_progress", "completed"]);
 
 // OpenCode's event stream as chat items, for one session (its subagents'
@@ -63,6 +72,15 @@ export class OpenCodeMapper {
   lastInputTokens = 0;
   // Compacting between retries makes the session busy and idle: not a turn.
   private holding = false;
+  // OpenCode is compacting the context (its summary request is out).
+  private compacting = false;
+  // A compaction ran in this turn; the messages that are its summary.
+  private compacted = false;
+  private summaries = new Set<string>();
+  // Tool calls not finished yet: the turn waits on them, not on the model.
+  private open = new Set<string>();
+  // When the session last did anything: the stall watchdog's clock.
+  private progressAt = Date.now();
 
   constructor(
     private sessionId: () => string | null,
@@ -84,12 +102,26 @@ export class OpenCodeMapper {
       this.agentRetried = false;
     }
     this.admitted = false;
+    this.progressAt = Date.now();
     this.items.startTurn();
   }
 
+  // How long the turn has waited on the model without a sign of life; 0
+  // while it isn't waiting on one (a tool runs, a retry is queued).
+  silentMs(now = Date.now()): number {
+    if (!this.items.inTurn || this.holding || this.retrying || this.open.size)
+      return 0;
+    return Math.max(0, now - this.progressAt);
+  }
+
   map(e: P): void {
     const p = (e.properties ?? {}) as P;
     if (p.sessionID && p.sessionID !== this.sessionId()) return;
+    if (
+      PROGRESS.test(e.type as string) &&
+      !(e.type === "session.status" && str((p.status as P)?.type) === "retry")
+    )
+      this.progressAt = Date.now();
     switch (e.type) {
       case "session.status": {
         const type = str((p.status as P)?.type);
@@ -113,6 +145,8 @@ export class OpenCodeMapper {
       case "session.error":
         return this.failed(p.error as P | undefined);
       case "session.compacted":
+        this.compacted = true;
+        this.setCompacting(false);
         return this.emit({
           type: "item",
           item: { id: randomUUID(), kind: "compacted", createdAt: Date.now() },
@@ -144,7 +178,15 @@ export class OpenCodeMapper {
     this.current.add(id);
     this.roles.set(id, str(info.role));
     if (info.role !== "assistant") return;
-    if (this.last.id !== id)
+    const summary =
+      info.summary === true ||
+      info.mode === "compaction" ||
+      info.agent === "compaction";
+    if (summary) {
+      this.summaries.add(id);
+      this.setCompacting(!(info.time as P)?.completed && !info.error);
+    }
+    if (!summary && this.last.id !== id)
       this.last = {
         id,
         finish: "",
@@ -153,9 +195,11 @@ export class OpenCodeMapper {
         text: new Map(),
         calls: new Set(),
       };
-    this.last.finish = str(info.finish) || this.last.finish;
-    this.last.provider = str(info.providerID) || this.last.provider;
-    this.last.model = str(info.modelID) || this.last.model;
+    if (!summary) {
+      this.last.finish = str(info.finish) || this.last.finish;
+      this.last.provider = str(info.providerID) || this.last.provider;
+      this.last.model = str(info.modelID) || this.last.model;
+    }
     if (info.error) this.failed(info.error as P);
     if (!(info.time as P)?.completed || this.counted.has(id)) return;
     this.counted.add(id);
@@ -181,8 +225,12 @@ export class OpenCodeMapper {
     const id = str(part.id);
     if (this.past.has(id) || this.past.has(str(part.messageID))) return;
     this.current.add(id);
+    // A compaction starts as a part of the message that asks for it.
+    if (part.type === "compaction") return this.setCompacting(true);
     // Only the agent's own messages: the prompt comes back as a part too.
     if (this.roles.get(str(part.messageID)) !== "assistant") return;
+    // The summary is the agent's memory, not part of the reply.
+    if (this.summaries.has(str(part.messageID))) return;
     if (part.type === "text" || part.type === "reasoning") {
       if (part.synthetic || part.ignored) return;
       const kind = part.type === "text" ? "assistant" : "reasoning";
@@ -200,6 +248,11 @@ export class OpenCodeMapper {
     }
     if (part.type === "tool") {
       this.toolIds.add(id);
+      const done = ["completed", "error"].includes(
+        str((part.state as P | undefined)?.status)
+      );
+      if (done) this.open.delete(id);
+      else this.open.add(id);
       if (this.last.id === str(part.messageID)) this.last.calls.add(id);
       this.tool(id, part);
     }
@@ -234,8 +287,15 @@ export class OpenCodeMapper {
       this.items.toolDone(id, "error", str(state.error), start);
   }
 
+  private setCompacting(on: boolean): void {
+    if (on === this.compacting) return;
+    this.compacting = on;
+    this.emit({ type: "compacting", active: on });
+  }
+
   private failed(error: P | undefined): void {
     if (!error) return;
+    this.setCompacting(false);
     if (error.name === "MessageAbortedError") this.aborted = true;
     else
       this.error =
@@ -268,6 +328,9 @@ export class OpenCodeMapper {
     for (const id of this.current) this.past.add(id);
     this.current.clear();
     this.parts.clear();
+    this.open.clear();
+    this.summaries.clear();
+    this.compacted = false;
   }
 
   // A failed turn is waiting for its retry to go out.
@@ -287,6 +350,7 @@ export class OpenCodeMapper {
 
   private idle(): void {
     if (this.holding || !this.admitted || !this.items.inTurn) return;
+    this.setCompacting(false);
     if (this.error && !this.aborted && this.retryTurn()) return;
     this.emit({ type: "usage", totals: { ...this.totals } });
     const text = [...this.last.text.values()].join("\n");
@@ -308,18 +372,26 @@ export class OpenCodeMapper {
       console.info("[chat] asked the model for its results summary");
       return;
     }
-    const ended =
-      this.aborted || !this.last.id
-        ? undefined
-        : turnOutcome({
-            finishReason: this.last.finish,
-            text,
-            toolCalls: this.last.calls.size,
-            error: this.error ?? undefined,
-            retries: this.retry.tried,
-            agentRetried: this.agentRetried,
-            summary: this.items.summary(),
-          });
+    const ended = this.aborted
+      ? undefined
+      : turnOutcome({
+          finishReason: this.last.finish,
+          text,
+          toolCalls: this.last.calls.size,
+          compacted: this.compacted,
+          toolsDone: /tool/i.test(this.last.finish) && !this.open.size,
+          error: this.error ?? undefined,
+          retries: this.retry.tried,
+          agentRetried: this.agentRetried,
+          summary: this.items.summary(),
+        });
+    this.finish(ended, text);
+    this.clearTurn();
+    this.nudged = this.nudgeDue = false;
+  }
+
+  // The turn is over: the end told, then the state reset.
+  private finish(ended: TurnEnded | undefined, text: string): void {
     if (ended)
       logTurnEnd({
         driver: "opencode",
@@ -335,6 +407,21 @@ export class OpenCodeMapper {
       finishReason: this.last.finish || undefined,
       ended,
     });
+  }
+
+  // The model stayed silent past the limit: the driver stops the session and
+  // the turn ends here, with what it got through kept.
+  stalled(ms: number): void {
+    if (!this.items.inTurn) return;
+    const compacting = this.compacting;
+    this.setCompacting(false);
+    this.retrying = false;
+    this.emit({ type: "usage", totals: { ...this.totals } });
+    const ended: TurnEnded = {
+      reason: "stalled",
+      notice: stalledNotice(ms, compacting),
+    };
+    this.finish(ended, "");
     this.clearTurn();
     this.nudged = this.nudgeDue = false;
   }

package/lib/chat/drivers/opencode.ts

@@ -8,7 +8,7 @@ import { openCodeRules } from "./opencode-rules";
 import { OpenCodeServer } from "./opencode-server";
 import { OpenCodeApprovals } from "./opencode-approvals";
 import { RESULTS_BRIEF, SUMMARY_NUDGE } from "./turn-outcome";
-import { openCodeConfigContent } from "./opencode-config";
+import { openCodeConfigContent, STALL_MS } from "./opencode-config";
 import { writeOpenCodeGuard } from "./opencode-plugin";
 import { typescriptPath } from "./edit-guard";
 import { continuePrompt, type RetryDecision } from "./transient-retry";
@@ -44,6 +44,9 @@ function conversationEnv(
   }
 }
 
+// How often a waiting turn is checked for silence.
+const WATCH_MS = 30_000;
+
 // How long a prompt may go without the session turning busy before the
 // turn is checked on.
 const ADMIT_MS = 15_000;
@@ -142,6 +145,20 @@ export const openCodeDriver: ChatDriver = {
     const held: { text: string; images?: ChatImage[] }[] = [];
     const stream = new AbortController();
     let closed = false;
+    // A turn silent for STALL_MS (an env override is for tests only) is
+    // stopped: OpenCode's own retries could wait for hours.
+    const stallMs = Number(process.env.AGENTOS_OPENCODE_STALL_MS) || STALL_MS;
+    const watchdog = setInterval(
+      () => {
+        const silent = mapper.silentMs();
+        if (silent < stallMs) return;
+        cancelRetry();
+        mapper.stalled(silent);
+        void abort();
+      },
+      Math.min(WATCH_MS, stallMs / 2)
+    );
+    watchdog.unref();
 
     const fail = (error: Error) => mapper.items.error(error.message);
     const ours = (id: unknown) => id === sessionId || children.has(str(id));
@@ -286,6 +303,7 @@ export const openCodeDriver: ChatDriver = {
     function close() {
       if (closed) return;
       closed = true;
+      clearInterval(watchdog);
       cancelRetry();
       approvals.pending.expireAll();
       stream.abort();

package/lib/chat/drivers/turn-outcome.ts

@@ -80,10 +80,26 @@ export function failureReport(o: {
   return `The model's server ${kind === "timeout" ? "timed out" : "kept failing"} (${why})${tries}. ${done} Not finished: the model's next reply, so the task is incomplete. Send "continue" to resume; the finished steps are kept.`;
 }
 
+export const COMPACTION_EMPTY_NOTICE =
+  'The model returned nothing after compaction, so the task is incomplete. Retry sends "continue"; the finished steps are kept.';
+
+export const CUT_OFF_NOTICE =
+  'The turn stopped right after a tool step, before the model replied, so the task may be incomplete. Retry sends "continue"; the finished steps are kept.';
+
+// Said when a model request got no answer for the whole stall limit.
+export function stalledNotice(ms: number, compacting: boolean): string {
+  const min = Math.max(1, Math.round(ms / 60_000));
+  return `${compacting ? "The model didn't finish compacting the context" : "Model request stalled"}: no response for ${plural(min, "minute")}, so AgentOS stopped waiting. The finished steps are kept. Retry sends "continue".`;
+}
+
 export function turnOutcome(r: {
   finishReason?: string;
   text: string;
   toolCalls: number;
+  // A compaction ran in this turn.
+  compacted?: boolean;
+  // Every tool call of the turn has finished.
+  toolsDone?: boolean;
   error?: string;
   retries?: number;
   agentRetried?: boolean;
@@ -107,7 +123,12 @@ export function turnOutcome(r: {
           })
         : "The model's server returned an error, shown above.",
     };
-  if (r.toolCalls > 0) return undefined;
+  if (r.toolCalls > 0)
+    return r.toolsDone
+      ? { reason: "cut_off", notice: CUT_OFF_NOTICE }
+      : undefined;
+  if (r.compacted && !r.text.trim())
+    return { reason: "compaction_empty", notice: COMPACTION_EMPTY_NOTICE };
   if (hasToolMarkup(r.text))
     return {
       reason: "parse_failure",

package/lib/chat/events.ts

@@ -27,6 +27,8 @@ export interface ChatModel {
   value: string;
   label: string;
   description?: string;
+  // Why it can't be picked now; it is listed greyed with this.
+  disabled?: string;
 }
 
 export type ToolStatus = "running" | "done" | "error" | "stopped";
@@ -151,7 +153,16 @@ interface Base {
 }
 
 export type TurnEndReason =
-  "no_tool_call" | "length" | "parse_failure" | "empty" | "error";
+  | "no_tool_call"
+  | "length"
+  | "parse_failure"
+  | "empty"
+  | "error"
+  // The model gave no reply for too long, or none after a compaction, or
+  // the turn stopped right after a tool step.
+  | "stalled"
+  | "compaction_empty"
+  | "cut_off";
 
 export type ChatItem =
   | (Base & {

package/lib/chat/group.ts

@@ -1,8 +1,16 @@
-import type { ChatItem } from "./events";
+import type { ChatItem, TurnEndReason } from "./events";
 import { readingOrder } from "./reading-order";
 import { stepCounts, type StepCounts } from "./tool-outcome";
 import { eventTurnAt, type EventTurn } from "./turns";
 
+// Ends that stop a turn mid-task: they show how many steps got done.
+const CUT_SHORT = new Set<TurnEndReason>([
+  "error",
+  "stalled",
+  "compaction_empty",
+  "cut_off",
+]);
+
 export type ToolItem = Extract<ChatItem, { kind: "tool" }>;
 export type UndoItem = Extract<ChatItem, { kind: "undo" }>;
 
@@ -99,7 +107,8 @@ export function groupTimeline(
       flush();
       const cut =
         item.kind === "turn_end" &&
-        (item.interrupted || item.ended?.reason === "error");
+        (item.interrupted ||
+          (item.ended !== undefined && CUT_SHORT.has(item.ended.reason)));
       blocks.push(
         cut && turnTools.length
           ? { type: "item", item, steps: stepCounts(turnTools) }

package/lib/chat/progress.ts

@@ -7,6 +7,8 @@ export type Phase = "planning" | "coding" | "testing" | "error";
 
 // A wait on one model call this long gets a hint that it may be normal.
 export const LONG_WAIT_MS = 2 * 60_000;
+export const LONG_COMPACT_HINT =
+  "Compacting a large context on a local model can take minutes.";
 export const LONG_WAIT_HINT =
   "Still waiting on the model; large prompts on local models can take minutes";
 
@@ -118,6 +120,8 @@ export function currentActivity(
       compacting: true,
       kind: "compacting",
       steps: 0,
+      hint:
+        now - compacting.since > LONG_WAIT_MS ? LONG_COMPACT_HINT : undefined,
     };
   const lastUser = items.findLast((i) => i.kind === "user" && !i.midTurn);
   const tools = turnTools(items);

package/lib/chat/role-models.ts

@@ -0,0 +1,46 @@
+/**
+ * The model list in a role session's composer. A chat's own list is whatever
+ * its agent reports (for Claude Code, only Claude's aliases), so an analyst
+ * would never be offered Qwen, Pi's models or DeepSeek. An analyst's list is
+ * the server's one catalog instead, with each model it can't move to greyed
+ * and given the reason.
+ */
+
+import type { Session } from "../db";
+import { modelDisplayName } from "../model-catalog";
+import { modelCatalog, unconfiguredChoices } from "../models/catalog";
+import { PI } from "../models/providers";
+import { sessionModelRef } from "../models/resolve";
+import { ANTHROPIC } from "../models/roles";
+import { analystBlock } from "../models/usable";
+import type { ChatModel } from "./events";
+
+const isAnalystChat = (s: Session) =>
+  s.agent_role === "analyst" &&
+  (s.agent_type === "claude" || s.agent_type === "pi");
+
+// The session's model as a ref, which is what its list's values are.
+export const composerModelValue = (s: Session): string =>
+  s.agent_type === "pi" ? `${PI}/${s.model}` : sessionModelRef(s);
+
+export function roleComposerModels(
+  session: Session,
+  own: ChatModel[]
+): ChatModel[] {
+  if (!isAnalystChat(session)) return own;
+  const agent = session.agent_type === "pi" ? "pi" : "claude";
+  const list = [...modelCatalog(), ...unconfiguredChoices()].map(
+    (c): ChatModel => {
+      const disabled = analystBlock(c, { agent });
+      return {
+        value: c.ref,
+        label: c.ref.startsWith(`${ANTHROPIC}/`)
+          ? modelDisplayName(c.label)
+          : c.label,
+        description: c.group,
+        ...(disabled && { disabled }),
+      };
+    }
+  );
+  return list.length ? list : own;
+}

package/lib/chat/runner-watch.ts

@@ -44,7 +44,7 @@ export function watchChat(sessionId: string, listener: Listener): () => void {
     hasMore: page.hasMore,
     tasks: present(sessionId, tasks),
     state: live?.state ?? demo?.state ?? "idle",
-    compacting: live?.compacting ?? null,
+    compacting: live?.compacting ?? demo?.compacting ?? null,
     modelWait: live?.modelWait ?? demo?.wait ?? null,
     queue: listQueue(sessionId),
     suggestion: getSession(sessionId).chat_suggestion ?? null,

package/lib/chat/settings.ts

@@ -9,6 +9,7 @@ import { db, type Session } from "../db";
 import { agentEnv } from "../agents/launch";
 import { modelDisplayName, resolveModelForAgent } from "../model-catalog";
 import { chatDriverFor } from "./drivers";
+import { composerModelValue, roleComposerModels } from "./role-models";
 import {
   CHAT_ACCESS,
   type ChatAccess,
@@ -75,15 +76,17 @@ export function cachedCommands(session: Session): ChatCommand[] {
 export function emitCapabilities(session: Session, listener?: Listener): void {
   const caps = registry.caps.get(capsKey(session));
   if (!caps) return;
-  const model = chatModel(session);
+  const models = roleComposerModels(session, caps.models);
+  const model =
+    models === caps.models ? chatModel(session) : composerModelValue(session);
   const m: ChatServerMessage = {
     type: "capabilities",
     commands: visibleCommands(caps),
-    models: caps.models,
+    models,
     model,
     modelLabel:
-      caps.models.find((o) => o.value === model)?.label ??
-      modelDisplayName(model),
+      models.find((o) => o.value === model)?.label ??
+      modelDisplayName(chatModel(session)),
     access: effectiveChatAccess(session.chat_access),
     plan: canPlan(session) ? !!session.chat_plan && !noApprovalsOn() : null,
     background: chatDriverFor(session.agent_type)?.backgroundTasks === true,

package/lib/chat/socket.ts

@@ -24,12 +24,12 @@ import {
   sendChat,
   sendQueuedNow,
   setChatAccess,
-  setChatModel,
   setChatPlan,
   stopChatTask,
   undoChat,
   watchChat,
 } from "./runner";
+import { setComposerModel } from "../models/session-model";
 import { stopChatTurn } from "./stop";
 import { clientSend } from "./client-send";
 import { searchChat } from "./search";
@@ -189,7 +189,8 @@ function onChatMessage(
         .then(answer)
     );
   } else if (msg.type === "interrupt") run(stopChatTurn(sessionId));
-  else if (msg.type === "set_model") run(setChatModel(sessionId, msg.model));
+  else if (msg.type === "set_model")
+    run(setComposerModel(sessionId, msg.model));
   else if (msg.type === "set_access") run(setChatAccess(sessionId, msg.access));
   else if (msg.type === "set_plan") run(setChatPlan(sessionId, !!msg.plan));
   else if (msg.type === "refresh_commands") run(refreshCapabilities(sessionId));