@nextclaw/ui 0.10.5 → 0.11.1

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

@@ -1,87 +0,0 @@
-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 {
-      snapshot: { selectedSessionKey }
-    } = useChatSessionListStore.getState();
-    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();
-      this.uiManager.goToChatRoot({ replace: true });
-      await this.actions.refetchSessions();
-    } finally {
-      useChatThreadStore.getState().setSnapshot({ isDeletePending: false });
-    }
-  };
-}

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

@@ -1,32 +0,0 @@
-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/useChatRuntimeController.ts

@@ -1,134 +0,0 @@
-import { useCallback, useEffect, useRef } from 'react';
-import { type AgentChatController, getStopDisabledReason } from '@nextclaw/agent-chat';
-import type { ChatRunView, SessionMessageView } from '@/api/types';
-import type { SendMessageParams, UseChatStreamControllerParams } from '@/components/chat/chat-stream/types';
-import { buildResumeMetadata, buildSendMetadata } from '@/components/chat/chat-stream/nextbot-parsers';
-import { buildUiMessagesFromHistoryMessages, normalizeRequestedSkills } from '@/lib/chat-runtime-utils';
-import { useValueFromBehaviorSubject, useValueFromObservable } from '@/hooks/useObservable';
-
-export function useChatRuntimeController(
-  params: UseChatStreamControllerParams,
-  controller: AgentChatController
-) {
-  const paramsRef = useRef(params);
-  useEffect(() => {
-    paramsRef.current = params;
-  });
-
-  const activeHistorySessionKeyRef = useRef<string | null>(null);
-
-  // Bind callbacks to controller
-  useEffect(() => {
-    controller.setCallbacks({
-      onRunSettled: async ({ sourceSessionId, resultSessionId }) => {
-        const bindings = paramsRef.current;
-        await bindings.refetchSessions();
-        const activeSessionKey = bindings.selectedSessionKeyRef.current;
-        if (!activeSessionKey || activeSessionKey === sourceSessionId || (resultSessionId && activeSessionKey === resultSessionId)) {
-          await bindings.refetchHistory();
-        }
-      },
-      onRunError: ({ sourceMessage, restoreDraft }) => {
-        if (restoreDraft) {
-          paramsRef.current.setDraft((prev) => (prev.trim().length === 0 && sourceMessage ? sourceMessage : prev));
-        }
-      },
-      onSessionChanged: (sessionId) => {
-        paramsRef.current.setSelectedSessionKey((prev) => (prev === sessionId ? prev : sessionId));
-      }
-    });
-  }, [controller]);
-
-  // Reactive state from controller observables
-  const uiMessages = useValueFromObservable(controller.messages$, controller.getMessages());
-  const isSending = useValueFromBehaviorSubject(controller.isAgentResponding$);
-  const isAwaitingAssistantOutput = useValueFromBehaviorSubject(controller.isAwaitingResponse$);
-  const activeRun = useValueFromBehaviorSubject(controller.activeRun$);
-  const lastSendError = useValueFromBehaviorSubject(controller.lastError$);
-
-  // Derived state
-  const activeBackendRunId = activeRun?.remoteRunId ?? null;
-  const stopDisabledReason = getStopDisabledReason(activeRun);
-  const canStopCurrentRun = Boolean(
-    activeRun && (stopDisabledReason === null || (activeRun.remoteStopCapable && !activeBackendRunId))
-  );
-
-  const sendMessage = useCallback(async (payload: SendMessageParams) => {
-    const requestedSkills = normalizeRequestedSkills(payload.requestedSkills);
-    const metadata = buildSendMetadata(payload, requestedSkills);
-    await controller.send({
-      message: payload.message,
-      sessionId: payload.sessionKey,
-      agentId: payload.agentId,
-      metadata,
-      restoreDraftOnError: payload.restoreDraftOnError,
-      stopCapable: payload.stopSupported,
-      stopReason: payload.stopReason
-    });
-  }, [controller]);
-
-  const resumeRun = useCallback(async (run: ChatRunView) => {
-    const backendRunId = run.runId?.trim();
-    const sessionKey = run.sessionKey?.trim();
-    if (!backendRunId || !sessionKey) {
-      return;
-    }
-    const metadata = buildResumeMetadata(run);
-    await controller.resume({
-      remoteRunId: backendRunId,
-      sessionId: sessionKey,
-      agentId: run.agentId,
-      metadata,
-      stopCapable: run.stopSupported,
-      stopReason: run.stopReason
-    });
-  }, [controller]);
-
-  const stopCurrentRun = useCallback(async () => {
-    await controller.stop();
-  }, [controller]);
-
-  const resetStreamState = useCallback(() => {
-    activeHistorySessionKeyRef.current = null;
-    controller.reset();
-  }, [controller]);
-
-  const applyHistoryMessages = useCallback((messages: SessionMessageView[], options?: { isLoading?: boolean }) => {
-    const isRunActive = Boolean(controller.activeRun$.getValue() || controller.isAgentResponding$.getValue());
-    if (isRunActive) {
-      return;
-    }
-    const selectedSessionKey = paramsRef.current.selectedSessionKeyRef.current;
-    if (selectedSessionKey !== activeHistorySessionKeyRef.current) {
-      activeHistorySessionKeyRef.current = selectedSessionKey;
-      if (controller.getMessages().length > 0) {
-        controller.setMessages([]);
-      }
-    }
-    if (!selectedSessionKey) {
-      if (controller.getMessages().length > 0) {
-        controller.setMessages([]);
-      }
-      return;
-    }
-    if (options?.isLoading && messages.length === 0) {
-      return;
-    }
-    controller.setMessages(buildUiMessagesFromHistoryMessages(messages));
-  }, [controller]);
-
-  return {
-    uiMessages,
-    isSending,
-    isAwaitingAssistantOutput,
-    canStopCurrentRun,
-    stopDisabledReason,
-    lastSendError,
-    activeBackendRunId,
-    sendMessage,
-    stopCurrentRun,
-    resumeRun,
-    resetStreamState,
-    applyHistoryMessages
-  };
-}