ompchamber 1.2.0 → 2.0.0

package/src/client/hooks/chat/btw/index.ts

@@ -15,18 +15,50 @@
  */
 
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
-import type { AgentImage, BtwState, StreamTransport } from '@/shared/types';
-import { BtwRequestError, abortBtwQuestion, askBtwQuestion, connectBtwStream, deleteBtwTopic, fetchBtwState, promoteBtwTopic } from '@/shared/lib/chat/btw/client';
+import type { AgentImage, Attachment, BtwState, ChatMessageData, StreamTransport } from '@/shared/types';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { attachmentImage, readTextAttachments } from '@/shared/lib/chat/attachments';
+import {
+  BtwRequestError,
+  abortBtwQuestion,
+  askBtwQuestion,
+  connectBtwStream,
+  deleteBtwTopic,
+  fetchBtwState,
+  promoteBtwTopic,
+  respondBtwDialog,
+  setBtwAccessMode,
+  setBtwModel,
+  setBtwThinkingLevel,
+} from '@/shared/lib/chat/btw/client';
 import type { StreamConnection } from '@/shared/lib/chat/omp/transport';
 
 /** Images the side session accepts, already read as base64. */
 export type BtwImage = AgentImage;
 
-/** The turn streaming right now; `text` accumulates its deltas. */
+/**
+ * The turn streaming right now. `messages` is the turn's conversation in the
+ * chat's own shape, upserted by `message.id` exactly as the chat stream does —
+ * so the panel renders a live side answer through the same components the chat
+ * uses, tool calls included.
+ */
 export interface BtwLiveAnswer {
   topicId: string;
   turnIndex: number;
-  text: string;
+  messages: ChatMessageData[];
+  /** Activity phrase for the panel's indicator, from the side child's frames. */
+  activity: string;
+}
+
+/**
+ * Composer picks for a topic's FIRST question. A topic that does not exist yet
+ * has no row to write them to, so they ride the ask and reach the spawn; later
+ * questions address an existing topic through the dedicated setters.
+ */
+export interface BtwFirstQuestionPicks {
+  model?: { provider: string; id: string };
+  thinkingLevel?: string;
+  approvalMode?: ApprovalMode;
 }
 
 export interface BtwSessionHandle {
@@ -37,8 +69,12 @@ export interface BtwSessionHandle {
   busy: boolean;
   /** Resolves with the canonical state the command produced, or null when it
    *  was refused (the reason is then in `error`). */
-  ask: (question: string, images?: BtwImage[], topicId?: string) => Promise<BtwState | null>;
+  ask: (question: string, attachments?: Attachment[], topicId?: string, picks?: BtwFirstQuestionPicks) => Promise<BtwState | null>;
   abort: (topicId: string) => Promise<void>;
+  setModel: (topicId: string, provider: string, modelId: string) => Promise<void>;
+  setThinkingLevel: (topicId: string, level: string) => Promise<void>;
+  setAccessMode: (topicId: string, mode: ApprovalMode) => Promise<void>;
+  respondToDialog: (topicId: string, id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => Promise<void>;
   /** Returns the new session id to open, or null when it was refused. */
   promote: (topicId: string) => Promise<string | null>;
   remove: (topicId: string) => Promise<void>;
@@ -74,20 +110,39 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
         switch (frame.type) {
           case 'btw_state':
             setState(frame.state);
-            // A settled turn's text is in the snapshot now; holding the live
-            // buffer any longer would keep painting the partial answer.
+            // The snapshot carries the running turn's conversation, so a client
+            // attaching mid-turn (a reload, a second tab) shows the answer the
+            // child already produced instead of an empty bubble. A snapshot with
+            // no live turn ends the local buffer — the persisted rows own it now.
+            setLive(frame.state.live
+              ? {
+                  topicId: frame.state.live.topicId,
+                  turnIndex: frame.state.live.turnIndex,
+                  messages: frame.state.live.messages,
+                  activity: frame.state.live.activity,
+                }
+              : null);
+            break;
+          case 'btw_message':
+            // Same upsert the chat stream performs: omp emits one frame per
+            // segment carrying that segment's full accumulated content, so a
+            // same-id frame replaces in place and a new id appends.
             setLive((current) => {
-              if (!current) return null;
-              const topic = frame.state.topics.find((candidate) => candidate.id === current.topicId);
-              const turn = topic?.turns.find((candidate) => candidate.index === current.turnIndex);
-              return turn && turn.status === 'running' ? current : null;
+              const base =
+                current && current.topicId === frame.topicId && current.turnIndex === frame.turnIndex
+                  ? current
+                  : { topicId: frame.topicId, turnIndex: frame.turnIndex, messages: [], activity: '' };
+              const existing = base.messages.findIndex((message) => message.id === frame.message.id);
+              const messages =
+                existing === -1
+                  ? [...base.messages, frame.message]
+                  : [...base.messages.slice(0, existing), frame.message, ...base.messages.slice(existing + 1)];
+              return { ...base, messages };
             });
             break;
-          case 'btw_delta':
+          case 'btw_activity':
             setLive((current) =>
-              current && current.topicId === frame.topicId && current.turnIndex === frame.turnIndex
-                ? { ...current, text: current.text + frame.text }
-                : { topicId: frame.topicId, turnIndex: frame.turnIndex, text: frame.text },
+              current && current.topicId === frame.topicId ? { ...current, activity: frame.verb } : current,
             );
             break;
           case 'btw_error':
@@ -127,9 +182,29 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
   );
 
   const ask = useCallback(
-    async (question: string, images?: BtwImage[], topicId?: string): Promise<BtwState | null> => {
+    async (
+      question: string,
+      attachments: Attachment[] = [],
+      topicId?: string,
+      picks?: BtwFirstQuestionPicks,
+    ): Promise<BtwState | null> => {
       setError(null);
-      const next = await run((id) => askBtwQuestion(id, { question, images, topicId }));
+      // Same split the chat send path makes: images travel as provider payloads,
+      // text files are inlined into the prompt. Both are read here, from the
+      // attachments the composer already filled in at attach time.
+      const images = attachments
+        .map((attachment) => attachmentImage(attachment))
+        .filter((image): image is NonNullable<typeof image> => image !== null);
+      const textFiles = (await readTextAttachments(attachments)).filter((file) => !file.missing);
+      const next = await run((id) => askBtwQuestion(id, {
+        question,
+        topicId,
+        ...(images.length ? { images } : {}),
+        ...(textFiles.length ? { textFiles } : {}),
+        // Only a first question carries picks; a follow-up addresses a topic
+        // that already owns them.
+        ...(topicId ? {} : picks ?? {}),
+      }));
       setLive(null);
       if (next && !next.runningTopicId) {
         setError('The side question was accepted but did not start running.');
@@ -147,6 +222,38 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
     [run],
   );
 
+  const setModel = useCallback(
+    async (topicId: string, provider: string, modelId: string) => {
+      setError(null);
+      await run((id) => setBtwModel(id, topicId, provider, modelId));
+    },
+    [run],
+  );
+
+  const setThinkingLevel = useCallback(
+    async (topicId: string, level: string) => {
+      setError(null);
+      await run((id) => setBtwThinkingLevel(id, topicId, level));
+    },
+    [run],
+  );
+
+  const setAccessMode = useCallback(
+    async (topicId: string, mode: ApprovalMode) => {
+      setError(null);
+      await run((id) => setBtwAccessMode(id, topicId, mode));
+    },
+    [run],
+  );
+
+  const respondToDialog = useCallback(
+    async (topicId: string, id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => {
+      setError(null);
+      await run((requestId) => respondBtwDialog(requestId, topicId, id, response));
+    },
+    [run],
+  );
+
   const remove = useCallback(
     async (topicId: string) => {
       setError(null);
@@ -176,5 +283,19 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
 
   const clearError = useCallback(() => setError(null), []);
 
-  return { state, live, error, busy, ask, abort, promote, remove, clearError };
+  return {
+    state,
+    live,
+    error,
+    busy,
+    ask,
+    abort,
+    setModel,
+    setThinkingLevel,
+    setAccessMode,
+    respondToDialog,
+    promote,
+    remove,
+    clearError,
+  };
 }

package/src/client/hooks/chat/btw/intercept.ts

@@ -7,8 +7,13 @@
  * `/btw [question]` typed into the main composer is the side-question entry
  * point, not chat text: the panel owns the token (omp's `/btw` is TUI-only, so
  * nothing downstream would understand it). This module is the whole
- * interception — recognize the command, carry the composer's images across as
- * provider payloads, and hand the question to the panel over `omp:btw`.
+ * interception — recognize the command and hand it, with the composer's
+ * attachments, to the panel over `omp:btw`.
+ *
+ * The attachments cross as the composer's own `Attachment` objects, not as
+ * pre-built provider payloads: the side session accepts the same shapes the chat
+ * does (images as payloads, text files inlined into the prompt), and it makes
+ * that split itself — from the fields the attach step already filled in.
  *
  * It lives beside the rest of the client-side btw state (`hooks/chat/btw/`)
  * rather than in the send handler: the attachment read goes through the shared
@@ -16,7 +21,6 @@
  */
 
 import type { Attachment } from '@/shared/types';
-import { attachmentImage } from '@/shared/lib/chat/attachments';
 
 /** A bare `/btw` opens the form on the current history; anything after it is
  *  the first question. Case-insensitive, because omp's command tokens are. */
@@ -30,13 +34,9 @@ export function dispatchBtwCommand(text: string, attachments: Attachment[]): boo
   const match = BTW_COMMAND_RE.exec(text);
   if (!match) return false;
 
-  const images = attachments
-    .map((attachment) => attachmentImage(attachment))
-    .filter((image): image is NonNullable<typeof image> => image !== null);
-
   window.dispatchEvent(
     new CustomEvent('omp:btw', {
-      detail: { question: match[1]?.trim() ?? '', ...(images.length ? { images } : {}) },
+      detail: { question: match[1]?.trim() ?? '', ...(attachments.length ? { attachments } : {}) },
     }),
   );
   return true;

package/src/client/hooks/chat/btw/mode.ts

@@ -16,17 +16,26 @@
  * arrived with the command is asked immediately, which is what the TUI does.
  */
 
-import { useCallback } from 'preact/hooks';
-import type { BtwState, BtwTopic } from '@/shared/types';
-import { useBtwSession, type BtwImage, type BtwLiveAnswer } from '@/client/hooks/chat/btw';
+import { useCallback, useState } from 'preact/hooks';
+import type { Attachment, BtwDialog, BtwState, BtwTopic, ChatMessageData } from '@/shared/types';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { useBtwSession, type BtwFirstQuestionPicks, type BtwLiveAnswer } from '@/client/hooks/chat/btw';
 import { useChamberEvent } from '@/client/hooks/ui/window-event';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
 import { useSearchParams } from '@/client/lib/router/search-params';
 import { readStreamTransport } from '@/shared/lib/chat/omp/transport';
+import { normalizeApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
+import { readChamberSetting } from '@/shared/lib/settings/client';
 
 /** Question sent when a question arrived carrying only images. */
 const ATTACHMENT_ONLY_QUESTION = 'Describe the attached image.';
 
+/** The composer's persisted access pick, for a topic that has none yet. */
+function readAccessMode(appSettings: Record<string, unknown>): ApprovalMode {
+  return normalizeApprovalMode(readChamberSetting<unknown>('omp_access_mode', appSettings));
+}
+
 export interface BtwMode {
   open: boolean;
   topics: BtwTopic[];
@@ -35,9 +44,16 @@ export interface BtwMode {
   runningTopicId: string | null;
   /** A command is still in flight — the panel holds its actions meanwhile. */
   busy: boolean;
-  /** Partial answer of the running turn, when it belongs to the active topic. */
-  liveAnswer: string;
+  /** The running turn's conversation, chat-shaped; empty when none. */
+  liveMessages: ChatMessageData[];
+  /** What that turn is doing, for the panel's indicator (side stream's own). */
+  liveVerb?: string;
   error: string | null;
+  /** Ask/approval dialogs the side child is blocked on, oldest first. */
+  dialogs: BtwDialog[];
+  /** Access mode the active topic's child runs under. */
+  accessMode: ApprovalMode;
+  thinkingLevel: string;
   askDraft: string;
   followUpDraft: string;
   setAskDraft: (value: string) => void;
@@ -51,8 +67,13 @@ export interface BtwMode {
   /** Submit the ask card: a question of its own. */
   submitAsk: () => void;
   /** Submit the side session's composer: a follow-up to the active topic. */
-  submitFollowUp: (question: string, images?: BtwImage[]) => void;
+  submitFollowUp: (question: string, attachments?: Attachment[]) => void;
   abort: () => void;
+  /** Re-target the side child's model (applies to the running turn). */
+  setModel: (provider: string, modelId: string) => void;
+  setThinkingLevel: (level: string) => void;
+  setAccessMode: (mode: ApprovalMode) => void;
+  respondToDialog: (id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => void;
   /** Returns the session id to open, or null when promotion was refused. */
   promote: () => Promise<string | null>;
   removeTopic: (topicId: string) => void;
@@ -61,7 +82,18 @@ export interface BtwMode {
 }
 
 export function useBtwMode(sessionId: string | null, appSettings: Record<string, unknown>): BtwMode {
-  const [open, setOpen] = useSessionState<boolean>('chat.btwOpen', false);
+  /**
+   * Whether the panel is on screen. Deliberately NOT restored from session
+   * state: a panel that reopens itself on every load leaves the user with no
+   * chat composer and a field they did not ask for, and a `/btw` typed into
+   * that field becomes a real question to the model. The panel is a mode the
+   * user enters, so every load starts in the chat.
+   *
+   * The drafts and the selected topic DO persist (`chat.btwAsk` and friends):
+   * leaving and re-entering the panel loses nothing, which is what those slots
+   * are for.
+   */
+  const [open, setOpen] = useState(false);
   const [askDraft, setAskDraft] = useSessionState<string>('chat.btwAsk', '');
   const [followUpDraft, setFollowUpDraft] = useSessionState<string>('chat.btwFollowUp', '');
   const [selectedTopicId, setSelectedTopicId] = useSessionState<string | null>('chat.btwTopicId', null);
@@ -79,6 +111,26 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
   const runningTopicId = session.state?.runningTopicId ?? null;
   const live: BtwLiveAnswer | null = session.live && session.live.topicId === activeTopic?.id ? session.live : null;
 
+  /**
+   * What the running turn is doing, for the panel's indicator.
+   *
+   * The verb is the SERVER's, derived from the side child's own frames
+   * (`describeAssistantPhase` / `describeToolActivity` over `btw_activity`) —
+   * never the chat's, whose run is a different process. Until the child reports
+   * one the turn is still working, which is all the panel can honestly say.
+   */
+  const liveVerb = live?.activity || (runningTopicId ? PHASE_VERBS.sideQuestion : undefined);
+
+  /**
+   * Composer picks made before a topic exists. They are per-session UI state
+   * rather than props, because the form must show what the FIRST question will
+   * actually run with — the topic that would otherwise own these values has not
+   * been created yet.
+   */
+  const [pendingModel, setPendingModel] = useSessionState<BtwFirstQuestionPicks['model'] | null>('chat.btwModel', null);
+  const [pendingThinking, setPendingThinking] = useSessionState<string>('chat.btwThinking', 'auto');
+  const [pendingAccess, setPendingAccess] = useSessionState<ApprovalMode | null>('chat.btwAccess', null);
+
   const selectNewest = useCallback(
     (next: BtwState | null) => {
       if (!next) return;
@@ -90,30 +142,45 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
   // `/btw [question]` hands the question over; a bare `/btw` only opens the
   // form, which is the history view.
   useChamberEvent('omp:btw', (event) => {
-    const detail = (event as CustomEvent<{ question?: string; images?: BtwImage[] }>).detail;
+    const detail = (event as CustomEvent<{ question?: string; attachments?: Attachment[] }>).detail;
     const question = detail?.question?.trim();
     setOpen(true);
-    if (question || detail?.images?.length) {
+    if (question || detail?.attachments?.length) {
       setAskDraft('');
-      void session.ask(question || ATTACHMENT_ONLY_QUESTION, detail?.images).then(selectNewest);
+      void session.ask(question || ATTACHMENT_ONLY_QUESTION, detail?.attachments).then(selectNewest);
     }
   });
 
+  /**
+   * What the next FIRST question will run with: the composer's picks until a
+   * topic exists, then that topic's own settings. Every setter below writes to
+   * the topic when there is one and to this pending slot when there is not —
+   * a pick that only reached the UI would silently not apply.
+   */
+  const firstQuestionPicks = useCallback(
+    (): BtwFirstQuestionPicks => ({
+      ...(pendingModel ? { model: pendingModel } : {}),
+      ...(pendingThinking && pendingThinking !== 'auto' ? { thinkingLevel: pendingThinking } : {}),
+      ...(pendingAccess ? { approvalMode: pendingAccess } : {}),
+    }),
+    [pendingModel, pendingThinking, pendingAccess],
+  );
+
   const submitAsk = useCallback(() => {
     const question = askDraft.trim();
     if (!question) return;
     setAskDraft('');
-    void session.ask(question).then(selectNewest);
-  }, [askDraft, session, setAskDraft, selectNewest]);
+    void session.ask(question, undefined, undefined, firstQuestionPicks()).then(selectNewest);
+  }, [askDraft, session, setAskDraft, selectNewest, firstQuestionPicks]);
 
   const submitFollowUp = useCallback(
-    (question: string, images?: BtwImage[]) => {
+    (question: string, attachments?: Attachment[]) => {
       const text = question.trim();
-      if (!text && !images?.length) return;
+      if (!text && !attachments?.length) return;
       setFollowUpDraft('');
       // With no topic in view yet, the side session's first question is the
       // topic — there is nothing to follow up on.
-      void session.ask(text || ATTACHMENT_ONLY_QUESTION, images, activeTopic?.id).then((next) => {
+      void session.ask(text || ATTACHMENT_ONLY_QUESTION, attachments, activeTopic?.id).then((next) => {
         if (!activeTopic) selectNewest(next);
       });
     },
@@ -150,8 +217,15 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     activeTopic,
     runningTopicId,
     busy: session.busy,
-    liveAnswer: live ? live.text : '',
+    liveMessages: live ? live.messages : [],
+    liveVerb,
     error: session.error,
+    dialogs: session.state?.dialogs ?? [],
+    // Before a topic exists the composer's own picks are what the next question
+    // will run with, so they are what the controls must show — and after it,
+    // the topic's own settings (which the pick was written to).
+    accessMode: activeTopic?.approvalMode ?? pendingAccess ?? readAccessMode(appSettings),
+    thinkingLevel: activeTopic?.thinkingLevel ?? pendingThinking,
     askDraft,
     followUpDraft,
     setAskDraft,
@@ -168,6 +242,27 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     abort: () => {
       if (runningTopicId) void session.abort(runningTopicId);
     },
+    setModel: (provider: string, modelId: string) => {
+      if (!activeTopic) {
+        setPendingModel({ provider, id: modelId });
+        return;
+      }
+      void session.setModel(activeTopic.id, provider, modelId);
+    },
+    setThinkingLevel: (level: string) => {
+      setPendingThinking(level);
+      if (!activeTopic) return;
+      void session.setThinkingLevel(activeTopic.id, level);
+    },
+    setAccessMode: (mode: ApprovalMode) => {
+      setPendingAccess(mode);
+      if (!activeTopic) return;
+      void session.setAccessMode(activeTopic.id, mode);
+    },
+    respondToDialog: (id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => {
+      if (!activeTopic) return;
+      void session.respondToDialog(activeTopic.id, id, response);
+    },
     promote,
     removeTopic,
     selectTopic: (topicId: string) => {

package/src/client/hooks/chat/composer/index.ts

@@ -13,6 +13,12 @@ export interface UseComposerTriggerOptions {
   disabled?: boolean;
   /** Workspace root to scope `@` file mentions to (null → app root). */
   rootPath?: string | null;
+  /**
+   * Whether the popup may open at all. A composer with no completable surface
+   * (the side-question form) turns it off so a stray `@` or `/` cannot open an
+   * empty list over its text.
+   */
+  enabled?: boolean;
 }
 
 export interface ComposerTriggerController {
@@ -55,7 +61,7 @@ function shouldOpen(trigger: ComposerTrigger | null, matches: ComposerMatchItem[
 
 /** Orchestrates the composer `@`-mention / `/`-command autocomplete flow. */
 export function useComposerTrigger(options: UseComposerTriggerOptions): ComposerTriggerController {
-  const { value, setValue, textareaRef, disabled = false, rootPath } = options;
+  const { value, setValue, textareaRef, disabled = false, rootPath, enabled = true } = options;
 
   const [trigger, setTrigger] = useState<ComposerTrigger | null>(null);
   const [activeIndex, setActiveIndexState] = useState(0);
@@ -77,7 +83,7 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
 
   const optionId = useCallback((index: number) => `${listboxId}-option-${index}`, [listboxId]);
 
-  const open = shouldOpen(trigger, matches);
+  const open = enabled && shouldOpen(trigger, matches);
 
   const close = useCallback(() => {
     setTrigger(null);
@@ -109,14 +115,14 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
       }
 
       setValue(text);
-      if (disabled) {
+      if (disabled || !enabled) {
         close();
         return;
       }
       setTrigger(detectComposerTrigger(text, caret));
       setActiveIndexState(0);
     },
-    [setValue, close, disabled],
+    [setValue, close, disabled, enabled],
   );
 
   const selectItem = useCallback(

package/src/client/hooks/chat/timeline/access-mode.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Access-control (approval) mode for the composer: a global, persisted user
+ * preference, unlike the per-session model/thinking picks. It hydrates from
+ * appSettings at first paint and is mirrored into a ref so the send path reads
+ * the latest value without re-creating `executeSend`. Extracted from
+ * useChatTimeline so that hook stays under the repo's per-file size ceiling.
+ */
+
+import { useCallback, useRef, useState } from 'preact/hooks';
+import { ACCESS_MODE_SETTING_KEY, normalizeApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { writeSetting } from '@/shared/lib/settings/client';
+
+export interface ChatTimelineAccessMode {
+  accessMode: ApprovalMode;
+  /** Live value for callbacks created once (send, queue delivery). */
+  accessModeRef: { current: ApprovalMode };
+  setAccessMode: (mode: ApprovalMode) => void;
+}
+
+export function useChatTimelineAccessMode(appSettings: Record<string, any>): ChatTimelineAccessMode {
+  const [accessMode, setAccessModeState] = useState<ApprovalMode>(() => normalizeApprovalMode(appSettings.omp_access_mode));
+  const accessModeRef = useRef<ApprovalMode>(accessMode);
+  accessModeRef.current = accessMode;
+
+  const setAccessMode = useCallback((mode: ApprovalMode) => {
+    setAccessModeState(mode);
+    accessModeRef.current = mode;
+    // Persist the last selection; the server reads this key as the spawn-time
+    // default. Fire-and-forget: the in-memory value is already authoritative
+    // for this session's requests, which carry it explicitly.
+    writeSetting(ACCESS_MODE_SETTING_KEY, mode);
+  }, []);
+
+  return { accessMode, accessModeRef, setAccessMode };
+}

package/src/client/hooks/chat/timeline/ask-frames.test.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The ask/approval routing split, and the one thing it must never do: paint a
+ * dialog as a modal and then take it back.
+ *
+ * On session open the pending dialogs are replayed from the agent-state probe
+ * (which answers out of the wrapper's local flags) long before the session
+ * JSONL lands, so every replayed frame looks unowned while `messages` is still
+ * empty — while the ask card that owns it is one fetch away. Deciding "no card
+ * owns this" during that window flashed the ask modal on every switch to a
+ * session parked on a question. These pin the hold, and that it never turns
+ * into a silently dropped question.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import type { ChatMessageData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+import { splitAskFrames } from '@/client/hooks/chat/timeline/ask-frames';
+
+/** An assistant turn whose `ask` tool call asked `questions`, as the JSONL and
+ *  the live stream both deliver it. */
+function askHistory(questions: string[]): ChatMessageData[] {
+  return [
+    {
+      id: 'msg-ask',
+      role: 'ai',
+      content: '',
+      toolCalls: [
+        {
+          id: 'call_ask',
+          type: 'ask',
+          name: 'ask',
+          title: 'ask',
+          input: { questions: questions.map((question) => ({ question, options: [{ label: 'A' }, { label: 'B' }] })) },
+        },
+      ],
+    },
+  ];
+}
+
+function selectFrame(id: string, title: string): ExtensionUiDialogRequest {
+  return { type: 'extension_ui_request', id, method: 'select', title, options: ['A (Recommended)', 'B', 'Other (type your own)'] };
+}
+
+function confirmFrame(id: string, title: string): ExtensionUiDialogRequest {
+  return { type: 'extension_ui_request', id, method: 'confirm', title };
+}
+
+describe('splitAskFrames', () => {
+  test('a question dialog is claimed by the ask card, not handed to the modal', () => {
+    const frame = selectFrame('f1', 'Which language?');
+    const split = splitAskFrames(askHistory(['Which language?']), [frame], true);
+
+    expect(split.framesByTool.get('call_ask')?.[0]?.map((held) => held.id)).toEqual(['f1']);
+    expect(split.modalRequest).toBeNull();
+  });
+
+  test('the modal is held while the session history is still loading', () => {
+    const question = selectFrame('f1', 'Which language?');
+    const gate = confirmFrame('g1', 'Run bash?');
+
+    // The regression: the frame has been replayed, its tool call has not.
+    expect(splitAskFrames([], [question], false)).toEqual({ framesByTool: new Map(), modalRequest: null });
+    // The hold is uniform — a gate cannot be told from an ask before history
+    // either, and it is re-decided the moment the history settles.
+    expect(splitAskFrames([], [gate], false).modalRequest).toBeNull();
+  });
+
+  test('once the history has settled an unclaimed dialog stays answerable', () => {
+    const frame = selectFrame('f1', 'Which language?');
+    expect(splitAskFrames([], [frame], true).modalRequest).toBe(frame);
+  });
+
+  test('an approval gate keeps the modal beside a claimed question', () => {
+    const question = selectFrame('f1', 'Which language?');
+    const gate = confirmFrame('g1', 'Run bash?');
+    const split = splitAskFrames(askHistory(['Which language?']), [question, gate], true);
+
+    expect(split.framesByTool.get('call_ask')?.[0]?.map((held) => held.id)).toEqual(['f1']);
+    expect(split.modalRequest).toBe(gate);
+  });
+});