@nextclaw/ui 0.14.1 → 0.14.2

package/src/features/chat/managers/__tests__/chat-run.manager.test.ts

@@ -1,236 +0,0 @@
-import type { NcpMessage } from '@nextclaw/ncp';
-import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
-import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
-import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
-
-function createChatRunManager() {
-  const uiManager = {
-    isAtChatRoot: vi.fn(() => true),
-    goToSession: vi.fn(),
-  };
-  return {
-    manager: new ChatRunManager(
-      uiManager as unknown as ConstructorParameters<typeof ChatRunManager>[0],
-    ),
-    uiManager,
-  };
-}
-
-describe('ChatRunManager', () => {
-  beforeEach(() => {
-    useChatInputStore.setState({
-      snapshot: {
-        ...useChatInputStore.getState().snapshot,
-        canStopGeneration: false,
-        sendError: null,
-        isSending: false,
-      },
-    });
-    useChatThreadStore.setState({
-      snapshot: {
-        ...useChatThreadStore.getState().snapshot,
-        isHistoryLoading: false,
-        messages: [],
-        isSending: false,
-        isAwaitingAssistantOutput: false,
-        contextWindow: null,
-      },
-    });
-  });
-
-  it('sends an envelope through the active runtime and materializes a root session', async () => {
-    const { manager, uiManager } = createChatRunManager();
-    const sendEnvelope = vi.fn(async () => ({
-      sessionId: 'materialized-session',
-      userMessageId: 'user-message-1',
-      assistantMessageId: null,
-      runId: 'run-1',
-    }));
-    manager.setActiveRuntime({
-      sessionKey: null,
-      sendEnvelope,
-      abortCurrentRun: vi.fn(),
-      resumeCurrentSessionRun: vi.fn(),
-    });
-
-    await manager.sendMessage({
-      message: 'hello',
-      agentId: 'engineer',
-      sessionType: 'codex',
-      projectRoot: '/tmp/project-alpha',
-      requestedSkills: ['project:/tmp/project-alpha/.agents/skills/review'],
-    });
-
-    expect(sendEnvelope).toHaveBeenCalledWith(
-      expect.objectContaining({
-        metadata: expect.objectContaining({
-          agentId: 'engineer',
-          session_type: 'codex',
-          projectRoot: '/tmp/project-alpha',
-          requested_skill_refs: ['project:/tmp/project-alpha/.agents/skills/review'],
-        }),
-      }),
-    );
-    expect(uiManager.goToSession).toHaveBeenCalledWith('materialized-session', { replace: true });
-  });
-
-  it('keeps the runtime-default sentinel in request metadata to override stale session model metadata', async () => {
-    const { manager } = createChatRunManager();
-    const sendEnvelope = vi.fn(async () => ({
-      sessionId: 'session-1',
-      userMessageId: 'user-message-1',
-      assistantMessageId: null,
-      runId: 'run-1',
-    }));
-    manager.setActiveRuntime({
-      sessionKey: 'session-1',
-      sendEnvelope,
-      abortCurrentRun: vi.fn(),
-      resumeCurrentSessionRun: vi.fn(),
-    });
-
-    await manager.sendMessage({
-      message: 'hello',
-      sessionKey: 'session-1',
-      agentId: 'main',
-      sessionType: 'codex',
-      model: RUNTIME_DEFAULT_MODEL_VALUE,
-    });
-
-    expect(sendEnvelope).toHaveBeenCalledWith(
-      expect.objectContaining({
-        metadata: expect.objectContaining({
-          model: RUNTIME_DEFAULT_MODEL_VALUE,
-          preferred_model: RUNTIME_DEFAULT_MODEL_VALUE,
-        }),
-      }),
-    );
-  });
-
-  it('does not send through a runtime for another session', async () => {
-    const { manager } = createChatRunManager();
-    const sendEnvelope = vi.fn();
-    manager.setActiveRuntime({
-      sessionKey: 'session-1',
-      sendEnvelope,
-      abortCurrentRun: vi.fn(),
-      resumeCurrentSessionRun: vi.fn(),
-    });
-
-    await manager.sendMessage({
-      message: 'hello',
-      sessionKey: 'session-2',
-      agentId: 'main',
-    });
-
-    expect(sendEnvelope).not.toHaveBeenCalled();
-  });
-
-  it('routes stop and resume commands through the active runtime', async () => {
-    const { manager } = createChatRunManager();
-    const abortCurrentRun = vi.fn(async () => undefined);
-    const resumeCurrentSessionRun = vi.fn(async () => undefined);
-    manager.setActiveRuntime({
-      sessionKey: 'session-1',
-      sendEnvelope: vi.fn(),
-      abortCurrentRun,
-      resumeCurrentSessionRun,
-    });
-
-    await manager.stopCurrentRun();
-    await manager.resumeRun({ sessionKey: 'session-1' });
-    await manager.resumeRun({ sessionKey: 'session-2' });
-
-    expect(abortCurrentRun).toHaveBeenCalledTimes(1);
-    expect(resumeCurrentSessionRun).toHaveBeenCalledTimes(1);
-  });
-
-  it('syncs the run snapshot into chat input and thread state', () => {
-    const { manager } = createChatRunManager();
-    const message: NcpMessage = {
-      id: 'message-1',
-      sessionId: 'session-1',
-      role: 'assistant',
-      status: 'final',
-      parts: [{ type: 'text', text: 'done' }],
-      timestamp: '2026-06-10T00:00:00.000Z',
-    };
-
-    manager.applyRunSnapshot({
-      routeSessionKey: 'session-1',
-      isHydrating: true,
-      isSending: false,
-      isRunning: true,
-      visibleMessages: [message],
-      contextWindow: {
-        usedContextTokens: 10,
-        totalContextTokens: 100,
-        availableContextTokens: 90,
-        prunedUsedContextTokens: 10,
-        droppedHistoryCount: 0,
-        truncatedToolResultCount: 0,
-        truncatedSystemPrompt: false,
-        truncatedUserMessage: false,
-        compacted: false,
-        compactedUsedContextTokens: 10,
-        compactedMessageCount: 0,
-        updatedAt: '2026-06-10T00:00:00.000Z',
-      },
-      sendErrorMessage: 'failed',
-      materializedSessionKey: null,
-    });
-
-    expect(useChatInputStore.getState().snapshot).toMatchObject({
-      canStopGeneration: true,
-      sendError: 'failed',
-      isSending: true,
-    });
-    expect(useChatThreadStore.getState().snapshot).toMatchObject({
-      isHistoryLoading: true,
-      messages: [message],
-      isSending: true,
-      isAwaitingAssistantOutput: true,
-    });
-  });
-
-  it('clears run-owned input and thread state', () => {
-    const { manager } = createChatRunManager();
-    useChatInputStore.getState().setSnapshot({
-      canStopGeneration: true,
-      sendError: 'failed',
-      isSending: true,
-    });
-    useChatThreadStore.getState().setSnapshot({
-      isHistoryLoading: true,
-      messages: [
-        {
-          id: 'message-1',
-          sessionId: 'session-1',
-          role: 'assistant',
-          status: 'final',
-          parts: [{ type: 'text', text: 'done' }],
-          timestamp: '2026-06-10T00:00:00.000Z',
-        },
-      ],
-      isSending: true,
-      isAwaitingAssistantOutput: true,
-    });
-
-    manager.clearRunState();
-
-    expect(useChatInputStore.getState().snapshot).toMatchObject({
-      canStopGeneration: false,
-      sendError: null,
-      isSending: false,
-    });
-    expect(useChatThreadStore.getState().snapshot).toMatchObject({
-      isHistoryLoading: false,
-      messages: [],
-      isSending: false,
-      isAwaitingAssistantOutput: false,
-      contextWindow: null,
-    });
-  });
-});

package/src/features/chat/managers/__tests__/chat-session-preference-sync.manager.test.ts

@@ -1,219 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
-import { updateNcpSession } from '@/shared/lib/api';
-import { ChatSessionPreferenceSync } from '@/features/chat/managers/chat-session-preference-sync.manager';
-import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
-import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
-import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
-import type * as SharedApiModule from '@/shared/lib/api';
-
-vi.mock('@/shared/lib/api', async (importOriginal) => {
-  const actual = await importOriginal<typeof SharedApiModule>();
-  return {
-    ...actual,
-    updateNcpSession: vi.fn(async () => ({
-      sessionId: 'session-1',
-      messageCount: 0,
-      updatedAt: new Date().toISOString(),
-      status: 'idle',
-      metadata: {}
-    }))
-  };
-});
-
-describe('ChatSessionPreferenceSync', () => {
-  afterEach(() => {
-    useChatInputStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        modelOptions: [],
-        selectedModel: '',
-        selectedThinkingLevel: null
-      }
-    }));
-    useChatSessionListStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedSessionKey: null
-      }
-    }));
-    useChatThreadStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        canDeleteSession: false
-      }
-    }));
-    vi.clearAllMocks();
-  });
-
-  it('persists the selected model and thinking to the current session metadata', async () => {
-    useChatInputStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedModel: 'openai/gpt-5',
-        selectedThinkingLevel: 'high'
-      }
-    }));
-    useChatSessionListStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedSessionKey: 'session-1'
-      }
-    }));
-    useChatThreadStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        canDeleteSession: true
-      }
-    }));
-
-    const sync = new ChatSessionPreferenceSync(updateNcpSession);
-    sync.syncSelectedSessionPreferences();
-    await vi.waitFor(() => {
-      expect(updateNcpSession).toHaveBeenCalledWith('session-1', {
-        preferredModel: 'openai/gpt-5',
-        preferredThinking: 'high'
-      });
-    });
-  });
-
-  it('clears the persisted model preference when runtime default is selected', async () => {
-    useChatInputStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedModel: RUNTIME_DEFAULT_MODEL_VALUE,
-        selectedThinkingLevel: null
-      }
-    }));
-    useChatSessionListStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedSessionKey: 'session-1'
-      }
-    }));
-    useChatThreadStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        canDeleteSession: true
-      }
-    }));
-
-    const sync = new ChatSessionPreferenceSync(updateNcpSession);
-    sync.syncSelectedSessionPreferences();
-    await vi.waitFor(() => {
-      expect(updateNcpSession).toHaveBeenCalledWith('session-1', {
-        preferredModel: null,
-        preferredThinking: null
-      });
-    });
-  });
-
-  it('uses the runtime-default thinking capability default when no session thinking is persisted', () => {
-    useChatInputStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        modelOptions: [
-          {
-            value: RUNTIME_DEFAULT_MODEL_VALUE,
-            modelLabel: 'Runtime default',
-            providerLabel: '',
-            isRuntimeDefault: true,
-            thinkingCapability: {
-              supported: ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'],
-              default: 'high',
-            },
-          },
-        ],
-        selectedModel: '',
-        selectedThinkingLevel: null,
-      }
-    }));
-
-    const sync = new ChatSessionPreferenceSync(updateNcpSession);
-    sync.syncInputSelection({
-      selectedSessionExists: true,
-      defaultModel: RUNTIME_DEFAULT_MODEL_VALUE,
-      selectedSessionPreferredThinking: null,
-      fallbackPreferredThinking: null,
-    });
-
-    expect(useChatInputStore.getState().snapshot).toMatchObject({
-      selectedModel: RUNTIME_DEFAULT_MODEL_VALUE,
-      selectedThinkingLevel: 'high',
-    });
-  });
-
-  it('does not rewrite the input snapshot when the resolved selection is unchanged', () => {
-    useChatInputStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        modelOptions: [
-          {
-            value: 'openai/gpt-5',
-            modelLabel: 'GPT-5',
-            providerLabel: 'OpenAI',
-            thinkingCapability: null,
-          },
-        ],
-        selectedModel: 'openai/gpt-5',
-        selectedThinkingLevel: null,
-      }
-    }));
-    const sync = new ChatSessionPreferenceSync(updateNcpSession);
-    const listener = vi.fn();
-    const unsubscribe = useChatInputStore.subscribe(listener);
-
-    sync.syncInputSelection({
-      selectedSessionExists: true,
-      selectedSessionPreferredModel: 'openai/gpt-5',
-      selectedSessionPreferredThinking: null,
-    });
-
-    unsubscribe();
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it('applies a historical session preferred model after its summary arrives', () => {
-    useChatInputStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        modelOptions: [
-          {
-            value: 'anthropic/claude-sonnet-4',
-            modelLabel: 'Claude Sonnet 4',
-            providerLabel: 'Anthropic',
-            thinkingCapability: null,
-          },
-          {
-            value: 'openai/gpt-5',
-            modelLabel: 'GPT-5',
-            providerLabel: 'OpenAI',
-            thinkingCapability: null,
-          },
-        ],
-        selectedModel: 'anthropic/claude-sonnet-4',
-        selectedThinkingLevel: null,
-      }
-    }));
-    const sync = new ChatSessionPreferenceSync(updateNcpSession);
-
-    sync.syncInputSelection({
-      selectedSessionKey: 'session-2',
-      selectedSessionExists: false,
-      fallbackPreferredModel: 'anthropic/claude-sonnet-4',
-    });
-    expect(useChatInputStore.getState().snapshot.selectedModel).toBe(
-      'anthropic/claude-sonnet-4',
-    );
-
-    sync.syncInputSelection({
-      selectedSessionKey: 'session-2',
-      selectedSessionExists: true,
-      selectedSessionPreferredModel: 'openai/gpt-5',
-      selectedSessionPreferredThinking: null,
-      fallbackPreferredModel: 'anthropic/claude-sonnet-4',
-    });
-
-    expect(useChatInputStore.getState().snapshot.selectedModel).toBe('openai/gpt-5');
-  });
-});