@nextclaw/ui 0.13.12 → 0.14.0

package/src/features/chat/hooks/use-chat-session-label.ts

@@ -1,18 +0,0 @@
-import { t } from '@/shared/lib/i18n';
-import { useChatSessionUpdate } from '@/features/chat/hooks/use-chat-session-update';
-
-type UpdateChatSessionLabelParams = {
-  sessionKey: string;
-  label: string | null;
-};
-export function useChatSessionLabel() {
-  const updateSession = useChatSessionUpdate();
-
-  return async (params: UpdateChatSessionLabelParams): Promise<void> => {
-    await updateSession({
-      sessionKey: params.sessionKey,
-      patch: { label: params.label },
-      successMessage: t('configSavedApplied')
-    });
-  };
-}

package/src/features/chat/hooks/use-hydrated-ncp-agent.test.tsx

@@ -1,90 +0,0 @@
-import { renderHook, waitFor } from "@testing-library/react";
-import type { NcpAgentClientEndpoint } from "@nextclaw/ncp";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { useHydratedNcpAgent } from "../../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-hydrated-ncp-agent.ts";
-
-const mocks = vi.hoisted(() => ({
-  manager: {
-    reset: vi.fn(),
-    hydrate: vi.fn(),
-    getSnapshot: vi.fn(() => ({
-      messages: [],
-      streamingMessage: null,
-      activeRun: null,
-    })),
-  },
-  runtime: {
-    snapshot: {
-      messages: [],
-      streamingMessage: null,
-      activeRun: null,
-      error: null,
-    },
-    visibleMessages: [],
-    activeRunId: null,
-    isRunning: false,
-    isSending: false,
-    send: vi.fn(),
-    abort: vi.fn(),
-    streamRun: vi.fn(),
-  },
-}));
-
-vi.mock(
-  "../../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-ncp-agent-runtime.js",
-  () => ({
-    useScopedAgentManager: () => mocks.manager,
-    useNcpAgentRuntime: () => mocks.runtime,
-  }),
-);
-
-describe("useHydratedNcpAgent", () => {
-  beforeEach(() => {
-    mocks.manager.reset.mockReset();
-    mocks.manager.hydrate.mockReset();
-    mocks.manager.getSnapshot.mockClear();
-    mocks.runtime.send.mockReset();
-    mocks.runtime.abort.mockReset();
-    mocks.runtime.streamRun.mockReset();
-  });
-
-  it("treats a newly selected session as hydrating immediately on rerender", async () => {
-    const client = {
-      stop: vi.fn().mockResolvedValue(undefined),
-      stream: vi.fn().mockResolvedValue(undefined),
-    } satisfies Pick<NcpAgentClientEndpoint, "stop" | "stream">;
-    const loadSeed = vi
-      .fn()
-      .mockResolvedValueOnce({ messages: [], status: "idle" })
-      .mockResolvedValueOnce({ messages: [], status: "idle" });
-
-    const { result, rerender } = renderHook(
-      ({ sessionId }: { sessionId: string }) =>
-        useHydratedNcpAgent({
-          sessionId,
-          client: client as never,
-          loadSeed,
-        }),
-      {
-        initialProps: {
-          sessionId: "session-a",
-        },
-      },
-    );
-
-    await waitFor(() => {
-      expect(result.current.isHydrating).toBe(false);
-    });
-    expect(client.stream).toHaveBeenCalledWith({ sessionId: "session-a" });
-
-    rerender({ sessionId: "session-b" });
-
-    expect(result.current.isHydrating).toBe(true);
-
-    await waitFor(() => {
-      expect(result.current.isHydrating).toBe(false);
-    });
-    expect(client.stream).toHaveBeenCalledWith({ sessionId: "session-b" });
-    expect(client.stream).toHaveBeenCalledTimes(2);
-  });
-});

package/src/features/chat/hooks/use-ncp-chat-derived-state.ts

@@ -1,181 +0,0 @@
-import { useEffect, useMemo, type MutableRefObject } from 'react';
-import type {
-  AgentProfileView,
-  NcpSessionSummaryView,
-  SessionEntryView,
-  SessionSkillEntryView
-} from '@/shared/lib/api';
-import { sessionDisplayName } from '@/features/chat/utils/chat-session-display.utils';
-import { adaptNcpSessionSummary } from '@/features/chat/utils/ncp-session-adapter.utils';
-import type { NcpChatPresenter } from '@/features/chat/managers/ncp-chat-presenter.manager';
-import type { UseHydratedNcpAgentResult } from '@nextclaw/ncp-react';
-import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-import type { ChatChildSessionTab } from '@/features/chat/stores/chat-thread.store';
-import type { ChatSessionTypeOption } from '@/features/chat/hooks/use-chat-session-type-state';
-import { resolveSessionTypeLabel } from '@/features/chat/hooks/use-chat-session-type-state';
-import { readNcpContextWindowValue } from '@/features/chat/utils/ncp-session-context-metadata.utils';
-
-function buildChildSessionTabs(params: {
-  parentSessionKey: string | null;
-  sessionSummaries: NcpSessionSummaryView[];
-}): ChatChildSessionTab[] {
-  if (!params.parentSessionKey) {
-    return [];
-  }
-  return params.sessionSummaries
-    .map(adaptNcpSessionSummary)
-    .filter((session) => session.parentSessionId === params.parentSessionKey)
-    .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
-    .map((session) => ({
-      sessionKey: session.key,
-      parentSessionKey: session.parentSessionId ?? null,
-      label: session.label ?? null,
-      agentId: session.agentId ?? null,
-    }));
-}
-
-export function useNcpChatDerivedState(params: {
-  sessionKey: string | null;
-  selectedSession: SessionEntryView | null;
-  selectedAgentId: string;
-  availableAgents: AgentProfileView[];
-  parentSessionId: string | null;
-  sessionSummaries: NcpSessionSummaryView[];
-  selectedSessionType: string;
-  sessionTypeOptions: ChatSessionTypeOption[];
-}) {
-  const {
-    availableAgents,
-    parentSessionId,
-    selectedAgentId,
-    selectedSession,
-    selectedSessionType,
-    sessionKey,
-    sessionSummaries,
-    sessionTypeOptions,
-  } = params;
-  const currentSessionDisplayName = selectedSession
-    ? sessionDisplayName(selectedSession)
-    : undefined;
-  const currentAgentId = selectedSession?.agentId ?? selectedAgentId;
-  const currentAgent =
-    availableAgents.find((agent) => agent.id === currentAgentId) ?? null;
-  const parentSession = useMemo(() => {
-    if (!parentSessionId) {
-      return null;
-    }
-    const parentSummary =
-      sessionSummaries.find(
-        (summary) => summary.sessionId === parentSessionId,
-      ) ?? null;
-    return parentSummary ? adaptNcpSessionSummary(parentSummary) : null;
-  }, [parentSessionId, sessionSummaries]);
-  const currentSessionTypeOption =
-    sessionTypeOptions.find((option) => option.value === selectedSessionType) ?? null;
-  const currentSessionTypeLabel =
-    currentSessionTypeOption?.label ?? resolveSessionTypeLabel(selectedSessionType);
-  const currentSessionTypeIcon = currentSessionTypeOption?.icon ?? null;
-  const currentChildSessionTabs = useMemo(
-    () =>
-      buildChildSessionTabs({
-        parentSessionKey: sessionKey,
-        sessionSummaries,
-      }),
-    [sessionKey, sessionSummaries],
-  );
-
-  return {
-    currentSessionDisplayName,
-    currentAgentId,
-    currentAgent,
-    parentSession,
-    currentSessionTypeLabel,
-    currentSessionTypeIcon,
-    currentChildSessionTabs,
-  };
-}
-
-export function useNcpChatSnapshotSync(params: {
-  presenter: NcpChatPresenter;
-  isProviderStateResolved: boolean;
-  defaultSessionType: string;
-  canStopCurrentRun: boolean;
-  stopDisabledReason: string | null;
-  lastSendError: string | null;
-  isSending: boolean;
-  modelOptions: ChatModelOption[];
-  sessionTypeOptions: ChatSessionTypeOption[];
-  selectedSessionType: string;
-  canEditSessionType: boolean;
-  sessionTypeUnavailable: boolean;
-  skillRecords: SessionSkillEntryView[];
-  isSkillsLoading: boolean;
-  sessionTypeUnavailableMessage: string | null;
-  currentSessionTypeLabel: string;
-  currentSessionTypeIcon: ChatSessionTypeOption['icon'];
-  sessionKey: string | null | undefined;
-  currentAgentId: string;
-  currentAgent: AgentProfileView | null;
-  availableAgents: AgentProfileView[];
-  currentSessionDisplayName?: string;
-  effectiveSessionProjectRoot: string | null;
-  effectiveSessionWorkingDir: string | null;
-  effectiveSessionProjectName: string | null;
-  selectedSession: SessionEntryView | null;
-  threadRef: MutableRefObject<HTMLDivElement | null>;
-  agent: Pick<UseHydratedNcpAgentResult, 'isHydrating' | 'snapshot' | 'visibleMessages'>;
-  isAwaitingAssistantOutput: boolean;
-  parentSession: SessionEntryView | null;
-  childSessionTabs: ChatChildSessionTab[];
-}) {
-  useEffect(() => {
-    params.presenter.chatInputManager.syncSnapshot({
-      isProviderStateResolved: params.isProviderStateResolved,
-      defaultSessionType: params.defaultSessionType,
-      canStopGeneration: params.canStopCurrentRun,
-      stopDisabledReason: params.stopDisabledReason,
-      stopSupported: true,
-      stopReason: undefined,
-      sendError: params.lastSendError,
-      isSending: params.isSending,
-      modelOptions: params.modelOptions,
-      sessionTypeOptions: params.sessionTypeOptions,
-      selectedSessionType: params.selectedSessionType,
-      canEditSessionType: params.canEditSessionType,
-      sessionTypeUnavailable: params.sessionTypeUnavailable,
-      skillRecords: params.skillRecords,
-      isSkillsLoading: params.isSkillsLoading,
-    });
-    params.presenter.chatThreadManager.syncSnapshot({
-      isProviderStateResolved: params.isProviderStateResolved,
-      modelOptions: params.modelOptions,
-      sessionTypeUnavailable: params.sessionTypeUnavailable,
-      sessionTypeUnavailableMessage: params.sessionTypeUnavailableMessage,
-      sessionTypeLabel: params.currentSessionTypeLabel,
-      sessionTypeIcon: params.currentSessionTypeIcon,
-      sessionKey: params.sessionKey ?? null,
-      agentId: params.currentAgentId,
-      agentDisplayName: params.currentAgent?.displayName ?? null,
-      agentAvatarUrl: params.currentAgent?.avatarUrl ?? null,
-      availableAgents: params.availableAgents,
-      sessionDisplayName: params.currentSessionDisplayName,
-      sessionProjectRoot: params.effectiveSessionProjectRoot,
-      sessionWorkingDir: params.effectiveSessionWorkingDir,
-      sessionProjectName: params.effectiveSessionProjectName,
-      canDeleteSession: Boolean(params.selectedSession),
-      threadRef: params.threadRef,
-      isHistoryLoading: params.agent.isHydrating,
-      messages: params.agent.visibleMessages,
-      isSending: params.isSending,
-      isAwaitingAssistantOutput: params.isAwaitingAssistantOutput,
-      contextWindow: readNcpContextWindowValue(params.agent.snapshot.contextWindow),
-      parentSessionKey: params.parentSession?.key ?? null,
-      parentSessionLabel: params.parentSession
-        ? sessionDisplayName(params.parentSession)
-        : null,
-      childSessionTabs: params.childSessionTabs,
-    });
-  }, [
-    params
-  ]);
-}

package/src/features/chat/hooks/use-ncp-chat-page-data.test.tsx

@@ -1,70 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { describe, expect, it, vi } from 'vitest';
-import { useNcpChatPageData } from './use-ncp-chat-page-data';
-
-const useNcpSessionSkillsMock = vi.fn();
-
-vi.mock('@/shared/hooks/use-config', () => ({
-  useConfig: () => ({
-    data: {
-      agents: { defaults: {} },
-      providers: {}
-    },
-    isFetched: true,
-    isSuccess: true
-  }),
-  useConfigMeta: () => ({
-    data: { providers: [] },
-    isFetched: true,
-    isSuccess: true
-  }),
-  useNcpSessions: () => ({
-    data: { sessions: [] }
-  }),
-  useNcpSessionSkills: (params: unknown) => useNcpSessionSkillsMock(params)
-}));
-
-vi.mock('./use-ncp-chat-session-types', () => ({
-  useNcpChatSessionTypes: () => ({
-    data: {
-      defaultType: 'native',
-      options: [{ value: 'native', label: 'Native' }]
-    }
-  })
-}));
-
-function renderPageData(params: { sessionKey: string | null }) {
-  return renderHook(() =>
-    useNcpChatPageData({
-      sessionKey: params.sessionKey,
-      query: '',
-      currentSelectedModel: '',
-      pendingSessionType: '',
-      setPendingSessionType: vi.fn(),
-      setSelectedModel: vi.fn(),
-      setSelectedThinkingLevel: vi.fn()
-    })
-  );
-}
-
-describe('useNcpChatPageData skills query', () => {
-  it('loads draft-session skills before a new chat materializes', () => {
-    useNcpSessionSkillsMock.mockReturnValue({ data: { records: [] }, isLoading: false });
-
-    renderPageData({ sessionKey: null });
-
-    expect(useNcpSessionSkillsMock).toHaveBeenCalledWith({
-      sessionId: 'draft-session'
-    });
-  });
-
-  it('loads real session skills after materialization', () => {
-    useNcpSessionSkillsMock.mockReturnValue({ data: { records: [] }, isLoading: false });
-
-    renderPageData({ sessionKey: 'session-1' });
-
-    expect(useNcpSessionSkillsMock).toHaveBeenCalledWith({
-      sessionId: 'session-1'
-    });
-  });
-});

package/src/features/chat/hooks/use-ncp-chat-page-data.ts

@@ -1,260 +0,0 @@
-import { useMemo } from 'react';
-import type { Dispatch, SetStateAction } from 'react';
-import type { SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
-import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-import { sessionMatchesQuery } from '@/features/chat/utils/chat-session-display.utils';
-import { adaptNcpSessionSummaries } from '@/features/chat/utils/ncp-session-adapter.utils';
-import { useChatSessionTypeState } from '@/features/chat/hooks/use-chat-session-type-state';
-import {
-  resolveRecentSessionPreferredValue,
-  useSyncSelectedModel,
-  useSyncSelectedThinking
-} from '@/features/chat/utils/chat-session-preference-governance.utils';
-import {
-  useConfig,
-  useNcpSessionSkills,
-  useNcpSessions,
-  useProviders,
-  useProviderTemplates
-} from '@/shared/hooks/use-config';
-import { useNcpChatSessionTypes } from './use-ncp-chat-session-types';
-import { buildProviderModelCatalog, composeProviderModel, resolveModelThinkingCapability } from '@/shared/lib/provider-models';
-
-export type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-
-type UseNcpChatPageDataParams = {
-  query: string;
-  sessionKey: string | null;
-  projectRootOverride?: string | null;
-  currentSelectedModel: string;
-  pendingSessionType: string;
-  setPendingSessionType: Dispatch<SetStateAction<string>>;
-  setSelectedModel: Dispatch<SetStateAction<string>>;
-  setSelectedThinkingLevel: Dispatch<SetStateAction<ThinkingLevel | null>>;
-};
-
-function filterSessionsByQuery(sessions: SessionEntryView[], query: string): SessionEntryView[] {
-  return sessions.filter((session) => sessionMatchesQuery(session, query));
-}
-
-function useNcpChatModelOptions(params: {
-  config: ReturnType<typeof useConfig>['data'];
-  providersView: ReturnType<typeof useProviders>['data'];
-  templatesView: ReturnType<typeof useProviderTemplates>['data'];
-}) {
-  const { config, providersView, templatesView } = params;
-  return useMemo<ChatModelOption[]>(() => {
-    const providers = buildProviderModelCatalog({
-      providersView,
-      templatesView,
-      config,
-      onlyConfigured: true
-    });
-    const seen = new Set<string>();
-    const options: ChatModelOption[] = [];
-    for (const provider of providers) {
-      for (const localModel of provider.models) {
-        const value = composeProviderModel(provider.prefix, localModel);
-        if (!value || seen.has(value)) {
-          continue;
-        }
-        seen.add(value);
-        options.push({
-          value,
-          modelLabel: localModel,
-          providerLabel: provider.displayName,
-          thinkingCapability: resolveModelThinkingCapability(provider.modelThinking, localModel, provider.aliases)
-        });
-      }
-    }
-    return options.sort((left, right) => {
-      const providerCompare = left.providerLabel.localeCompare(right.providerLabel);
-      if (providerCompare !== 0) {
-        return providerCompare;
-      }
-      return left.modelLabel.localeCompare(right.modelLabel);
-    });
-  }, [config, providersView, templatesView]);
-}
-
-function useRecentSessionPreferences(params: {
-  sessions: SessionEntryView[];
-  sessionKey: string | null;
-  sessionType: string;
-}) {
-  const { sessions, sessionKey, sessionType } = params;
-  const recentSessionPreferredModel = useMemo(
-    () =>
-      resolveRecentSessionPreferredValue<string>({
-        sessions,
-        selectedSessionKey: sessionKey ?? '',
-        sessionType,
-        readPreference: (session) => session.preferredModel?.trim() || undefined
-      }),
-    [sessionKey, sessionType, sessions]
-  );
-  const recentSessionPreferredThinking = useMemo(
-    () =>
-      resolveRecentSessionPreferredValue<ThinkingLevel>({
-        sessions,
-        selectedSessionKey: sessionKey ?? '',
-        sessionType,
-        readPreference: (session) => session.preferredThinking ?? undefined
-      }),
-    [sessionKey, sessionType, sessions]
-  );
-  return {
-    recentSessionPreferredModel,
-    recentSessionPreferredThinking
-  };
-}
-
-function useCurrentModelThinkingState(params: {
-  currentSelectedModel: string;
-  modelOptions: ChatModelOption[];
-}) {
-  const { currentSelectedModel, modelOptions } = params;
-  const currentModelOption = useMemo(
-    () => modelOptions.find((option) => option.value === currentSelectedModel),
-    [currentSelectedModel, modelOptions]
-  );
-  const supportedThinkingLevels = useMemo(
-    () => (currentModelOption?.thinkingCapability?.supported as ThinkingLevel[] | undefined) ?? [],
-    [currentModelOption?.thinkingCapability?.supported]
-  );
-  const defaultThinkingLevel = useMemo(
-    () => (currentModelOption?.thinkingCapability?.default as ThinkingLevel | null | undefined) ?? null,
-    [currentModelOption?.thinkingCapability?.default]
-  );
-  return {
-    supportedThinkingLevels,
-    defaultThinkingLevel
-  };
-}
-
-export function filterModelOptionsBySessionType(params: {
-  modelOptions: ChatModelOption[];
-  supportedModels?: string[];
-}): ChatModelOption[] {
-  const { modelOptions, supportedModels } = params;
-  if (!supportedModels || supportedModels.length === 0) {
-    return modelOptions;
-  }
-  const supportedModelSet = new Set(supportedModels);
-  const filtered = modelOptions.filter((option) => supportedModelSet.has(option.value));
-  return filtered.length > 0 ? filtered : modelOptions;
-}
-
-export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
-  const {
-    currentSelectedModel,
-    pendingSessionType,
-    projectRootOverride,
-    query,
-    sessionKey,
-    setPendingSessionType,
-    setSelectedModel,
-    setSelectedThinkingLevel,
-  } = params;
-  const configQuery = useConfig();
-  const providersQuery = useProviders();
-  const templatesQuery = useProviderTemplates();
-  const sessionsQuery = useNcpSessions({ limit: 200 });
-  const sessionTypesQuery = useNcpChatSessionTypes();
-  const sessionSkillsQuery = useNcpSessionSkills({
-    sessionId: sessionKey?.trim() || 'draft-session',
-    ...(Object.prototype.hasOwnProperty.call(params, 'projectRootOverride')
-      ? { projectRoot: projectRootOverride ?? null }
-      : {})
-  });
-  const isProviderStateResolved =
-    (configQuery.isFetched || configQuery.isSuccess) &&
-    (providersQuery.isFetched || providersQuery.isSuccess) &&
-    (templatesQuery.isFetched || templatesQuery.isSuccess);
-  const modelOptions = useNcpChatModelOptions({
-    config: configQuery.data,
-    providersView: providersQuery.data,
-    templatesView: templatesQuery.data
-  });
-
-  const sessionSummaries = useMemo(
-    () => sessionsQuery.data?.sessions ?? [],
-    [sessionsQuery.data?.sessions]
-  );
-  const allSessions = useMemo(
-    () => adaptNcpSessionSummaries(sessionSummaries),
-    [sessionSummaries]
-  );
-  const sessions = useMemo(
-    () => filterSessionsByQuery(allSessions, query),
-    [allSessions, query]
-  );
-  const selectedSession = useMemo(
-    () => allSessions.find((session) => session.key === sessionKey) ?? null,
-    [allSessions, sessionKey]
-  );
-  const skillRecords = useMemo(
-    () => sessionSkillsQuery.data?.records ?? [],
-    [sessionSkillsQuery.data?.records]
-  );
-  const sessionTypeState = useChatSessionTypeState({
-    selectedSession,
-    pendingSessionType,
-    setPendingSessionType,
-    sessionTypesData: sessionTypesQuery.data
-  });
-  const filteredModelOptions = useMemo(
-    () =>
-      filterModelOptionsBySessionType({
-        modelOptions,
-        supportedModels: sessionTypeState.selectedSessionTypeOption?.supportedModels
-      }),
-    [modelOptions, sessionTypeState.selectedSessionTypeOption?.supportedModels]
-  );
-  const { recentSessionPreferredModel, recentSessionPreferredThinking } =
-    useRecentSessionPreferences({
-      sessions: allSessions,
-      sessionKey,
-      sessionType: sessionTypeState.selectedSessionType
-    });
-  const { supportedThinkingLevels, defaultThinkingLevel } =
-    useCurrentModelThinkingState({
-      currentSelectedModel,
-      modelOptions: filteredModelOptions
-    });
-
-  useSyncSelectedModel({
-    modelOptions: filteredModelOptions,
-    selectedSessionKey: sessionKey ?? '',
-    selectedSessionExists: Boolean(selectedSession),
-    selectedSessionPreferredModel: selectedSession?.preferredModel,
-    fallbackPreferredModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? recentSessionPreferredModel,
-    defaultModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? configQuery.data?.agents.defaults.model,
-    setSelectedModel
-  });
-  useSyncSelectedThinking({
-    supportedThinkingLevels,
-    selectedSessionKey: sessionKey ?? '',
-    selectedSessionExists: Boolean(selectedSession),
-    selectedSessionPreferredThinking: selectedSession?.preferredThinking ?? null,
-    fallbackPreferredThinking: recentSessionPreferredThinking ?? null,
-    defaultThinkingLevel,
-    setSelectedThinkingLevel
-  });
-
-  return {
-    configQuery,
-    providersQuery,
-    templatesQuery,
-    sessionsQuery,
-    sessionTypesQuery,
-    sessionSkillsQuery,
-    isProviderStateResolved,
-    modelOptions: filteredModelOptions,
-    sessionSummaries,
-    sessions,
-    skillRecords,
-    selectedSession,
-    ...sessionTypeState
-  };
-}

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

@@ -1,35 +0,0 @@
-import type { ChatStreamActions } from '@/features/chat/types/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);
-}