Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

44.5 KB
Raw Blame
// @vitest-environment jsdom

/**
 * modelSelectorProviderGroups.test.tsx
 * ---------------------------------------------------------------------------
 * 验证模型选择器按供应商分组渲染:
 *   1. 两个供应商分别显示自己的分组标题
 *   2. 每个模型出现在正确的供应商下
 *   3. flat 模式(不传 onProviderChange)不显示供应商标题
 *   4. 分割线只出现在组间,不出现在第一组之前
 *   5. 长供应商名称不撑破弹层(truncate)
 */

import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
import React from 'react';
import { beforeEach, describe, expect, it, vi } from 'vitest';

// The shared-quota rail observes auth; this component fixture has no auth host.
vi.mock('@/contexts/AuthContext', () => ({ useOptionalAuthUser: () => null }));

vi.mock('react-i18next', async (importOriginal) => ({
  ...(await importOriginal<typeof import('react-i18next')>()),
  useTranslation: () => ({
    t: (key: string, options?: Record<string, string>) => {
      const translations: Record<string, string> = {
        'settings.providers.anthropic.title': 'Anthropic',
        'settings.providers.xd.title': 'Cindy AI',
        'settings.providers.xd.accountTier.free': '免费版',
        'newChat.modelSelector.trigger.placeholder': '选择模型',
        'newChat.modelSelector.trigger.loading': '正在读取模型…',
        'newChat.modelSelector.trigger.unresolved': '模型信息暂不可用',
        'newChat.modelSelector.trigger.aria': `Select model. Current: ${options?.model ?? ''}`,
        'newChat.modelSelector.trigger.ariaWithEffort': `Select model. Current: ${options?.model ?? ''}, effort: ${options?.effort ?? ''}`,
        'newChat.modelSelector.modelListAria': '模型列表',
        'newChat.modelSelector.search.noResults': '无匹配模型',
        'newChat.modelSelector.pricing.free': '限时免费',
        'newChat.modelSelector.source.disconnected': '已断开',
        'newChat.modelSelector.trigger.agent.claudeCode': 'Claude Code',
        'newChat.modelSelector.trigger.agent.codex': 'Codex',
        'newChat.modelSelector.trigger.currentAndNext': `${options?.current} → ${options?.next}`,
        'effortLevels.high': '最高',
      };
      return translations[key] ?? options?.defaultValue ?? key;
    },
  }),
}));

const floatingUiMocks = vi.hoisted(() => {
  const limitShiftResult = { fn: () => ({ x: 0, y: 0 }), options: {} };
  return {
    autoUpdate: vi.fn(() => () => {}),
    flip: vi.fn((options: unknown) => ({ name: 'flip', options })),
    limitShift: vi.fn(() => limitShiftResult),
    limitShiftResult,
    offset: vi.fn((options: unknown) => ({ name: 'offset', options })),
    shift: vi.fn((options: unknown) => ({ name: 'shift', options })),
    size: vi.fn((options: unknown) => ({ name: 'size', options })),
    useFloating: vi.fn(),
  };
});

vi.mock('@floating-ui/react-dom', () => ({
  autoUpdate: floatingUiMocks.autoUpdate,
  flip: floatingUiMocks.flip,
  limitShift: floatingUiMocks.limitShift,
  offset: floatingUiMocks.offset,
  shift: floatingUiMocks.shift,
  size: floatingUiMocks.size,
  useFloating: (options: unknown) => {
    floatingUiMocks.useFloating(options);
    return {
      refs: { setFloating: () => {} },
      floatingStyles: { position: 'fixed', left: 120, top: 24 },
      isPositioned: true,
      placement: 'left',
    };
  },
}));

vi.mock('@/components/ui/popover', async () => {
  const React = await import('react');
  const OpenContext = React.createContext<{
    open: boolean;
    onOpenChange?: (open: boolean) => void;
  }>({ open: true });
  return {
    Popover: ({
      children,
      open,
      onOpenChange,
    }: {
      children: React.ReactNode;
      open?: boolean;
      onOpenChange?: (open: boolean) => void;
    }) =>
      React.createElement(
        OpenContext.Provider,
        { value: { open: open ?? true, onOpenChange } },
        children,
      ),
    PopoverTrigger: ({ children }: { children: React.ReactNode }) => {
      const state = React.useContext(OpenContext);
      const child = children as React.ReactElement<{ onClick?: React.MouseEventHandler }>;
      return React.cloneElement(child, {
        onClick: (event: React.MouseEvent) => {
          child.props.onClick?.(event);
          state.onOpenChange?.(!state.open);
        },
      });
    },
    PopoverAnchor: ({ children }: { children: React.ReactNode }) => children,
    PopoverContent: React.forwardRef<
      HTMLDivElement,
      {
        children: React.ReactNode;
        className?: string;
        collisionPadding?:
          | number
          | {
              top?: number;
              right?: number;
              bottom?: number;
              left?: number;
            };
      }
    >(({ children, className, collisionPadding }, ref) => {
      const state = React.useContext(OpenContext);
      const collisionPaddingTop =
        typeof collisionPadding === 'number' ? collisionPadding : collisionPadding?.top;
      return state.open
        ? React.createElement(
            'div',
            {
              ref,
              'data-testid': 'model-options-popover',
              'data-collision-padding-top': collisionPaddingTop,
              className,
            },
            children,
          )
        : null;
    }),
  };
});

vi.mock('@/lib/scrollbarAutoHide', () => ({ flashScrollbar: vi.fn() }));

vi.mock('@/hooks/useAgentCapabilities', () => ({
  evictDeviceCapabilities: vi.fn(),
  prefetchDeviceCapabilities: vi.fn(async () => {}),
  useAgentCapabilities: () => ({ capabilities: null, loading: false, error: null }),
}));

vi.mock('@/hooks/useApiKey', () => ({
  useApiKey: () => ({ hasSavedKey: true }),
}));

vi.mock('@/hooks/useConnectedSource', () => ({
  useConnectedSource: () => ({ hasConnectedSource: true, loading: false }),
}));

vi.mock('@/hooks/useModelPricing', () => ({
  useGatewayModelPricing: () => ({}),
  useReferenceModelPricing: () => ({}),
}));

const modelAccessState = vi.hoisted(() => ({
  accountTier: null as 'free' | 'paid' | 'not_applicable' | null,
}));
vi.mock('@/hooks/useModelAccessStatus', () => ({
  useModelAccessStatus: () => ({
    state: 'ok',
    source: 'server',
    endpoint: 'https://gateway.example.com',
    accountTier: modelAccessState.accountTier,
  }),
}));

const providersRef = vi.hoisted(() => {
  const DEFAULT_PROVIDERS = [
    {
      id: 'anthropic',
      name: 'Anthropic',
      source: 'builtin',
      agents: ['claude-code'],
      auth: { method: 'oauth' },
      routing: { 'claude-code': {} },
      connected: true,
      models: {
        'claude-code': [
          {
            id: 'claude-opus-4-8',
            name: 'Opus 4.8',
            contextWindow: 200000,
            efforts: ['low', 'medium', 'high'],
            defaultEffort: 'high',
          },
          {
            id: 'claude-sonnet-4-6',
            name: 'Sonnet 4.6',
            contextWindow: 200000,
            efforts: ['low', 'medium', 'high'],
            defaultEffort: 'medium',
          },
        ],
      },
    },
    {
      id: 'custom-dashscope',
      name: '阿里云百炼',
      source: 'user',
      agents: ['claude-code'],
      auth: { method: 'api-key' },
      routing: { 'claude-code': {} },
      connected: true,
      models: {
        'claude-code': [
          {
            id: 'qwen3.7-plus',
            name: 'qwen3.7-plus',
            contextWindow: 131072,
            efforts: ['low', 'medium', 'high'],
            defaultEffort: 'medium',
          },
        ],
      },
    },
  ] as unknown[];
  return { DEFAULT_PROVIDERS, providers: DEFAULT_PROVIDERS, loading: false, loadFailed: false,
    error: null as { reason: 'legacy-busy' } | null, refetch: vi.fn(async () => true) };
});
vi.mock('@/hooks/useProviders', () => ({
  useProviders: () => ({ providers: providersRef.providers, providerOrder: [],
    loading: providersRef.loading, loadFailed: providersRef.loadFailed, error: providersRef.error, refetch: providersRef.refetch }),
}));

vi.mock('@/hooks/useDeviceProviders', () => ({
  evictDeviceProviders: vi.fn(),
  prefetchDeviceProviders: vi.fn(async () => {}),
  useDeviceProviders: () => ({
    providers: [],
    loading: false,
    error: null,
    unsupported: false,
  }),
}));

// selectVisibleModels 只喂 trigger 的 currentModel(分组列表另有来源),既有用例一律按
// 空清单跑 —— trigger 显示占位符。pill 形态的用例需要一个**真实模型名 + 档位**才能验,
// 故走 hoisted ref 逐用例开洞,默认值不动,既有用例行为逐字节不变。
const visibleModelsRef = vi.hoisted(() => ({ models: [] as unknown[] }));
vi.mock('@/lib/providerModels', () => ({
  providerMonogram: (name: string) => name.slice(0, 1).toUpperCase(),
  isLocalOnlyProviderForAgent: () => false,
  filterChatBridgedCodexProviders: (providers: unknown[]) => providers,
  resolveVisibleModelAgentKind: ({ agentKind }: { agentKind: string | null }) =>
    agentKind ?? 'claude-code',
  selectVisibleModels: () => visibleModelsRef.models,
}));

vi.mock('@/state/modelVisibilityPrefs', () => ({
  isModelEnabled: () => true,
  useModelVisibilityVersion: () => 0,
}));

vi.mock('@/state/providerModelMemory', () => ({
  useProviderModelMemoryVersion: () => 0,
}));

vi.mock('@/state/deviceLinkModelMirror', () => ({
  useDeviceLinkModelMirrorVersion: () => 0,
}));

import { ModelSelector } from '@/components/new-chat/ModelSelector';

const requestProviderModelsAutoRefresh = vi.fn(async () => ({ ok: true as const }));

beforeEach(() => {
  requestProviderModelsAutoRefresh.mockClear();
  floatingUiMocks.autoUpdate.mockClear();
  floatingUiMocks.flip.mockClear();
  floatingUiMocks.limitShift.mockClear();
  floatingUiMocks.offset.mockClear();
  floatingUiMocks.shift.mockClear();
  floatingUiMocks.size.mockClear();
  floatingUiMocks.useFloating.mockClear();
  providersRef.providers = providersRef.DEFAULT_PROVIDERS;
  providersRef.loading = false;
  providersRef.loadFailed = false;
  providersRef.error = null;
  providersRef.refetch.mockClear();
  modelAccessState.accountTier = null;
  visibleModelsRef.models = [];
  (window as unknown as { electronAPI: unknown }).electronAPI = {
    maker: { requestProviderModelsAutoRefresh },
  };
});

function renderSelector(props: Partial<React.ComponentProps<typeof ModelSelector>> = {}) {
  return render(
    React.createElement(ModelSelector, {
      // Compatibility renderer for capabilities-only remote hosts.
      unifiedPanel: false,
      modelId: 'claude-opus-4-8',
      effort: 'high',
      onModelChange: vi.fn(),
      onEffortChange: vi.fn(),
      vendorKey: 'cc',
      currentProviderId: 'anthropic',
      onProviderChange: vi.fn(),
      ...props,
    }),
  );
}

async function openDropdown(): Promise<void> {
  await act(async () => {
    fireEvent.click(screen.getByRole('button', { name: /Select model/ }));
  });
}

describe('model selector display identity during switches', () => {
  const props = {
    unifiedPanel: false,
    modelId: 'chatgpt/gpt-6',
    effort: 'high',
    vendorKey: 'codex' as const,
    currentProviderId: 'openai',
    actualRoute: true,
    onModelChange: vi.fn(),
    onEffortChange: vi.fn(),
  };
  const provider = {
    id: 'openai', name: 'OpenAI', source: 'builtin', agents: ['codex'],
    auth: { method: 'oauth' }, routing: { codex: {} }, connected: true,
    models: { codex: [{ id: 'gpt-6', name: 'GPT-6', efforts: ['high'] }] },
  };
  const trigger = () => screen.getByRole('button');

  it.each([false, true])('resolves implicit aliases using the eligible default source (session=%s)', (actualRoute) => {
    const gateway = { ...provider, id: 'xd', models: { codex: [{ id: 'gpt-6', name: 'Gateway GPT' }] } };
    providersRef.providers = [gateway, provider];
    const implicit = { ...props, currentProviderId: null, actualRoute };
    const { rerender } = render(<ModelSelector {...implicit} switching />);
    expect(trigger().textContent).toContain('GPT-6');
    expect(trigger().textContent).not.toContain('Gateway GPT');
    providersRef.providers = [gateway, { ...provider, connected: false }];
    rerender(<ModelSelector {...implicit} />);
    expect(trigger().textContent).toContain('Gateway GPT');
  });

  it.each([false, true])('preserves disabled-model eligibility for implicit sources (session=%s)', (actualRoute) => {
    const gateway = { ...provider, id: 'xd', models: { codex: [{ id: 'gpt-6', name: 'Gateway GPT' }] } };
    const disabled = { ...provider, models: { codex: [{ id: 'gpt-6', name: 'Saved GPT', disabled: true }] } };
    providersRef.providers = [gateway, disabled];
    render(<ModelSelector {...props} currentProviderId={null} actualRoute={actualRoute} />);
    expect(trigger().textContent).toContain(actualRoute ? 'Saved GPT' : 'Gateway GPT');
  });

  it('resolves an implicit current model in the pending tooltip', () => {
    providersRef.providers = [provider];
    render(<ModelSelector {...props} currentProviderId={null}
      agentIdentity={{ vendorKey: 'codex', state: 'pending' }}
      currentSelection={{ agentKind: 'codex', model: props.modelId, providerId: null, effort: 'high', fastMode: false }} />);
    expect(trigger().title).toContain('Codex · GPT-6 · OpenAI');
    expect(trigger().title).not.toContain(props.modelId);
  });

  it.each([false, true])('keeps the long-context product when choosing an implicit source (session=%s)', (actualRoute) => {
    providersRef.providers = [
      { ...provider, models: { codex: [{ id: 'glm-5.2', name: 'Standard GLM' }] } },
      { ...provider, id: 'xd', name: 'Gateway', models: { codex: [{ id: 'glm-5.2[1m]', name: 'GLM 1M' }] } },
    ];
    render(<ModelSelector {...props} modelId="glm-5.2[1m]" currentProviderId={null} actualRoute={actualRoute}
      agentIdentity={{ vendorKey: 'codex', state: 'pending' }}
      currentSelection={{ agentKind: 'codex', model: 'glm-5.2[1m]', providerId: null, effort: 'high', fastMode: false }} />);
    expect(trigger().textContent).toContain('GLM 1M');
    expect(trigger().title).toContain('Codex · GLM 1M · Cindy AI');
    expect(trigger().title).not.toContain('Standard GLM');
    expect(trigger().title).not.toContain('OpenAI');
  });

  it('resolves a wire alias immediately, including while the switch is in flight', () => {
    providersRef.providers = [provider];
    const { rerender } = render(<ModelSelector {...props} switching />);
    expect(trigger().textContent).toContain('GPT-6');
    expect(trigger().getAttribute('aria-label')).not.toContain(props.modelId);
    rerender(<ModelSelector {...props} switching={false} />);
    expect(trigger().textContent).toContain('GPT-6');
  });

  it('retains the selected name when discovery loses the catalog, then accepts updated names', () => {
    providersRef.providers = [provider];
    const { rerender } = render(<ModelSelector {...props} switching />);
    providersRef.providers = [];
    rerender(<ModelSelector {...props} switching sourceDisconnected />);
    expect(trigger().textContent).toContain('GPT-6');
    expect(trigger().textContent).not.toContain(props.modelId);
    // A failed switch/refresh must not leave the wire ID behind once in-flight ends.
    rerender(<ModelSelector {...props} sourceDisconnected />);
    expect(trigger().textContent).toContain('GPT-6');
    expect(trigger().textContent).toContain('已断开');
    providersRef.providers = [{ ...provider, models: { codex: [{ id: 'gpt-6', name: 'Custom GPT label' }] } }];
    rerender(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('Custom GPT label');
  });

  it.each([
    { modelId: 'chatgpt/unknown-model' },
    { currentProviderId: 'another-account' },
    { vendorKey: 'pi' as const },
    { deviceId: 'another-device' },
  ])('does not reuse the previous name across a selection boundary: %j', (change) => {
    providersRef.providers = [provider];
    const { rerender } = render(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('GPT-6');
    providersRef.providers = [];
    rerender(<ModelSelector {...props} {...change} />);
    expect(trigger().textContent).not.toContain('GPT-6');
    expect(trigger().textContent).not.toContain(change.modelId ?? props.modelId);
  });

  it.each([false, true])('distinguishes an unknown saved model from an empty selection (disconnected=%s)', (sourceDisconnected) => {
    providersRef.providers = [];
    render(<ModelSelector {...props} sourceDisconnected={sourceDisconnected} />);
    expect(trigger().textContent).toContain('模型信息暂不可用');
    expect(trigger().textContent).not.toContain('选择模型');
    expect(trigger().textContent).not.toContain(props.modelId);
    expect(trigger().getAttribute('title')).not.toContain(props.modelId);
    expect(trigger().getAttribute('aria-label')).not.toContain(props.modelId);
  });

  it('shows loading for a selected model until its catalog arrives, and keeps the name through refresh', () => {
    providersRef.providers = [];
    providersRef.loading = true;
    const { rerender } = render(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('正在读取模型…');
    providersRef.providers = [provider];
    providersRef.loading = false;
    rerender(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('GPT-6');
    providersRef.providers = [];
    providersRef.loading = true;
    rerender(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('GPT-6');
    expect(trigger().textContent).not.toContain('正在读取模型…');
  });

  it('still prompts for a model when there is no selection', () => {
    render(<ModelSelector {...props} modelId="" />);
    expect(trigger().textContent).toContain('选择模型');
  });

  it('settles a failed first catalog load, then recovers through retry without clearing the selection', () => {
    providersRef.providers = [];
    providersRef.loading = true;
    const { rerender } = render(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('正在读取模型…');

    providersRef.loadFailed = true;
    rerender(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('模型信息暂不可用');
    expect(trigger().textContent).not.toContain('正在读取模型…');
    expect(trigger().textContent).not.toContain('选择模型');

    providersRef.loadFailed = false;
    rerender(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('正在读取模型…');
    providersRef.providers = [provider];
    providersRef.loading = false;
    rerender(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('GPT-6');

    providersRef.providers = [];
    providersRef.loadFailed = true;
    rerender(<ModelSelector {...props} />);
    expect(trigger().textContent).toContain('GPT-6');
  });

  it('preserves an explicitly supplied diagnostic label', () => {
    providersRef.providers = [];
    render(<ModelSelector {...props} unknownModelLabel={() => 'Unavailable saved model'} sourceDisconnected />);
    expect(trigger().textContent).toContain('Unavailable saved model');
  });

  it('uses display names in the pending selection tooltip and accessibility label', () => {
    providersRef.providers = [provider];
    const pendingProps = {
      ...props,
      agentIdentity: { vendorKey: 'codex' as const, state: 'pending' as const },
      currentSelection: { agentKind: 'codex' as const, model: 'chatgpt/missing', providerId: 'openai', effort: 'high', fastMode: false },
    };
    const { rerender } = render(<ModelSelector {...pendingProps} />);
    providersRef.providers = [];
    rerender(<ModelSelector {...pendingProps} />);
    for (const attribute of ['title', 'aria-label']) {
      expect(trigger().getAttribute(attribute)).toContain('GPT-6');
      expect(trigger().getAttribute(attribute)).toContain('选择模型');
      expect(trigger().getAttribute(attribute)).not.toContain('chatgpt/');
    }
  });
});

type FloatingOptions = {
  strategy: string;
  placement: string;
  transform: boolean;
  open: boolean;
  elements: { reference: HTMLElement };
  whileElementsMounted: (
    reference: HTMLElement,
    floating: HTMLElement,
    update: () => void,
  ) => () => void;
};

function floatingOptionsForReference(reference: HTMLElement): FloatingOptions {
  // React/Floating UI 可能因并发重渲染产生多次调用;按「当前连接锚点 + open」取值,
  // 守护实际生效的浮层,而不是把调用顺序误当成契约。
  const options = floatingUiMocks.useFloating.mock.calls
    .map(([call]) => call as FloatingOptions)
    .findLast((call) => call.open && call.elements?.reference === reference);
  expect(options).toBeDefined();
  if (!options) throw new Error('Floating UI options for the active model row were not found');
  return options;
}

function sizeOptionsForFloatingPanel(): {
  apply: (args: { elements: { floating: HTMLElement }; availableHeight: number }) => void;
} {
  // size middleware 的行为由其稳定参数和 apply 回调表达;匹配参数可避开其它渲染留下的调用。
  const options = floatingUiMocks.size.mock.calls
    .map(
      ([call]) =>
        call as {
          padding?: number;
          boundary?: Element[];
          altBoundary?: boolean;
          apply?: (args: { elements: { floating: HTMLElement }; availableHeight: number }) => void;
        },
    )
    .findLast(
      (call) =>
        call.padding === 8 &&
        Array.isArray(call.boundary) &&
        call.boundary.length === 0 &&
        call.altBoundary === false &&
        typeof call.apply === 'function',
    );
  expect(options).toBeDefined();
  if (!options?.apply) throw new Error('Floating UI size middleware was not configured');
  return { apply: options.apply };
}

async function openModelOptionsPanel(row: HTMLElement): Promise<void> {
  await act(async () => {
    // ArrowLeft 是模型行公开支持的配置入口;调用前由用例等待 MorphPopover 的 settle 焦点,
    // 避免把异步焦点交接顺序误当成浮层锚点契约。
    fireEvent.keyDown(row, { key: 'ArrowLeft' });
  });
}

async function waitForSearchInputFocus(): Promise<HTMLElement> {
  const searchInput = screen.getByRole('textbox');
  // MorphPopover settle 后才把焦点交给搜索框;先等这个最终状态,避免后续 ArrowLeft
  // reveal 与尚未完成的焦点交接竞态。
  await waitFor(() => expect(document.activeElement).toBe(searchInput));
  return searchInput;
}

describe('ModelSelector provider groups', () => {
  it.each([false, true])('offers recovery instead of an empty local catalog (unified=%s)', async (unifiedPanel) => {
    providersRef.providers = [];
    providersRef.loading = true;
    providersRef.error = { reason: 'legacy-busy' };
    renderSelector({ unifiedPanel });
    await openDropdown();
    expect(screen.getByRole('status').textContent).toContain('catalogRecovery.legacy');
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'settings.providers.catalogRecovery.retry' }));
    });
    expect(providersRef.refetch).toHaveBeenCalledOnce();
  });

  it('retains the usable local list when a subsequent refresh fails', async () => {
    providersRef.error = { reason: 'legacy-busy' };
    renderSelector();
    await openDropdown();
    expect(screen.getByRole('status').textContent).toContain('catalogRecovery.legacy');
    expect(screen.getAllByRole('option').length).toBeGreaterThan(0);
  });

  it('keeps classic-picker recovery visible when the snapshot has no connected source for the current engine', async () => {
    providersRef.providers = [{
      id: 'gemini', name: 'Gemini', source: 'builtin', connected: true,
      agents: [], models: {}, auth: { method: 'api-key' },
    }];
    providersRef.error = { reason: 'legacy-busy' };
    renderSelector({ onNavigateToProviders: vi.fn() });
    await openDropdown();
    expect(screen.getByRole('status').textContent).toContain('catalogRecovery.legacy');
    expect(screen.getByRole('button', { name: 'newChat.modelSelector.source.connectCta' })).toBeTruthy();
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'settings.providers.catalogRecovery.retry' }));
    });
    expect(providersRef.refetch).toHaveBeenCalledOnce();
  });

  it('never presents the local recovery action in a remote device picker', async () => {
    providersRef.loading = true;
    providersRef.error = { reason: 'legacy-busy' };
    renderSelector({ deviceId: 'remote-device' });
    await openDropdown();
    expect(screen.queryByText('settings.providers.catalogRecovery.legacy')).toBeNull();
    expect(screen.queryByRole('button', { name: 'settings.providers.catalogRecovery.retry' })).toBeNull();
  });

  it('offers source navigation with only a connected media provider and no chat candidates', async () => {
    providersRef.providers = [{
      id: 'gemini', name: 'Gemini', source: 'builtin', connected: true,
      agents: [], models: {}, auth: { method: 'api-key' },
    }];
    const onNavigateToProviders = vi.fn();
    renderSelector({
      unifiedPanel: true, unifiedAgents: ['pi', 'codex'],
      vendorKey: 'pi', modelId: '', currentProviderId: null,
      onProviderChange: undefined, onUnifiedSelect: vi.fn(), onNavigateToProviders,
    });
    await openDropdown();
    fireEvent.click(screen.getByRole('button', { name: 'newChat.modelSelector.source.connect' }));
    expect(onNavigateToProviders).toHaveBeenCalledOnce();
  });

  it('仅在本机经典 Cindy AI 分组旁显示免费版标签', async () => {
    providersRef.providers = [
      ...(providersRef.DEFAULT_PROVIDERS as unknown[]),
      {
        id: 'xd',
        name: 'Cindy AI',
        source: 'builtin',
        agents: ['claude-code'],
        auth: { method: 'apiKey' },
        routing: { 'claude-code': {} },
        connected: true,
        models: {
          'claude-code': [
            {
              id: 'cindy-free-model',
              name: 'Cindy Free Model',
              contextWindow: 200000,
              efforts: ['high'],
              defaultEffort: 'high',
            },
          ],
        },
      },
    ] as unknown[];
    modelAccessState.accountTier = 'free';

    const view = renderSelector();
    await openDropdown();
    const badge = screen.getByTestId('cindy-ai-model-group-free-tier-badge');
    expect(badge.textContent).toBe('免费版');
    expect(badge.classList.contains('ml-auto')).toBe(true);

    view.unmount();
    modelAccessState.accountTier = 'paid';
    const paidView = renderSelector();
    await openDropdown();
    expect(screen.queryByTestId('cindy-ai-model-group-free-tier-badge')).toBeNull();

    paidView.unmount();
    modelAccessState.accountTier = 'not_applicable';
    renderSelector();
    await openDropdown();
    expect(screen.queryByTestId('cindy-ai-model-group-free-tier-badge')).toBeNull();
  });

  it('renders a group heading for each provider', async () => {
    renderSelector();
    await openDropdown();
    const popover = screen.getByTestId('model-options-popover');
    const groups = within(popover).getAllByRole('group');
    expect(groups).toHaveLength(2);
    expect(within(groups[0]).getByText('Anthropic')).toBeTruthy();
    expect(within(groups[1]).getByText('阿里云百炼')).toBeTruthy();
  });

  it('places each model under the correct provider group', async () => {
    renderSelector();
    await openDropdown();
    const popover = screen.getByTestId('model-options-popover');
    const groups = within(popover).getAllByRole('group');
    const anthropicGroup = groups[0];
    const dashscopeGroup = groups[1];
    expect(within(anthropicGroup).getByText('Opus 4.8')).toBeTruthy();
    expect(within(anthropicGroup).getByText('Sonnet 4.6')).toBeTruthy();
    expect(within(dashscopeGroup).getByText('qwen3.7-plus')).toBeTruthy();
    expect(within(dashscopeGroup).queryByText('Opus 4.8')).toBeNull();
  });

  it('hides effort summaries when the entry only supports selecting a model id', async () => {
    renderSelector({ configurationEnabled: false });
    await openDropdown();

    const popover = screen.getByTestId('model-options-popover');
    expect(within(popover).queryByTitle('high')).toBeNull();
    expect(within(popover).queryByTitle('medium')).toBeNull();
  });

  it('keeps the create-agent secondary panel at the original left/center position with layout coordinates', async () => {
    renderSelector({ visualVariant: 'create-agent', useMorphPopover: true });
    await openDropdown();
    await waitForSearchInputFocus();

    const modelList = screen.getByRole('listbox', { name: '模型列表' });
    const row = within(modelList).getByRole('option', { name: /Opus 4\.8/ });
    await openModelOptionsPanel(row);

    const secondaryPanel = await screen.findByTestId('model-options-floating-panel');
    const positioner = secondaryPanel.closest<HTMLElement>('[data-radix-popper-content-wrapper]');
    expect(positioner).not.toBeNull();
    expect(positioner?.parentElement).toBe(document.body);
    expect(positioner?.style.position).toBe('fixed');
    expect(positioner?.style.left).toBe('120px');
    expect(positioner?.style.top).toBe('24px');
    // Electron app-region 依赖布局矩形,定位层不能通过 translate 重新定位;这里只守护
    // no-translate 行为,不锁定 jsdom 对空 transform 的具体序列化。
    expect(positioner?.style.transform ?? '').not.toMatch(/translate/);
    expect(
      (positioner?.style as CSSStyleDeclaration & { WebkitAppRegion: string }).WebkitAppRegion,
    ).toBe('no-drag');
    expect(secondaryPanel.className).toContain('overflow-hidden');
    expect(secondaryPanel.className).not.toContain('max-h-[');
    expect(secondaryPanel.className).not.toContain('overflow-y-auto');

    const floatingOptions = floatingOptionsForReference(row);
    expect(floatingOptions).toMatchObject({
      strategy: 'fixed',
      placement: 'left',
      transform: false,
      open: true,
    });
    expect(floatingOptions.elements.reference).toBe(row);
    const floatingElement = document.createElement('div');
    const cleanup = floatingOptions.whileElementsMounted(row, floatingElement, vi.fn());
    // autoUpdate 必须绑定当前行与浮层元素;按参数匹配,避免其它重渲染的调用顺序影响断言。
    const autoUpdateCall = floatingUiMocks.autoUpdate.mock.calls.findLast(
      (call: unknown[]) => call[0] === row && call[1] === floatingElement,
    );
    expect(autoUpdateCall).toEqual([
      row,
      floatingElement,
      expect.any(Function),
      { animationFrame: false },
    ]);
    cleanup();

    // middleware 参数保留左侧贴边、碰撞留白和可用高度回归;按参数匹配而非取最后调用,
    // 避免 React 并发重渲染改变 mock 调用顺序。
    const offsetOptions = floatingUiMocks.offset.mock.calls
      .map(([call]) => call)
      .findLast(
        (call) =>
          (call as { mainAxis?: number; alignmentAxis?: number })?.mainAxis === 8 &&
          (call as { mainAxis?: number; alignmentAxis?: number })?.alignmentAxis === 0,
      );
    expect(offsetOptions).toEqual({ mainAxis: 8, alignmentAxis: 0 });
    const shiftOptions = floatingUiMocks.shift.mock.calls
      .map(([call]) => call)
      .findLast(
        (call) =>
          (call as { mainAxis?: boolean; crossAxis?: boolean; padding?: number })?.mainAxis ===
            true &&
          (call as { mainAxis?: boolean; crossAxis?: boolean; padding?: number })?.crossAxis ===
            false &&
          (call as { mainAxis?: boolean; crossAxis?: boolean; padding?: number })?.padding === 8,
      );
    expect(shiftOptions).toEqual(
      expect.objectContaining({
        mainAxis: true,
        crossAxis: false,
        limiter: floatingUiMocks.limitShiftResult,
        padding: 8,
        boundary: [],
        altBoundary: false,
      }),
    );
    const flipOptions = floatingUiMocks.flip.mock.calls
      .map(([call]) => call)
      .findLast(
        (call) =>
          (call as { padding?: number; boundary?: Element[]; altBoundary?: boolean })?.padding ===
            8 &&
          Array.isArray(
            (call as { padding?: number; boundary?: Element[]; altBoundary?: boolean })?.boundary,
          ) &&
          (call as { padding?: number; boundary?: Element[]; altBoundary?: boolean })?.boundary
            ?.length === 0 &&
          (call as { padding?: number; boundary?: Element[]; altBoundary?: boolean })
            ?.altBoundary === false,
      );
    expect(flipOptions).toEqual({ padding: 8, boundary: [], altBoundary: false });
    const sizeOptions = sizeOptionsForFloatingPanel();
    sizeOptions.apply({ elements: { floating: floatingElement }, availableHeight: 180 });
    expect(floatingElement.style.getPropertyValue('--radix-popover-content-available-height')).toBe(
      '180px',
    );

    const panelOptions = within(secondaryPanel).getAllByRole('option');
    const firstPanelOption = panelOptions[0];
    const lastPanelOption = panelOptions.at(-1);
    expect(lastPanelOption).toBeDefined();
    lastPanelOption?.focus();
    fireEvent.keyDown(lastPanelOption as HTMLElement, { key: 'Tab' });
    expect(document.activeElement).toBe(firstPanelOption);
    fireEvent.keyDown(firstPanelOption, { key: 'Tab', shiftKey: true });
    expect(document.activeElement).toBe(lastPanelOption);

    fireEvent.keyDown(row, { key: 'Escape' });
    // Escape 关闭的是行级浮层,一级模型列表仍保持打开;等待两个最终 DOM 状态而非依赖
    // keydown 后 React 同步 flush 的具体顺序。
    await waitFor(() => {
      expect(screen.queryByTestId('model-options-floating-panel')).toBeNull();
      expect(screen.getByRole('listbox', { name: '模型列表' })).toBeTruthy();
    });
  });

  it('refreshes the create-agent floating anchor after search remounts the active model row', async () => {
    renderSelector({ visualVariant: 'create-agent', useMorphPopover: true });
    await openDropdown();

    const searchInput = await waitForSearchInputFocus();

    const modelList = screen.getByRole('listbox', { name: '模型列表' });
    const originalRow = within(modelList).getByRole('option', { name: /Opus 4\.8/ });
    await openModelOptionsPanel(originalRow);
    await screen.findByTestId('model-options-floating-panel');

    const originalFloatingOptions = floatingOptionsForReference(originalRow);
    expect(originalFloatingOptions.elements.reference).toBe(originalRow);

    await act(async () => {
      fireEvent.change(searchInput, { target: { value: 'qwen' } });
    });
    // 搜索过滤会卸载旧行,行级浮层必须随之关闭,不能继续引用 detached DOM;这是行为契约,
    // 不依赖 useFloating 的渲染/调用次数。
    await waitFor(() => {
      expect(originalRow.isConnected).toBe(false);
      expect(screen.queryByTestId('model-options-floating-panel')).toBeNull();
    });

    await act(async () => {
      fireEvent.change(searchInput, { target: { value: '' } });
    });
    // 清空搜索会重新挂载新行,但旧 editing 状态不能让浮层自动复活或把新行误标 active。
    await waitFor(() => {
      const restoredRow = within(modelList).getByRole('option', { name: /Opus 4\.8/ });
      expect(restoredRow).not.toBe(originalRow);
      expect(restoredRow.getAttribute('data-model-options-active')).toBeNull();
      expect(screen.queryByTestId('model-options-floating-panel')).toBeNull();
    });
    const restoredRow = within(modelList).getByRole('option', { name: /Opus 4\.8/ });

    await openModelOptionsPanel(restoredRow);
    await screen.findByTestId('model-options-floating-panel');

    const restoredFloatingOptions = floatingOptionsForReference(restoredRow);
    expect(restoredFloatingOptions.elements.reference).toBe(restoredRow);
    expect(restoredFloatingOptions.elements.reference.isConnected).toBe(true);
  });

  it('keeps the existing Radix secondary popover outside the create-agent variant', async () => {
    renderSelector();
    await openDropdown();

    const popover = screen.getByTestId('model-options-popover');
    const row = within(popover).getByRole('option', { name: /Opus 4\.8/ });
    await act(async () => {
      fireEvent.pointerEnter(row);
    });

    const details = screen.getByRole('group', { name: /Opus 4\.8/ });
    const secondaryPanel = details.closest('[data-testid="model-options-popover"]');
    expect(secondaryPanel?.getAttribute('data-collision-padding-top')).toBe('8');
    expect(screen.queryByTestId('model-options-floating-panel')).toBeNull();
  });

  it('does not mark another account selected when the stored source is disconnected', async () => {
    const modelId = 'claude-fable-5';
    const model = {
      id: modelId,
      name: 'Fable 5',
      contextWindow: 200000,
      efforts: ['low', 'medium', 'high'],
      defaultEffort: 'high',
    };
    providersRef.providers = [
      {
        id: 'anthropic',
        name: 'Anthropic',
        source: 'builtin',
        agents: ['claude-code'],
        auth: { method: 'oauth' },
        routing: { 'claude-code': {} },
        connected: false,
        models: { 'claude-code': [model] },
      },
      {
        id: 'xd',
        name: 'Cindy AI',
        source: 'builtin',
        agents: ['claude-code'],
        auth: { method: 'api-key' },
        routing: { 'claude-code': {} },
        connected: true,
        models: { 'claude-code': [model] },
      },
    ] as unknown[];
    const onProviderChange = vi.fn();

    renderSelector({
      modelId,
      effort: 'high',
      currentProviderId: 'anthropic',
      sourceDisconnected: true,
      reselectEmitsChange: true,
      selectedRowClickOpensConfiguration: true,
      onProviderChange,
    });
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: /已断开/ }));
    });

    const popover = screen.getByTestId('model-options-popover');
    const xdGroup = within(popover).getByRole('group', { name: 'Cindy AI' });
    const fallbackRow = within(xdGroup).getByRole('option', { name: /Fable 5/ });
    expect(fallbackRow.getAttribute('aria-selected')).toBe('false');

    fireEvent.click(fallbackRow);
    expect(onProviderChange).toHaveBeenCalledWith('xd', modelId, 'high');
    // This is a new account selection, not a click on the currently selected row.
    expect(screen.queryByRole('group', { name: /Fable 5/ })).toBeNull();
  });

  it('opens a selected provider configuration without persisting its derived effort', async () => {
    const onProviderChange = vi.fn();
    renderSelector({
      reselectEmitsChange: true,
      selectedRowClickOpensConfiguration: true,
      onProviderChange,
    });
    await openDropdown();

    fireEvent.click(screen.getByRole('option', { name: /Opus 4\.8/ }));

    expect(onProviderChange).not.toHaveBeenCalled();
    expect(screen.getByRole('group', { name: /Opus 4\.8/ })).toBeTruthy();
  });

  it('returns the target provider effort for the same model id', async () => {
    const modelId = 'shared-model';
    const anthropicModel = {
      id: modelId,
      name: 'Shared Model',
      contextWindow: 200000,
      efforts: ['low', 'high'],
      defaultEffort: 'high',
    };
    const xdModel = {
      ...anthropicModel,
      efforts: ['low'],
      defaultEffort: 'low',
    };
    providersRef.providers = [
      {
        ...(providersRef.DEFAULT_PROVIDERS[0] as Record<string, unknown>),
        models: { 'claude-code': [anthropicModel] },
      },
      {
        id: 'xd',
        name: 'Cindy AI',
        source: 'builtin',
        agents: ['claude-code'],
        auth: { method: 'api-key' },
        routing: { 'claude-code': {} },
        connected: true,
        models: { 'claude-code': [xdModel] },
      },
    ] as unknown[];
    const onProviderChange = vi.fn();

    try {
      renderSelector({ modelId, effort: 'high', currentProviderId: 'anthropic', onProviderChange });
      await openDropdown();
      const xdGroup = within(screen.getByTestId('model-options-popover')).getByRole('group', {
        name: 'Cindy AI',
      });
      fireEvent.click(within(xdGroup).getByRole('option', { name: /Shared Model/ }));
      expect(onProviderChange).toHaveBeenCalledWith('xd', modelId, 'low');
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('does not render group headings in flat mode (no onProviderChange)', async () => {
    renderSelector({ currentProviderId: undefined, onProviderChange: undefined });
    await openDropdown();
    const popover = screen.getByTestId('model-options-popover');
    expect(within(popover).queryAllByRole('group')).toHaveLength(0);
  });

  it('renders separator between groups but not before the first', async () => {
    renderSelector();
    await openDropdown();
    const popover = screen.getByTestId('model-options-popover');
    const groups = within(popover).getAllByRole('group');
    expect(groups).toHaveLength(2);
    const firstGroupSeparators = groups[0].querySelectorAll('[class*="h-px"]');
    expect(firstGroupSeparators).toHaveLength(0);
  });

  it('truncates long provider names', async () => {
    providersRef.providers = [
      {
        id: 'long-name-provider',
        name: 'A Very Long Provider Name That Should Definitely Be Truncated In The Dropdown',
        source: 'user',
        agents: ['claude-code'],
        auth: { method: 'api-key' },
        routing: { 'claude-code': {} },
        connected: true,
        models: {
          'claude-code': [
            {
              id: 'some-model',
              name: 'Some Model',
              contextWindow: 100000,
              efforts: [],
              defaultEffort: null,
            },
          ],
        },
      },
    ] as unknown[];
    renderSelector({ modelId: 'some-model', currentProviderId: 'long-name-provider' });
    await openDropdown();
    const popover = screen.getByTestId('model-options-popover');
    const heading = within(popover).getByText(/A Very Long Provider Name/);
    expect(heading.className).toContain('truncate');
  });
});

/**
 * composer pill 的引擎表达(model-selector-unified §1.1,Chris 2026-08-12 裁决 / bug7)。
 *
 * 旧形态把 harness 名字写成文本前缀:「Codex · GPT-5.6-Luna · 最高」—— 三段并列,
 * 用户第一眼读到的是 harness 而不是模型。新形态只在 composer 生效:模型名在前,
 * 引擎小标与深度档字挨在一起收尾;其余 7 个入口(scheduler / IM / Hook / Subagent /
 * Worker / GhostErrand / 设置)不传 engineMarkVendor,展示逐像素不变。
 */
describe('ModelSelector composer pill 引擎小标', () => {
  const triggerOf = (): HTMLElement => screen.getByRole('button', { name: /Select model/ });

  /** 让 trigger 拿到真实的模型名与档位(默认 harness 恒是占位符,见 visibleModelsRef)。 */
  const withRealModel = (): void => {
    visibleModelsRef.models = [
      {
        id: 'claude-opus-4-8',
        displayName: 'Opus 4.8',
        efforts: ['low', 'medium', 'high'],
        defaultEffort: 'high',
        contextWindow: 200000,
      },
    ];
  };

  it('传 engineMarkVendor 时用小标取代 harness 名字文本', () => {
    renderSelector({
      engineMarkVendor: 'codex',
      agentIdentity: { vendorKey: 'codex', state: 'current' },
    });
    const trigger = triggerOf();
    expect(trigger.querySelector('[data-composer-engine-mark="codex"]')).toBeTruthy();
    // 名字文本不再出现在 pill 上(但仍留在 title / aria-label 里,读屏与 hover 不丢信息)。
    expect(trigger.textContent).not.toContain('Codex');
    expect(trigger.getAttribute('title')).toContain('Codex');
    expect(trigger.getAttribute('aria-label')).toContain('Codex');
  });

  it('小标紧跟模型名之后、深度档字之前(图标与档字成组收尾)', () => {
    withRealModel();
    renderSelector({
      engineMarkVendor: 'codex',
      agentIdentity: { vendorKey: 'codex', state: 'current' },
    });
    const trigger = triggerOf();
    const mark = trigger.querySelector('[data-composer-engine-mark="codex"]') as HTMLElement;
    const modelName = within(trigger).getByText('Opus 4.8');
    const effort = within(trigger).getByText('最高');
    // Node.DOCUMENT_POSITION_FOLLOWING = 4
    expect(modelName.compareDocumentPosition(mark) & 4).toBeTruthy();
    expect(mark.compareDocumentPosition(effort) & 4).toBeTruthy();
  });

  it('窄工具条下先截模型名,小标与档字保留', () => {
    withRealModel();
    renderSelector({
      engineMarkVendor: 'codex',
      agentIdentity: { vendorKey: 'codex', state: 'current' },
      compactToolbar: true,
    });
    const trigger = triggerOf();
    expect(trigger.querySelector('[data-composer-engine-mark="codex"]')).toBeTruthy();
    expect(within(trigger).getByText('最高')).toBeTruthy();
    expect(within(trigger).getByText('Opus 4.8').className).toContain('truncate');
  });

  it('不传 engineMarkVendor 的入口维持名字文本形态(其余 7 个消费者不受影响)', () => {
    renderSelector({ agentIdentity: { vendorKey: 'codex', state: 'current' } });
    const trigger = triggerOf();
    expect(trigger.querySelector('[data-composer-engine-mark]')).toBeNull();
    expect(trigger.textContent).toContain('Codex');
  });
});