@nextclaw/ui 0.10.5 → 0.11.1

package/src/api/config.stream.test.ts

@@ -1,115 +0,0 @@
-import { sendChatTurnStream, streamChatRun } from '@/api/config';
-
-const mocks = vi.hoisted(() => ({
-  request: vi.fn(),
-  openStream: vi.fn()
-}));
-
-vi.mock('@/transport', () => ({
-  appClient: {
-    request: mocks.request,
-    openStream: mocks.openStream
-  }
-}));
-
-describe('api/config stream routing', () => {
-  beforeEach(() => {
-    mocks.request.mockReset();
-    mocks.openStream.mockReset();
-  });
-
-  it('routes sendChatTurnStream through appClient.openStream', async () => {
-    const onReady = vi.fn();
-    const onDelta = vi.fn();
-    const onSessionEvent = vi.fn();
-
-    mocks.openStream.mockImplementation(({ onEvent }) => {
-      onEvent({ name: 'ready', payload: { sessionKey: 's1' } });
-      onEvent({ name: 'delta', payload: { delta: 'hello' } });
-      onEvent({ name: 'session_event', payload: { type: 'session.updated' } });
-      onEvent({ name: 'final', payload: { sessionKey: 's1', reply: 'hello world' } });
-      return {
-        finished: Promise.resolve({ sessionKey: 's1', reply: 'hello world' }),
-        cancel: vi.fn()
-      };
-    });
-
-    const result = await sendChatTurnStream(
-      { message: 'hi' } as never,
-      { onReady, onDelta, onSessionEvent }
-    );
-
-    expect(mocks.openStream).toHaveBeenCalledWith({
-      method: 'POST',
-      path: '/api/chat/turn/stream',
-      body: { message: 'hi' },
-      signal: undefined,
-      onEvent: expect.any(Function)
-    });
-    expect(onReady).toHaveBeenCalledWith({ sessionKey: 's1' });
-    expect(onDelta).toHaveBeenCalledWith({ delta: 'hello' });
-    expect(onSessionEvent).toHaveBeenCalledWith({ data: { type: 'session.updated' } });
-    expect(result).toEqual({ sessionKey: 's1', reply: 'hello world' });
-  });
-
-  it('routes streamChatRun through appClient.openStream and preserves query params', async () => {
-    const onReady = vi.fn();
-    const onDelta = vi.fn();
-    const onSessionEvent = vi.fn();
-
-    mocks.openStream.mockImplementation(() => ({
-      finished: Promise.resolve({ sessionKey: 's1', reply: 'resumed' }),
-      cancel: vi.fn()
-    }));
-
-    const result = await streamChatRun(
-      { runId: 'run-1', fromEventIndex: 42 },
-      { onReady, onDelta, onSessionEvent }
-    );
-
-    expect(mocks.openStream).toHaveBeenCalledWith({
-      method: 'GET',
-      path: '/api/chat/runs/run-1/stream?fromEventIndex=42',
-      signal: undefined,
-      onEvent: expect.any(Function)
-    });
-    expect(onReady).not.toHaveBeenCalled();
-    expect(onDelta).not.toHaveBeenCalled();
-    expect(onSessionEvent).not.toHaveBeenCalled();
-    expect(result).toEqual({ sessionKey: 's1', reply: 'resumed' });
-  });
-
-  it('surfaces transport error events as rejected stream promises', async () => {
-    mocks.openStream.mockImplementation(({ onEvent }) => {
-      let resolveFinished!: () => void;
-      let rejectFinished!: (error: Error) => void;
-      const finished = new Promise<void>((resolve, reject) => {
-        resolveFinished = resolve;
-        rejectFinished = reject;
-      });
-      queueMicrotask(() => {
-        try {
-          onEvent({ name: 'error', payload: { message: 'chat stream failed' } });
-          resolveFinished();
-        } catch (error) {
-          rejectFinished(error instanceof Error ? error : new Error(String(error)));
-        }
-      });
-      return {
-        finished,
-        cancel: vi.fn()
-      };
-    });
-
-    await expect(
-      sendChatTurnStream(
-        { message: 'hi' } as never,
-        {
-          onReady: vi.fn(),
-          onDelta: vi.fn(),
-          onSessionEvent: vi.fn()
-        }
-      )
-    ).rejects.toThrow('chat stream failed');
-  });
-});

package/src/components/chat/chat-chain.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { resolveChatChain } from '@/components/chat/chat-chain';
-
-describe('resolveChatChain', () => {
-  it('defaults to ncp when no query or env override is provided', () => {
-    vi.stubEnv('VITE_CHAT_CHAIN', '');
-
-    expect(resolveChatChain('')).toBe('ncp');
-  });
-
-  it('allows explicit legacy rollback from query string', () => {
-    vi.stubEnv('VITE_CHAT_CHAIN', 'ncp');
-
-    expect(resolveChatChain('?chatChain=legacy')).toBe('legacy');
-  });
-
-  it('accepts env override when query string is absent', () => {
-    vi.stubEnv('VITE_CHAT_CHAIN', 'legacy');
-
-    expect(resolveChatChain('')).toBe('legacy');
-  });
-});

package/src/components/chat/chat-chain.ts

@@ -1,23 +0,0 @@
-export type ChatChain = 'legacy' | 'ncp';
-
-const DEFAULT_CHAT_CHAIN: ChatChain = 'ncp';
-
-function normalizeChatChain(value: string | null | undefined): ChatChain | null {
-  if (typeof value !== 'string') {
-    return null;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (normalized === 'legacy' || normalized === 'ncp') {
-    return normalized;
-  }
-  return null;
-}
-
-export function resolveChatChain(search: string): ChatChain {
-  const fromSearch = normalizeChatChain(new URLSearchParams(search).get('chatChain'));
-  if (fromSearch) {
-    return fromSearch;
-  }
-  const fromEnv = normalizeChatChain(import.meta.env.VITE_CHAT_CHAIN);
-  return fromEnv ?? DEFAULT_CHAT_CHAIN;
-}

package/src/components/chat/chat-page-data.ts

@@ -1,171 +0,0 @@
-import { useMemo } from 'react';
-import type { Dispatch, SetStateAction } from 'react';
-import type { SessionEntryView, ThinkingLevel } from '@/api/types';
-import type { ChatModelOption } from '@/components/chat/chat-input.types';
-import { useChatSessionTypeState } from '@/components/chat/useChatSessionTypeState';
-import {
-  resolveRecentSessionPreferredThinking,
-  resolveRecentSessionPreferredModel,
-  useSyncSelectedModel,
-  useSyncSelectedThinking
-} from '@/components/chat/chat-session-preference-governance';
-import {
-  useChatCapabilities,
-  useChatSessionTypes,
-  useConfig,
-  useConfigMeta,
-  useSessionHistory,
-  useSessions,
-} from '@/hooks/useConfig';
-import { useMarketplaceInstalled } from '@/hooks/useMarketplace';
-import { buildProviderModelCatalog, composeProviderModel, resolveModelThinkingCapability } from '@/lib/provider-models';
-
-type UseChatPageDataParams = {
-  query: string;
-  selectedSessionKey: string | null;
-  selectedAgentId: string;
-  currentSelectedModel: string;
-  pendingSessionType: string;
-  setPendingSessionType: Dispatch<SetStateAction<string>>;
-  setSelectedModel: Dispatch<SetStateAction<string>>;
-  setSelectedThinkingLevel: Dispatch<SetStateAction<ThinkingLevel | null>>;
-};
-
-export function useChatPageData(params: UseChatPageDataParams) {
-  const configQuery = useConfig();
-  const configMetaQuery = useConfigMeta();
-  const sessionsQuery = useSessions({ q: params.query.trim() || undefined, limit: 120, activeMinutes: 0 });
-  const installedSkillsQuery = useMarketplaceInstalled('skill');
-  const chatCapabilitiesQuery = useChatCapabilities({
-    sessionKey: params.selectedSessionKey,
-    agentId: params.selectedAgentId
-  });
-  const historyQuery = useSessionHistory(params.selectedSessionKey, 300);
-  const sessionTypesQuery = useChatSessionTypes();
-  const isProviderStateResolved =
-    (configQuery.isFetched || configQuery.isSuccess) &&
-    (configMetaQuery.isFetched || configMetaQuery.isSuccess);
-
-  const modelOptions = useMemo<ChatModelOption[]>(() => {
-    const providers = buildProviderModelCatalog({
-      meta: configMetaQuery.data,
-      config: configQuery.data,
-      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);
-    });
-  }, [configMetaQuery.data, configQuery.data]);
-
-  const sessions = useMemo(() => sessionsQuery.data?.sessions ?? [], [sessionsQuery.data?.sessions]);
-  const skillRecords = useMemo(() => installedSkillsQuery.data?.records ?? [], [installedSkillsQuery.data?.records]);
-  const selectedSession = useMemo(
-    () => sessions.find((session) => session.key === params.selectedSessionKey) ?? null,
-    [params.selectedSessionKey, sessions]
-  );
-
-  const sessionTypeState = useChatSessionTypeState({
-    selectedSession,
-    selectedSessionKey: params.selectedSessionKey,
-    pendingSessionType: params.pendingSessionType,
-    setPendingSessionType: params.setPendingSessionType,
-    sessionTypesData: sessionTypesQuery.data
-  });
-  const recentSessionPreferredModel = useMemo(
-    () =>
-      resolveRecentSessionPreferredModel({
-        sessions,
-        selectedSessionKey: params.selectedSessionKey,
-        sessionType: sessionTypeState.selectedSessionType
-      }),
-    [params.selectedSessionKey, sessionTypeState.selectedSessionType, sessions]
-  );
-  const currentModelOption = useMemo(
-    () => modelOptions.find((option) => option.value === params.currentSelectedModel),
-    [modelOptions, params.currentSelectedModel]
-  );
-  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]
-  );
-  const recentSessionPreferredThinking = useMemo(
-    () =>
-      resolveRecentSessionPreferredThinking({
-        sessions,
-        selectedSessionKey: params.selectedSessionKey,
-        sessionType: sessionTypeState.selectedSessionType
-      }),
-    [params.selectedSessionKey, sessionTypeState.selectedSessionType, sessions]
-  );
-
-  useSyncSelectedModel({
-    modelOptions,
-    selectedSessionKey: params.selectedSessionKey,
-    selectedSessionExists: Boolean(selectedSession),
-    selectedSessionPreferredModel: selectedSession?.preferredModel,
-    fallbackPreferredModel: recentSessionPreferredModel,
-    defaultModel: configQuery.data?.agents.defaults.model,
-    setSelectedModel: params.setSelectedModel
-  });
-  useSyncSelectedThinking({
-    supportedThinkingLevels,
-    selectedSessionKey: params.selectedSessionKey,
-    selectedSessionExists: Boolean(selectedSession),
-    selectedSessionPreferredThinking: selectedSession?.preferredThinking ?? null,
-    fallbackPreferredThinking: recentSessionPreferredThinking ?? null,
-    defaultThinkingLevel,
-    setSelectedThinkingLevel: params.setSelectedThinkingLevel
-  });
-
-  const historyMessages = useMemo(() => historyQuery.data?.messages ?? [], [historyQuery.data?.messages]);
-
-  return {
-    configQuery,
-    configMetaQuery,
-    sessionsQuery,
-    installedSkillsQuery,
-    chatCapabilitiesQuery,
-    historyQuery,
-    sessionTypesQuery,
-    isProviderStateResolved,
-    modelOptions,
-    sessions,
-    skillRecords,
-    selectedSession,
-    historyMessages,
-    ...sessionTypeState
-  };
-}
-
-export function sessionDisplayName(session: SessionEntryView): string {
-  if (session.label && session.label.trim()) {
-    return session.label.trim();
-  }
-  const chunks = session.key.split(':');
-  return chunks[chunks.length - 1] || session.key;
-}

package/src/components/chat/chat-page-runtime.ts

@@ -1,190 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
-import type { ChatRunView } from '@/api/types';
-import { useChatRuns } from '@/hooks/useConfig';
-import { buildActiveRunBySessionKey, buildSessionRunStatusByKey } from '@/lib/session-run-status';
-
-export type ChatMainPanelView = 'chat' | 'cron' | 'skills';
-
-export function useSessionRunStatus(params: {
-  view: ChatMainPanelView;
-  selectedSessionKey: string | null;
-  activeBackendRunId: string | null;
-  isLocallyRunning: boolean;
-  resumeRun: (run: ChatRunView) => Promise<void>;
-}) {
-  const { view, selectedSessionKey, activeBackendRunId, isLocallyRunning, resumeRun } = params;
-  const [suppressedSessionState, setSuppressedSessionState] = useState<{
-    sessionKey: string;
-    runId?: string;
-  } | null>(null);
-  const wasLocallyRunningRef = useRef(false);
-  const resumedRunBySessionRef = useRef(new Map<string, string>());
-  const completedRunBySessionRef = useRef(new Map<string, string>());
-  const locallySettledAtBySessionRef = useRef(new Map<string, number>());
-  const latestBackendRunIdRef = useRef<string | null>(activeBackendRunId);
-  const autoResumeEligibleSessionsRef = useRef(new Set<string>());
-
-  useEffect(() => {
-    if (!selectedSessionKey) {
-      return;
-    }
-    autoResumeEligibleSessionsRef.current.add(selectedSessionKey);
-  }, [selectedSessionKey]);
-
-  useEffect(() => {
-    if (!selectedSessionKey) {
-      return;
-    }
-    if (isLocallyRunning) {
-      autoResumeEligibleSessionsRef.current.delete(selectedSessionKey);
-    }
-  }, [isLocallyRunning, selectedSessionKey]);
-
-  const sessionStatusRunsQuery = useChatRuns(
-    view === 'chat'
-      ? {
-          states: ['queued', 'running'],
-          limit: 200,
-          syncActiveStates: true,
-          isLocallyRunning
-        }
-      : undefined
-  );
-  const activeRunBySessionKey = useMemo(
-    () => buildActiveRunBySessionKey(sessionStatusRunsQuery.data?.runs ?? []),
-    [sessionStatusRunsQuery.data?.runs]
-  );
-  const sessionRunStatusByKey = useMemo(() => {
-    const next = buildSessionRunStatusByKey(activeRunBySessionKey);
-    if (suppressedSessionState) {
-      const activeRun = activeRunBySessionKey.get(suppressedSessionState.sessionKey) ?? null;
-      if (activeRun && (!suppressedSessionState.runId || activeRun.runId === suppressedSessionState.runId)) {
-        next.delete(suppressedSessionState.sessionKey);
-      }
-    }
-    return next;
-  }, [activeRunBySessionKey, suppressedSessionState]);
-  const activeRun = useMemo(() => {
-    if (!selectedSessionKey) {
-      return null;
-    }
-    const run = activeRunBySessionKey.get(selectedSessionKey) ?? null;
-    const shouldSuppress = (() => {
-      if (!run || !suppressedSessionState) {
-        return false;
-      }
-      if (suppressedSessionState.sessionKey !== selectedSessionKey) {
-        return false;
-      }
-      return !suppressedSessionState.runId || run.runId === suppressedSessionState.runId;
-    })();
-    if (shouldSuppress) {
-      return null;
-    }
-    return run;
-  }, [activeRunBySessionKey, selectedSessionKey, suppressedSessionState]);
-
-  useEffect(() => {
-    if (!activeBackendRunId) {
-      return;
-    }
-    latestBackendRunIdRef.current = activeBackendRunId;
-  }, [activeBackendRunId]);
-
-  useEffect(() => {
-    if (view !== 'chat' || !selectedSessionKey || !activeRun) {
-      return;
-    }
-    if (!autoResumeEligibleSessionsRef.current.has(selectedSessionKey)) {
-      return;
-    }
-    if (isLocallyRunning) {
-      return;
-    }
-    if (activeBackendRunId === activeRun.runId) {
-      return;
-    }
-    const resumedRunId = resumedRunBySessionRef.current.get(selectedSessionKey);
-    if (resumedRunId === activeRun.runId) {
-      return;
-    }
-    const completedRunId = completedRunBySessionRef.current.get(selectedSessionKey);
-    if (completedRunId && completedRunId === activeRun.runId) {
-      return;
-    }
-    const locallySettledAt = locallySettledAtBySessionRef.current.get(selectedSessionKey);
-    if (typeof locallySettledAt === 'number') {
-      const requestedAt = Date.parse(activeRun.requestedAt ?? '');
-      if (Number.isFinite(requestedAt)) {
-        if (requestedAt <= locallySettledAt + 2_000) {
-          return;
-        }
-      } else if (Date.now() - locallySettledAt <= 8_000) {
-        return;
-      }
-    }
-    resumedRunBySessionRef.current.set(selectedSessionKey, activeRun.runId);
-    autoResumeEligibleSessionsRef.current.delete(selectedSessionKey);
-    void resumeRun(activeRun);
-  }, [activeBackendRunId, activeRun, isLocallyRunning, resumeRun, selectedSessionKey, view]);
-
-  useEffect(() => {
-    if (!selectedSessionKey) {
-      resumedRunBySessionRef.current.clear();
-      completedRunBySessionRef.current.clear();
-      locallySettledAtBySessionRef.current.clear();
-      autoResumeEligibleSessionsRef.current.clear();
-      return;
-    }
-    if (!activeRunBySessionKey.has(selectedSessionKey)) {
-      resumedRunBySessionRef.current.delete(selectedSessionKey);
-      completedRunBySessionRef.current.delete(selectedSessionKey);
-      locallySettledAtBySessionRef.current.delete(selectedSessionKey);
-    }
-  }, [activeRunBySessionKey, selectedSessionKey]);
-
-  useEffect(() => {
-    const wasRunning = wasLocallyRunningRef.current;
-    wasLocallyRunningRef.current = isLocallyRunning;
-    if (isLocallyRunning) {
-      return;
-    }
-    if (wasRunning && selectedSessionKey) {
-      const completedRunId = latestBackendRunIdRef.current?.trim() || activeRunBySessionKey.get(selectedSessionKey)?.runId?.trim();
-      if (completedRunId) {
-        completedRunBySessionRef.current.set(selectedSessionKey, completedRunId);
-      }
-      locallySettledAtBySessionRef.current.set(selectedSessionKey, Date.now());
-      setSuppressedSessionState({
-        sessionKey: selectedSessionKey,
-        ...(completedRunId ? { runId: completedRunId } : {})
-      });
-      void sessionStatusRunsQuery.refetch();
-    }
-  }, [activeRunBySessionKey, isLocallyRunning, selectedSessionKey, sessionStatusRunsQuery]);
-
-  useEffect(() => {
-    if (!suppressedSessionState) {
-      return;
-    }
-    const activeRun = activeRunBySessionKey.get(suppressedSessionState.sessionKey) ?? null;
-    if (!activeRun) {
-      setSuppressedSessionState(null);
-      return;
-    }
-    if (suppressedSessionState.runId && activeRun.runId !== suppressedSessionState.runId) {
-      setSuppressedSessionState(null);
-    }
-  }, [activeRunBySessionKey, suppressedSessionState]);
-
-  useEffect(() => {
-    if (!isLocallyRunning) {
-      return;
-    }
-    if (suppressedSessionState?.sessionKey === selectedSessionKey) {
-      setSuppressedSessionState(null);
-    }
-  }, [isLocallyRunning, selectedSessionKey, suppressedSessionState]);
-
-  return { sessionRunStatusByKey };
-}

package/src/components/chat/chat-stream/nextbot-parsers.ts

@@ -1,52 +0,0 @@
-import type { RunMetadataParsers } from '@nextclaw/agent-chat';
-import type { ChatRunView } from '@/api/types';
-import type { NextbotAgentRunMetadata, SendMessageParams } from '@/components/chat/chat-stream/types';
-
-export const nextbotParsers: RunMetadataParsers = {
-  parseReady: (metadata) => {
-    if (metadata.driver !== 'nextbot-stream' || metadata.kind !== 'ready') {
-      return null;
-    }
-    return {
-      remoteRunId: typeof metadata.backendRunId === 'string' ? metadata.backendRunId : undefined,
-      sessionId: typeof metadata.sessionKey === 'string' ? metadata.sessionKey : undefined,
-      stopCapable: typeof metadata.stopSupported === 'boolean' ? metadata.stopSupported : undefined,
-      stopReason: typeof metadata.stopReason === 'string' ? metadata.stopReason : undefined
-    };
-  },
-  parseFinal: (metadata) => {
-    if (metadata.driver !== 'nextbot-stream' || metadata.kind !== 'final') {
-      return null;
-    }
-    return {
-      sessionId: typeof metadata.sessionKey === 'string' ? metadata.sessionKey : undefined,
-      hasOutput: Boolean(metadata.hasAssistantSessionEvent)
-    };
-  }
-};
-
-export function buildSendMetadata(payload: SendMessageParams, requestedSkills: string[]): NextbotAgentRunMetadata {
-  return {
-    driver: 'nextbot-stream',
-    mode: 'send',
-    payload,
-    requestedSkills
-  };
-}
-
-export function buildResumeMetadata(run: ChatRunView): NextbotAgentRunMetadata {
-  const fromEventIndex =
-    Number.isFinite(run.eventCount) && run.eventCount > 0
-      ? Math.max(0, Math.trunc(run.eventCount))
-      : undefined;
-  return {
-    driver: 'nextbot-stream',
-    mode: 'resume',
-    runId: run.runId!,
-    ...(typeof fromEventIndex === 'number' ? { fromEventIndex } : {}),
-    sessionKey: run.sessionKey,
-    ...(run.agentId ? { agentId: run.agentId } : {}),
-    stopSupported: run.stopSupported,
-    ...(run.stopReason ? { stopReason: run.stopReason } : {})
-  };
-}