ompchamber 1.0.0 → 1.2.0

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

@@ -0,0 +1,181 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The composer's attach-and-send pipeline: everything between "a file arrived"
+ * and "a prompt is dispatched", plus the one line of feedback each outcome
+ * produces.
+ *
+ * Extracted from ChatInput so the component stays a layout shell and the
+ * composer keeps room under the repo's per-file size ceiling.
+ *
+ * The rules encoded here, each of which was a bug once:
+ *
+ * - A drop registers its files in the attachment hook BEFORE the component
+ *   re-renders, so a send clicked immediately afterwards must read the hook's
+ *   list, not the component's `attachments` prop — that prop is a frame behind
+ *   and an empty read clears the composer and dispatches nothing.
+ * - A send waits for in-flight reads and then uses the list those reads
+ *   returned: an attachment whose bytes landed during the wait is sent
+ *   complete, never as the pre-read entry.
+ * - A send that would carry neither text nor any readable attachment is
+ *   REPORTED, never dispatched. An empty prompt reaching the model is worse
+ *   than not sending, and it is what a failed read used to produce.
+ */
+
+import { useCallback, useRef, useState } from 'preact/hooks';
+import type { SetStateAction } from 'preact/compat';
+import type { Attachment } from '@/shared/types';
+import { attachmentName, describeAttachmentBudget } from '@/shared/lib/chat/attachments';
+import { useComposerAttachments } from '@/client/hooks/chat/composer/attachments';
+import { useFileDrop, DROP_LIMIT_NOTICE, type FileDropProps } from '@/client/hooks/chat/composer/file-drop';
+import type { PrimedReads } from '@/client/hooks/chat/composer/file-reads';
+import {
+  describeReferenceFailure,
+  describeUnreadable,
+  readDroppedReference,
+  referenceName,
+  type ReferenceFailure,
+} from '@/client/hooks/chat/composer/drop-references';
+
+export interface UseComposerPipelineOptions {
+  attachments: Attachment[];
+  setAttachments: (updater: SetStateAction<Attachment[]>) => void;
+  /** Current composer text, read at send time. */
+  value: string;
+  disabled: boolean;
+  /** Workspace root, used to resolve a dropped path reference. */
+  rootPath?: string | null;
+  onSend: (attachments: Attachment[], options?: { steering?: boolean }) => void;
+}
+
+export interface ComposerPipeline {
+  /** Inline notice shown above the input; null when there is nothing to say. */
+  notice: string | null;
+  dismissNotice: () => void;
+  /** True while a file drag hovers the composer. */
+  isDragging: boolean;
+  /** Drag handlers for the composer card. */
+  dropProps: FileDropProps;
+  /** Attach a batch (picker, paste, or a drop the caller already parsed). */
+  acceptFiles: (files: File[], incomplete?: boolean, references?: string[], primed?: PrimedReads) => void;
+  /** Remove one attachment. */
+  removeAttachment: (id: string) => void;
+  /** Send the composer's contents. */
+  submit: (options?: { steering?: boolean }) => void;
+}
+
+export function useComposerPipeline({
+  attachments,
+  setAttachments,
+  value,
+  disabled,
+  rootPath,
+  onSend,
+}: UseComposerPipelineOptions): ComposerPipeline {
+  const { addFiles, removeAttachment, readyForSend, peek, clear } = useComposerAttachments({ attachments, setAttachments });
+  // Guards a double click: the composer is cleared only after the reads land, so
+  // without this a second click would dispatch the same attachment twice.
+  const sendingRef = useRef(false);
+  const [notice, setNotice] = useState<string | null>(null);
+
+  // A download dragged out of a web page carries no File — only a URL. The
+  // server reads it, because the browser cannot fetch an arbitrary path and the
+  // drop gives no bytes to work with.
+  const attachReferences = useCallback(async (references: string[]) => {
+    const resolved: File[] = [];
+    const failed: string[] = [];
+    const reasons = new Map<string, ReferenceFailure>();
+    await Promise.all(references.map(async (reference) => {
+      const name = referenceName(reference);
+      const result = await readDroppedReference(reference, rootPath ?? null);
+      if (result.ok) {
+        resolved.push(result.file);
+        return;
+      }
+      failed.push(name);
+      reasons.set(name, result.reason);
+    }));
+    if (resolved.length > 0) {
+      const { unreadable } = await addFiles(resolved);
+      setNotice(unreadable.length > 0 ? describeUnreadable(unreadable) : null);
+    }
+    if (failed.length > 0) {
+      // Named per cause: "outside the folders the chamber may read" is something
+      // the user can act on, while a bare "could not be read" is not.
+      const reason = reasons.get(failed[0]) ?? 'unavailable';
+      setNotice(describeReferenceFailure(failed, reason));
+    }
+  }, [addFiles, rootPath]);
+
+  const acceptFiles = useCallback((
+    files: File[],
+    incomplete = false,
+    references: string[] = [],
+    primed?: PrimedReads,
+  ) => {
+    void (async () => {
+      const { added, skipped, unreadable } = await addFiles(files, primed);
+      if (skipped.length > 0) {
+        setNotice(describeAttachmentBudget(skipped));
+      } else if (incomplete) {
+        setNotice(DROP_LIMIT_NOTICE);
+      } else if (unreadable.length > 0) {
+        // Reported, never silent: a chip whose bytes never arrived would send a
+        // prompt that names a file the model cannot see.
+        setNotice(describeUnreadable(unreadable));
+      } else if (added > 0) {
+        setNotice(null);
+      }
+      if (references.length > 0) await attachReferences(references);
+    })();
+  }, [addFiles, attachReferences]);
+
+  // OS drag-and-drop. Bound to the composer CARD, not the textarea: the whole
+  // composer is the drop target, so a drop anywhere inside it (including on the
+  // textarea) bubbles here instead of letting the browser navigate away.
+  const { isDragging, dropProps } = useFileDrop({ disabled, onFiles: acceptFiles });
+
+  const submit = useCallback((options?: { steering?: boolean }) => {
+    // The hook's list, not the prop: a drop registers its files before this
+    // component re-renders, so a send clicked right after a drop would see an
+    // empty prop, clear the composer and dispatch a prompt carrying nothing.
+    const pending = peek();
+    if (!value.trim() && pending.length === 0) {
+      return;
+    }
+    if (sendingRef.current) {
+      return;
+    }
+    sendingRef.current = true;
+    // Bytes are read at attach time; waiting here returns the list as it stands
+    // once those reads land, so an attachment whose read was still in flight is
+    // sent complete rather than empty.
+    void readyForSend().then((outgoing) => {
+      clear();
+      // "Readable" means there is something TO SEND. An attachment whose read
+      // produced an empty string has a `content` field but no content, and
+      // treating that as readable is how a prompt with an empty body went out.
+      const readable = outgoing.some((a) => (a.content?.length ?? 0) > 0 || a.dataBase64 !== undefined);
+      if (!value.trim() && outgoing.length > 0 && !readable) {
+        setNotice(describeUnreadable(outgoing.map((a) => attachmentName(a))));
+        return;
+      }
+      onSend(outgoing, options);
+    }).finally(() => {
+      sendingRef.current = false;
+    });
+  }, [clear, onSend, peek, readyForSend, value]);
+
+  return {
+    notice,
+    dismissNotice: useCallback(() => setNotice(null), []),
+    isDragging,
+    dropProps,
+    acceptFiles,
+    removeAttachment,
+    submit,
+  };
+}

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

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
-import type { ChatMessageData, OmpAgentCallbacks, OmpAgentHandle, OmpAgentState, StreamTransport } from '@/shared/types';
+import type { AgentImage, ChatMessageData, OmpAgentCallbacks, OmpAgentHandle, OmpAgentState, StreamTransport } from '@/shared/types';
 import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
 import { type ToolResultRecord, useOmpAgentStream } from '@/client/hooks/chat/omp/stream';
 import { useOmpPromptSender } from '@/client/hooks/chat/omp/prompt-send';
@@ -120,7 +120,7 @@ export function useOmpAgent(sessionId: string | null, callbacks: OmpAgentCallbac
    *  arrives via the interruptPending guard. */
   const sendInterruptAndReply = useCallback(async (
     message: string,
-    images?: { data: string; mimeType: string }[],
+    images?: AgentImage[],
   ): Promise<boolean> => {
     const sid = sessionIdRef.current;
     if (!sid) return false;
@@ -153,7 +153,7 @@ export function useOmpAgent(sessionId: string | null, callbacks: OmpAgentCallbac
   /** Enqueue a follow-up message the agent processes after the current turn. */
   const sendFollowUp = useCallback(async (
     message: string,
-    images?: { data: string; mimeType: string }[],
+    images?: AgentImage[],
   ): Promise<boolean> => {
     const sid = sessionIdRef.current;
     if (!sid) return false;

package/src/client/hooks/chat/omp/prompt-send.ts

@@ -17,7 +17,7 @@
 
 import { useCallback } from 'preact/hooks';
 import type { Dispatch, SetStateAction } from 'preact/compat';
-import type { OmpAgentState } from '@/shared/types';
+import type { AgentImage, OmpAgentState } from '@/shared/types';
 import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 
 export interface OmpPromptSenderDeps {
@@ -29,11 +29,11 @@ export interface OmpPromptSenderDeps {
 }
 
 export interface OmpPromptSender {
-  sendPrompt: (message: string, images?: { data: string; mimeType: string }[], options?: { accessMode?: ApprovalMode }) => Promise<boolean>;
+  sendPrompt: (message: string, images?: AgentImage[], options?: { accessMode?: ApprovalMode }) => Promise<boolean>;
   sendNewPrompt: (
     message: string,
     cwd: string,
-    images?: { data: string; mimeType: string }[],
+    images?: AgentImage[],
     composerOptions?: { model?: { provider: string; modelId: string } | null; thinkingLevel?: string | null; accessMode?: ApprovalMode },
   ) => Promise<{ sessionId: string; model: { provider: string; modelId: string } | null } | null>;
 }
@@ -44,7 +44,7 @@ export function useOmpPromptSender(deps: OmpPromptSenderDeps): OmpPromptSender {
   /** Send a prompt to the omp session via the RPC bridge. */
   const sendPrompt = useCallback(async (
     message: string,
-    images?: { data: string; mimeType: string }[],
+    images?: AgentImage[],
     options?: { accessMode?: ApprovalMode },
   ) => {
     const sid = sessionIdRef.current;
@@ -105,7 +105,7 @@ export function useOmpPromptSender(deps: OmpPromptSenderDeps): OmpPromptSender {
   const sendNewPrompt = useCallback(async (
     message: string,
     cwd: string,
-    images?: { data: string; mimeType: string }[],
+    images?: AgentImage[],
     composerOptions?: { model?: { provider: string; modelId: string } | null; thinkingLevel?: string | null; accessMode?: ApprovalMode },
   ): Promise<{ sessionId: string; model: { provider: string; modelId: string } | null } | null> => {
     setState((prev) => ({ ...prev, isGenerating: true, error: null }));

package/src/client/hooks/chat/timeline/actions.ts

@@ -16,6 +16,9 @@ import type { Dispatch, SetStateAction } from 'preact/compat';
 import type { Attachment, ChatMessageData, OmpAgentHandle, QueuedMessageModel } from '@/shared/types';
 import type { QueuedMessage } from '@/client/components/workspace/chat-timeline/QueueList';
 import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+import { applyComposerPick, consumeComposerPick, stashComposerPick, type DeferredModelStore } from '@/client/hooks/chat/timeline/deferred-model';
+import { dispatchBtwCommand } from '@/client/hooks/chat/btw/intercept';
+import { prepareQueuedAttachments } from '@/shared/lib/chat/attachments';
 
 export interface ChatTimelineActionsDeps {
   inputValue: string;
@@ -48,6 +51,9 @@ export interface ChatTimelineActionsDeps {
   /** Live composer model/thinking mirror, snapshotted onto queued items so
    *  auto-delivery replays the exact settings. */
   composerModelRef: { current: { provider: string; modelId: string; thinkingLevel: string } | null };
+  /** Picks made while a turn streams: held back so they cannot re-target the
+   *  in-flight answer, then pushed onto the session before the next prompt. */
+  deferredComposerPickRef: DeferredModelStore;
   /** Global access-control mode, snapshotted onto queued items. */
   accessModeRef: { current: ApprovalMode };
   setSearchParams: (fn: (prev: URLSearchParams) => URLSearchParams, opts?: { replace?: boolean }) => void;
@@ -89,6 +95,7 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     pendingComposerModelRef,
     pendingThinkingLevelRef,
     composerModelRef,
+    deferredComposerPickRef,
     accessModeRef,
     setSearchParams,
   } = deps;
@@ -101,6 +108,14 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     // resume delivering after this run ends.
     stopHoldRef.current = false;
 
+    // `/btw [question]` is the side-question entry point, not chat text: the
+    // panel owns it (omp's `/btw` is TUI-only, so nothing downstream would
+    // understand the token). A bare `/btw` only opens the panel's history.
+    if (dispatchBtwCommand(textToSend, attachments)) {
+      setInputValue('');
+      return;
+    }
+
     if (isGenerating) {
       if (options?.steering) {
         // Explicit steering while a run is active.
@@ -135,7 +150,12 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
       // panel is a view of it. Delivery happens when the run ends — the
       // wrapper's terminal `agent_end` claims the head and dispatches it.
       setInputValue('');
-      enqueueMessage({ text: textToSend, attachments, model });
+      // The queue row is JSON: a `File` does not survive it. Capture the text
+      // contents and the display fields now, so delivery can inline the files
+      // and render the chips without a live handle.
+      void prepareQueuedAttachments(attachments).then((prepared) => {
+        enqueueMessage({ text: textToSend, attachments: prepared, model });
+      });
       return;
     }
 
@@ -285,16 +305,32 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
       pendingThinkingLevelRef.current = level;
       return;
     }
+    // A pick made mid-run is intent for the NEXT prompt: pushing it now would
+    // re-target the turn already streaming (omp applies set_thinking_level to
+    // the running turn's next LLM call).
+    if (isGenerating) {
+      stashComposerPick(deferredComposerPickRef, { thinkingLevel: level });
+      return;
+    }
+    consumeComposerPick(deferredComposerPickRef, { thinkingLevel: level });
     void ompAgent.setThinkingLevel(level);
-  }, [isOmpSession, ompAgent, pendingThinkingLevelRef]);
+  }, [isGenerating, isOmpSession, ompAgent, pendingThinkingLevelRef, deferredComposerPickRef]);
 
   const handleModelChange = useCallback((provider: string, modelId: string) => {
     if (!isOmpSession) {
       pendingComposerModelRef.current = { provider, modelId };
       return;
     }
-    void ompAgent.setModel(provider, modelId);
-  }, [isOmpSession, ompAgent, pendingComposerModelRef]);
+    // Same rule as the thinking pick: a mid-run model change is held back so
+    // the answer being streamed finishes on the model it started with, and is
+    // applied right before the next prompt this composer sends.
+    if (isGenerating) {
+      stashComposerPick(deferredComposerPickRef, { provider, modelId });
+      return;
+    }
+    consumeComposerPick(deferredComposerPickRef, { provider, modelId });
+    void applyComposerPick(ompAgent, { provider, modelId });
+  }, [isGenerating, isOmpSession, ompAgent, pendingComposerModelRef, deferredComposerPickRef]);
 
   return {
     handleSend,

package/src/client/hooks/chat/timeline/deferred-model.test.ts

@@ -0,0 +1,219 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A composer model/thinking pick made while a turn is streaming must not reach
+ * the live session: omp applies `set_model` to the RUNNING turn, so pushing it
+ * immediately re-targets the answer in flight (verified against omp's RPC
+ * handler and by driving a live session — one run answered its first turn on
+ * the old model and its next turns on the new one).
+ *
+ * The pick is held and pushed right before the next prompt instead. These run
+ * against a real DOM (happy-dom) because the hooks are Preact hooks: the
+ * modules below are imported inside `beforeAll`, after those globals exist,
+ * since Preact binds its environment at evaluation time.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
+import { Window } from 'happy-dom';
+import type { h as PreactH, render as PreactRender } from 'preact';
+import type { act as PreactAct } from 'preact/test-utils';
+import type { useChatTimelineActions as UseChatTimelineActions, ChatTimelineActionsResult } from '@/client/hooks/chat/timeline/actions';
+import type { ComposerModelPick, DeferredModelStore } from '@/client/hooks/chat/timeline/deferred-model';
+import { flushDeferredPick } from '@/client/hooks/chat/timeline/deferred-model';
+import type { OmpAgentHandle } from '@/shared/types';
+
+let useChatTimelineActions: typeof UseChatTimelineActions;
+let h: typeof PreactH;
+let render: typeof PreactRender;
+let act: typeof PreactAct;
+
+let container: HTMLElement;
+
+interface Harness {
+  calls: string[];
+  deferred: { current: ComposerModelPick | null };
+  actions: ChatTimelineActionsResult;
+}
+
+/** A recording agent handle plus the calls it received. */
+function makeAgent() {
+  const calls: string[] = [];
+  const agent = {
+    setModel: async (provider: string, modelId: string) => { calls.push(`set_model:${provider}/${modelId}`); },
+    setThinkingLevel: async (level: string) => { calls.push(`set_thinking_level:${level}`); },
+  } as unknown as OmpAgentHandle;
+  return { calls, agent };
+}
+
+/** Mounts the real hook and records every model/thinking RPC it pushes. */
+async function mountActions(isGenerating: boolean, stashed: ComposerModelPick | null): Promise<Harness> {
+  const deferred: { current: ComposerModelPick | null } = { current: stashed };
+  const { calls, agent } = makeAgent();
+
+  const captured: ChatTimelineActionsResult[] = [];
+  const Probe = () => {
+    captured.push(useChatTimelineActions({
+      inputValue: '',
+      setInputValue: () => {},
+      setInputAttachments: () => {},
+      isGenerating,
+      isOmpSession: true,
+      sessionId: '01a0ca36-f3be-7252-a95c-3d45d180c539',
+      appSettings: {},
+      messageQueue: [],
+      enqueueMessage: () => {},
+      removeMessage: () => {},
+      executeSend: async () => {},
+      steerOmpAgent: async () => {},
+      ompAgent: agent,
+      abortControllerRef: { current: null },
+      setGenerating: () => {},
+      stopHoldRef: { current: false },
+      persistMessages: () => {},
+      setLocalMessages: () => {},
+      pendingComposerModelRef: { current: null },
+      pendingThinkingLevelRef: { current: null },
+      composerModelRef: { current: null },
+      deferredComposerPickRef: deferred,
+      accessModeRef: { current: 'yolo' },
+      setSearchParams: () => {},
+    }));
+    return null;
+  };
+  await act(async () => {
+    render(h(Probe, {}), container);
+  });
+  // The handlers fire-and-forget their RPC, so let the microtask chain settle.
+  for (let i = 0; i < 10; i++) await Promise.resolve();
+  return { calls, deferred, actions: captured[captured.length - 1] };
+}
+
+/** The DOM surface this file installs for Preact to render into. */
+function domGlobals(win: Window): Record<string, unknown> {
+  return {
+    window: win,
+    document: win.document,
+    navigator: win.navigator,
+    Node: win.Node,
+    Element: win.Element,
+    HTMLElement: win.HTMLElement,
+  };
+}
+
+const installed: Record<string, unknown> = {};
+const displaced: Record<string, unknown> = {};
+
+beforeAll(async () => {
+  const win = new Window({ url: 'http://localhost' });
+  for (const [key, value] of Object.entries(domGlobals(win))) {
+    displaced[key] = (globalThis as Record<string, unknown>)[key];
+    installed[key] = value;
+    (globalThis as Record<string, unknown>)[key] = value;
+  }
+  ({ useChatTimelineActions } = await import('@/client/hooks/chat/timeline/actions'));
+  ({ h, render } = await import('preact'));
+  ({ act } = await import('preact/test-utils'));
+});
+
+// Every test file shares one process, so the globals go back the way they were.
+afterAll(() => {
+  for (const key of Object.keys(installed)) {
+    if (displaced[key] === undefined) delete (globalThis as Record<string, unknown>)[key];
+    else (globalThis as Record<string, unknown>)[key] = displaced[key];
+  }
+});
+
+beforeEach(() => {
+  container = document.createElement('div');
+  document.body.appendChild(container);
+});
+
+describe('composer model/thinking picks during a stream', () => {
+  test('a mid-stream model pick sends no RPC and is stashed', async () => {
+    const { calls, deferred, actions } = await mountActions(true, null);
+    actions.handleModelChange('kenari', 'deepseek-v4-pro');
+
+    expect(calls).toEqual([]);
+    expect(deferred.current).toEqual({ provider: 'kenari', modelId: 'deepseek-v4-pro' });
+  });
+
+  test('a mid-stream thinking pick sends no RPC and is stashed', async () => {
+    const { calls, deferred, actions } = await mountActions(true, null);
+    actions.handleThinkingLevelChange('high');
+
+    expect(calls).toEqual([]);
+    expect(deferred.current).toEqual({ thinkingLevel: 'high' });
+  });
+
+  test('model then thinking mid-stream both survive to the next prompt', async () => {
+    const { calls, deferred, actions } = await mountActions(true, null);
+    actions.handleModelChange('kenari', 'deepseek-v4-pro');
+    actions.handleThinkingLevelChange('max');
+
+    expect(calls).toEqual([]);
+    expect(deferred.current).toEqual({ provider: 'kenari', modelId: 'deepseek-v4-pro', thinkingLevel: 'max' });
+  });
+
+  test('an idle pick reaches the session immediately', async () => {
+    const { calls, deferred, actions } = await mountActions(false, null);
+    actions.handleModelChange('kenari', 'deepseek-v4-pro');
+    actions.handleThinkingLevelChange('high');
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+
+    expect(calls).toEqual(['set_model:kenari/deepseek-v4-pro', 'set_thinking_level:high']);
+    expect(deferred.current).toBeNull();
+  });
+
+  test('an idle model pick leaves a stashed thinking level pending', async () => {
+    const { calls, deferred, actions } = await mountActions(false, { thinkingLevel: 'high' });
+    actions.handleModelChange('kenari', 'deepseek-v4-pro');
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+
+    // The level was never applied here, so it must still wait for the next
+    // prompt rather than being dropped or pushed now.
+    expect(calls).toEqual(['set_model:kenari/deepseek-v4-pro']);
+    expect(deferred.current).toEqual({ thinkingLevel: 'high' });
+  });
+
+  test("'auto' thinking is never pushed onto the live session", async () => {
+    const { calls, deferred, actions } = await mountActions(false, null);
+    actions.handleThinkingLevelChange('auto');
+
+    expect(calls).toEqual([]);
+    expect(deferred.current).toBeNull();
+  });
+});
+
+describe('flushing a pick onto the session', () => {
+  test('pushes the stashed model and thinking level, then clears the slot', async () => {
+    const { calls, agent } = makeAgent();
+    const store: DeferredModelStore = { current: { provider: 'kenari', modelId: 'deepseek-v4-pro', thinkingLevel: 'max' } };
+
+    await flushDeferredPick(agent, store);
+
+    expect(calls).toEqual(['set_model:kenari/deepseek-v4-pro', 'set_thinking_level:max']);
+    expect(store.current).toBeNull();
+  });
+
+  test("a stashed 'auto' level is not pushed as a concrete level", async () => {
+    const { calls, agent } = makeAgent();
+    const store: DeferredModelStore = { current: { provider: 'kenari', modelId: 'deepseek-v4-pro', thinkingLevel: 'auto' } };
+
+    await flushDeferredPick(agent, store);
+
+    expect(calls).toEqual(['set_model:kenari/deepseek-v4-pro']);
+    expect(store.current).toBeNull();
+  });
+
+  test('flushing an empty slot sends nothing', async () => {
+    const { calls, agent } = makeAgent();
+    const store: DeferredModelStore = { current: null };
+
+    await flushDeferredPick(agent, store);
+
+    expect(calls).toEqual([]);
+  });
+});

package/src/client/hooks/chat/timeline/deferred-model.ts

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Composer model/thinking picks that must NOT reach the live session yet.
+ *
+ * omp applies `set_model` / `set_thinking_level` to the RUNNING turn: the next
+ * LLM call inside the stream (the one after a tool result) goes out on the new
+ * model, so a pick made while an answer streams visibly re-targets that answer
+ * mid-flight. A composer pick is intent for the NEXT prompt, so while a turn is
+ * running it is stashed here and pushed to the session right before the next
+ * prompt the composer starts (plain send, steer, or queued delivery).
+ *
+ * The slot holds only what has NOT reached the session yet, so a pick applied
+ * directly (idle composer) clears exactly the fields it applied — a stashed
+ * thinking level survives a later model change instead of being resurrected
+ * over it.
+ *
+ * Verified against omp's RPC handler: `set_model` resolves the model and calls
+ * the session's `setModel` immediately — nothing defers it to a turn boundary.
+ */
+
+import type { OmpAgentHandle } from '@/shared/types';
+
+/** Fields a composer pick can carry; each handler owns its own. */
+export interface ComposerModelPick {
+  provider?: string;
+  modelId?: string;
+  thinkingLevel?: string;
+}
+
+/** Mutable slot the timeline hook owns; the composer and send paths share it. */
+export interface DeferredModelStore {
+  current: ComposerModelPick | null;
+}
+
+/**
+ * Slot that never holds a pick, for composers with no stream to defer against
+ * (the New Chat modal): every guard reads it as "nothing pending", so their
+ * adoption behaviour stays exactly as it was.
+ */
+export const NO_PENDING_PICK: DeferredModelStore = { current: null };
+
+/** A pick that names a model must name both halves of it. */
+function hasModel(pick: ComposerModelPick): pick is ComposerModelPick & { provider: string; modelId: string } {
+  return Boolean(pick.provider && pick.modelId);
+}
+
+/**
+ * Record a pick made while a turn is streaming. Merged over the previous stash
+ * so a model pick and a later thinking pick both survive to the next prompt.
+ */
+export function stashComposerPick(store: DeferredModelStore, pick: ComposerModelPick): void {
+  store.current = { ...store.current, ...pick };
+}
+
+/**
+ * Drop the fields a pick just applied directly, keeping any still-pending ones.
+ * Without this, a stashed pick would be flushed over the newer selection on the
+ * next send and silently revert the user's latest choice.
+ */
+export function consumeComposerPick(store: DeferredModelStore, pick: ComposerModelPick): void {
+  const pending = store.current;
+  if (!pending) return;
+  const next: ComposerModelPick = { ...pending };
+  if (pick.provider || pick.modelId) {
+    delete next.provider;
+    delete next.modelId;
+  }
+  if (pick.thinkingLevel) delete next.thinkingLevel;
+  store.current = next.provider || next.modelId || next.thinkingLevel ? next : null;
+}
+
+/**
+ * Push a pick onto the live session. `thinkingLevel: 'auto'` means "leave omp's
+ * level alone" — the same rule the send path applies — so it is skipped rather
+ * than translated into a concrete level.
+ */
+export async function applyComposerPick(agent: OmpAgentHandle, pick: ComposerModelPick): Promise<void> {
+  if (hasModel(pick)) await agent.setModel(pick.provider, pick.modelId);
+  if (pick.thinkingLevel && pick.thinkingLevel !== 'auto') await agent.setThinkingLevel(pick.thinkingLevel);
+}
+
+/** Push the stashed pick (if any) onto the session and clear the slot. */
+export async function flushDeferredPick(agent: OmpAgentHandle, store: DeferredModelStore): Promise<void> {
+  const pick = store.current;
+  if (!pick) return;
+  store.current = null;
+  await applyComposerPick(agent, pick);
+}