@nextclaw/ui 0.11.8 → 0.11.10

package/src/components/chat/containers/chat-message-list.container.tsx

@@ -1,82 +1,121 @@
 import { useMemo } from "react";
-import { type UiMessage } from "@nextclaw/agent-chat";
-import { ChatMessageList } from "@nextclaw/agent-chat-ui";
+import type { NcpMessage } from "@nextclaw/ncp";
 import {
-  adaptChatMessages,
+  type ChatMessageViewModel,
+  ChatMessageList,
+} from "@nextclaw/agent-chat-ui";
+import {
+  adaptChatMessage,
+  type ChatMessageAdapterTexts,
   type ChatMessageSource,
 } from "@/components/chat/adapters/chat-message.adapter";
+import { adaptNcpMessageToUiMessage } from "@/components/chat/ncp/ncp-session-adapter";
 import { useI18n } from "@/components/providers/I18nProvider";
 import { formatDateTime, t } from "@/lib/i18n";
 
 type ChatMessageListContainerProps = {
-  uiMessages: UiMessage[];
+  messages: readonly NcpMessage[];
   isSending: boolean;
   className?: string;
 };
 
+const messageViewModelCache = new WeakMap<
+  NcpMessage,
+  { language: string; viewModel: ChatMessageViewModel }
+>();
+
+function buildChatMessageAdapterTexts(
+  language: string,
+): ChatMessageAdapterTexts {
+  void language;
+  return {
+    roleLabels: {
+      user: t("chatRoleUser"),
+      assistant: t("chatRoleAssistant"),
+      tool: t("chatRoleTool"),
+      system: t("chatRoleSystem"),
+      fallback: t("chatRoleMessage"),
+    },
+    reasoningLabel: t("chatReasoning"),
+    toolCallLabel: t("chatToolCall"),
+    toolResultLabel: t("chatToolResult"),
+    toolNoOutputLabel: t("chatToolNoOutput"),
+    toolOutputLabel: t("chatToolOutput"),
+    toolStatusPreparingLabel: t("chatToolStatusPreparing"),
+    toolStatusRunningLabel: t("chatToolStatusRunning"),
+    toolStatusCompletedLabel: t("chatToolStatusCompleted"),
+    toolStatusFailedLabel: t("chatToolStatusFailed"),
+    toolStatusCancelledLabel: t("chatToolStatusCancelled"),
+    imageAttachmentLabel: t("chatImageAttachment"),
+    fileAttachmentLabel: t("chatFileAttachment"),
+    unknownPartLabel: t("chatUnknownPart"),
+  };
+}
+
+function buildChatMessageTexts(language: string) {
+  void language;
+  return {
+    copyCodeLabel: t("chatCodeCopy"),
+    copiedCodeLabel: t("chatCodeCopied"),
+    typingLabel: t("chatTyping"),
+  };
+}
+
 export function ChatMessageListContainer(props: ChatMessageListContainerProps) {
   const { language } = useI18n();
-  const sourceMessages = useMemo<ChatMessageSource[]>(
-    () =>
-      props.uiMessages.map((message) => ({
-        id: message.id,
-        role: message.role,
+  const texts = useMemo<ChatMessageAdapterTexts>(
+    () => buildChatMessageAdapterTexts(language),
+    [language],
+  );
+
+  const messages = useMemo(() => {
+    return props.messages.map((message) => {
+      const cached = messageViewModelCache.get(message);
+      if (cached && cached.language === language) {
+        return cached.viewModel;
+      }
+
+      const uiMessage = adaptNcpMessageToUiMessage(message);
+      const sourceMessage: ChatMessageSource = {
+        id: uiMessage.id,
+        role: uiMessage.role,
         meta: {
-          timestamp: message.meta?.timestamp,
-          status: message.meta?.status,
+          timestamp: uiMessage.meta?.timestamp,
+          status: uiMessage.meta?.status,
         },
-        parts: message.parts as unknown as ChatMessageSource["parts"],
-      })),
-    [props.uiMessages],
-  );
+        parts: uiMessage.parts as unknown as ChatMessageSource["parts"],
+      };
+      const viewModel = adaptChatMessage(sourceMessage, {
+        formatTimestamp: (value) => formatDateTime(value, language),
+        texts,
+      });
+
+      messageViewModelCache.set(message, { language, viewModel });
+      return viewModel;
+    });
+  }, [language, props.messages, texts]);
 
-  const messages = useMemo(
+  const hasAssistantDraft = useMemo(
     () =>
-      adaptChatMessages({
-        uiMessages: sourceMessages,
-        formatTimestamp: (value) => formatDateTime(value, language),
-        texts: {
-          roleLabels: {
-            user: t("chatRoleUser"),
-            assistant: t("chatRoleAssistant"),
-            tool: t("chatRoleTool"),
-            system: t("chatRoleSystem"),
-            fallback: t("chatRoleMessage"),
-          },
-          reasoningLabel: t("chatReasoning"),
-          toolCallLabel: t("chatToolCall"),
-          toolResultLabel: t("chatToolResult"),
-          toolNoOutputLabel: t("chatToolNoOutput"),
-          toolOutputLabel: t("chatToolOutput"),
-          toolStatusPreparingLabel: t("chatToolStatusPreparing"),
-          toolStatusRunningLabel: t("chatToolStatusRunning"),
-          toolStatusCompletedLabel: t("chatToolStatusCompleted"),
-          toolStatusFailedLabel: t("chatToolStatusFailed"),
-          toolStatusCancelledLabel: t("chatToolStatusCancelled"),
-          imageAttachmentLabel: t("chatImageAttachment"),
-          fileAttachmentLabel: t("chatFileAttachment"),
-          unknownPartLabel: t("chatUnknownPart"),
-        },
-      }),
-    [language, sourceMessages],
+      messages.some(
+        (message) =>
+          message.role === "assistant" &&
+          (message.status === "streaming" || message.status === "pending"),
+      ),
+    [messages],
+  );
+  const messageTexts = useMemo(
+    () => buildChatMessageTexts(language),
+    [language],
   );
 
   return (
     <ChatMessageList
       messages={messages}
       isSending={props.isSending}
-      hasAssistantDraft={props.uiMessages.some(
-        (message) =>
-          message.role === "assistant" &&
-          (message.meta?.status === "streaming" ||
-            message.meta?.status === "pending"),
-      )}
+      hasAssistantDraft={hasAssistantDraft}
       className={props.className}
-      texts={{
-        copyCodeLabel: t("chatCodeCopy"),
-        copiedCodeLabel: t("chatCodeCopied"),
-        typingLabel: t("chatTyping"),
-      }}
+      texts={messageTexts}
     />
   );
 }

package/src/components/chat/managers/chat-session-list.manager.ts

@@ -1,7 +1,6 @@
 import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
 import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
-import type { ChatSessionListSnapshot } from '@/components/chat/stores/chat-session-list.store';
 import type { SetStateAction } from 'react';
 import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
 
@@ -11,16 +10,6 @@ export class ChatSessionListManager {
     private streamActionsManager: ChatStreamActionsManager
   ) {}
 
-  private hasSnapshotChanges = (patch: Partial<ChatSessionListSnapshot>): boolean => {
-    const current = useChatSessionListStore.getState().snapshot;
-    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatSessionListSnapshot, ChatSessionListSnapshot[keyof ChatSessionListSnapshot]]>) {
-      if (!Object.is(current[key], value)) {
-        return true;
-      }
-    }
-    return false;
-  };
-
   private resolveUpdateValue = <T>(prev: T, next: SetStateAction<T>): T => {
     if (typeof next === 'function') {
       return (next as (value: T) => T)(prev);
@@ -28,13 +17,6 @@ export class ChatSessionListManager {
     return next;
   };
 
-  syncSnapshot = (patch: Partial<ChatSessionListSnapshot>) => {
-    if (!this.hasSnapshotChanges(patch)) {
-      return;
-    }
-    useChatSessionListStore.getState().setSnapshot(patch);
-  };
-
   setSelectedAgentId = (next: SetStateAction<string>) => {
     const prev = useChatSessionListStore.getState().snapshot.selectedAgentId;
     const value = this.resolveUpdateValue(prev, next);

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

@@ -14,7 +14,7 @@ import { createNcpAppClientFetch } from '@/components/chat/ncp/ncp-app-client-fe
 import { parseSessionKeyFromRoute, resolveAgentIdFromSessionKey } from '@/components/chat/chat-session-route';
 import { useNcpChatPageData } from '@/components/chat/ncp/ncp-chat-page-data';
 import { NcpChatPresenter } from '@/components/chat/ncp/ncp-chat.presenter';
-import { adaptNcpMessagesToUiMessages, buildNcpSessionRunStatusByKey, createNcpSessionId } from '@/components/chat/ncp/ncp-session-adapter';
+import { createNcpSessionId } from '@/components/chat/ncp/ncp-session-adapter';
 import { ChatPresenterProvider } from '@/components/chat/presenter/chat-presenter-context';
 import type { ResumeRunParams } from '@/components/chat/chat-stream/types';
 import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
@@ -74,12 +74,10 @@ export function NcpChatPage({ view }: ChatPageProps) {
     [routeSessionIdParam]
   );
   const {
-    sessionsQuery,
     installedSkillsQuery,
     isProviderStateResolved,
     modelOptions,
     sessionSummaries,
-    sessions,
     skillRecords,
     selectedSession,
     sessionTypeOptions,
@@ -97,7 +95,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
     setSelectedModel: presenter.chatInputManager.setSelectedModel,
     setSelectedThinkingLevel: presenter.chatInputManager.setSelectedThinkingLevel
   });
-  const refetchSessions = sessionsQuery.refetch;
 
   const activeSessionId = selectedSessionKey ?? draftSessionId;
   const sessionSummariesRef = useRef(sessionSummaries);
@@ -151,32 +148,11 @@ export function NcpChatPage({ view }: ChatPageProps) {
     }
   }, [presenter, selectedSessionKey]);
 
-  const uiMessages = useMemo(
-    () => adaptNcpMessagesToUiMessages(agent.visibleMessages),
-    [agent.visibleMessages]
-  );
   const isSending = agent.isSending || agent.isRunning;
   const isAwaitingAssistantOutput = agent.isRunning;
   const canStopCurrentRun = agent.isRunning;
   const stopDisabledReason = agent.isRunning ? null : '__preparing__';
   const lastSendError = agent.hydrateError?.message ?? agent.snapshot.error?.message ?? null;
-  const activeBackendRunId = agent.activeRunId;
-  const sessionRunStatusByKey = useMemo(
-    () =>
-      buildNcpSessionRunStatusByKey({
-        summaries: sessionSummaries,
-        activeSessionId,
-        isLocallyRunning: isSending || Boolean(activeBackendRunId)
-      }),
-    [activeBackendRunId, activeSessionId, isSending, sessionSummaries]
-  );
-
-  useEffect(() => {
-    if (!isSending && !activeBackendRunId) {
-      return;
-    }
-    void refetchSessions();
-  }, [activeBackendRunId, isSending, refetchSessions]);
 
   useEffect(() => {
     presenter.chatStreamActionsManager.bind({
@@ -201,9 +177,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
           return;
         }
         try {
-          void sessionsQuery.refetch();
           await agent.send(envelope);
-          await sessionsQuery.refetch();
         } catch (error) {
           if (payload.restoreDraftOnError) {
             if (payload.composerNodes && payload.composerNodes.length > 0) {
@@ -222,7 +196,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
       },
       stopCurrentRun: async () => {
         await agent.abort();
-        await sessionsQuery.refetch();
       },
       resumeRun: async (run: ResumeRunParams) => {
         if (run.sessionKey !== activeSessionId) {
@@ -235,7 +208,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
       },
       applyHistoryMessages: () => {}
     });
-  }, [activeSessionId, agent, presenter, sessionsQuery]);
+  }, [activeSessionId, agent, presenter]);
 
   useChatSessionSync({
     view,
@@ -264,12 +237,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
     sessionTypeOptions.find((option) => option.value === selectedSessionType)?.label ??
     resolveSessionTypeLabel(selectedSessionType);
 
-  useEffect(() => {
-    presenter.chatThreadManager.bindActions({
-      refetchSessions: sessionsQuery.refetch
-    });
-  }, [presenter, sessionsQuery.refetch]);
-
   useEffect(() => {
     presenter.chatInputManager.syncSnapshot({
       isProviderStateResolved,
@@ -288,16 +255,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
       skillRecords,
       isSkillsLoading: installedSkillsQuery.isLoading
     });
-    presenter.chatSessionListManager.syncSnapshot({
-      sessions,
-      query,
-      isLoading: sessionsQuery.isLoading
-    });
-    presenter.chatRunStatusManager.syncSnapshot({
-      sessionRunStatusByKey,
-      isLocallyRunning: isSending || Boolean(activeBackendRunId),
-      activeBackendRunId
-    });
     presenter.chatThreadManager.syncSnapshot({
       isProviderStateResolved,
       modelOptions,
@@ -309,12 +266,11 @@ export function NcpChatPage({ view }: ChatPageProps) {
       canDeleteSession: Boolean(selectedSession),
       threadRef,
       isHistoryLoading: agent.isHydrating,
-      uiMessages,
+      messages: agent.visibleMessages,
       isSending,
       isAwaitingAssistantOutput
     });
   }, [
-    activeBackendRunId,
     agent.isHydrating,
     canEditSessionType,
     canStopCurrentRun,
@@ -329,20 +285,16 @@ export function NcpChatPage({ view }: ChatPageProps) {
     modelOptions.length,
     modelOptions,
     presenter,
-    query,
     selectedSession,
     selectedSessionKey,
     selectedSessionType,
-    sessionRunStatusByKey,
     sessionTypeOptions,
     sessionTypeUnavailable,
     sessionTypeUnavailableMessage,
-    sessions,
-    sessionsQuery.isLoading,
     skillRecords,
     stopDisabledReason,
     threadRef,
-    uiMessages
+    agent.visibleMessages
   ]);
 
   return (

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

@@ -1,3 +1,5 @@
+import { appQueryClient } from '@/app-query-client';
+import { deleteNcpSessionSummaryInQueryClient } from '@/api/ncp-session-query-cache';
 import { deleteNcpSession as deleteNcpSessionApi } from '@/api/ncp-session';
 import type { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
 import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
@@ -7,30 +9,13 @@ import type { ChatThreadSnapshot } from '@/components/chat/stores/chat-thread.st
 import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
 import { t } from '@/lib/i18n';
 
-export type NcpChatThreadManagerActions = {
-  refetchSessions: () => Promise<unknown>;
-};
-
-const noopAsync = async () => {};
-
 export class NcpChatThreadManager {
-  private actions: NcpChatThreadManagerActions = {
-    refetchSessions: noopAsync
-  };
-
   constructor(
     private uiManager: ChatUiManager,
     private sessionListManager: ChatSessionListManager,
     private streamActionsManager: ChatStreamActionsManager
   ) {}
 
-  bindActions = (patch: Partial<NcpChatThreadManagerActions>) => {
-    this.actions = {
-      ...this.actions,
-      ...patch
-    };
-  };
-
   private hasSnapshotChanges = (patch: Partial<ChatThreadSnapshot>): boolean => {
     const current = useChatThreadStore.getState().snapshot;
     for (const [key, value] of Object.entries(patch) as Array<[keyof ChatThreadSnapshot, ChatThreadSnapshot[keyof ChatThreadSnapshot]]>) {
@@ -78,9 +63,10 @@ export class NcpChatThreadManager {
     useChatThreadStore.getState().setSnapshot({ isDeletePending: true });
     try {
       await deleteNcpSessionApi(selectedSessionKey);
+      deleteNcpSessionSummaryInQueryClient(appQueryClient, selectedSessionKey);
+      appQueryClient.removeQueries({ queryKey: ['ncp-session-messages', selectedSessionKey] });
       this.streamActionsManager.resetStreamState();
       this.uiManager.goToChatRoot({ replace: true });
-      await this.actions.refetchSessions();
     } finally {
       useChatThreadStore.getState().setSnapshot({ isDeletePending: false });
     }

package/src/components/chat/ncp/ncp-chat.presenter.ts

@@ -1,4 +1,3 @@
-import { ChatRunStatusManager } from '@/components/chat/managers/chat-run-status.manager';
 import { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
 import { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
 import { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
@@ -14,7 +13,6 @@ export class NcpChatPresenter {
     this.chatStreamActionsManager,
     () => this.getDraftSessionId()
   );
-  chatRunStatusManager = new ChatRunStatusManager();
   chatThreadManager = new NcpChatThreadManager(
     this.chatUiManager,
     this.chatSessionListManager,

package/src/components/chat/ncp/ncp-session-adapter.test.ts

@@ -1,7 +1,6 @@
 import {
   adaptNcpMessageToUiMessage,
   adaptNcpSessionSummary,
-  buildNcpSessionRunStatusByKey,
   readNcpSessionPreferredThinking
 } from '@/components/chat/ncp/ncp-session-adapter';
 import type { NcpSessionSummaryView } from '@/api/types';
@@ -95,25 +94,3 @@ describe('readNcpSessionPreferredThinking', () => {
     expect(thinking).toBe('high');
   });
 });
-
-describe('buildNcpSessionRunStatusByKey', () => {
-  it('marks the active local session as running before the server summary catches up', () => {
-    const statuses = buildNcpSessionRunStatusByKey({
-      summaries: [createSummary({ sessionId: 'ncp-session-1', status: 'idle' })],
-      activeSessionId: 'ncp-session-1',
-      isLocallyRunning: true
-    });
-
-    expect(statuses.get('ncp-session-1')).toBe('running');
-  });
-
-  it('keeps persisted running sessions marked as running', () => {
-    const statuses = buildNcpSessionRunStatusByKey({
-      summaries: [createSummary({ sessionId: 'ncp-session-2', status: 'running' })],
-      activeSessionId: null,
-      isLocallyRunning: false
-    });
-
-    expect(statuses.get('ncp-session-2')).toBe('running');
-  });
-});

package/src/components/chat/ncp/ncp-session-adapter.ts

@@ -1,7 +1,6 @@
 import { ToolInvocationStatus, type UIMessage } from '@nextclaw/agent-chat';
 import type { NcpMessagePart } from '@nextclaw/ncp';
 import type { NcpMessageView, NcpSessionSummaryView, SessionEntryView, ThinkingLevel } from '@/api/types';
-import type { SessionRunStatus } from '@/lib/session-run-status';
 
 const THINKING_LEVEL_SET = new Set<string>(['off', 'minimal', 'low', 'medium', 'high', 'adaptive', 'xhigh']);
 
@@ -206,24 +205,6 @@ export function adaptNcpSessionSummaries(summaries: NcpSessionSummaryView[]): Se
   return summaries.map(adaptNcpSessionSummary);
 }
 
-export function buildNcpSessionRunStatusByKey(params: {
-  summaries: readonly NcpSessionSummaryView[];
-  activeSessionId?: string | null;
-  isLocallyRunning?: boolean;
-}): Map<string, SessionRunStatus> {
-  const map = new Map<string, SessionRunStatus>();
-  for (const summary of params.summaries) {
-    if (summary.status === 'running') {
-      map.set(summary.sessionId, 'running');
-    }
-  }
-  const activeSessionId = readOptionalString(params.activeSessionId);
-  if (params.isLocallyRunning && activeSessionId) {
-    map.set(activeSessionId, 'running');
-  }
-  return map;
-}
-
 export function createNcpSessionId(): string {
   return `ncp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }

package/src/components/chat/ncp/use-ncp-session-list-view.ts

@@ -0,0 +1,42 @@
+import { useMemo } from 'react';
+import type { SessionEntryView } from '@/api/types';
+import { adaptNcpSessionSummaries } from '@/components/chat/ncp/ncp-session-adapter';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import { useNcpSessions } from '@/hooks/useConfig';
+import type { SessionRunStatus } from '@/lib/session-run-status';
+
+export type NcpSessionListItemView = {
+  session: SessionEntryView;
+  runStatus?: SessionRunStatus;
+};
+
+function filterSessionsByQuery(sessions: readonly SessionEntryView[], query: string): SessionEntryView[] {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) {
+    return [...sessions];
+  }
+
+  return sessions.filter((session) => session.key.toLowerCase().includes(normalizedQuery));
+}
+
+export function useNcpSessionListView(params: { limit?: number } = {}) {
+  const query = useChatSessionListStore((state) => state.snapshot.query);
+  const sessionsQuery = useNcpSessions({ limit: params.limit ?? 200 });
+
+  const items = useMemo<NcpSessionListItemView[]>(() => {
+    const summaries = sessionsQuery.data?.sessions ?? [];
+    const sessions = adaptNcpSessionSummaries(summaries);
+    const filteredSessions = filterSessionsByQuery(sessions, query);
+    const summaryBySessionId = new Map(summaries.map((summary) => [summary.sessionId, summary]));
+
+    return filteredSessions.map((session) => ({
+      session,
+      runStatus: summaryBySessionId.get(session.key)?.status === 'running' ? 'running' : undefined
+    }));
+  }, [query, sessionsQuery.data?.sessions]);
+
+  return {
+    isLoading: sessionsQuery.isLoading,
+    items
+  };
+}

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

@@ -3,7 +3,6 @@ import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
 import { createContext, useContext } from 'react';
 import type { ReactNode } from 'react';
 import type { SetStateAction } from 'react';
-import type { ChatRunStatusManager } from '@/components/chat/managers/chat-run-status.manager';
 import type { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
 import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
 import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
@@ -33,7 +32,6 @@ export type ChatInputManagerLike = {
 };
 
 export type ChatThreadManagerLike = {
-  bindActions: (patch: { refetchSessions?: () => Promise<unknown> }) => void;
   syncSnapshot: (patch: Partial<ChatThreadSnapshot>) => void;
   deleteSession: () => void;
   createSession: () => void;
@@ -45,7 +43,6 @@ export type ChatPresenterLike = {
   chatStreamActionsManager: ChatStreamActionsManager;
   chatInputManager: ChatInputManagerLike;
   chatSessionListManager: ChatSessionListManager;
-  chatRunStatusManager: ChatRunStatusManager;
   chatThreadManager: ChatThreadManagerLike;
 };
 

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

@@ -1,12 +1,8 @@
 import { create } from 'zustand';
-import type { SessionEntryView } from '@/api/types';
-
 export type ChatSessionListSnapshot = {
-  sessions: SessionEntryView[];
   selectedSessionKey: string | null;
   selectedAgentId: string;
   query: string;
-  isLoading: boolean;
 };
 
 type ChatSessionListStore = {
@@ -15,11 +11,9 @@ type ChatSessionListStore = {
 };
 
 const initialSnapshot: ChatSessionListSnapshot = {
-  sessions: [],
   selectedSessionKey: null,
   selectedAgentId: 'main',
-  query: '',
-  isLoading: false
+  query: ''
 };
 
 export const useChatSessionListStore = create<ChatSessionListStore>((set) => ({

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

@@ -1,6 +1,6 @@
 import { create } from 'zustand';
 import type { MutableRefObject } from 'react';
-import type { UiMessage } from '@nextclaw/agent-chat';
+import type { NcpMessage } from '@nextclaw/ncp';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 
 export type ChatThreadSnapshot = {
@@ -15,7 +15,7 @@ export type ChatThreadSnapshot = {
   isDeletePending: boolean;
   threadRef: MutableRefObject<HTMLDivElement | null> | null;
   isHistoryLoading: boolean;
-  uiMessages: UiMessage[];
+  messages: readonly NcpMessage[];
   isSending: boolean;
   isAwaitingAssistantOutput: boolean;
 };
@@ -37,7 +37,7 @@ const initialSnapshot: ChatThreadSnapshot = {
   isDeletePending: false,
   threadRef: null,
   isHistoryLoading: false,
-  uiMessages: [],
+  messages: [],
   isSending: false,
   isAwaitingAssistantOutput: false
 };