@1agh/maude 0.45.1 → 0.46.0

package/apps/studio/client/panels/acp-runtime.js

@@ -144,6 +144,45 @@ export function createAcpConnection() {
   const commandListeners = new Set();
   let commands = [];
 
+  // Session capabilities (feature-acp-panel-dynamic-claude-code-capabilities)
+  // — the live, dynamic replacement for the old hardcoded MODELS/EFFORTS
+  // arrays. `caps` = `{modes, configOptions}`, sourced entirely from the ACP
+  // session (never a static list); `sessionInfo` = the agent-generated title.
+  const capsListeners = new Set();
+  let caps = { modes: null, configOptions: [] };
+  const sessionInfoListeners = new Set();
+  let sessionInfo = { title: null, updatedAt: null };
+
+  // Usage (Milestone D) — the raw `usage` frame's payload, replayed on
+  // subscribe like caps/commands/sessionInfo above. Parsed into render-ready
+  // shape by acp-usage.js's parseUsage, not here (keep this file transport-only).
+  const usageListeners = new Set();
+  let usage = null;
+
+  // Pending permission requests (Milestone B — retires DDR-125 F2's blanket
+  // auto-approve). Surfaced OUTSIDE the assistant-ui message stream (like
+  // commands/caps above) via a panel-level subscription, since a request can
+  // arrive mid-turn and the run() loop only understands text/tool-call/
+  // reasoning parts — not "pause here for a human decision."
+  const permissionListeners = new Set();
+  let pendingPermissions = [];
+  function emitPermissions() {
+    const snap = pendingPermissions.slice();
+    for (const fn of permissionListeners) fn(snap);
+  }
+
+  // Pending elicitation requests (feature-acp-ask-user-question — AskUserQuestion
+  // + generic MCP form input). Same "outside the assistant-ui message stream"
+  // treatment as pendingPermissions above, for the same reason: a request can
+  // arrive mid-turn and the run() loop only understands text/tool-call/reasoning
+  // parts, not "pause here for a human form."
+  const elicitationListeners = new Set();
+  let pendingElicitations = [];
+  function emitElicitations() {
+    const snap = pendingElicitations.slice();
+    for (const fn of elicitationListeners) fn(snap);
+  }
+
   function emitStatus() {
     for (const fn of statusListeners) fn({ ...status });
   }
@@ -184,6 +223,22 @@ export function createAcpConnection() {
     emitBackground();
   }
 
+  // Connection-problem error card (Task C3) — the bridge `error` frame (a
+  // socket/adapter failure mid-turn) is ALSO thrown from prompt()'s generator
+  // (so assistant-ui's own turn-failed bookkeeping still runs), but a thrown
+  // generator error renders as a bare, unstyled assistant-ui fallback. Expose
+  // it as its own channel too so the panel can render a proper retry card
+  // instead — same "chrome, not turn content" treatment as commands/caps.
+  const errorListeners = new Set();
+  let lastError = null; // { message } | null
+  function emitError() {
+    for (const fn of errorListeners) fn(lastError);
+  }
+  function setError(message) {
+    lastError = message ? { message } : null;
+    emitError();
+  }
+
   function onFrame(frame) {
     if (frame.t === 'ready') {
       status.ready = true;
@@ -199,6 +254,62 @@ export function createAcpConnection() {
       for (const fn of commandListeners) fn(commands);
       return;
     }
+    // Same treatment for the capability channel — chrome, not turn content,
+    // arrives on establish + on every live mode/config-option change.
+    if (frame.t === 'caps') {
+      caps = { modes: frame.modes ?? null, configOptions: frame.configOptions ?? [] };
+      for (const fn of capsListeners) fn(caps);
+      return;
+    }
+    if (frame.t === 'session-info') {
+      sessionInfo = { title: frame.title ?? null, updatedAt: frame.updatedAt ?? null };
+      for (const fn of sessionInfoListeners) fn(sessionInfo);
+      return;
+    }
+    if (frame.t === 'usage') {
+      usage = frame.usage ?? null;
+      for (const fn of usageListeners) fn(usage);
+      return;
+    }
+    if (frame.t === 'permission-request') {
+      pendingPermissions = [
+        ...pendingPermissions,
+        { id: frame.id, toolCall: frame.toolCall, options: frame.options ?? [] },
+      ];
+      emitPermissions();
+      return;
+    }
+    if (frame.t === 'elicitation-request') {
+      pendingElicitations = [
+        ...pendingElicitations,
+        {
+          id: frame.id,
+          message: frame.message,
+          mode: frame.mode,
+          requestedSchema: frame.requestedSchema,
+          // Present only when this elicitation is scoped to a specific tool
+          // call (e.g. the built-in AskUserQuestion) — absent for a raw
+          // session-scoped MCP-server elicitation. ElicitationPrompt.jsx uses
+          // this to avoid a blanket "from Claude" attribution it can't back up.
+          toolCallId: frame.toolCallId,
+        },
+      ];
+      emitElicitations();
+      return;
+    }
+    // The bridge settled a pending elicitation itself (timeout/cancel/stop) —
+    // drop it from the pending list even though the client never responded,
+    // so the card doesn't sit open with a Submit button that's already dead.
+    // A client-driven response already removed its own entry optimistically
+    // (respondElicitation below), so this is a no-op for that path — it only
+    // does real work for a settlement the client didn't initiate.
+    if (frame.t === 'elicitation-resolved') {
+      if (pendingElicitations.some((p) => p.id === frame.id)) {
+        pendingElicitations = pendingElicitations.filter((p) => p.id !== frame.id);
+        emitElicitations();
+      }
+      return;
+    }
     // Everything else belongs to the active prompt turn.
     trackActivity(frame);
     if (turnHandler) turnHandler(frame);
@@ -256,6 +367,13 @@ export function createAcpConnection() {
       return () => backgroundListeners.delete(fn);
     },
 
+    /** Subscribe to the connection-problem error card's source (Task C3); replays the current one, if any. */
+    onError(fn) {
+      errorListeners.add(fn);
+      fn(lastError);
+      return () => errorListeners.delete(fn);
+    },
+
     /** Subscribe to the slash-command catalogue; replays the current list. */
     onCommands(fn) {
       commandListeners.add(fn);
@@ -263,12 +381,111 @@ export function createAcpConnection() {
       return () => commandListeners.delete(fn);
     },
 
+    /** Subscribe to the live capability set (`{modes, configOptions}`); replays the current snapshot. */
+    onCaps(fn) {
+      capsListeners.add(fn);
+      fn(caps);
+      return () => capsListeners.delete(fn);
+    },
+
+    /** Subscribe to the agent-generated chat title; replays the current snapshot. */
+    onSessionInfo(fn) {
+      sessionInfoListeners.add(fn);
+      fn(sessionInfo);
+      return () => sessionInfoListeners.delete(fn);
+    },
+
+    /** Subscribe to the raw usage frame (Milestone D); replays the current snapshot (may be null). */
+    onUsage(fn) {
+      usageListeners.add(fn);
+      fn(usage);
+      return () => usageListeners.delete(fn);
+    },
+
+    /** Subscribe to the list of currently-pending permission requests; replays the current snapshot. */
+    onPermission(fn) {
+      permissionListeners.add(fn);
+      fn(pendingPermissions);
+      return () => permissionListeners.delete(fn);
+    },
+
+    /** Subscribe to the list of currently-pending elicitation requests; replays the current snapshot. */
+    onElicitation(fn) {
+      elicitationListeners.add(fn);
+      fn(pendingElicitations);
+      return () => elicitationListeners.delete(fn);
+    },
+
+    /**
+     * Answer a pending permission request — `decision` is one of the
+     * request's own `options[].optionId`, or `'cancelled'` to reject. Removes
+     * it from the pending list optimistically (the server has no separate
+     * "resolved" frame; the turn just continues). A response for an id that's
+     * no longer pending (already timed out, or a duplicate click) is a no-op.
+     */
+    async respondPermission(id, decision) {
+      if (!pendingPermissions.some((p) => p.id === id)) return;
+      pendingPermissions = pendingPermissions.filter((p) => p.id !== id);
+      emitPermissions();
+      try {
+        await ensureOpen();
+        ws?.send(JSON.stringify({ t: 'permission-response', id, decision }));
+      } catch {
+        /* socket unavailable — the bridge's own timeout will deny this request */
+      }
+    },
+
+    /**
+     * Answer a pending elicitation request — `response` is `{ action, content? }`,
+     * `action` one of `'accept'`/`'decline'`/`'cancel'`. Mirrors `respondPermission`
+     * exactly, including the optimistic removal + no-op-on-stale-id behavior.
+     */
+    async respondElicitation(id, response) {
+      if (!pendingElicitations.some((p) => p.id === id)) return;
+      pendingElicitations = pendingElicitations.filter((p) => p.id !== id);
+      emitElicitations();
+      try {
+        await ensureOpen();
+        ws?.send(JSON.stringify({ t: 'elicitation-response', id, ...response }));
+      } catch {
+        /* socket unavailable — the bridge's own timeout will decline this request */
+      }
+    },
+
+    /**
+     * Live-set the session mode (Manual/Plan/…) for `chatId` on an
+     * ALREADY-established session — no respawn. Fire-and-forget like `warm`;
+     * the server validates against its own last-advertised roster and
+     * silently ignores an unadvertised id, so a stale/racy pick never corrupts
+     * state — the next `caps` frame is the source of truth either way.
+     */
+    async setMode(chatId, modeId) {
+      try {
+        await ensureOpen();
+        ws?.send(JSON.stringify({ t: 'set-mode', chat: chatId || undefined, modeId }));
+      } catch {
+        /* socket unavailable — non-fatal */
+      }
+    },
+
+    /** Live-set one config option (model/effort/fast/…) for `chatId`. See `setMode`. */
+    async setConfig(chatId, configId, value) {
+      try {
+        await ensureOpen();
+        ws?.send(JSON.stringify({ t: 'set-config', chat: chatId || undefined, configId, value }));
+      } catch {
+        /* socket unavailable — non-fatal */
+      }
+    },
+
     /**
      * Warm the adapter WITHOUT prompting so the agent publishes its command
      * catalogue. Fired when the user starts typing a slash command. Best-effort;
-     * a dead socket just leaves autocomplete on the static list.
+     * a dead socket just leaves autocomplete on the static list. `model`/
+     * `effort`/`mode` are the user's PERSISTED picks — applied once, live, by
+     * the bridge right after the session establishes (never onto an existing one).
      */
-    async warm(chatId, model, effort) {
+    async warm(chatId, model, effort, mode) {
       try {
         await ensureOpen();
         ws?.send(
@@ -277,6 +494,7 @@ export function createAcpConnection() {
             chat: chatId || undefined,
             model: model || undefined,
             effort: effort || undefined,
+            mode: mode || undefined,
           })
         );
       } catch {
@@ -287,17 +505,25 @@ export function createAcpConnection() {
     /**
      * Drive one prompt turn. Async-generates the bridge's `update` frames until
      * `turn-end`; throws on `error`; sends `cancel` when `abortSignal` aborts.
+     * `model`/`effort`/`mode` — see `warm`.
      */
-    async *prompt(text, chatId, abortSignal, model, effort) {
-      await ensureOpen();
+    async *prompt(text, chatId, abortSignal, model, effort, mode) {
+      try {
+        await ensureOpen();
+      } catch (err) {
+        setError(err?.message || 'Could not reach the Claude bridge.');
+        throw err;
+      }
       const queue = [];
       let wake = null;
       let ended = false;
       let failure = null;
       turnHandler = (frame) => {
         if (frame.t === 'turn-end') ended = true;
-        else if (frame.t === 'error') failure = frame.message || 'The Claude bridge errored.';
-        else queue.push(frame); // update / connected / permission
+        else if (frame.t === 'error') {
+          failure = frame.message || 'The Claude bridge errored.';
+          setError(failure); // Task C3 — the styled retry card's source
+        } else queue.push(frame); // update / connected / permission
         if (wake) {
           const w = wake;
           wake = null;
@@ -319,6 +545,7 @@ export function createAcpConnection() {
       // setBusy(true) fires FIRST so the finished-ping deferral (ChatPanel) sees
       // busy before these empty emits.
       resetBackground();
+      setError(null); // a fresh turn clears any stale card from a prior failure
       if (activeTools.size) {
         activeTools.clear();
         emitActivity();
@@ -331,6 +558,7 @@ export function createAcpConnection() {
             chat: chatId || undefined,
             model: model || undefined,
             effort: effort || undefined,
+            mode: mode || undefined,
           })
         );
         for (;;) {
@@ -369,7 +597,9 @@ export function createAcpConnection() {
   };
 }
 
-function lastUserText(messages) {
+/** The last user message's plain text — shared by the adapter's run() AND the
+ *  connection-problem card's "Try again" (Task C3), which re-sends it verbatim. */
+export function lastUserText(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
     const m = messages[i];
     if (m.role !== 'user') continue;
@@ -512,7 +742,15 @@ function expandPasteChips(text, map) {
  * parts, preserving the order in which the agent emits them. `available_commands_update`
  * and `usage_update` are intentionally dropped (chrome noise, not chat content).
  */
-export function makeAcpAdapter(conn, getChatId, getModel, getEffort, getAttachments, getContext) {
+export function makeAcpAdapter(
+  conn,
+  getChatId,
+  getModel,
+  getEffort,
+  getAttachments,
+  getContext,
+  getMode
+) {
   return {
     async *run({ messages, abortSignal }) {
       // Let any in-flight clipboard-image upload finish so its chip expands to a
@@ -540,7 +778,8 @@ export function makeAcpAdapter(conn, getChatId, getModel, getEffort, getAttachme
         getChatId(),
         abortSignal,
         getModel?.(),
-        getEffort?.()
+        getEffort?.(),
+        getMode?.()
       )) {
         if (frame.t !== 'update') continue;
         applyUpdate(parts, toolIndex, frame.update);

package/apps/studio/client/panels/acp-usage.js

@@ -0,0 +1,65 @@
+// Pure parser for the `usage` WS frame (Milestone D — context-window meter +
+// cost + single-window rate-limit banner). Scope is deliberately the genuinely
+// dynamic subset the ACP adapter exposes today (see the plan's Milestone D
+// research): a context-window gauge + session cost (from `usage_update`) and
+// an event-driven SINGLE-window rate-limit signal (`SDKRateLimitInfo` riding
+// `_meta["_claude/rateLimit"]`). The full multi-window "Plan usage limits"
+// panel is explicitly OUT of scope — that data isn't reachable through the
+// pinned adapter version; do not fabricate it here.
+
+const RATE_LIMIT_LABELS = {
+  five_hour: '5-hour limit',
+  seven_day: 'Weekly limit',
+  seven_day_opus: 'Weekly · Opus',
+  seven_day_sonnet: 'Weekly · Sonnet',
+  seven_day_overage_included: 'Weekly (overage included)',
+  overage: 'Overage',
+};
+
+/** A friendly label for an `SDKRateLimitInfo.rateLimitType` — an unrecognized
+ *  or missing type falls back to a generic label rather than `undefined`, so
+ *  a future rate-limit-type the adapter adds still renders something sane. */
+function rateLimitLabel(type) {
+  return RATE_LIMIT_LABELS[type] || 'Usage limit';
+}
+
+/**
+ * `{ used, size, cost?, rateLimit? }` (the bridge's `BridgeUsage` shape, sent
+ * verbatim in a `{t:'usage', usage}` frame) → the render-ready shape:
+ *   { context: { used, size, pct } | null, cost: {amount,currency} | null,
+ *     rateLimit: { type, label, pct, resetsAt, status } | null, asOf }
+ * Tolerant of a missing/malformed frame or `_meta` — always returns a valid,
+ * renderable (if mostly-null) shape rather than throwing. `now` defaults to
+ * `Date.now()`; callers (tests) can inject a fixed value for determinism.
+ */
+export function parseUsage(frame, now = Date.now()) {
+  const usage = frame && typeof frame === 'object' ? frame.usage : null;
+  const asOf = now;
+  if (!usage || typeof usage !== 'object') {
+    return { context: null, cost: null, rateLimit: null, asOf };
+  }
+  const used = typeof usage.used === 'number' ? usage.used : null;
+  const size = typeof usage.size === 'number' ? usage.size : null;
+  const context =
+    used != null && size != null && size > 0
+      ? { used, size, pct: Math.max(0, Math.min(100, Math.round((used / size) * 100))) }
+      : null;
+  const cost =
+    usage.cost && typeof usage.cost === 'object' && typeof usage.cost.amount === 'number'
+      ? { amount: usage.cost.amount, currency: usage.cost.currency || 'USD' }
+      : null;
+
+  const raw = usage.rateLimit;
+  let rateLimit = null;
+  if (raw && typeof raw === 'object' && typeof raw.status === 'string') {
+    rateLimit = {
+      type: raw.rateLimitType || null,
+      label: rateLimitLabel(raw.rateLimitType),
+      pct: typeof raw.utilization === 'number' ? Math.max(0, Math.min(100, Math.round(raw.utilization))) : null,
+      resetsAt: raw.resetsAt || null,
+      status: raw.status,
+    };
+  }
+
+  return { context, cost, rateLimit, asOf };
+}

package/apps/studio/client/panels/transcript-view.js

@@ -0,0 +1,36 @@
+// Pure transcript view-mode filter (Task C4). Operates on a message's raw
+// content parts BEFORE grouping (ToolGroup.jsx) — a pure, order-preserving
+// filter, never a hardcoded assumption about what part types exist beyond the
+// three the adapter emits (text / reasoning / tool-call).
+
+export const TRANSCRIPT_VIEWS = ['normal', 'thinking', 'verbose', 'summary'];
+export const DEFAULT_TRANSCRIPT_VIEW = 'normal';
+
+/**
+ * `parts` (a message's content array) + `mode` → the parts to actually render.
+ *   - normal   — text + tool-calls; reasoning hidden (today's default look).
+ *   - thinking — everything, including reasoning ("Thinking" disclosures).
+ *   - verbose  — everything (same set as thinking); the extra "verbose-ness"
+ *                is a RENDER-detail toggle (see transcriptForcesExpand), not a
+ *                different part set — tool calls stay visible either way.
+ *   - summary  — only the LAST text part (the final answer), nothing else.
+ * An unrecognized mode falls back to `normal` rather than showing everything
+ * (fail toward less noise, not more).
+ */
+export function filterTranscriptParts(parts, mode) {
+  const list = Array.isArray(parts) ? parts : [];
+  if (mode === 'summary') {
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i]?.type === 'text') return [list[i]];
+    }
+    return [];
+  }
+  if (mode === 'thinking' || mode === 'verbose') return list.slice();
+  return list.filter((p) => p?.type !== 'reasoning'); // normal (and any unknown mode)
+}
+
+/** Verbose mode auto-expands tool-call detail (groups start open, cards show
+ *  raw args/result) instead of requiring a click per card. */
+export function transcriptForcesExpand(mode) {
+  return mode === 'verbose';
+}