@nextclaw/ui 0.6.9 → 0.6.11

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

@@ -0,0 +1,76 @@
+import type { Dispatch, MutableRefObject, SetStateAction } from 'react';
+import type {
+  ChatRunView,
+  ChatTurnStreamDeltaEvent,
+  ChatTurnStreamReadyEvent,
+  ChatTurnStreamSessionEvent,
+  SessionMessageView
+} from '@/api/types';
+
+export type SendMessageParams = {
+  runId?: string;
+  message: string;
+  sessionKey: string;
+  agentId: string;
+  sessionType?: string;
+  model?: string;
+  requestedSkills?: string[];
+  stopSupported?: boolean;
+  stopReason?: string;
+  restoreDraftOnError?: boolean;
+};
+
+export type ActiveRunState = {
+  localRunId: number;
+  sessionKey: string;
+  agentId?: string;
+  backendRunId?: string;
+  backendStopSupported: boolean;
+  backendStopReason?: string;
+};
+
+export type StreamReadyPayload = {
+  sessionKey: string;
+  runId?: string;
+  stopSupported?: boolean;
+  stopReason?: string;
+  requestedAt?: string;
+};
+
+export type StreamReadyEvent = ChatTurnStreamReadyEvent;
+export type StreamDeltaEvent = ChatTurnStreamDeltaEvent;
+export type StreamSessionEvent = ChatTurnStreamSessionEvent;
+
+export type NextbotAgentRunMetadata =
+  | {
+      driver: 'nextbot-stream';
+      mode: 'send';
+      payload: SendMessageParams;
+      requestedSkills: string[];
+    }
+  | {
+      driver: 'nextbot-stream';
+      mode: 'resume';
+      runId: string;
+      fromEventIndex?: number;
+      sessionKey?: string;
+      agentId?: string;
+      stopSupported?: boolean;
+      stopReason?: string;
+    };
+
+export type UseChatStreamControllerParams = {
+  selectedSessionKeyRef: MutableRefObject<string | null>;
+  setSelectedSessionKey: Dispatch<SetStateAction<string | null>>;
+  setDraft: Dispatch<SetStateAction<string>>;
+  refetchSessions: () => Promise<unknown>;
+  refetchHistory: () => Promise<unknown>;
+};
+
+export type ChatStreamActions = {
+  sendMessage: (payload: SendMessageParams) => Promise<void>;
+  stopCurrentRun: () => Promise<void>;
+  resumeRun: (run: ChatRunView) => Promise<void>;
+  resetStreamState: () => void;
+  applyHistoryMessages: (messages: SessionMessageView[], options?: { isLoading?: boolean }) => void;
+};

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

@@ -0,0 +1,142 @@
+import { updateSession } from '@/api/config';
+import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
+import { buildNewSessionKey } from '@/components/chat/chat-session-route';
+import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import { normalizeSessionType } from '@/components/chat/useChatSessionTypeState';
+import type { ChatInputSnapshot } from '@/components/chat/stores/chat-input.store';
+import type { SetStateAction } from 'react';
+import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
+
+export class ChatInputManager {
+  constructor(
+    private uiManager: ChatUiManager,
+    private streamActionsManager: ChatStreamActionsManager
+  ) {}
+
+  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
+    const current = useChatInputStore.getState().snapshot;
+    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
+      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);
+    }
+    return next;
+  };
+
+  syncSnapshot = (patch: Partial<ChatInputSnapshot>) => {
+    if (!this.hasSnapshotChanges(patch)) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot(patch);
+  };
+
+  setDraft = (next: SetStateAction<string>) => {
+    const prev = useChatInputStore.getState().snapshot.draft;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ draft: value });
+  };
+
+  setPendingSessionType = (next: SetStateAction<string>) => {
+    const prev = useChatInputStore.getState().snapshot.pendingSessionType;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ pendingSessionType: value });
+  };
+
+  send = async () => {
+    const inputSnapshot = useChatInputStore.getState().snapshot;
+    const sessionSnapshot = useChatSessionListStore.getState().snapshot;
+    const message = inputSnapshot.draft.trim();
+    if (!message) {
+      return;
+    }
+    const requestedSkills = inputSnapshot.selectedSkills;
+    const hasSelectedSession = Boolean(sessionSnapshot.selectedSessionKey);
+    const sessionKey = sessionSnapshot.selectedSessionKey ?? buildNewSessionKey(sessionSnapshot.selectedAgentId);
+    if (!hasSelectedSession) {
+      this.uiManager.goToSession(sessionKey, { replace: true });
+    }
+    this.setDraft('');
+    this.setSelectedSkills([]);
+    await this.streamActionsManager.sendMessage({
+      message,
+      sessionKey,
+      agentId: sessionSnapshot.selectedAgentId,
+      sessionType: inputSnapshot.selectedSessionType,
+      model: inputSnapshot.selectedModel || undefined,
+      stopSupported: inputSnapshot.stopSupported,
+      stopReason: inputSnapshot.stopReason,
+      requestedSkills,
+      restoreDraftOnError: true
+    });
+  };
+
+  stop = async () => {
+    await this.streamActionsManager.stopCurrentRun();
+  };
+
+  goToProviders = () => {
+    this.uiManager.goToProviders();
+  };
+
+  setSelectedModel = (next: SetStateAction<string>) => {
+    const prev = useChatInputStore.getState().snapshot.selectedModel;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ selectedModel: value });
+  };
+
+  selectSessionType = (value: string) => {
+    const normalized = normalizeSessionType(value);
+    useChatInputStore.getState().setSnapshot({ selectedSessionType: normalized, pendingSessionType: normalized });
+    void this.syncRemoteSessionType(normalized);
+  };
+
+  setSelectedSkills = (next: SetStateAction<string[]>) => {
+    const prev = useChatInputStore.getState().snapshot.selectedSkills;
+    const value = this.resolveUpdateValue(prev, next);
+    if (Object.is(value, prev)) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({ selectedSkills: value });
+  };
+
+  selectModel = (value: string) => {
+    this.setSelectedModel(value);
+  };
+
+  selectSkills = (next: string[]) => {
+    this.setSelectedSkills(next);
+  };
+
+  private syncRemoteSessionType = async (normalizedType: string) => {
+    const sessionSnapshot = useChatSessionListStore.getState().snapshot;
+    const selectedSessionKey = sessionSnapshot.selectedSessionKey;
+    if (!selectedSessionKey) {
+      return;
+    }
+    const selectedSession = sessionSnapshot.sessions.find((session) => session.key === selectedSessionKey);
+    if (!selectedSession?.sessionTypeMutable) {
+      return;
+    }
+    if (normalizeSessionType(selectedSession.sessionType) === normalizedType) {
+      return;
+    }
+    await updateSession(selectedSessionKey, { sessionType: normalizedType });
+  };
+}

package/src/components/chat/managers/chat-run-status.manager.ts

@@ -0,0 +1,32 @@
+import { useChatRunStatusStore } from '@/components/chat/stores/chat-run-status.store';
+import type { ChatRunStatusSnapshot } from '@/components/chat/stores/chat-run-status.store';
+
+function isMapEqual<T>(left: ReadonlyMap<string, T>, right: ReadonlyMap<string, T>): boolean {
+  if (left === right) {
+    return true;
+  }
+  if (left.size !== right.size) {
+    return false;
+  }
+  for (const [key, value] of left.entries()) {
+    if (!Object.is(value, right.get(key))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export class ChatRunStatusManager {
+  syncSnapshot = (patch: Partial<ChatRunStatusSnapshot>) => {
+    const current = useChatRunStatusStore.getState().snapshot;
+    const nextMap = patch.sessionRunStatusByKey;
+    if (
+      (nextMap ? isMapEqual(current.sessionRunStatusByKey, nextMap) : true) &&
+      (patch.isLocallyRunning === undefined || Object.is(current.isLocallyRunning, patch.isLocallyRunning)) &&
+      (patch.activeBackendRunId === undefined || Object.is(current.activeBackendRunId, patch.activeBackendRunId))
+    ) {
+      return;
+    }
+    useChatRunStatusStore.getState().setSnapshot(patch);
+  };
+}

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

@@ -0,0 +1,77 @@
+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';
+
+export class ChatSessionListManager {
+  constructor(
+    private uiManager: ChatUiManager,
+    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);
+    }
+    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);
+    if (value === prev) {
+      return;
+    }
+    useChatSessionListStore.getState().setSnapshot({ selectedAgentId: value });
+  };
+
+  setSelectedSessionKey = (next: SetStateAction<string | null>) => {
+    const prev = useChatSessionListStore.getState().snapshot.selectedSessionKey;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatSessionListStore.getState().setSnapshot({ selectedSessionKey: value });
+  };
+
+  createSession = () => {
+    const defaultSessionType = useChatInputStore.getState().snapshot.defaultSessionType || 'native';
+    this.streamActionsManager.resetStreamState();
+    this.setSelectedSessionKey(null);
+    useChatInputStore.getState().setSnapshot({ pendingSessionType: defaultSessionType });
+    this.uiManager.goToChatRoot();
+  };
+
+  selectSession = (sessionKey: string) => {
+    this.setSelectedSessionKey(sessionKey);
+    this.uiManager.goToSession(sessionKey);
+  };
+
+  setQuery = (next: SetStateAction<string>) => {
+    const prev = useChatSessionListStore.getState().snapshot.query;
+    const value = this.resolveUpdateValue(prev, next);
+    if (value === prev) {
+      return;
+    }
+    useChatSessionListStore.getState().setSnapshot({ query: value });
+  };
+}

package/src/components/chat/managers/chat-stream-actions.manager.ts

@@ -0,0 +1,34 @@
+import type { ChatStreamActions } from '@/components/chat/chat-stream/types';
+
+const noopAsync = async () => {};
+const noop = () => {};
+
+export class ChatStreamActionsManager {
+  private actions: ChatStreamActions = {
+    sendMessage: noopAsync,
+    stopCurrentRun: noopAsync,
+    resumeRun: noopAsync,
+    resetStreamState: noop,
+    applyHistoryMessages: noop
+  };
+
+  bind = (patch: Partial<ChatStreamActions>) => {
+    this.actions = {
+      ...this.actions,
+      ...patch
+    };
+  };
+
+  sendMessage = (payload: Parameters<ChatStreamActions['sendMessage']>[0]) => this.actions.sendMessage(payload);
+
+  stopCurrentRun = () => this.actions.stopCurrentRun();
+
+  resumeRun = (run: Parameters<ChatStreamActions['resumeRun']>[0]) => this.actions.resumeRun(run);
+
+  resetStreamState = () => this.actions.resetStreamState();
+
+  applyHistoryMessages = (
+    messages: Parameters<ChatStreamActions['applyHistoryMessages']>[0],
+    options?: Parameters<ChatStreamActions['applyHistoryMessages']>[1]
+  ) => this.actions.applyHistoryMessages(messages, options);
+}

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

@@ -0,0 +1,86 @@
+import { deleteSession as deleteSessionApi } from '@/api/config';
+import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
+import { useChatThreadStore } from '@/components/chat/stores/chat-thread.store';
+import type { ChatSessionListManager } from '@/components/chat/managers/chat-session-list.manager';
+import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import type { ChatThreadSnapshot } from '@/components/chat/stores/chat-thread.store';
+import { t } from '@/lib/i18n';
+import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
+
+export type ChatThreadManagerActions = {
+  refetchSessions: () => Promise<unknown>;
+};
+
+const noopAsync = async () => {};
+export class ChatThreadManager {
+  private actions: ChatThreadManagerActions = {
+    refetchSessions: noopAsync
+  };
+
+  constructor(
+    private uiManager: ChatUiManager,
+    private sessionListManager: ChatSessionListManager,
+    private streamActionsManager: ChatStreamActionsManager
+  ) {}
+
+  bindActions = (patch: Partial<ChatThreadManagerActions>) => {
+    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]]>) {
+      if (!Object.is(current[key], value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  syncSnapshot = (patch: Partial<ChatThreadSnapshot>) => {
+    if (!this.hasSnapshotChanges(patch)) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot(patch);
+  };
+
+  deleteSession = () => {
+    void this.deleteCurrentSession();
+  };
+
+  createSession = () => {
+    this.sessionListManager.createSession();
+  };
+
+  goToProviders = () => {
+    this.uiManager.goToProviders();
+  };
+
+  private deleteCurrentSession = async () => {
+    const selectedSessionKey = useChatSessionListStore.getState().snapshot.selectedSessionKey;
+    if (!selectedSessionKey) {
+      return;
+    }
+    const confirmed = await this.uiManager.confirm({
+      title: t('chatDeleteSessionConfirm'),
+      variant: 'destructive',
+      confirmLabel: t('delete')
+    });
+    if (!confirmed) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot({ isDeletePending: true });
+    try {
+      await deleteSessionApi(selectedSessionKey);
+      this.streamActionsManager.resetStreamState();
+      useChatSessionListStore.getState().setSnapshot({ selectedSessionKey: null });
+      this.uiManager.goToChatRoot({ replace: true });
+      await this.actions.refetchSessions();
+    } finally {
+      useChatThreadStore.getState().setSnapshot({ isDeletePending: false });
+    }
+  };
+}

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

@@ -0,0 +1,65 @@
+import { buildSessionPath } from '@/components/chat/chat-session-route';
+import type { NavigateFunction, NavigateOptions } from 'react-router-dom';
+
+type ChatUiState = {
+  pathname: string;
+};
+
+type ChatUiActions = {
+  navigate: NavigateFunction | null;
+  confirm: (params: { title: string; variant: 'destructive'; confirmLabel: string }) => Promise<boolean>;
+};
+
+const noopConfirm = async (_params: { title: string; variant: 'destructive'; confirmLabel: string }) => false;
+
+export class ChatUiManager {
+  private state: ChatUiState = {
+    pathname: ''
+  };
+
+  private actions: ChatUiActions = {
+    navigate: null,
+    confirm: noopConfirm
+  };
+
+  syncState = (patch: Partial<ChatUiState>) => {
+    this.state = {
+      ...this.state,
+      ...patch
+    };
+  };
+
+  bindActions = (patch: Partial<ChatUiActions>) => {
+    this.actions = {
+      ...this.actions,
+      ...patch
+    };
+  };
+
+  confirm = async (params: { title: string; variant: 'destructive'; confirmLabel: string }) => {
+    return this.actions.confirm(params);
+  };
+
+  navigateTo = (to: string, options?: NavigateOptions) => {
+    if (!this.actions.navigate) {
+      return;
+    }
+    if (this.state.pathname === to && !options?.replace) {
+      return;
+    }
+    this.actions.navigate(to, options);
+    this.state.pathname = to;
+  };
+
+  goToProviders = () => {
+    this.navigateTo('/providers');
+  };
+
+  goToChatRoot = (options?: NavigateOptions) => {
+    this.navigateTo('/chat', options);
+  };
+
+  goToSession = (sessionKey: string, options?: NavigateOptions) => {
+    this.navigateTo(buildSessionPath(sessionKey), options);
+  };
+}

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

@@ -0,0 +1,25 @@
+import { createContext, useContext } from 'react';
+import type { ReactNode } from 'react';
+import type { ChatPresenter } from '@/components/chat/presenter/chat.presenter';
+
+const ChatPresenterContext = createContext<ChatPresenter | null>(null);
+
+type ChatPresenterProviderProps = {
+  presenter: ChatPresenter;
+  children: ReactNode;
+};
+
+export function ChatPresenterProvider({ presenter, children }: ChatPresenterProviderProps) {
+  return <ChatPresenterContext.Provider value={presenter}>{children}</ChatPresenterContext.Provider>;
+}
+
+export function usePresenter(): ChatPresenter {
+  const presenter = useContext(ChatPresenterContext);
+  if (!presenter) {
+    throw new Error('usePresenter must be used inside ChatPresenterProvider');
+  }
+  return presenter;
+}
+
+// Backward-compatible alias with the name from project notes.
+export const usePresneter = usePresenter;

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

@@ -0,0 +1,32 @@
+import { ChatInputManager } from '@/components/chat/managers/chat-input.manager';
+import { nextbotParsers } from '@/components/chat/chat-stream/nextbot-parsers';
+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 { ChatThreadManager } from '@/components/chat/managers/chat-thread.manager';
+import { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
+import { NextbotRuntimeAgent } from '@/components/chat/chat-stream/nextbot-runtime-agent';
+import { AgentChatController } from '@nextclaw/agent-chat';
+
+export class ChatPresenter {
+  chatUiManager = new ChatUiManager();
+  runtimeAgent = new NextbotRuntimeAgent();
+  chatController = new AgentChatController(
+    {
+      agent: this.runtimeAgent,
+      getToolDefs: () => [],
+      getContexts: () => [],
+      getToolExecutor: () => undefined
+    },
+    { metadataParsers: nextbotParsers }
+  );
+  chatStreamActionsManager = new ChatStreamActionsManager();
+  chatInputManager = new ChatInputManager(this.chatUiManager, this.chatStreamActionsManager);
+  chatSessionListManager = new ChatSessionListManager(this.chatUiManager, this.chatStreamActionsManager);
+  chatRunStatusManager = new ChatRunStatusManager();
+  chatThreadManager = new ChatThreadManager(
+    this.chatUiManager,
+    this.chatSessionListManager,
+    this.chatStreamActionsManager
+  );
+}

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

@@ -0,0 +1,62 @@
+import { create } from 'zustand';
+import type { MarketplaceInstalledRecord } from '@/api/types';
+
+export type ChatInputSnapshot = {
+  isProviderStateResolved: boolean;
+  draft: string;
+  pendingSessionType: string;
+  defaultSessionType: string;
+  canStopGeneration: boolean;
+  stopDisabledReason: string | null;
+  sendError: string | null;
+  isSending: boolean;
+  modelOptions: Array<{ value: string; modelLabel: string; providerLabel: string }>;
+  selectedModel: string;
+  sessionTypeOptions: Array<{ value: string; label: string }>;
+  selectedSessionType?: string;
+  stopSupported: boolean;
+  stopReason?: string;
+  canEditSessionType: boolean;
+  sessionTypeUnavailable: boolean;
+  skillRecords: MarketplaceInstalledRecord[];
+  isSkillsLoading: boolean;
+  selectedSkills: string[];
+};
+
+type ChatInputStore = {
+  snapshot: ChatInputSnapshot;
+  setSnapshot: (patch: Partial<ChatInputSnapshot>) => void;
+};
+
+const initialSnapshot: ChatInputSnapshot = {
+  isProviderStateResolved: false,
+  draft: '',
+  pendingSessionType: 'native',
+  defaultSessionType: 'native',
+  canStopGeneration: false,
+  stopDisabledReason: null,
+  sendError: null,
+  isSending: false,
+  modelOptions: [],
+  selectedModel: '',
+  sessionTypeOptions: [],
+  selectedSessionType: undefined,
+  stopSupported: false,
+  stopReason: undefined,
+  canEditSessionType: false,
+  sessionTypeUnavailable: false,
+  skillRecords: [],
+  isSkillsLoading: false,
+  selectedSkills: []
+};
+
+export const useChatInputStore = create<ChatInputStore>((set) => ({
+  snapshot: initialSnapshot,
+  setSnapshot: (patch) =>
+    set((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        ...patch
+      }
+    }))
+}));

package/src/components/chat/stores/chat-run-status.store.ts

@@ -0,0 +1,30 @@
+import { create } from 'zustand';
+import type { SessionRunStatus } from '@/lib/session-run-status';
+
+export type ChatRunStatusSnapshot = {
+  sessionRunStatusByKey: ReadonlyMap<string, SessionRunStatus>;
+  isLocallyRunning: boolean;
+  activeBackendRunId: string | null;
+};
+
+type ChatRunStatusStore = {
+  snapshot: ChatRunStatusSnapshot;
+  setSnapshot: (patch: Partial<ChatRunStatusSnapshot>) => void;
+};
+
+const initialSnapshot: ChatRunStatusSnapshot = {
+  sessionRunStatusByKey: new Map(),
+  isLocallyRunning: false,
+  activeBackendRunId: null
+};
+
+export const useChatRunStatusStore = create<ChatRunStatusStore>((set) => ({
+  snapshot: initialSnapshot,
+  setSnapshot: (patch) =>
+    set((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        ...patch
+      }
+    }))
+}));