@nextclaw/ui 0.15.21 → 0.15.23

package/src/features/chat/features/conversation/hooks/use-session-conversation-composer-nodes.ts

@@ -0,0 +1,26 @@
+import { useCallback } from 'react';
+
+import type {
+  SessionConversationInputActions,
+  SessionConversationInputSnapshot,
+} from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+import {
+  deriveChatComposerDraft,
+  deriveSelectedSkillsFromComposer,
+  pruneComposerAttachments,
+} from '@/features/chat/features/input/utils/chat-composer-state.utils';
+
+export function useSessionConversationComposerNodes(
+  inputActions: SessionConversationInputActions,
+) {
+  return useCallback((nodes: SessionConversationInputSnapshot['nodes']) => {
+    const nextNodes = [...nodes];
+    inputActions.update((current) => ({
+      nodes: nextNodes,
+      attachments: pruneComposerAttachments(nextNodes, current.attachments),
+      text: deriveChatComposerDraft(nextNodes),
+      selectedSkills: deriveSelectedSkillsFromComposer(nextNodes),
+      sendError: null,
+    }));
+  }, [inputActions]);
+}

package/src/features/chat/features/conversation/hooks/use-session-conversation-controller.ts

@@ -1,17 +1,22 @@
 import { useCallback, useMemo } from 'react';
 import { buildNcpRequestEnvelope } from '@nextclaw/ncp-react';
 import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
-import type { NcpAgentSendEnvelope, NcpMessage, NcpRunHandle } from '@nextclaw/ncp';
+import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
 
 import { deriveNcpMessagePartsFromComposer } from '@/features/chat/features/input/utils/chat-composer-state.utils';
 import { isNcpChatSendDisabled } from '@/features/chat/features/input/utils/ncp-chat-input-availability.utils';
 import { buildChatRunMetadata } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
+import { createNcpSessionId } from '@/features/chat/features/session/utils/ncp-session-adapter.utils';
 import {
   buildSessionQueuedInputComposerSnapshot,
   buildSessionQueuedInputPreview,
 } from '@/features/chat/features/conversation/utils/session-queued-input.utils';
 import type { SessionConversationInputSnapshot } from './use-session-conversation-input-state';
 import type { useSessionConversationInputQuery } from './use-session-conversation-input-query';
+import {
+  useSessionConversationRecoveryActions,
+  type SessionConversationRecoveryAgent,
+} from './use-session-conversation-recovery-actions';
 
 type SessionConversationInputQuery = ReturnType<typeof useSessionConversationInputQuery>;
 type ComposerDraftSnapshot = Pick<
@@ -19,11 +24,8 @@ type ComposerDraftSnapshot = Pick<
   'text' | 'nodes' | 'selectedSkills' | 'skillRecords' | 'attachments'
 >;
 
-type SessionConversationAgent = {
+type SessionConversationAgent = SessionConversationRecoveryAgent & {
   readonly isHydrating: boolean;
-  readonly isSending: boolean;
-  readonly isRunning: boolean;
-  readonly visibleMessages: readonly NcpMessage[];
   readonly snapshot: {
     readonly activeRun?: {
       readonly sessionId?: string | null;
@@ -133,7 +135,9 @@ function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDra
   return {
     composerSnapshot,
     metadata: buildChatRunMetadata({
-      agentId: materializationContext ? undefined : selectedAgentId,
+      agentId: materializationContext
+        ? undefined
+        : inputQuery.selectedSession?.agentId?.trim() || selectedAgentId,
       model: materializationContext
         ? resolveModelForSend(inputSnapshot.selectedModel)
         : resolveModelForSend(
@@ -205,13 +209,34 @@ export function useSessionConversationController(params: UseSessionConversationC
   );
   const hasSendableDraft = hasSendableMessagePart(parts);
   const isSending = agent.isSending || agent.isRunning;
-  const sendDisabled = isNcpChatSendDisabled({
-    snapshot: buildInputAvailabilitySnapshot(inputQuery),
-    hasSendableDraft,
-    isRuntimeBlocked,
-  }) || agent.isSending;
+  const activityState = inputQuery.selectedSession?.activityPreview?.state;
+  const canContinue = Boolean(
+    sessionKey &&
+    !isSending &&
+    !isRuntimeBlocked &&
+    (activityState === 'cancelled' || activityState === 'failed'),
+  );
+  const primaryAction: 'continue' | 'send' =
+    canContinue && !hasSendableDraft ? 'continue' : 'send';
+  const sendDisabled = primaryAction === 'continue'
+    ? false
+    : isNcpChatSendDisabled({
+        snapshot: buildInputAvailabilitySnapshot(inputQuery),
+        hasSendableDraft,
+        isRuntimeBlocked,
+      }) || agent.isSending;
+
+  const { continueRun, editMessage } = useSessionConversationRecoveryActions({
+    agent,
+    sessionKey,
+    setSendError,
+  });
 
   const send = useCallback(async () => {
+    if (primaryAction === 'continue') {
+      await continueRun();
+      return;
+    }
     const draft = buildSubmissionDraft({
       agentIsSending: agent.isSending,
       inputSnapshot,
@@ -224,7 +249,9 @@ export function useSessionConversationController(params: UseSessionConversationC
     if (!draft) {
       return;
     }
-    const envelope = buildSubmissionEnvelope(draft, sessionKey);
+    const submissionSessionKey =
+      sessionKey ?? (materializationContext ? null : createNcpSessionId());
+    const envelope = buildSubmissionEnvelope(draft, submissionSessionKey);
     if (!envelope) {
       return;
     }
@@ -246,6 +273,7 @@ export function useSessionConversationController(params: UseSessionConversationC
     }
   }, [
     agent,
+    continueRun,
     inputQuery,
     inputSnapshot,
     isRuntimeBlocked,
@@ -256,6 +284,7 @@ export function useSessionConversationController(params: UseSessionConversationC
     selectedAgentId,
     sessionKey,
     setSendError,
+    primaryAction,
   ]);
 
   const editQueuedInput = useCallback((id: string) => {
@@ -290,8 +319,11 @@ export function useSessionConversationController(params: UseSessionConversationC
   }, [agent]);
 
   return {
+    canContinue,
     canStopGeneration: agent.isRunning,
+    continueRun,
     deleteQueuedInput,
+    editMessage,
     editQueuedInput,
     hasSendableDraft,
     isSending,
@@ -301,6 +333,7 @@ export function useSessionConversationController(params: UseSessionConversationC
     })),
     send,
     sendDisabled,
+    primaryAction,
     stop,
     stopDisabled: !agent.isRunning,
   };

package/src/features/chat/features/conversation/hooks/use-session-conversation-input-attachments.ts

@@ -46,6 +46,7 @@ export function useSessionConversationInputAttachments(params: UseSessionConvers
           insertedAttachments.map((attachment) => ({
             tokenKey: attachment.id,
             label: attachment.name,
+            previewUrl: attachment.mimeType.startsWith('image/') ? attachment.url : undefined,
           })),
         );
       }

package/src/features/chat/features/conversation/hooks/use-session-conversation-input-query.ts

@@ -16,6 +16,7 @@ import { resolveRecentSessionPreferredValue } from '@/features/chat/features/ses
 import { useChatSessionTypeState } from '@/features/chat/features/session-type/hooks/use-chat-session-type-state';
 import { chatRecentModelsManager } from '@/features/chat/managers/chat-recent-models.manager';
 import { useChatQueryStore } from '@/features/chat/stores/ncp-chat-query.store';
+import { useSessionProviderModelCatalog } from './use-session-provider-model-catalog';
 
 import type { SessionConversationInputSnapshot } from './use-session-conversation-input-state';
 
@@ -38,6 +39,8 @@ export function useSessionConversationInputQuery(params: UseSessionConversationI
   const isProviderStateResolved = useNcpChatProviderStateResolved();
   const querySnapshot = useChatQueryStore((state) => state.snapshot);
   const config = querySnapshot.configQuery?.data ?? null;
+  const providersView = querySnapshot.providersQuery?.data ?? null;
+  const templatesView = querySnapshot.providerTemplatesQuery?.data ?? null;
   const sessionSummaries =
     querySnapshot.sessionsQuery?.data?.sessions ?? EMPTY_NCP_SESSION_SUMMARIES;
   const sessionSkillsQuery = useNcpSessionSkills({
@@ -68,10 +71,10 @@ export function useSessionConversationInputQuery(params: UseSessionConversationI
     () =>
       buildNcpChatProviderModelOptions({
         config,
-        providersView: querySnapshot.providersQuery?.data ?? null,
-        templatesView: querySnapshot.providerTemplatesQuery?.data ?? null,
+        providersView,
+        templatesView,
       }),
-    [config, querySnapshot.providerTemplatesQuery?.data, querySnapshot.providersQuery?.data],
+    [config, providersView, templatesView],
   );
   const modelOptions = useMemo(
     () =>
@@ -90,6 +93,18 @@ export function useSessionConversationInputQuery(params: UseSessionConversationI
       sessionTypeState.selectedSessionTypeOption?.supportedModels,
     ],
   );
+  const {
+    addDiscoveredModel,
+    dismissDiscoveredModels,
+    discoveredModelOptions,
+    refreshProviderModelCatalog,
+  } = useSessionProviderModelCatalog({
+    config,
+    providersView,
+    templatesView,
+    modelSelectionMode: sessionTypeState.selectedSessionTypeOption?.modelSelectionMode,
+    supportedModels: sessionTypeState.selectedSessionTypeOption?.supportedModels,
+  });
   const availableModelValueSet = useMemo(
     () => new Set(modelOptions.map((option) => option.value)),
     [modelOptions],
@@ -124,13 +139,18 @@ export function useSessionConversationInputQuery(params: UseSessionConversationI
   );
 
   return useMemo(() => ({
+    addDiscoveredModel,
     defaultModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? config?.agents.defaults.model,
     defaultProjectRoot,
+    dismissDiscoveredModels,
+    discoveredModelOptions,
     fallbackPreferredModel,
     fallbackPreferredThinking,
     isProviderStateResolved,
     isSkillsLoading,
     modelOptions,
+    providersView,
+    refreshProviderModelCatalog,
     selectedSession,
     selectedSessionKey,
     sessionTypeState,
@@ -143,6 +163,11 @@ export function useSessionConversationInputQuery(params: UseSessionConversationI
     isProviderStateResolved,
     isSkillsLoading,
     modelOptions,
+    addDiscoveredModel,
+    dismissDiscoveredModels,
+    discoveredModelOptions,
+    refreshProviderModelCatalog,
+    providersView,
     selectedSession,
     selectedSessionKey,
     sessionTypeState,

package/src/features/chat/features/conversation/hooks/use-session-conversation-input-state.ts

@@ -1,10 +1,16 @@
-import { useCallback, useMemo, useState, type SetStateAction } from 'react';
+import { useCallback, useEffect, useMemo, type SetStateAction } from 'react';
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
 
 import type { ThinkingLevel } from '@/shared/lib/api';
 import { DEFAULT_SESSION_TYPE } from '@/features/chat/features/session-type/utils/chat-session-type.utils';
 import { createChatComposerNodesFromDraft } from '@/features/chat/features/input/utils/chat-composer-state.utils';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+import {
+  resolveChatComposerDraftKey,
+  useChatComposerDraftStore,
+  type ChatComposerDraftSnapshot,
+} from '@/features/chat/stores/chat-composer-draft.store';
 import {
   useSessionConversationPreferenceActions,
   type SessionConversationPreferenceSyncParams,
@@ -34,9 +40,11 @@ export type SessionConversationInputSnapshot = SessionConversationComposerState
   readonly sendError: string | null;
 };
 
+type SessionConversationOwnedInputSnapshot = ChatComposerDraftSnapshot;
+
 export type SessionConversationInputPatch =
-  Partial<SessionConversationInputSnapshot> |
-  ((snapshot: SessionConversationInputSnapshot) => Partial<SessionConversationInputSnapshot>);
+  Partial<SessionConversationOwnedInputSnapshot> |
+  ((snapshot: SessionConversationInputSnapshot) => Partial<SessionConversationOwnedInputSnapshot>);
 
 export type SessionConversationInputActions = {
   readonly update: (patch: SessionConversationInputPatch) => void;
@@ -73,7 +81,7 @@ const EMPTY_COMPOSER_STATE: SessionConversationComposerState = {
 
 const createInitialInputSnapshot = (
   initialPrompt?: string | null,
-): SessionConversationInputSnapshot => {
+): SessionConversationOwnedInputSnapshot => {
   const prompt = initialPrompt?.trim() ?? '';
   const composer = prompt
     ? {
@@ -89,7 +97,6 @@ const createInitialInputSnapshot = (
     selectedThinkingLevel: null,
     pendingSessionType: DEFAULT_SESSION_TYPE,
     selectedSessionType: DEFAULT_SESSION_TYPE,
-    pendingProjectRoot: null,
     composerFocusRequestId: prompt ? 1 : 0,
     sendError: null,
   };
@@ -127,20 +134,80 @@ const mergeAttachments = (
   return merged;
 };
 
-export const useSessionConversationInputState = (initialPrompt?: string | null) => {
-  const [snapshot, setSnapshot] = useState<SessionConversationInputSnapshot>(
+function useSessionConversationAttachmentActions(params: {
+  attachments: readonly NcpDraftAttachment[];
+  update: (patch: SessionConversationInputPatch) => void;
+}) {
+  const { attachments: currentAttachments, update } = params;
+  const setAttachments = useCallback((attachments: readonly NcpDraftAttachment[]) => {
+    update({ attachments });
+  }, [update]);
+  const addAttachments = useCallback((attachments: readonly NcpDraftAttachment[]) => {
+    if (attachments.length === 0) {
+      return [];
+    }
+    const existingKeys = new Set(currentAttachments.map(buildAttachmentKey));
+    const nextAttachments = mergeAttachments(currentAttachments, attachments);
+    const insertedAttachments = nextAttachments.filter(
+      (attachment) => !existingKeys.has(buildAttachmentKey(attachment)),
+    );
+    if (insertedAttachments.length > 0) {
+      update({ attachments: nextAttachments });
+    }
+    return insertedAttachments;
+  }, [currentAttachments, update]);
+  const removeAttachment = useCallback((attachmentId: string) => {
+    update((current) => ({
+      attachments: current.attachments.filter((attachment) => attachment.id !== attachmentId),
+    }));
+  }, [update]);
+  return { addAttachments, removeAttachment, setAttachments };
+}
+
+function usePersistedConversationInputSnapshot(
+  initialPrompt: string | null | undefined,
+  sessionKey: string | null,
+) {
+  const draftKey = resolveChatComposerDraftKey(sessionKey);
+  const initialSnapshot = useMemo(
     () => createInitialInputSnapshot(initialPrompt),
+    [initialPrompt],
   );
+  const snapshot = useChatComposerDraftStore(
+    (state) => state.drafts[draftKey] ?? initialSnapshot,
+  );
+
+  useEffect(() => {
+    useChatComposerDraftStore.getState().ensureDraft(draftKey, initialSnapshot);
+  }, [draftKey, initialSnapshot]);
 
   const update = useCallback((patch: SessionConversationInputPatch) => {
-    setSnapshot((current) => {
-      const resolvedPatch = typeof patch === 'function' ? patch(current) : patch;
+    useChatComposerDraftStore.getState().updateDraft(draftKey, initialSnapshot, (current) => {
+      const resolvedPatch = typeof patch === 'function'
+        ? patch({
+            ...current,
+            pendingProjectRoot: useChatThreadStore.getState().snapshot.draftProjectRoot,
+          })
+        : patch;
       return {
         ...current,
         ...resolvedPatch,
       };
     });
-  }, []);
+  }, [draftKey, initialSnapshot]);
+
+  return { snapshot, update };
+}
+
+export const useSessionConversationInputState = (
+  initialPrompt?: string | null,
+  sessionKey: string | null = null,
+) => {
+  const pendingProjectRoot = useChatThreadStore((state) => state.snapshot.draftProjectRoot);
+  const { snapshot, update } = usePersistedConversationInputSnapshot(
+    initialPrompt,
+    sessionKey,
+  );
 
   const syncComposer = useCallback((composer: SessionConversationComposerState) => {
     update({
@@ -191,30 +258,14 @@ export const useSessionConversationInputState = (initialPrompt?: string | null)
     update({ composerFocusRequestId: 0 });
   }, [update]);
 
-  const setAttachments = useCallback((attachments: readonly NcpDraftAttachment[]) => {
-    update({ attachments });
-  }, [update]);
-
-  const addAttachments = useCallback((attachments: readonly NcpDraftAttachment[]) => {
-    if (attachments.length === 0) {
-      return [];
-    }
-    const existingKeys = new Set(snapshot.attachments.map(buildAttachmentKey));
-    const nextAttachments = mergeAttachments(snapshot.attachments, attachments);
-    const insertedAttachments = nextAttachments.filter(
-      (attachment) => !existingKeys.has(buildAttachmentKey(attachment)),
-    );
-    if (insertedAttachments.length > 0) {
-      update({ attachments: nextAttachments });
-    }
-    return insertedAttachments;
-  }, [snapshot.attachments, update]);
-
-  const removeAttachment = useCallback((attachmentId: string) => {
-    update((current) => ({
-      attachments: current.attachments.filter((attachment) => attachment.id !== attachmentId),
-    }));
-  }, [update]);
+  const {
+    addAttachments,
+    removeAttachment,
+    setAttachments,
+  } = useSessionConversationAttachmentActions({
+    attachments: snapshot.attachments,
+    update,
+  });
 
   const preferenceActions = useSessionConversationPreferenceActions({
     selectedModel: snapshot.selectedModel,
@@ -236,8 +287,8 @@ export const useSessionConversationInputState = (initialPrompt?: string | null)
   }, [update]);
 
   const setPendingProjectRoot = useCallback((projectRoot: string | null) => {
-    update({ pendingProjectRoot: projectRoot });
-  }, [update]);
+    useChatThreadStore.getState().setSnapshot({ draftProjectRoot: projectRoot });
+  }, []);
 
   const setSelectedSkills = useCallback((
     selectedSkills: readonly string[],
@@ -289,7 +340,10 @@ export const useSessionConversationInputState = (initialPrompt?: string | null)
   ]);
 
   return {
-    inputSnapshot: snapshot,
+    inputSnapshot: {
+      ...snapshot,
+      pendingProjectRoot,
+    },
     inputActions: actions,
   };
 };

package/src/features/chat/features/conversation/hooks/use-session-conversation-recovery-actions.ts

@@ -0,0 +1,64 @@
+import { useCallback } from 'react';
+import type { NcpMessage, NcpRunHandle } from '@nextclaw/ncp';
+import type {
+  AgentRunContinueIngressPayload,
+  AgentRunEditMessageIngressPayload,
+} from '@nextclaw/shared';
+
+export type SessionConversationRecoveryAgent = {
+  readonly isRunning: boolean;
+  readonly isSending: boolean;
+  readonly continueRun: (
+    payload: AgentRunContinueIngressPayload,
+  ) => Promise<NcpRunHandle>;
+  readonly editMessage: (
+    payload: AgentRunEditMessageIngressPayload,
+  ) => Promise<NcpRunHandle>;
+};
+
+export type SessionConversationMessageEdit = {
+  readonly message: NcpMessage;
+  readonly messageId: string;
+};
+
+export function useSessionConversationRecoveryActions({
+  agent,
+  sessionKey,
+  setSendError,
+}: {
+  readonly agent: SessionConversationRecoveryAgent;
+  readonly sessionKey: string | null;
+  readonly setSendError: (message: string | null) => void;
+}) {
+  const continueRun = useCallback(async () => {
+    if (!sessionKey || agent.isSending || agent.isRunning) {
+      return;
+    }
+    setSendError(null);
+    try {
+      await agent.continueRun({ sessionId: sessionKey });
+    } catch (error) {
+      setSendError(error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  }, [agent, sessionKey, setSendError]);
+
+  const editMessage = useCallback(async (payload: SessionConversationMessageEdit) => {
+    if (!sessionKey || agent.isSending || agent.isRunning) {
+      return;
+    }
+    setSendError(null);
+    try {
+      await agent.editMessage({
+        message: payload.message,
+        messageId: payload.messageId,
+        sessionId: sessionKey,
+      });
+    } catch (error) {
+      setSendError(error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  }, [agent, sessionKey, setSendError]);
+
+  return { continueRun, editMessage };
+}

package/src/features/chat/features/conversation/hooks/use-session-conversation-slash-commands.ts

@@ -39,6 +39,7 @@ export function useSessionConversationSlashCommands(params: {
     return [
       {
         key: 'side-chat',
+        icon: 'message-square-plus',
         title: t('chatSlashCommandSideChatTitle', language),
         description: t('chatSlashCommandSideChatDescription', language),
         detailLines: [t('chatSlashCommandSideChatDetail', language)],
@@ -47,6 +48,7 @@ export function useSessionConversationSlashCommands(params: {
       },
       {
         key: 'compact-context',
+        icon: 'list-collapse',
         title: t('chatSlashCommandCompactContextTitle', language),
         description: t('chatSlashCommandCompactContextDescription', language),
         detailLines: [t('chatSlashCommandCompactContextDetail', language)],

package/src/features/chat/features/conversation/hooks/use-session-provider-model-catalog.ts

@@ -0,0 +1,84 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import type { RuntimeModelSelectionMode } from '@nextclaw/shared';
+
+import type { ConfigView, ProvidersView, ProviderTemplatesView } from '@/shared/lib/api';
+import { useProviderModelCatalog, useUpdateProvider } from '@/shared/hooks/use-config';
+import { normalizeStringList } from '@/shared/lib/provider-models';
+import {
+  buildNcpChatDiscoveredModelOptions,
+  filterNcpChatDiscoveredModelOptionsBySessionType,
+} from '@/features/chat/features/ncp/utils/ncp-chat-query-derived.utils';
+import { providerModelCatalogNoticeManager } from '@/features/chat/managers/provider-model-catalog-notice.manager';
+
+type UseSessionProviderModelCatalogParams = {
+  readonly config: ConfigView | null;
+  readonly providersView: ProvidersView | null;
+  readonly templatesView: ProviderTemplatesView | null;
+  readonly modelSelectionMode?: RuntimeModelSelectionMode;
+  readonly supportedModels?: string[];
+};
+
+export function useSessionProviderModelCatalog(params: UseSessionProviderModelCatalogParams) {
+  const {
+    config,
+    modelSelectionMode,
+    providersView,
+    supportedModels,
+    templatesView,
+  } = params;
+  const catalogQuery = useProviderModelCatalog();
+  const { mutateAsync: updateProvider } = useUpdateProvider();
+  const [noticeRevision, setNoticeRevision] = useState(0);
+  const catalogModelOptions = useMemo(
+    () => buildNcpChatDiscoveredModelOptions({
+      catalogView: catalogQuery.data ?? null,
+      config,
+      providersView,
+      templatesView,
+    }),
+    [catalogQuery.data, config, providersView, templatesView],
+  );
+  useEffect(() => {
+    providerModelCatalogNoticeManager.initializeLargeCatalogs(catalogModelOptions);
+  }, [catalogModelOptions]);
+  const discoveredModelOptions = useMemo(
+    () => {
+      void noticeRevision;
+      return filterNcpChatDiscoveredModelOptionsBySessionType({
+        modelOptions: providerModelCatalogNoticeManager.filterUnseen(catalogModelOptions),
+        modelSelectionMode,
+        supportedModels,
+      });
+    },
+    [catalogModelOptions, modelSelectionMode, noticeRevision, supportedModels],
+  );
+  const addDiscoveredModel = useCallback(async (value: string) => {
+    const option = discoveredModelOptions.find((candidate) => candidate.value === value);
+    const provider = option ? providersView?.providers[option.providerId] : undefined;
+    if (!option || !provider) {
+      return null;
+    }
+    await updateProvider({
+      provider: option.providerId,
+      data: {
+        models: normalizeStringList([...(provider.models ?? []), option.providerModel]),
+      },
+      silentSuccess: true,
+    });
+    providerModelCatalogNoticeManager.acknowledge([option]);
+    setNoticeRevision((current) => current + 1);
+    return option;
+  }, [discoveredModelOptions, providersView, updateProvider]);
+  const dismissDiscoveredModels = useCallback(() => {
+    if (providerModelCatalogNoticeManager.acknowledge(discoveredModelOptions)) {
+      setNoticeRevision((current) => current + 1);
+    }
+  }, [discoveredModelOptions]);
+
+  return {
+    addDiscoveredModel,
+    dismissDiscoveredModels,
+    discoveredModelOptions,
+    refreshProviderModelCatalog: catalogQuery.refetch,
+  };
+}

package/src/features/chat/features/conversation/utils/__tests__/session-message-composer.utils.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildSessionMessageComposerSnapshot } from '@/features/chat/features/conversation/utils/session-message-composer.utils';
+
+describe('buildSessionMessageComposerSnapshot', () => {
+  it('round-trips text, attachment and requested skill state into the shared composer', () => {
+    const snapshot = buildSessionMessageComposerSnapshot({
+      attachmentIdPrefix: 'edit-user-1',
+      availableSkills: [{ ref: 'skill://review', name: 'Review' }],
+      message: {
+        id: 'user-1',
+        sessionId: 'session-1',
+        role: 'user',
+        status: 'final',
+        timestamp: '2026-08-08T10:00:00.000Z',
+        metadata: { requested_skill_refs: ['skill://review'] },
+        parts: [
+          { type: 'text', text: 'check this' },
+          { type: 'file', name: 'notes.txt', mimeType: 'text/plain', sizeBytes: 12 },
+        ],
+      },
+    });
+
+    expect(snapshot.text).toContain('check this');
+    expect(snapshot.selectedSkills).toEqual(['skill://review']);
+    expect(snapshot.skillRecords).toEqual([{ ref: 'skill://review', name: 'Review' }]);
+    expect(snapshot.attachments).toEqual([
+      expect.objectContaining({ id: 'edit-user-1-1', name: 'notes.txt' }),
+    ]);
+    expect(snapshot.nodes).toEqual(expect.arrayContaining([
+      expect.objectContaining({ type: 'token', tokenKind: 'file' }),
+    ]));
+  });
+});