@nextclaw/ui 0.12.7 → 0.12.9

package/src/components/chat/ncp/tests/ncp-chat-thread.manager.test.ts

@@ -0,0 +1,189 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { appQueryClient } from '@/app-query-client';
+import { NcpChatThreadManager } from '@/components/chat/ncp/ncp-chat-thread.manager';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
+
+const { deleteNcpSessionMock, deleteSummaryMock } = vi.hoisted(() => ({
+  deleteNcpSessionMock: vi.fn(async () => ({ deleted: true, sessionId: 'parent-session-1' })),
+  deleteSummaryMock: vi.fn(),
+}));
+
+vi.mock('@/api/ncp-session', () => ({
+  deleteNcpSession: deleteNcpSessionMock,
+}));
+
+vi.mock('@/api/ncp-session-query-cache', () => ({
+  deleteNcpSessionSummaryInQueryClient: deleteSummaryMock,
+}));
+
+describe('NcpChatThreadManager', () => {
+  beforeEach(() => {
+    useChatSessionListStore.setState({
+      optimisticReadAtBySessionKey: {},
+      snapshot: {
+        ...useChatSessionListStore.getState().snapshot,
+        selectedSessionKey: 'parent-session-1',
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: 'parent-session-1',
+        workspacePanelParentKey: null,
+        childSessionTabs: [
+          {
+            sessionKey: 'child-session-1',
+            parentSessionKey: 'parent-session-1',
+            label: 'Child Session 1',
+            agentId: 'reviewer',
+          },
+        ],
+        activeChildSessionKey: null,
+      },
+    });
+  });
+
+  it('opens the child-session panel for the requested parent session and keeps focus on the chosen child', () => {
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openChildSessionPanel({
+      parentSessionKey: 'parent-session-1',
+      activeChildSessionKey: 'child-session-1',
+    });
+
+    expect(useChatThreadStore.getState().snapshot.workspacePanelParentKey).toBe('parent-session-1');
+    expect(useChatThreadStore.getState().snapshot.activeChildSessionKey).toBe('child-session-1');
+    expect(uiManager.goToSession).not.toHaveBeenCalled();
+  });
+
+  it('routes to the parent session before opening the child-session panel when needed', () => {
+    useChatSessionListStore.setState({
+      snapshot: {
+        ...useChatSessionListStore.getState().snapshot,
+        selectedSessionKey: 'another-session',
+      },
+    });
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openChildSessionPanel({
+      parentSessionKey: 'parent-session-1',
+      activeChildSessionKey: 'child-session-1',
+    });
+
+    expect(uiManager.goToSession).toHaveBeenCalledWith('parent-session-1');
+  });
+
+  it('keeps preview and diff for the same file as separate workspace tabs', () => {
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
+      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
+    );
+
+    manager.openFilePreview({
+      path: 'README.md',
+      label: 'README.md',
+      viewMode: 'preview',
+    });
+    manager.openFilePreview({
+      path: 'README.md',
+      label: 'README.md',
+      viewMode: 'diff',
+      beforeText: 'old\n',
+      afterText: 'new\n',
+    });
+
+    expect(useChatThreadStore.getState().snapshot.workspaceFileTabs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          key: 'parent-session-1::preview::README.md',
+          path: 'README.md',
+          viewMode: 'preview',
+        }),
+        expect.objectContaining({
+          key: 'parent-session-1::diff::README.md',
+          path: 'README.md',
+          viewMode: 'diff',
+        }),
+      ]),
+    );
+  });
+
+  it('clears the selected thread state after deleting the current session', async () => {
+    const removeQueries = vi.spyOn(appQueryClient, 'removeQueries').mockImplementation(async () => undefined);
+    const uiManager = {
+      goToSession: vi.fn(),
+      goToChatRoot: vi.fn(),
+      goToProviders: vi.fn(),
+      confirm: vi.fn(async () => true),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
+    const sessionListManager = {
+      setSelectedSessionKey: vi.fn((value: string | null) => {
+        useChatSessionListStore.getState().setSnapshot({
+          selectedSessionKey: value,
+        });
+      }),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[1];
+    const streamActionsManager = {
+      resetStreamState: vi.fn(),
+    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[2];
+    const manager = new NcpChatThreadManager(
+      uiManager,
+      sessionListManager,
+      streamActionsManager,
+    );
+
+    await (manager as unknown as { deleteCurrentSession: () => Promise<void> }).deleteCurrentSession();
+
+    expect(sessionListManager.setSelectedSessionKey).toHaveBeenCalledWith(null);
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      sessionKey: null,
+      canDeleteSession: false,
+      messages: [],
+      workspacePanelParentKey: null,
+      childSessionTabs: [],
+      activeChildSessionKey: null,
+      workspaceFileTabs: [],
+      activeWorkspaceFileKey: null,
+    });
+    expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
+    expect(deleteSummaryMock).toHaveBeenCalledWith(appQueryClient, 'parent-session-1');
+    expect(removeQueries).toHaveBeenCalledWith({
+      queryKey: ['ncp-session-messages', 'parent-session-1'],
+    });
+    expect(uiManager.goToChatRoot).toHaveBeenCalledWith({ replace: true });
+
+    removeQueries.mockRestore();
+  });
+});

package/src/components/chat/presenter/chat-presenter-context.tsx

@@ -1,4 +1,8 @@
-import type { ChatComposerNode, ChatToolActionViewModel } from '@nextclaw/agent-chat-ui';
+import type {
+  ChatComposerNode,
+  ChatFileOpenActionViewModel,
+  ChatToolActionViewModel,
+} from '@nextclaw/agent-chat-ui';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
 import { createContext, useContext } from 'react';
 import type { ReactNode } from 'react';
@@ -37,9 +41,16 @@ export type ChatThreadManagerLike = {
   deleteSession: () => void;
   createSession: () => void;
   goToProviders: () => void;
+  openChildSessionPanel: (params: {
+    parentSessionKey: string;
+    activeChildSessionKey?: string | null;
+  }) => void;
+  openFilePreview: (action: ChatFileOpenActionViewModel) => void;
   openSessionFromToolAction: (action: ChatToolActionViewModel) => void;
   selectChildSessionDetail: (sessionKey: string) => void;
-  closeChildSessionDetail: () => void;
+  selectWorkspaceFile: (fileKey: string) => void;
+  closeWorkspaceFile: (fileKey: string) => void;
+  closeWorkspacePanel: () => void;
   goToParentSession: () => void;
 };
 

package/src/components/chat/session-header/chat-session-header-actions.test.tsx

@@ -6,6 +6,7 @@ import { ChatSessionHeaderActions } from '@/components/chat/session-header/chat-
 const mocks = vi.hoisted(() => ({
   updateSessionProject: vi.fn(),
   onDeleteSession: vi.fn(),
+  onOpenChildSessions: vi.fn(),
 }));
 
 vi.mock('@/components/chat/hooks/use-chat-session-project', () => ({
@@ -20,6 +21,7 @@ describe('ChatSessionHeaderActions', () => {
   beforeEach(() => {
     mocks.updateSessionProject.mockReset();
     mocks.onDeleteSession.mockReset();
+    mocks.onOpenChildSessions.mockReset();
   });
 
   it('keeps only the set-project action in the more-actions menu when a project is already attached', async () => {
@@ -31,6 +33,8 @@ describe('ChatSessionHeaderActions', () => {
         canDeleteSession
         isDeletePending={false}
         projectRoot="/tmp/project-alpha"
+        childSessionCount={0}
+        onOpenChildSessions={mocks.onOpenChildSessions}
         onDeleteSession={mocks.onDeleteSession}
       />
     );
@@ -51,6 +55,8 @@ describe('ChatSessionHeaderActions', () => {
         canDeleteSession={false}
         isDeletePending={false}
         projectRoot={null}
+        childSessionCount={0}
+        onOpenChildSessions={mocks.onOpenChildSessions}
         onDeleteSession={mocks.onDeleteSession}
       />
     );
@@ -60,4 +66,24 @@ describe('ChatSessionHeaderActions', () => {
     expect(screen.getByText('Set Project Directory')).toBeTruthy();
     expect(screen.queryByText('Clear Project Directory')).toBeNull();
   });
+
+  it('shows a dedicated child-session entry button when the current session has child sessions', async () => {
+    const user = userEvent.setup();
+
+    render(
+      <ChatSessionHeaderActions
+        sessionKey="session-children"
+        canDeleteSession
+        isDeletePending={false}
+        projectRoot={null}
+        childSessionCount={2}
+        onOpenChildSessions={mocks.onOpenChildSessions}
+        onDeleteSession={mocks.onDeleteSession}
+      />
+    );
+
+    await user.click(screen.getByRole('button', { name: 'View child sessions' }));
+
+    expect(mocks.onOpenChildSessions).toHaveBeenCalledTimes(1);
+  });
 });

package/src/components/chat/session-header/chat-session-header-actions.tsx

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { FolderOpen, MoreHorizontal, Trash2 } from 'lucide-react';
+import { FolderOpen, GitBranch, MoreHorizontal, Trash2 } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
 import { useChatSessionProject } from '@/components/chat/hooks/use-chat-session-project';
@@ -12,6 +12,8 @@ type ChatSessionHeaderActionsProps = {
   canDeleteSession: boolean;
   isDeletePending: boolean;
   projectRoot?: string | null;
+  childSessionCount?: number;
+  onOpenChildSessions?: () => void;
   onDeleteSession: () => void;
 };
 
@@ -20,6 +22,8 @@ export function ChatSessionHeaderActions({
   canDeleteSession,
   isDeletePending,
   projectRoot,
+  childSessionCount = 0,
+  onOpenChildSessions,
   onDeleteSession,
 }: ChatSessionHeaderActionsProps) {
   const updateSessionProject = useChatSessionProject();
@@ -46,6 +50,20 @@ export function ChatSessionHeaderActions({
 
   return (
     <>
+      {childSessionCount > 0 && onOpenChildSessions ? (
+        <Button
+          type="button"
+          variant="ghost"
+          size="icon"
+          className="rounded-lg shrink-0 text-gray-400 hover:text-gray-700"
+          aria-label={t('chatSessionOpenChildSessions')}
+          title={t('chatSessionOpenChildSessions')}
+          onClick={onOpenChildSessions}
+          disabled={isBusy}
+        >
+          <GitBranch className="h-4 w-4" />
+        </Button>
+      ) : null}
       <Popover open={isMenuOpen} onOpenChange={setIsMenuOpen}>
         <PopoverTrigger asChild>
           <Button

package/src/components/chat/stores/chat-session-list.store.ts

@@ -13,42 +13,39 @@ export type ChatSessionListSnapshot = {
 };
 
 export function hasUnreadSessionUpdate(
-  updatedAt: string | null | undefined,
-  readUpdatedAt: string | undefined,
+  lastMessageAt: string | null | undefined,
+  readAt: string | undefined,
 ): boolean {
-  const normalizedUpdatedAt = updatedAt?.trim();
-  if (!normalizedUpdatedAt) {
+  const normalizedLastMessageAt = lastMessageAt?.trim();
+  if (!normalizedLastMessageAt) {
     return false;
   }
-  const normalizedReadUpdatedAt = readUpdatedAt?.trim();
-  if (!normalizedReadUpdatedAt) {
-    return true;
+  const normalizedReadAt = readAt?.trim();
+  if (!normalizedReadAt) {
+    // Until this client establishes a read watermark, avoid guessing unread state.
+    return false;
   }
-  return normalizedUpdatedAt.localeCompare(normalizedReadUpdatedAt) > 0;
+  return normalizedLastMessageAt.localeCompare(normalizedReadAt) > 0;
 }
 
 export function shouldShowUnreadSessionIndicator(params: {
   active: boolean;
-  updatedAt: string | null | undefined;
-  readUpdatedAt: string | undefined;
+  lastMessageAt: string | null | undefined;
+  readAt: string | undefined;
   runStatus?: SessionRunStatus;
 }): boolean {
-  const { active, readUpdatedAt, runStatus, updatedAt } = params;
+  const { active, readAt, runStatus, lastMessageAt } = params;
   if (active || runStatus === 'running') {
     return false;
   }
-  return hasUnreadSessionUpdate(updatedAt, readUpdatedAt);
+  return hasUnreadSessionUpdate(lastMessageAt, readAt);
 }
 
 type ChatSessionListStore = {
   snapshot: ChatSessionListSnapshot;
-  readUpdatedAtBySessionKey: Record<string, string>;
-  hasHydratedReadWatermarks: boolean;
+  optimisticReadAtBySessionKey: Record<string, string>;
   setSnapshot: (patch: Partial<ChatSessionListSnapshot>) => void;
-  markSessionRead: (sessionKey: string, updatedAt: string | null | undefined) => void;
-  hydrateReadWatermarks: (
-    entries: readonly { sessionKey: string; updatedAt: string | null | undefined }[],
-  ) => void;
+  markSessionRead: (sessionKey: string, readAt: string | null | undefined) => void;
 };
 
 type ChatSessionListStoreSet = Parameters<StateCreator<ChatSessionListStore>>[0];
@@ -72,56 +69,30 @@ function createSetSnapshotAction(set: ChatSessionListStoreSet) {
 }
 
 function createMarkSessionReadAction(set: ChatSessionListStoreSet) {
-  return (sessionKey: string, updatedAt: string | null | undefined) =>
+  return (sessionKey: string, readAt: string | null | undefined) =>
     set((state) => {
       const normalizedSessionKey = sessionKey.trim();
-      const normalizedUpdatedAt = updatedAt?.trim();
-      if (!normalizedSessionKey || !normalizedUpdatedAt) {
+      const normalizedReadAt = readAt?.trim();
+      if (!normalizedSessionKey || !normalizedReadAt) {
         return state;
       }
-      if (state.readUpdatedAtBySessionKey[normalizedSessionKey] === normalizedUpdatedAt) {
+      const previousReadAt = state.optimisticReadAtBySessionKey[normalizedSessionKey];
+      if (previousReadAt && previousReadAt.localeCompare(normalizedReadAt) >= 0) {
         return state;
       }
       return {
         ...state,
-        readUpdatedAtBySessionKey: {
-          ...state.readUpdatedAtBySessionKey,
-          [normalizedSessionKey]: normalizedUpdatedAt
-        }
-      };
-    });
-}
-
-function createHydrateReadWatermarksAction(set: ChatSessionListStoreSet) {
-  return (
-    entries: readonly { sessionKey: string; updatedAt: string | null | undefined }[],
-  ) =>
-    set((state) => {
-      if (state.hasHydratedReadWatermarks) {
-        return state;
-      }
-      const nextReadUpdatedAtBySessionKey = { ...state.readUpdatedAtBySessionKey };
-      for (const entry of entries) {
-        const normalizedSessionKey = entry.sessionKey.trim();
-        const normalizedUpdatedAt = entry.updatedAt?.trim();
-        if (!normalizedSessionKey || !normalizedUpdatedAt || nextReadUpdatedAtBySessionKey[normalizedSessionKey]) {
-          continue;
+        optimisticReadAtBySessionKey: {
+          ...state.optimisticReadAtBySessionKey,
+          [normalizedSessionKey]: normalizedReadAt
         }
-        nextReadUpdatedAtBySessionKey[normalizedSessionKey] = normalizedUpdatedAt;
-      }
-      return {
-        ...state,
-        hasHydratedReadWatermarks: true,
-        readUpdatedAtBySessionKey: nextReadUpdatedAtBySessionKey
       };
     });
 }
 
 export const useChatSessionListStore = create<ChatSessionListStore>((set) => ({
   snapshot: initialSnapshot,
-  readUpdatedAtBySessionKey: {},
-  hasHydratedReadWatermarks: false,
+  optimisticReadAtBySessionKey: {},
   setSnapshot: createSetSnapshotAction(set),
-  markSessionRead: createMarkSessionReadAction(set),
-  hydrateReadWatermarks: createHydrateReadWatermarksAction(set)
+  markSessionRead: createMarkSessionReadAction(set)
 }));

package/src/components/chat/stores/chat-thread.store.ts

@@ -1,6 +1,7 @@
 import { create } from 'zustand';
 import type { MutableRefObject } from 'react';
 import type { NcpMessage } from '@nextclaw/ncp';
+import type { ChatFileOperationLineViewModel } from '@nextclaw/agent-chat-ui';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 import type { AgentProfileView } from '@/api/types';
 
@@ -11,6 +12,23 @@ export type ChatChildSessionTab = {
   agentId?: string | null;
 };
 
+export type ChatWorkspaceFileTab = {
+  key: string;
+  parentSessionKey: string | null;
+  path: string;
+  label?: string | null;
+  viewMode: 'preview' | 'diff';
+  line?: number | null;
+  column?: number | null;
+  rawText?: string | null;
+  beforeText?: string | null;
+  afterText?: string | null;
+  patchText?: string | null;
+  oldStartLine?: number | null;
+  newStartLine?: number | null;
+  fullLines?: ChatFileOperationLineViewModel[];
+};
+
 export type ChatThreadSnapshot = {
   isProviderStateResolved: boolean;
   modelOptions: ChatModelOption[];
@@ -34,8 +52,11 @@ export type ChatThreadSnapshot = {
   isAwaitingAssistantOutput: boolean;
   parentSessionKey?: string | null;
   parentSessionLabel?: string | null;
+  workspacePanelParentKey?: string | null;
   childSessionTabs: ChatChildSessionTab[];
   activeChildSessionKey?: string | null;
+  workspaceFileTabs: ChatWorkspaceFileTab[];
+  activeWorkspaceFileKey?: string | null;
 };
 
 type ChatThreadStore = {
@@ -66,8 +87,11 @@ const initialSnapshot: ChatThreadSnapshot = {
   isAwaitingAssistantOutput: false,
   parentSessionKey: null,
   parentSessionLabel: null,
+  workspacePanelParentKey: null,
   childSessionTabs: [],
   activeChildSessionKey: null,
+  workspaceFileTabs: [],
+  activeWorkspaceFileKey: null,
 };
 
 export const useChatThreadStore = create<ChatThreadStore>((set) => ({

package/src/components/common/ProviderScopedModelInput.tsx

@@ -64,6 +64,11 @@ export function ProviderScopedModelInput({
       setModelId(currentModel);
       return;
     }
+    if (!currentModel) {
+      setModelId('');
+      setProviderName((currentProvider) => (providerMap.has(currentProvider) ? currentProvider : ''));
+      return;
+    }
     const matchedProvider = findProviderByModel(currentModel, providerCatalog);
     const effectiveProvider = matchedProvider ?? '';
     const aliases = providerMap.get(effectiveProvider)?.aliases ?? [];
@@ -72,9 +77,14 @@ export function ProviderScopedModelInput({
   }, [hasProviders, providerCatalog, providerMap, value]);
 
   const handleProviderChange = (nextProvider: string) => {
+    const nextProviderModel = normalizeModelOptions(providerMap.get(nextProvider)?.models ?? [])[0] ?? '';
     setProviderName(nextProvider);
-    setModelId('');
-    onChange('');
+    setModelId(nextProviderModel);
+    if (!nextProviderModel) {
+      onChange('');
+      return;
+    }
+    onChange(composeProviderModel(providerMap.get(nextProvider)?.prefix ?? nextProvider, nextProviderModel));
   };
 
   const handleModelChange = (nextModelId: string) => {

package/src/components/config/ModelConfig.test.tsx

@@ -1,5 +1,7 @@
-import { render, screen, waitFor } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import { useState } from 'react';
+import { ProviderScopedModelInput } from '@/components/common/ProviderScopedModelInput';
 import { ModelConfig } from '@/components/config/ModelConfig';
 import { setLanguage } from '@/lib/i18n';
 
@@ -19,7 +21,7 @@ const mocks = vi.hoisted(() => ({
           apiKeySet: true,
           models: ['gpt-5.2']
         }
-      }
+      } as Record<string, { enabled: boolean; apiKeySet: boolean; models: string[] }>
     },
     isLoading: false
   },
@@ -58,6 +60,9 @@ describe('ModelConfig', () => {
   beforeEach(() => {
     mocks.mutate.mockReset();
     setLanguage('en');
+    HTMLElement.prototype.hasPointerCapture = vi.fn(() => false);
+    HTMLElement.prototype.setPointerCapture = vi.fn();
+    HTMLElement.prototype.releasePointerCapture = vi.fn();
     mocks.configQuery.data = {
       agents: {
         defaults: {
@@ -82,9 +87,42 @@ describe('ModelConfig', () => {
           defaultModels: ['openai/gpt-5.2'],
           keywords: [],
           envKey: 'OPENAI_API_KEY'
+        },
+        {
+          name: 'deepseek',
+          displayName: 'DeepSeek',
+          modelPrefix: 'deepseek',
+          defaultModels: ['deepseek/deepseek-chat', 'deepseek/deepseek-reasoner'],
+          keywords: [],
+          envKey: 'DEEPSEEK_API_KEY'
+        },
+        {
+          name: 'customhub',
+          displayName: 'CustomHub',
+          modelPrefix: 'customhub',
+          defaultModels: [],
+          keywords: [],
+          envKey: 'CUSTOMHUB_API_KEY'
         }
       ]
     };
+    mocks.configQuery.data.providers = {
+      openai: {
+        enabled: true,
+        apiKeySet: true,
+        models: ['gpt-5.2']
+      },
+      deepseek: {
+        enabled: true,
+        apiKeySet: true,
+        models: ['deepseek-chat', 'deepseek-reasoner']
+      },
+      customhub: {
+        enabled: true,
+        apiKeySet: true,
+        models: []
+      }
+    };
   });
 
   it('submits the workspace together with the selected model', async () => {
@@ -136,4 +174,72 @@ describe('ModelConfig', () => {
       });
     });
   });
+
+  it('switches to the new provider without clearing the selection and auto-fills its first model', async () => {
+    const user = userEvent.setup();
+
+    render(<ModelConfig />);
+
+    const providerTrigger = screen.getByRole('combobox');
+    fireEvent.keyDown(providerTrigger, { key: 'ArrowDown' });
+    await user.click(screen.getByRole('option', { name: 'DeepSeek' }));
+    await user.click(screen.getByRole('button', { name: /save/i }));
+
+    await waitFor(() => {
+      expect(mocks.mutate).toHaveBeenCalledWith({
+        model: 'deepseek/deepseek-chat',
+        workspace: '~/old-workspace'
+      });
+    });
+
+    expect(providerTrigger.textContent).toContain('DeepSeek');
+    expect(screen.getByDisplayValue('deepseek-chat')).toBeTruthy();
+  });
+
+  it('keeps the provider selected when the shared input switches to a provider without preset models', async () => {
+    const user = userEvent.setup();
+
+    function Harness() {
+      const [value, setValue] = useState('openai/gpt-5.2');
+
+      return (
+        <ProviderScopedModelInput
+          value={value}
+          onChange={setValue}
+          providerCatalog={[
+            {
+              name: 'openai',
+              displayName: 'OpenAI',
+              prefix: 'openai',
+              aliases: ['openai'],
+              models: ['gpt-5.2'],
+              modelThinking: {},
+              configured: true
+            },
+            {
+              name: 'customhub',
+              displayName: 'CustomHub',
+              prefix: 'customhub',
+              aliases: ['customhub'],
+              models: [],
+              modelThinking: {},
+              configured: true
+            }
+          ]}
+        />
+      );
+    }
+
+    render(<Harness />);
+
+    const providerTrigger = screen.getByRole('combobox');
+    fireEvent.keyDown(providerTrigger, { key: 'ArrowDown' });
+    await user.click(screen.getByRole('option', { name: 'CustomHub' }));
+
+    const modelInput = screen.getByPlaceholderText('provider/model');
+    await user.type(modelInput, 'reasoner-v1');
+
+    expect(providerTrigger.textContent).toContain('CustomHub');
+    expect(screen.getByDisplayValue('reasoner-v1')).toBeTruthy();
+  });
 });