fix: model mentions name a model in the prompt instead of switching

apps/mobile/src/features/threads/NewTaskDraftScreen.tsx

@@ -976,9 +976,6 @@ export function NewTaskDraftScreen(props: {
         onSendMessage={handleStart}
         onReconnectEnvironment={() => onReconnectEnvironment(selectedProject.environmentId)}
         canSwitchThreadProvider
-        onUpdateThreadModelSelection={(selection) =>
-          flow.setSelectedModelKey(`${selection.instanceId}:${selection.model}`, selection.options)
-        }
         onUpdateThreadInteractionMode={flow.planModeEnabled ? flow.setInteractionMode : undefined}
         onRespondToApproval={async () => {}}
         onSelectUserInputOption={() => {}}

apps/mobile/src/features/threads/ThreadComposer.tsx

@@ -56,8 +56,6 @@ import Animated, {
 import { useUniwindTheme } from "../../lib/useUniwindTheme";
 import { themeColorWithAlpha } from "../../lib/mobileTheme";
 import { armAgentAwarenessLiveActivityForLocalWork } from "../agent-awareness/remoteRegistration";
-import { updateThreadDraftModelSelection } from "../../state/use-thread-composer-state";
-import { withRememberedModelOptions } from "../../state/use-model-option-memory";
 import { scopedThreadKey } from "../../lib/scopedEntities";
 import {
   getComposerDraftSnapshot,
@@ -244,7 +242,6 @@ export interface ThreadComposerProps {
   ) => Promise<MessageId | null>;
   readonly onShowUsageLimits: (report: UsageLimitsReport | null) => void;
   readonly canSwitchProvider: boolean;
-  readonly onUpdateModelSelection?: (modelSelection: ModelSelection) => void;
   readonly onUpdateInteractionMode?: (interactionMode: ProviderInteractionMode) => void;
   readonly onHeightChange?: (height: number) => void;
   readonly onEditorFocusChange?: (focused: boolean) => void;
@@ -547,6 +544,17 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
     props.selectedThread.projectId,
     "composer",
   );
+  // Mentions name any model for the agent, so they aren't limited to models this thread can switch to.
+  const mentionModelOptions =
+    lockedProviderInstanceId === undefined
+      ? modelOptions
+      : buildModelOptions(
+          props.serverConfig,
+          currentModelSelection,
+          undefined,
+          props.selectedThread.projectId,
+          "composer",
+        );
   const mentionableEnvironments = useMentionableEnvironments();
   const composerMenu = useComposerCommandMenu({
     draftMessage: draftMessage,
@@ -575,21 +583,8 @@ export const ThreadComposer = function ThreadComposer(props: ThreadComposerProps
     offersUsageLimits: usageLimitsOffered,
     onUsageLimits:
       usageLimitsOffered && draftAttachments.length === 0 ? openUsageLimits : undefined,
-    modelOptions,
+    modelOptions: mentionModelOptions,
     modelProviders: props.serverConfig?.providers,
-    onSelectModel:
-      props.interactionLocked === true
-        ? undefined
-        : (option) => {
-            const selection = withRememberedModelOptions(option.selection);
-            if (props.onUpdateModelSelection) props.onUpdateModelSelection(selection);
-            else
-              updateThreadDraftModelSelection(
-                composerOwnerKey,
-                selection,
-                props.serverConfig?.providers ?? [],
-              );
-          },
   });
   const voiceInput = useVoiceInputController({
     ownerKey: composerDraftKey,

apps/mobile/src/features/threads/ThreadDetailScreen.tsx

@@ -41,7 +41,6 @@ import { deriveBottomControlInsets, type NativeLayoutMetrics } from "../../lib/r
 import type {
   EnvironmentId,
   MessageId,
-  ModelSelection,
   ProviderInteractionMode,
   RuntimeRequestId,
   ScopedThreadRef,
@@ -286,7 +285,6 @@ export interface ThreadDetailScreenProps {
   ) => Promise<MessageId | null>;
   readonly onReconnectEnvironment: () => void;
   readonly canSwitchThreadProvider: boolean;
-  readonly onUpdateThreadModelSelection?: (modelSelection: ModelSelection) => void;
   readonly onUpdateThreadInteractionMode?: (interactionMode: ProviderInteractionMode) => void;
   readonly onRespondToApproval: ApprovalResponder;
   readonly onSelectUserInputOption: (
@@ -1641,7 +1639,6 @@ function ThreadDetailBody(props: ThreadDetailScreenProps) {
                         onSendMessage={handleSendMessage}
                         onShowUsageLimits={showUsageLimits}
                         canSwitchProvider={props.canSwitchThreadProvider}
-                        onUpdateModelSelection={props.onUpdateThreadModelSelection}
                         onUpdateInteractionMode={props.onUpdateThreadInteractionMode}
                         onHeightChange={handleComposerHeightChange}
                         onEditorFocusChange={handleOwnedInputFocusChange}

apps/mobile/src/features/threads/use-composer-command-menu.test.ts

@@ -164,6 +164,24 @@ describe("mobile model mentions", () => {
     };
   };
 
+  it("replaces a model mention with prompt text and places the cursor after it", () => {
+    const modelOption = option("codex:gpt-5.4");
+    expect(
+      resolveComposerCommandSelection({
+        draftMessage: "@gpt",
+        trigger: { rangeStart: 0, rangeEnd: 4 },
+        item: {
+          id: `model:${modelOption.key}`,
+          type: "model",
+          option: modelOption,
+          label: modelOption.label,
+          description: modelOption.providerLabel,
+        },
+        allowInteractionMode: true,
+      }),
+    ).toEqual({ text: "model:codex/gpt-5.4 ", cursor: 20, interactionMode: null });
+  });
+
   it("offers current, visible models labelled with their provider", () => {
     const items = buildComposerModelItems(
       [

apps/mobile/src/features/threads/use-composer-command-menu.ts

@@ -51,7 +51,10 @@ import {
   resolveProviderSkillsForCwd,
   resolveProviderSlashCommandsForCwd,
 } from "@t3tools/client-runtime/providerSkills";
-import { rankComposerModelMentions } from "@t3tools/client-runtime/composerModelMentions";
+import {
+  formatComposerModelMention,
+  rankComposerModelMentions,
+} from "@t3tools/client-runtime/composerModelMentions";
 import { useAtomRefresh } from "@effect/atom-react";
 import { Atom } from "effect/reactivity";
 import { useEffect, useState } from "react";
@@ -244,6 +247,8 @@ export function resolveComposerCommandSelection(input: {
     replacement = `/${item.command} `;
   } else if (item.type === "provider-slash-command") {
     replacement = `/${item.command.name} `;
+  } else if (item.type === "model") {
+    replacement = `${formatComposerModelMention(item.option.selection.instanceId, item.option.selection.model)} `;
   }
   return {
     ...replaceTextRange(draftMessage, trigger.rangeStart, trigger.rangeEnd, replacement),
@@ -273,7 +278,6 @@ export function useComposerCommandMenu({
   onUsageLimits,
   modelOptions,
   modelProviders,
-  onSelectModel,
 }: {
   readonly draftMessage: string;
   readonly ownerKey: string | null;
@@ -294,10 +298,9 @@ export function useComposerCommandMenu({
   readonly onChangeDraftMessage: (value: string) => void;
   readonly onUpdateInteractionMode?: (mode: ProviderInteractionMode) => void;
   readonly onUsageLimits?: () => void;
-  /** Models an `@` mention can switch to; leave `onSelectModel` unset when switching isn't allowed. */
+  /** Models an `@` mention can name in the prompt. */
   readonly modelOptions?: ReadonlyArray<ModelOption>;
   readonly modelProviders?: ReadonlyArray<ServerProvider>;
-  readonly onSelectModel?: (option: ModelOption) => void;
 }) {
   const [localSelection, setLocalSelection] = useState(() => ({
     ownerKey,
@@ -520,7 +523,7 @@ export function useComposerCommandMenu({
         ? matchComposerEnvironmentItems({ environments, environmentId, query: trigger.query })
         : [];
       const modelItems =
-        modelOptions && modelProviders && onSelectModel
+        modelOptions && modelProviders
           ? buildComposerModelItems(modelOptions, trigger.query, modelProviders)
           : [];
       return [
@@ -546,14 +549,6 @@ export function useComposerCommandMenu({
 
   const onSelect = (item: ComposerCommandItem) => {
     if (!trigger) return;
-    if (item.type === "model") {
-      if (trigger.kind !== "path" || !onSelectModel) return;
-      const cleared = replaceTextRange(draftMessage, trigger.rangeStart, trigger.rangeEnd, "");
-      setSelection({ start: cleared.cursor, end: cleared.cursor });
-      onChangeDraftMessage(cleared.text);
-      onSelectModel(item.option);
-      return;
-    }
     if (item.type === "environment") {
       if (!ownerKey || trigger.kind !== "path") return;
       const record = environmentComposerContext(item.environmentId, item.label);

apps/web/src/components/chat/ChatComposer.modelMentions.browser.test.tsx

@@ -5,12 +5,11 @@ import type { Editor } from "@tiptap/core";
 import { createRef, type ReactNode } from "react";
 import { expect, it, vi } from "vite-plus/test";
 import { userEvent } from "vite-plus/test/browser";
-import { act, fakeTimers, render } from "../../../test/render";
+import { act, render } from "../../../test/render";
 import { useComposerDraftStore } from "../../composerDraftStore";
 import { AppAtomRegistryProvider } from "../../rpc/atomRegistry";
 import { makeThreadFixture } from "../../test-fixtures";
 import { ChatComposer, type ChatComposerHandle, type ChatComposerProps } from "./ChatComposer";
-import { useComposerSelection } from "./useComposerSelection";
 
 vi.mock("../../state/primaryEnvironment", async () => {
   const { Atom } = await import("effect/reactivity");
@@ -70,9 +69,6 @@ function setup() {
     slashCommands: [],
     skills: [],
   };
-  const focusComposer = () => composerRef.current?.focusAtEnd();
-  // ChatView schedules focusAtEnd after a provider selection.
-  const scheduleComposerFocus = vi.fn(() => window.requestAnimationFrame(focusComposer));
   const noop = () => {};
   const props: ChatComposerProps = {
     composerDraftTarget: target,
@@ -178,58 +174,27 @@ function setup() {
     toggleInteractionMode: noop,
     handleRuntimeModeChange: noop,
     handleInteractionModeChange: noop,
-    focusComposer,
-    scheduleComposerFocus,
+    focusComposer: noop,
+    scheduleComposerFocus: noop,
     setThreadError: noop,
     onExpandImage: noop,
     onFileOpen: noop,
   };
   return { props, composerRef };
 }
 
-function ComposerWithSelection({ props }: { props: ChatComposerProps }) {
-  const selection = useComposerSelection({
-    environmentId: props.environmentId,
-    composerDraftTarget: props.composerDraftTarget,
-    draftThread: null,
-    activeThread: props.activeThread,
-    activeRuntime: null,
-    activeProjectSettings: { settings: { newWorktreesStartFromOrigin: false } },
-    settings: props.settings,
-    providerStatuses: props.providerStatuses,
-    lockedProvider: null,
-    supportsProviderSwitchingViaHandoff: false,
-    multipleModelSelections: null,
-    runtimeMode: props.runtimeMode,
-    interactionMode: props.interactionMode,
-    interactionModeEnabled: true,
-    isLocalDraftThread: false,
-    canOverrideServerThreadEnvMode: false,
-    setPendingServerThreadEnvModeEntry: () => {},
-    setPendingServerThreadStartFromOriginByThreadId: () => {},
-    scheduleComposerFocus: props.scheduleComposerFocus,
-  });
-  return <ChatComposer {...props} onProviderModelSelect={selection.onProviderModelSelectStable} />;
-}
-
-it("keeps typing at the removed model mention before the remaining text", async () => {
+it("inserts the picked model as text without switching the thread's model", async () => {
   const { props, composerRef } = setup();
   await using screen = await render(
     <AppAtomRegistryProvider>
-      <ComposerWithSelection props={props} />
+      <ChatComposer {...props} />
     </AppAtomRegistryProvider>,
   );
   const element = screen.container.querySelector<HTMLElement & { editor: Editor }>(".tiptap");
   if (!element) throw new Error("Composer did not mount");
-  const editor = element.editor;
-  using _timers = fakeTimers();
   await act(() => composerRef.current?.focusAt(7));
   await userEvent.keyboard("@gpt");
   expect(props.promptRef.current).toBe("before @gpt after");
   await userEvent.keyboard("{Enter}");
-  await act(() => vi.advanceTimersByTime(32));
-  expect(editor.getText()).toBe("before  after");
-  await expect.element(element).toHaveTextContent("before after");
-  await userEvent.keyboard("X");
-  await expect.element(element).toHaveTextContent("before X after");
+  await expect.poll(() => props.promptRef.current).toBe("before model:codex/gpt-5.4 after");
 });

apps/web/src/components/chat/ChatComposer.tsx

@@ -43,6 +43,7 @@ import {
 import type { EnvironmentConnectionPresentation } from "@t3tools/client-runtime/connection";
 import { settlePromise, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
 import * as Schema from "effect/Schema";
+import { formatComposerModelMention } from "@t3tools/client-runtime/composerModelMentions";
 import { isPasteAsTextShortcut } from "@t3tools/client-runtime/text-paste";
 import { serializeComposerFileLink } from "@t3tools/shared/composerTrigger";
 import { folderDropTarget, resolveDroppedFolderPath } from "./folderDrop";
@@ -1168,17 +1169,12 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     selectedProviderSlashCommands,
     showSkillsInSlashMenu: settings.showSkillsInSlashMenu,
     questionAttachmentTarget,
-    modelMentions:
-      questionAttachmentTarget === null && !isSendBusy && !providerCatalogPending
-        ? {
-            instanceEntries: providerInstanceEntries,
-            modelOptionsByInstance,
-            lockedProvider,
-            lockedContinuationGroupKey,
-            isModelDisabled: (instanceId, model) =>
-              getModelDisabledReason(instanceId, model) !== null,
-          }
-        : null,
+    modelMentions: !providerCatalogPending
+      ? {
+          instanceEntries: providerInstanceEntries,
+          modelOptionsByInstance,
+        }
+      : null,
   });
 
   const composerMenuOpen = Boolean(composerTrigger);
@@ -2059,27 +2055,18 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
     }
     if (item.type === "model") {
       if (trigger.kind !== "path") return;
-      const applied = applyPromptReplacement(trigger.rangeStart, trigger.rangeEnd, "", {
-        expectedText: snapshot.value.slice(trigger.rangeStart, trigger.rangeEnd),
+      const replacement = `${formatComposerModelMention(item.instanceId, item.model)} `;
+      const replacementRangeEnd = extendReplacementRangeForTrailingSpace(
+        snapshot.value,
+        trigger.rangeEnd,
+        replacement,
+      );
+      const applied = applyPromptReplacement(trigger.rangeStart, replacementRangeEnd, replacement, {
+        expectedText: snapshot.value.slice(trigger.rangeStart, replacementRangeEnd),
       });
-      if (!applied) return;
-      setComposerHighlightedItemId(null);
-      // With several models picked, a mention adds one instead of replacing them all.
-      if (multipleModelSelections !== null) {
-        if (
-          !multipleModelSelections.some(
-            (selection) =>
-              selection.instanceId === item.instanceId && selection.model === item.model,
-          )
-        ) {
-          setMultipleModelSelections([
-            ...multipleModelSelections,
-            createModelSelection(item.instanceId, item.model),
-          ]);
-        }
-        return;
+      if (applied) {
+        setComposerHighlightedItemId(null);
       }
-      onProviderModelSelect(item.instanceId, item.model, { focusComposer: false });
       return;
     }
     if (item.type === "environment") {

apps/web/src/components/chat/composerModelMentions.test.ts

@@ -53,9 +53,6 @@ function match(
   return matchComposerModelItems({
     instanceEntries: [traex, opencode, claude],
     modelOptionsByInstance,
-    lockedProvider: null,
-    lockedContinuationGroupKey: null,
-    isModelDisabled: () => false,
     query,
     ...overrides,
   }).map((item) => `${item.instanceId}:${item.model}`);
@@ -66,15 +63,6 @@ describe("matchComposerModelItems", () => {
     expect(match("gpt").toSorted()).toEqual(["opencode:traex/gpt-6.1", "traex:gpt-6.1"]);
   });
 
-  it("leaves out providers a started thread can't switch to and disabled models", () => {
-    expect(match("opus", { lockedProvider: claude.driverKind })).toEqual([
-      "claudeAgent:claude-opus-5-5",
-    ]);
-    expect(
-      match("opus", { isModelDisabled: (instanceId) => instanceId === claude.instanceId }),
-    ).toEqual(["opencode:anthropic/opus"]);
-  });
-
   it("leaves out providers that are not ready", () => {
     expect(
       match("gpt", { instanceEntries: [{ ...traex, status: "error" as const }, opencode] }),