@nextclaw/ui 0.9.0 → 0.9.2

package/src/components/chat/chat-composer-state.ts

@@ -0,0 +1,53 @@
+import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import {
+  createChatComposerTokenNode,
+  createChatComposerNodesFromText,
+  createEmptyChatComposerNodes,
+  extractChatComposerTokenKeys,
+  normalizeChatComposerNodes,
+  removeChatComposerTokenNodes,
+  serializeChatComposerPlainText
+} from '@nextclaw/agent-chat-ui';
+
+export function createInitialChatComposerNodes(): ChatComposerNode[] {
+  return createEmptyChatComposerNodes();
+}
+
+export function createChatComposerNodesFromDraft(text: string): ChatComposerNode[] {
+  return createChatComposerNodesFromText(text);
+}
+
+export function deriveChatComposerDraft(nodes: ChatComposerNode[]): string {
+  return serializeChatComposerPlainText(nodes);
+}
+
+export function deriveSelectedSkillsFromComposer(nodes: ChatComposerNode[]): string[] {
+  return extractChatComposerTokenKeys(nodes, 'skill');
+}
+
+export function syncComposerSkills(
+  nodes: ChatComposerNode[],
+  nextSkills: string[],
+  skillRecords: Array<{ spec: string; label?: string }>
+): ChatComposerNode[] {
+  const nextSkillSet = new Set(nextSkills);
+  const prunedNodes = removeChatComposerTokenNodes(
+    nodes,
+    (node) => node.tokenKind === 'skill' && !nextSkillSet.has(node.tokenKey)
+  );
+  const existingSkills = extractChatComposerTokenKeys(prunedNodes, 'skill');
+  const recordMap = new Map(skillRecords.map((record) => [record.spec, record]));
+  const appendedNodes = nextSkills
+    .filter((skill) => !existingSkills.includes(skill))
+    .map((skill) =>
+      createChatComposerTokenNode({
+        tokenKind: 'skill',
+        tokenKey: skill,
+        label: recordMap.get(skill)?.label || skill
+      })
+    );
+
+  return appendedNodes.length === 0
+    ? prunedNodes
+    : normalizeChatComposerNodes([...prunedNodes, ...appendedNodes]);
+}

package/src/components/chat/chat-page-data.ts

@@ -4,7 +4,6 @@ import type { SessionEntryView, ThinkingLevel } from '@/api/types';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 import { useChatSessionTypeState } from '@/components/chat/useChatSessionTypeState';
 import {
-  resolveSelectedModelValue,
   resolveRecentSessionPreferredModel,
   useSyncSelectedModel
 } from '@/components/chat/chat-page-runtime';
@@ -115,25 +114,13 @@ export function useChatPageData(params: UseChatPageDataParams) {
   useSyncSelectedModel({
     modelOptions,
     selectedSessionKey: params.selectedSessionKey,
+    selectedSessionExists: Boolean(selectedSession),
     selectedSessionPreferredModel: selectedSession?.preferredModel,
     fallbackPreferredModel: recentSessionPreferredModel,
     defaultModel: configQuery.data?.agents.defaults.model,
     setSelectedModel: params.setSelectedModel
   });
 
-  const hydratedSessionModel = useMemo(
-    () =>
-      resolveSelectedModelValue({
-        currentSelectedModel: '',
-        modelOptions,
-        selectedSessionPreferredModel: selectedSession?.preferredModel,
-        fallbackPreferredModel: recentSessionPreferredModel,
-        defaultModel: configQuery.data?.agents.defaults.model,
-        preferSessionPreferredModel: true
-      }),
-    [configQuery.data?.agents.defaults.model, modelOptions, recentSessionPreferredModel, selectedSession?.preferredModel]
-  );
-
   const historyMessages = useMemo(() => historyQuery.data?.messages ?? [], [historyQuery.data?.messages]);
   const selectedSessionThinkingLevel = useMemo(() => {
     if (!params.selectedSessionKey) {
@@ -171,7 +158,6 @@ export function useChatPageData(params: UseChatPageDataParams) {
     sessions,
     skillRecords,
     selectedSession,
-    hydratedSessionModel,
     historyMessages,
     selectedSessionThinkingLevel,
     ...sessionTypeState

package/src/components/chat/chat-page-runtime.test.ts

@@ -82,6 +82,32 @@ describe('resolveSelectedModelValue', () => {
     ).toBe('openai/gpt-5');
   });
 
+  it('preserves the current valid model when a draft session materializes before the new session metadata exists', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'openai/gpt-5',
+        modelOptions,
+        fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+        defaultModel: 'anthropic/claude-sonnet-4',
+        preferSessionPreferredModel: true,
+        preserveCurrentSelectedModelOnSessionChange: true
+      })
+    ).toBe('openai/gpt-5');
+  });
+
+  it('still falls back when the current model is no longer valid during draft session materialization', () => {
+    expect(
+      resolveSelectedModelValue({
+        currentSelectedModel: 'missing/model',
+        modelOptions,
+        fallbackPreferredModel: 'openai/gpt-5',
+        defaultModel: 'anthropic/claude-sonnet-4',
+        preferSessionPreferredModel: true,
+        preserveCurrentSelectedModelOnSessionChange: true
+      })
+    ).toBe('openai/gpt-5');
+  });
+
   it('uses the recent same-runtime model when the current session has no valid preferred model', () => {
     expect(
       resolveSelectedModelValue({

package/src/components/chat/chat-page-runtime.ts

@@ -27,6 +27,7 @@ export function resolveSelectedModelValue(params: {
   fallbackPreferredModel?: string;
   defaultModel?: string;
   preferSessionPreferredModel?: boolean;
+  preserveCurrentSelectedModelOnSessionChange?: boolean;
 }): string {
   const {
     currentSelectedModel,
@@ -34,12 +35,16 @@ export function resolveSelectedModelValue(params: {
     selectedSessionPreferredModel,
     fallbackPreferredModel,
     defaultModel,
-    preferSessionPreferredModel = false
+    preferSessionPreferredModel = false,
+    preserveCurrentSelectedModelOnSessionChange = false
   } = params;
   if (modelOptions.length === 0) {
     return '';
   }
-  if (!preferSessionPreferredModel && hasModelOption(modelOptions, currentSelectedModel)) {
+  if (
+    hasModelOption(modelOptions, currentSelectedModel) &&
+    (!preferSessionPreferredModel || preserveCurrentSelectedModelOnSessionChange)
+  ) {
     return currentSelectedModel.trim();
   }
   if (hasModelOption(modelOptions, selectedSessionPreferredModel)) {
@@ -86,6 +91,7 @@ export function resolveRecentSessionPreferredModel(params: {
 export function useSyncSelectedModel(params: {
   modelOptions: ChatModelOption[];
   selectedSessionKey?: string | null;
+  selectedSessionExists?: boolean;
   selectedSessionPreferredModel?: string;
   fallbackPreferredModel?: string;
   defaultModel?: string;
@@ -94,6 +100,7 @@ export function useSyncSelectedModel(params: {
   const {
     modelOptions,
     selectedSessionKey,
+    selectedSessionExists = false,
     selectedSessionPreferredModel,
     fallbackPreferredModel,
     defaultModel,
@@ -115,11 +122,21 @@ export function useSyncSelectedModel(params: {
         selectedSessionPreferredModel,
         fallbackPreferredModel,
         defaultModel,
-        preferSessionPreferredModel: sessionChanged
+        preferSessionPreferredModel: sessionChanged,
+        preserveCurrentSelectedModelOnSessionChange:
+          sessionChanged && Boolean(selectedSessionKey) && !selectedSessionExists
       });
     });
     previousSessionKeyRef.current = selectedSessionKey;
-  }, [defaultModel, fallbackPreferredModel, modelOptions, selectedSessionKey, selectedSessionPreferredModel, setSelectedModel]);
+  }, [
+    defaultModel,
+    fallbackPreferredModel,
+    modelOptions,
+    selectedSessionExists,
+    selectedSessionKey,
+    selectedSessionPreferredModel,
+    setSelectedModel
+  ]);
 }
 
 export function useSessionRunStatus(params: {

package/src/components/chat/chat-stream/types.ts

@@ -1,3 +1,4 @@
+import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import type { Dispatch, MutableRefObject, SetStateAction } from 'react';
 import type {
   ChatRunView,
@@ -20,6 +21,7 @@ export type SendMessageParams = {
   stopSupported?: boolean;
   stopReason?: string;
   restoreDraftOnError?: boolean;
+  composerNodes?: ChatComposerNode[];
 };
 
 export type ActiveRunState = {
@@ -65,6 +67,7 @@ export type UseChatStreamControllerParams = {
   selectedSessionKeyRef: MutableRefObject<string | null>;
   setSelectedSessionKey: Dispatch<SetStateAction<string | null>>;
   setDraft: Dispatch<SetStateAction<string>>;
+  setComposerNodes: Dispatch<SetStateAction<ChatComposerNode[]>>;
   refetchSessions: () => Promise<unknown>;
   refetchHistory: () => Promise<unknown>;
 };

package/src/components/chat/containers/chat-input-bar.container.tsx

@@ -1,18 +1,15 @@
-import { useMemo } from 'react';
+import { useMemo, useState } from 'react';
 import { ChatInputBar } from '@nextclaw/agent-chat-ui';
 import {
   buildChatSlashItems,
   buildModelStateHint,
   buildModelToolbarSelect,
-  buildSelectedSkillItems,
   buildSkillPickerModel,
   buildThinkingToolbarSelect,
-  resolveSlashQuery,
   type ChatModelRecord,
   type ChatSkillRecord,
   type ChatThinkingLevel
 } from '@/components/chat/adapters/chat-input-bar.adapter';
-import { useChatInputBarController } from '@/components/chat/chat-input/chat-input-bar.controller';
 import { usePresenter } from '@/components/chat/presenter/chat-presenter-context';
 import { useI18n } from '@/components/providers/I18nProvider';
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
@@ -72,6 +69,7 @@ export function ChatInputBarContainer() {
   const presenter = usePresenter();
   const { language } = useI18n();
   const snapshot = useChatInputStore((state) => state.snapshot);
+  const [slashQuery, setSlashQuery] = useState<string | null>(null);
 
   const officialSkillBadgeLabel = useMemo(() => {
     // Keep memo reactive to locale switches even though `t` is imported as a stable function.
@@ -110,31 +108,11 @@ export function ChatInputBarContainer() {
       ? t('chatInputPlaceholder')
       : t('chatModelNoOptions');
 
-  const slashQuery = resolveSlashQuery(snapshot.draft);
   const slashItems = useMemo(
     () => buildChatSlashItems(skillRecords, slashQuery ?? '', slashTexts),
     [slashQuery, skillRecords, slashTexts]
   );
 
-  const controller = useChatInputBarController({
-    isSlashMode: slashQuery !== null,
-    slashItems,
-    isSlashLoading: snapshot.isSkillsLoading,
-    onSelectSlashItem: (item) => {
-      if (!item.value) {
-        return;
-      }
-      if (!snapshot.selectedSkills.includes(item.value)) {
-        presenter.chatInputManager.selectSkills([...snapshot.selectedSkills, item.value]);
-      }
-      presenter.chatInputManager.setDraft('');
-    },
-    onSend: presenter.chatInputManager.send,
-    onStop: presenter.chatInputManager.stop,
-    isSending: snapshot.isSending,
-    canStopGeneration: snapshot.canStopGeneration
-  });
-
   const selectedModelOption = modelRecords.find((option) => option.value === snapshot.selectedModel);
   const selectedModelThinkingCapability = selectedModelOption?.thinkingCapability;
   const thinkingSupportedLevels = selectedModelThinkingCapability?.supported ?? [];
@@ -183,27 +161,23 @@ export function ChatInputBarContainer() {
 
   return (
     <ChatInputBar
-      value={snapshot.draft}
-      placeholder={textareaPlaceholder}
-      disabled={inputDisabled}
-      onValueChange={presenter.chatInputManager.setDraft}
-      onKeyDown={controller.onTextareaKeyDown}
+      composer={{
+        nodes: snapshot.composerNodes,
+        placeholder: textareaPlaceholder,
+        disabled: inputDisabled,
+        onNodesChange: presenter.chatInputManager.setComposerNodes,
+        onSlashQueryChange: setSlashQuery
+      }}
       slashMenu={{
-        isOpen: controller.isSlashPanelOpen,
         isLoading: snapshot.isSkillsLoading,
         items: slashItems,
-        activeIndex: controller.activeSlashIndex,
-        activeItem: controller.activeSlashItem,
         texts: {
           slashLoadingLabel: t('chatSlashLoading'),
           slashSectionLabel: t('chatSlashSectionSkills'),
           slashEmptyLabel: t('chatSlashNoResult'),
           slashHintLabel: t('chatSlashHint'),
           slashSkillHintLabel: t('chatSlashSkillHint')
-        },
-        onSelectItem: controller.onSelectSlashItem,
-        onOpenChange: controller.onSlashPanelOpenChange,
-        onSetActiveIndex: controller.onSetActiveSlashIndex
+        }
       }}
       hint={buildModelStateHint({
         isModelOptionsLoading,
@@ -214,17 +188,14 @@ export function ChatInputBarContainer() {
           configureProviderLabel: t('chatGoConfigureProvider')
         }
       })}
-      selectedItems={{
-        items: buildSelectedSkillItems(snapshot.selectedSkills, skillRecords),
-        onRemove: (key) => presenter.chatInputManager.selectSkills(snapshot.selectedSkills.filter((skill) => skill !== key))
-      }}
       toolbar={{
         selects: toolbarSelects,
         accessories: [
           {
             key: 'attach',
-            label: t('chatInputAttachComingSoon'),
+            label: t('chatInputAttach'),
             icon: 'paperclip',
+            iconOnly: true,
             disabled: true,
             tooltip: t('chatInputAttachComingSoon')
           }

package/src/components/chat/legacy/LegacyChatPage.tsx

@@ -24,7 +24,6 @@ export function LegacyChatPage({ view }: ChatPageProps) {
   const { sessionId: routeSessionIdParam } = useParams<{ sessionId?: string }>();
   const threadRef = useRef<HTMLDivElement | null>(null);
   const selectedSessionKeyRef = useRef<string | null>(selectedSessionKey);
-  const modelHydratedSessionKeyRef = useRef<string | null>(null);
   const thinkingHydratedSessionKeyRef = useRef<string | null>(null);
   const routeSessionKey = useMemo(
     () => parseSessionKeyFromRoute(routeSessionIdParam),
@@ -40,7 +39,6 @@ export function LegacyChatPage({ view }: ChatPageProps) {
     sessions,
     skillRecords,
     selectedSession,
-    hydratedSessionModel,
     historyMessages,
     selectedSessionThinkingLevel,
     sessionTypeOptions,
@@ -75,6 +73,7 @@ export function LegacyChatPage({ view }: ChatPageProps) {
       selectedSessionKeyRef,
       setSelectedSessionKey: presenter.chatSessionListManager.setSelectedSessionKey,
       setDraft: presenter.chatInputManager.setDraft,
+      setComposerNodes: presenter.chatInputManager.setComposerNodes,
       refetchSessions: sessionsQuery.refetch,
       refetchHistory: historyQuery.refetch
     },
@@ -139,13 +138,6 @@ export function LegacyChatPage({ view }: ChatPageProps) {
   }, [presenter, sessionsQuery.refetch]);
 
   useEffect(() => {
-    const shouldHydrateModelFromSession =
-      !isSending &&
-      !isAwaitingAssistantOutput &&
-      !sessionsQuery.isLoading &&
-      isProviderStateResolved &&
-      modelOptions.length > 0 &&
-      selectedSessionKey !== modelHydratedSessionKeyRef.current;
     const shouldHydrateThinkingFromHistory =
       !isSending &&
       !isAwaitingAssistantOutput &&
@@ -164,7 +156,6 @@ export function LegacyChatPage({ view }: ChatPageProps) {
       sendError: lastSendError,
       isSending,
       modelOptions,
-      ...(shouldHydrateModelFromSession ? { selectedModel: hydratedSessionModel } : {}),
       sessionTypeOptions,
       selectedSessionType,
       ...(shouldHydrateThinkingFromHistory ? { selectedThinkingLevel: selectedSessionThinkingLevel } : {}),
@@ -173,14 +164,10 @@ export function LegacyChatPage({ view }: ChatPageProps) {
       skillRecords,
       isSkillsLoading: installedSkillsQuery.isLoading
     });
-    if (shouldHydrateModelFromSession) {
-      modelHydratedSessionKeyRef.current = selectedSessionKey;
-    }
     if (shouldHydrateThinkingFromHistory) {
       thinkingHydratedSessionKeyRef.current = selectedSessionKey;
     }
     if (!selectedSessionKey) {
-      modelHydratedSessionKeyRef.current = null;
       thinkingHydratedSessionKeyRef.current = null;
     }
     presenter.chatSessionListManager.syncSnapshot({
@@ -220,7 +207,6 @@ export function LegacyChatPage({ view }: ChatPageProps) {
     historyQuery.isLoading,
     installedSkillsQuery.isLoading,
     isAwaitingAssistantOutput,
-    hydratedSessionModel,
     isProviderStateResolved,
     isSending,
     lastSendError,

package/src/components/chat/managers/chat-input.manager.ts

@@ -1,3 +1,11 @@
+import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import {
+  createInitialChatComposerNodes,
+  createChatComposerNodesFromDraft,
+  deriveChatComposerDraft,
+  deriveSelectedSkillsFromComposer,
+  syncComposerSkills
+} from '@/components/chat/chat-composer-state';
 import { updateSession } from '@/api/config';
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
 import { buildNewSessionKey } from '@/components/chat/chat-session-route';
@@ -36,6 +44,17 @@ export class ChatInputManager {
     return next;
   };
 
+  private isSameStringArray = (left: string[], right: string[]): boolean =>
+    left.length === right.length && left.every((value, index) => value === right[index]);
+
+  private syncComposerSnapshot = (nodes: ChatComposerNode[]) => {
+    useChatInputStore.getState().setSnapshot({
+      composerNodes: nodes,
+      draft: deriveChatComposerDraft(nodes),
+      selectedSkills: deriveSelectedSkillsFromComposer(nodes)
+    });
+  };
+
   syncSnapshot = (patch: Partial<ChatInputSnapshot>) => {
     if (!this.hasSnapshotChanges(patch)) {
       return;
@@ -46,8 +65,8 @@ export class ChatInputManager {
       Object.prototype.hasOwnProperty.call(patch, 'selectedModel') ||
       Object.prototype.hasOwnProperty.call(patch, 'selectedThinkingLevel')
     ) {
-      const snapshot = useChatInputStore.getState().snapshot;
-      this.reconcileThinkingForModel(snapshot.selectedModel);
+      const { selectedModel } = useChatInputStore.getState().snapshot;
+      this.reconcileThinkingForModel(selectedModel);
     }
   };
 
@@ -57,7 +76,16 @@ export class ChatInputManager {
     if (value === prev) {
       return;
     }
-    useChatInputStore.getState().setSnapshot({ draft: value });
+    this.syncComposerSnapshot(createChatComposerNodesFromDraft(value));
+  };
+
+  setComposerNodes = (next: SetStateAction<ChatComposerNode[]>) => {
+    const prev = useChatInputStore.getState().snapshot.composerNodes;
+    const value = this.resolveUpdateValue(prev, next);
+    if (Object.is(value, prev)) {
+      return;
+    }
+    this.syncComposerSnapshot(value);
   };
 
   setPendingSessionType = (next: SetStateAction<string>) => {
@@ -76,14 +104,13 @@ export class ChatInputManager {
     if (!message) {
       return;
     }
-    const requestedSkills = inputSnapshot.selectedSkills;
+    const { selectedSkills: requestedSkills, composerNodes } = inputSnapshot;
     const hasSelectedSession = Boolean(sessionSnapshot.selectedSessionKey);
     const sessionKey = sessionSnapshot.selectedSessionKey ?? buildNewSessionKey(sessionSnapshot.selectedAgentId);
     if (!hasSelectedSession) {
       this.uiManager.goToSession(sessionKey, { replace: true });
     }
-    this.setDraft('');
-    this.setSelectedSkills([]);
+    this.setComposerNodes(createInitialChatComposerNodes());
     await this.streamActionsManager.sendMessage({
       message,
       sessionKey,
@@ -94,7 +121,8 @@ export class ChatInputManager {
       stopSupported: inputSnapshot.stopSupported,
       stopReason: inputSnapshot.stopReason,
       requestedSkills,
-      restoreDraftOnError: true
+      restoreDraftOnError: true,
+      composerNodes
     });
   };
 
@@ -132,12 +160,13 @@ export class ChatInputManager {
   };
 
   setSelectedSkills = (next: SetStateAction<string[]>) => {
-    const prev = useChatInputStore.getState().snapshot.selectedSkills;
+    const snapshot = useChatInputStore.getState().snapshot;
+    const { selectedSkills: prev } = snapshot;
     const value = this.resolveUpdateValue(prev, next);
-    if (Object.is(value, prev)) {
+    if (this.isSameStringArray(value, prev)) {
       return;
     }
-    useChatInputStore.getState().setSnapshot({ selectedSkills: value });
+    this.syncComposerSnapshot(syncComposerSkills(snapshot.composerNodes, value, snapshot.skillRecords));
   };
 
   selectModel = (value: string) => {
@@ -174,15 +203,16 @@ export class ChatInputManager {
   private reconcileThinkingForModel(model: string): void {
     const snapshot = useChatInputStore.getState().snapshot;
     const modelOption = snapshot.modelOptions.find((option) => option.value === model);
-    const nextThinking = this.resolveThinkingForModel(modelOption, snapshot.selectedThinkingLevel);
-    if (nextThinking !== snapshot.selectedThinkingLevel) {
+    const { selectedThinkingLevel } = snapshot;
+    const nextThinking = this.resolveThinkingForModel(modelOption, selectedThinkingLevel);
+    if (nextThinking !== selectedThinkingLevel) {
       useChatInputStore.getState().setSnapshot({ selectedThinkingLevel: nextThinking });
     }
   }
 
   private syncRemoteSessionType = async (normalizedType: string) => {
     const sessionSnapshot = useChatSessionListStore.getState().snapshot;
-    const selectedSessionKey = sessionSnapshot.selectedSessionKey;
+    const { selectedSessionKey } = sessionSnapshot;
     if (!selectedSessionKey) {
       return;
     }

package/src/components/chat/ncp/NcpChatPage.tsx

@@ -71,7 +71,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
   const { sessionId: routeSessionIdParam } = useParams<{ sessionId?: string }>();
   const threadRef = useRef<HTMLDivElement | null>(null);
   const selectedSessionKeyRef = useRef<string | null>(selectedSessionKey);
-  const modelHydratedSessionKeyRef = useRef<string | null>(null);
   const thinkingHydratedSessionKeyRef = useRef<string | null>(null);
   const routeSessionKey = useMemo(
     () => parseSessionKeyFromRoute(routeSessionIdParam),
@@ -86,7 +85,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
     sessions,
     skillRecords,
     selectedSession,
-    hydratedSessionModel,
     selectedSessionThinkingLevel,
     sessionTypeOptions,
     defaultSessionType,
@@ -212,9 +210,17 @@ export function NcpChatPage({ view }: ChatPageProps) {
           await sessionsQuery.refetch();
         } catch (error) {
           if (payload.restoreDraftOnError) {
-            presenter.chatInputManager.setDraft((currentDraft) =>
-              currentDraft.trim().length === 0 ? payload.message : currentDraft
-            );
+            if (payload.composerNodes && payload.composerNodes.length > 0) {
+              presenter.chatInputManager.setComposerNodes((currentNodes) =>
+                currentNodes.length === 1 && currentNodes[0]?.type === 'text' && currentNodes[0].text.length === 0
+                  ? payload.composerNodes ?? currentNodes
+                  : currentNodes
+              );
+            } else {
+              presenter.chatInputManager.setDraft((currentDraft) =>
+                currentDraft.trim().length === 0 ? payload.message : currentDraft
+              );
+            }
           }
           throw error;
         }
@@ -270,13 +276,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
   }, [presenter, sessionsQuery.refetch]);
 
   useEffect(() => {
-    const shouldHydrateModelFromSession =
-      !isSending &&
-      !isAwaitingAssistantOutput &&
-      !sessionsQuery.isLoading &&
-      isProviderStateResolved &&
-      modelOptions.length > 0 &&
-      selectedSessionKey !== modelHydratedSessionKeyRef.current;
     const shouldHydrateThinkingFromSession =
       !isSending &&
       !isAwaitingAssistantOutput &&
@@ -295,7 +294,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
       sendError: lastSendError,
       isSending,
       modelOptions,
-      ...(shouldHydrateModelFromSession ? { selectedModel: hydratedSessionModel } : {}),
       sessionTypeOptions,
       selectedSessionType,
       ...(shouldHydrateThinkingFromSession ? { selectedThinkingLevel: selectedSessionThinkingLevel } : {}),
@@ -304,14 +302,10 @@ export function NcpChatPage({ view }: ChatPageProps) {
       skillRecords,
       isSkillsLoading: installedSkillsQuery.isLoading
     });
-    if (shouldHydrateModelFromSession) {
-      modelHydratedSessionKeyRef.current = selectedSessionKey;
-    }
     if (shouldHydrateThinkingFromSession) {
       thinkingHydratedSessionKeyRef.current = selectedSessionKey;
     }
     if (!selectedSessionKey) {
-      modelHydratedSessionKeyRef.current = null;
       thinkingHydratedSessionKeyRef.current = null;
     }
     presenter.chatSessionListManager.syncSnapshot({
@@ -349,7 +343,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
     defaultSessionType,
     installedSkillsQuery.isLoading,
     isAwaitingAssistantOutput,
-    hydratedSessionModel,
     isProviderStateResolved,
     isSending,
     lastSendError,