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。

110 KB
Raw Blame
// @vitest-environment jsdom

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

import type { Effort } from '@/lib/userPreferences.types';

const modelSelectorI18nRef = vi.hoisted(() => ({
  language: 'zh-CN',
  resolvedLanguage: 'zh-CN',
}));

// 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: () => ({
    i18n: modelSelectorI18nRef,
    t: (
      key: string,
      options?: {
        defaultValue?: string;
        input?: string;
        output?: string;
        source?: string;
        value?: string;
        model?: string;
        current?: string;
        next?: string;
        agent?: string;
        effort?: string;
        price?: string;
        percent?: string;
        rate?: string;
      },
    ) => {
      const translations: Record<string, string> = {
        'modelDescriptions.complexWork': '适合复杂分析、编程与细致写作。',
        'modelDescriptions.quickAnswers': '适合简短问答、摘要与短文写作。',
        'effortLevels.xhigh': '超高',
        'settings.providers.anthropic.title': 'Anthropic',
        'settings.providers.xd.title': 'Cindy AI',
        'newChat.modelSelector.trigger.placeholder': '选择模型',
        'newChat.modelSelector.trigger.loading': '正在读取模型…',
        'newChat.modelSelector.trigger.unresolved': '模型信息暂不可用',
        'newChat.modelSelector.trigger.agent.claudeCode': 'Claude Code',
        'newChat.modelSelector.trigger.agent.codex': 'Codex',
        'newChat.modelSelector.modelListAria': '模型列表',
        'newChat.modelSelector.hidden': '已隐藏',
        'newChat.modelSelector.pricing.free': '限时免费',
        'newChat.modelSelector.source.disconnected': '已断开',
        'newChat.modelSelector.source.unavailable': '模型不可用',
        'newChat.modelSelector.source.reconnect': '重新连接',
        'newChat.modelSelector.source.manage': '管理来源',
        'newChat.modelSelector.meta.fastBadge': '快速',
        'newChat.modelSelector.remoteLoading': '正在从远程设备读取模型…',
        'newChat.modelSelector.remoteLoadFailed': '无法读取远程设备上的模型。请检查连接后重试。',
        'newChat.modelSelector.remoteLoadFailedShort': '模型读取失败',
        'newChat.modelSelector.retryRemoteModels': '重新读取模型',
        'newChat.modelSelector.search.noResults': '没有匹配的模型',
      };
      if (key === 'newChat.modelSelector.priceTip') {
        return `Input ${options?.input} · Output ${options?.output} per 1M tokens`;
      }
      if (key === 'newChat.modelSelector.meta.context') {
        return `${options?.value} context`;
      }
      if (key === 'newChat.modelSelector.meta.codexCompatibilityMode') {
        return 'Codex compatibility mode';
      }
      if (key === 'newChat.modelSelector.source.viaSource') {
        return `Source: ${options?.source}`;
      }
      if (key === 'newChat.modelSelector.trigger.currentAndNext') return `Current: ${options?.current}\nNext message: ${options?.next}`;
      if (key === 'newChat.modelSelector.trigger.aria') {
        return `Select model. Current: ${options?.model}`;
      }
      if (key === 'newChat.modelSelector.trigger.ariaWithEffort') {
        return `Select model. Current: ${options?.model}, effort: ${options?.effort}`;
      }
      if (key === 'newChat.modelSelector.trigger.agent.pending') {
        return `Next: ${options?.agent}`;
      }
      if (key === 'newChat.modelSelector.trigger.pendingAria') {
        return `Select model. Next message: ${options?.agent} · ${options?.model}`;
      }
      if (key === 'newChat.modelSelector.trigger.pendingAriaWithEffort') {
        return `Select model. Next message: ${options?.agent} · ${options?.model}, effort: ${options?.effort}`;
      }
      if (key === 'newChat.modelSelector.pricing.discount') {
        return `立省 ${options?.percent}%`;
      }
      return translations[key] ?? options?.defaultValue ?? key;
    },
  }),
}));

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) => {
          child.props.onClick?.(event);
          state.onOpenChange?.(!state.open);
        },
      });
    },
    PopoverAnchor: ({ children }: { children: React.ReactNode }) => children,
    PopoverContent: ({
      children,
      className,
      align,
      sideOffset,
      onPointerEnter,
      onPointerLeave,
    }: {
      children: React.ReactNode;
      className?: string;
      align?: 'start' | 'center' | 'end';
      sideOffset?: number;
      onPointerEnter?: React.PointerEventHandler<HTMLDivElement>;
      onPointerLeave?: React.PointerEventHandler<HTMLDivElement>;
    }) => {
      const state = React.useContext(OpenContext);
      return state.open
        ? React.createElement(
            'div',
            {
              className,
              'data-testid': 'model-options-popover',
              'data-align': align,
              'data-side-offset': sideOffset,
              onPointerEnter,
              onPointerLeave,
            },
            React.createElement('button', {
              hidden: true,
              type: 'button',
              'data-testid': 'mock-popover-dismiss',
              onClick: () => state.onOpenChange?.(false),
            }),
            children,
          )
        : null;
    },
  };
});

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

const agentCapabilitiesRef = vi.hoisted(() => {
  const DEFAULT_CAPABILITIES = {
    availableModels: [
      {
        id: 'claude-opus-4-8',
        displayName: 'Opus 4.8',
        description: 'Most capable for ambitious work',
        contextWindow: 200000,
        efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
        defaultEffort: 'high',
        effortDisplayNames: {
          xhigh: 'X-High',
        },
      },
      {
        id: 'claude-sonnet-4-6',
        displayName: 'Sonnet 4.6',
        contextWindow: 200000,
        efforts: ['low', 'medium', 'high'],
        defaultEffort: 'medium',
      },
      {
        id: 'claude-haiku-4-5',
        displayName: 'Haiku 4.5',
        description: 'Fastest for quick answers',
        contextWindow: 200000,
        efforts: [],
        defaultEffort: null,
      },
    ],
    effortLevels: [{ id: 'xhigh', displayName: 'X-High' }],
    hasFastMode: false,
  };
  return {
    DEFAULT_CAPABILITIES,
    capabilities: DEFAULT_CAPABILITIES as unknown,
    loading: false,
    error: null as string | null,
  };
});
vi.mock('@/hooks/useAgentCapabilities', () => ({
  evictDeviceCapabilities: vi.fn(),
  prefetchDeviceCapabilities: vi.fn(async () => {}),
  useAgentCapabilities: () => ({
    capabilities: agentCapabilitiesRef.capabilities,
    loading: agentCapabilitiesRef.loading,
    error: agentCapabilitiesRef.error,
  }),
}));

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

vi.mock('@/hooks/useConnectedSource', () => ({
  useConnectedSource: (agent: string | null, modelId?: string) => ({
    hasConnectedSource:
      !agent ||
      !modelId ||
      (agent === 'claude-code' && modelId.startsWith('claude-')) ||
      (agent === 'codex' && modelId === 'gpt-5.5'),
    loading: false,
  }),
}));

const pricingRef = vi.hoisted(() => {
  const DEFAULT_PRICING = {
    anthropic: {
      'claude-opus-4-8': {
        providerId: 'anthropic',
        modelId: 'claude-opus-4-8',
        currency: 'USD',
        source: 'subscription-reference',
        approximate: true,
        inputPerMtok: 3,
        outputPerMtok: 15,
        cacheReadPerMtok: 0.3,
        cacheCreatePerMtok: 3.75,
      },
    },
  };
  return { DEFAULT_PRICING, pricing: DEFAULT_PRICING as unknown, renderCalls: 0 };
});
vi.mock('@/hooks/useModelPricing', () => ({
  useGatewayModelPricing: () => {
    pricingRef.renderCalls += 1;
    return pricingRef.pricing;
  },
  useReferenceModelPricing: () => pricingRef.pricing,
}));

// 可变 providers mock:默认 = anthropic fixture(分段/hover 用例依赖),
// 个别来源解析用例可临时替换,用完必须还原 DEFAULT_PROVIDERS。
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',
            description: 'Most capable for ambitious work',
            contextWindow: 200000,
            efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
            defaultEffort: 'high',
          },
          {
            id: 'claude-sonnet-4-6',
            name: 'Sonnet 4.6',
            contextWindow: 200000,
            efforts: ['low', 'medium', 'high'],
            defaultEffort: 'medium',
          },
          {
            id: 'claude-haiku-4-5',
            name: 'Haiku 4.5',
            description: 'Fastest for quick answers',
            contextWindow: 200000,
            efforts: [],
            defaultEffort: null,
          },
        ],
      },
    },
  ] as unknown[];
  return {
    DEFAULT_PROVIDERS,
    providers: DEFAULT_PROVIDERS,
    providerOrder: [] as string[],
    loading: false,
  };
});
vi.mock('@/hooks/useProviders', () => ({
  useProviders: () => ({
    providers: providersRef.providers,
    providerOrder: providersRef.providerOrder,
    loading: providersRef.loading,
  }),
}));

const deviceProvidersRef = vi.hoisted(() => ({
  providers: [] as unknown[],
  loading: false,
  error: null as string | null,
  unsupported: false,
  modelVisibilityOverrides: undefined as Record<string, boolean> | undefined,
  prefetch: vi.fn(async () => {}),
}));
vi.mock('@/hooks/useDeviceProviders', () => ({
  evictDeviceProviders: vi.fn(),
  prefetchDeviceProviders: (...args: Parameters<typeof deviceProvidersRef.prefetch>) =>
    deviceProvidersRef.prefetch(...args),
  useDeviceProviders: () => ({
    providers: deviceProvidersRef.providers,
    loading: deviceProvidersRef.loading,
    error: deviceProvidersRef.error,
    unsupported: deviceProvidersRef.unsupported,
    modelVisibilityOverrides: deviceProvidersRef.modelVisibilityOverrides,
  }),
}));

interface VisibleModelFixture {
  id: string;
  displayName: string;
  description?: string;
  contextWindow: number;
  efforts: string[];
  defaultEffort: string | null;
  effortDisplayNames?: Record<string, string>;
  supportsFastMode?: boolean;
  codexCompatibilityWireProtocol?: 'openai-chat' | 'anthropic-messages';
}

const visibleModelsRef = vi.hoisted(() => ({
  models: null as VisibleModelFixture[] | null,
}));
vi.mock('@/lib/providerModels', () => ({
  providerMonogram: (name: string) => name.slice(0, 1).toUpperCase(),
  // #245 新增:ModelSelector 渲染路径直接调用;fixture providers 无 routing,按不过滤透传。
  isLocalOnlyProviderForAgent: () => false,
  filterChatBridgedCodexProviders: (providers: unknown[]) => providers,
  isDeviceModelVisible: (
    overrides: Record<string, boolean> | undefined,
    agent: string,
    providerId: string,
    model: { id: string; defaultEnabled?: boolean },
  ) =>
    overrides === undefined
      ? true
      : (overrides[`${agent}:${providerId}:${model.id}`] ?? model.defaultEnabled !== false),
  resolveVisibleModelAgentKind: ({ agentKind }: { agentKind: 'claude-code' | 'codex' | null }) =>
    agentKind ?? 'claude-code',
  selectVisibleModels: ({ agentKind }: { agentKind: 'claude-code' | 'codex' | null }) => {
    if (visibleModelsRef.models) return visibleModelsRef.models;
    return [
      {
        id: 'claude-opus-4-8',
        displayName: 'Opus 4.8',
        description: 'Most capable for ambitious work',
        contextWindow: 200000,
        efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
        defaultEffort: 'high',
        effortDisplayNames: {
          xhigh: 'X-High',
        },
      },
      {
        id: 'claude-sonnet-4-6',
        displayName: 'Sonnet 4.6',
        contextWindow: 200000,
        efforts: ['low', 'medium', 'high'],
        defaultEffort: 'medium',
      },
      {
        id: 'claude-haiku-4-5',
        displayName: 'Haiku 4.5',
        description: 'Fastest for quick answers',
        contextWindow: 200000,
        efforts: [],
        defaultEffort: null,
      },
      {
        id: 'gpt-5.5',
        displayName: 'GPT-5.5',
        contextWindow: 400000,
        efforts: ['low', 'medium', 'high'],
        defaultEffort: 'medium',
      },
    ].filter((model) => {
      if (agentKind === 'claude-code') return model.id.startsWith('claude-');
      if (agentKind === 'codex') return model.id.startsWith('gpt-');
      return true;
    });
  },
}));

const modelVisibilityRef = vi.hoisted(
  (): {
    isEnabled: (agent: string, providerId: string, model: { id: string }) => boolean;
  } => ({
    isEnabled: () => true,
  }),
);
vi.mock('@/state/modelVisibilityPrefs', () => ({
  isModelEnabled: (agent: string, providerId: string, model: { id: string }) =>
    modelVisibilityRef.isEnabled(agent, providerId, model),
  useModelVisibilityVersion: () => 0,
}));

vi.mock('@/state/providerModelMemory', async (importOriginal) => ({
  ...(await importOriginal<typeof import('@/state/providerModelMemory')>()),
  useProviderModelMemoryVersion: () => 0,
}));

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

import {
  ModelSelector as SharedModelSelector,
  ModelSelectorContent as SharedModelSelectorContent,
  UNIFIED_COMPACT_PANEL_MAX_WIDTH_PX,
  UNIFIED_COMPACT_PANEL_WIDTH_CLASS,
  modelCompactEffortLabel,
  modelEffortLabel,
  modelListMaxHeightForRows,
  modelTagDensityForWidth,
  resolveRemoteModelListStatus,
  resolveModelSelectorAgentIdentity,
} from '@/components/new-chat/ModelSelector';
// Retain coverage of the capabilities-only compatibility renderer and common trigger.
// Default A interaction contracts live in unifiedModelPanelRendering.test.tsx.
const ModelSelector = (props: React.ComponentProps<typeof SharedModelSelector>) =>
  React.createElement(SharedModelSelector, { unifiedPanel: false, ...props });
const ModelSelectorContent = (props: React.ComponentProps<typeof SharedModelSelectorContent>) =>
  React.createElement(SharedModelSelectorContent, { unifiedPanel: false, ...props });
import { makerChatStore } from '@/lib/makerChatStore';

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

afterEach(() => { vi.useRealTimers(); });

beforeEach(() => {
  modelSelectorI18nRef.language = 'zh-CN';
  modelSelectorI18nRef.resolvedLanguage = 'zh-CN';
  requestProviderModelsAutoRefresh.mockClear();
  modelVisibilityRef.isEnabled = () => true;
  providersRef.providers = providersRef.DEFAULT_PROVIDERS;
  providersRef.providerOrder = [];
  providersRef.loading = false;
  agentCapabilitiesRef.loading = false;
  agentCapabilitiesRef.error = null;
  deviceProvidersRef.loading = false;
  deviceProvidersRef.error = null;
  deviceProvidersRef.unsupported = false;
  deviceProvidersRef.modelVisibilityOverrides = undefined;
  deviceProvidersRef.prefetch.mockReset();
  deviceProvidersRef.prefetch.mockResolvedValue(undefined);
  (window as unknown as { electronAPI: unknown }).electronAPI = {
    maker: { requestProviderModelsAutoRefresh },
  };
});

describe('resolveRemoteModelListStatus', () => {
  const ready = { capabilities: {}, loading: false, error: null };
  const pending = { capabilities: null, loading: true, error: null };
  const failed = { capabilities: null, loading: false, error: 'offline' };

  it('requires the selected agent capability and provider result before declaring ready', () => {
    expect(
      resolveRemoteModelListStatus({
        deviceId: 'dev-a',
        agentKind: 'claude-code',
        cc: pending,
        codex: failed,
        pi: failed,
        providers: { loading: false, error: null },
      }),
    ).toBe('loading');
    expect(
      resolveRemoteModelListStatus({
        deviceId: 'dev-a',
        agentKind: 'claude-code',
        cc: ready,
        codex: failed,
        pi: failed,
        providers: { loading: false, error: null },
      }),
    ).toBe('ready');
  });

  it('reports capability or connection failures instead of authoritative empty', () => {
    expect(
      resolveRemoteModelListStatus({
        deviceId: 'dev-a',
        agentKind: 'claude-code',
        cc: failed,
        codex: ready,
        pi: ready,
        providers: { loading: false, error: null },
      }),
    ).toBe('error');
    expect(
      resolveRemoteModelListStatus({
        deviceId: 'dev-a',
        agentKind: null,
        cc: ready,
        codex: failed,
        pi: ready,
        providers: { loading: false, error: null },
      }),
    ).toBe('error');
    expect(
      resolveRemoteModelListStatus({
        deviceId: 'dev-a',
        agentKind: 'claude-code',
        cc: ready,
        codex: ready,
        pi: ready,
        providers: { loading: false, error: 'timeout', unsupported: false },
      }),
    ).toBe('error');
  });

  it('only treats an unsupported provider channel as a compatible flat-list fallback', () => {
    expect(
      resolveRemoteModelListStatus({
        deviceId: 'dev-old',
        agentKind: 'claude-code',
        cc: ready,
        codex: ready,
        pi: ready,
        providers: { loading: false, error: 'channel not allowed', unsupported: true },
      }),
    ).toBe('ready');
  });
});

describe('ModelSelector trigger variants', () => {
  it('keeps required model status tags as the fluid picker narrows', () => {
    expect(modelTagDensityForWidth(null)).toBe('full');
    // 320px pane 还要扣掉图标、effort、勾选和左右 padding;英文 Subscription
    // 会把模型名压成 GPT-...,所以此时只保留当前模型的已隐藏标识。
    expect(modelTagDensityForWidth(320)).toBe('hidden');
    expect(modelTagDensityForWidth(370)).toBe('subscription');
    expect(modelTagDensityForWidth(UNIFIED_COMPACT_PANEL_MAX_WIDTH_PX)).toBe('subscription');
    expect(modelTagDensityForWidth(UNIFIED_COMPACT_PANEL_MAX_WIDTH_PX + 1)).toBe('full');
  });

  // 打开选择器既发起刷新、又把「发现在途」状态推给内容区(见 useModelDiscoveryPending),
  // 所以点击要走 act:那次刷新 resolve 后还有一次 setPending(false) 落在微任务里。
  const clickTrigger = async (): Promise<void> => {
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: /Current: Opus 4\.8/ }));
    });
  };

  it('remote loading replaces the placeholder and no-results empty state', async () => {
    const originalCapabilities = agentCapabilitiesRef.capabilities;
    const originalModels = visibleModelsRef.models;
    agentCapabilitiesRef.capabilities = null;
    agentCapabilitiesRef.loading = true;
    deviceProvidersRef.loading = true;
    visibleModelsRef.models = [];
    const view = render(
      React.createElement(ModelSelector, {
        modelId: 'remote-model',
        effort: 'medium',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        deviceId: 'dev-a',
      }),
    );
    try {
      const trigger = screen.getByRole('button', { name: /正在从远程设备读取模型/ });
      expect(trigger.textContent).toContain('正在从远程设备读取模型…');
      await act(async () => {
        fireEvent.click(trigger);
      });
      expect(screen.getAllByText('正在从远程设备读取模型…').length).toBeGreaterThan(1);
      expect(screen.queryByText('没有匹配的模型')).toBeNull();
    } finally {
      view.unmount();
      agentCapabilitiesRef.capabilities = originalCapabilities;
      agentCapabilitiesRef.loading = false;
      deviceProvidersRef.loading = false;
      visibleModelsRef.models = originalModels;
    }
  });

  it('remote failures show an explicit retry state instead of no matching models', async () => {
    const originalCapabilities = agentCapabilitiesRef.capabilities;
    const originalModels = visibleModelsRef.models;
    agentCapabilitiesRef.capabilities = null;
    agentCapabilitiesRef.error = 'offline';
    visibleModelsRef.models = [];
    const view = render(
      React.createElement(ModelSelector, {
        modelId: 'remote-model',
        effort: 'medium',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        deviceId: 'dev-a',
      }),
    );
    try {
      const trigger = screen.getByRole('button', { name: /模型读取失败/ });
      expect(trigger.textContent).toContain('模型读取失败');
      await act(async () => {
        fireEvent.click(trigger);
      });
      expect(screen.getByText('无法读取远程设备上的模型。请检查连接后重试。')).toBeTruthy();
      expect(screen.getByRole('button', { name: '重新读取模型' })).toBeTruthy();
      expect(screen.queryByText('没有匹配的模型')).toBeNull();
      deviceProvidersRef.prefetch.mockRejectedValueOnce(new Error('offline'));
      await act(async () => {
        fireEvent.click(screen.getByRole('button', { name: '重新读取模型' }));
        await Promise.resolve();
      });
      expect(deviceProvidersRef.prefetch).toHaveBeenCalledWith('dev-a');
    } finally {
      view.unmount();
      agentCapabilitiesRef.capabilities = originalCapabilities;
      agentCapabilitiesRef.error = null;
      visibleModelsRef.models = originalModels;
    }
  });

  it('unified panel remote failures show retry instead of no matching models', async () => {
    const originalCapabilities = agentCapabilitiesRef.capabilities;
    const originalModels = visibleModelsRef.models;
    agentCapabilitiesRef.capabilities = null;
    agentCapabilitiesRef.error = 'offline';
    visibleModelsRef.models = [];
    const view = render(
      React.createElement(SharedModelSelector, {
        modelId: 'remote-model',
        effort: 'medium',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        deviceId: 'dev-a',
      }),
    );
    try {
      const trigger = screen.getByRole('button', { name: /模型读取失败/ });
      expect(trigger.textContent).toContain('模型读取失败');
      await act(async () => {
        fireEvent.click(trigger);
      });
      expect(screen.getByText('无法读取远程设备上的模型。请检查连接后重试。')).toBeTruthy();
      expect(screen.getByRole('button', { name: '重新读取模型' })).toBeTruthy();
      expect(screen.queryByText('没有匹配的模型')).toBeNull();
      deviceProvidersRef.prefetch.mockRejectedValueOnce(new Error('offline'));
      await act(async () => {
        fireEvent.click(screen.getByRole('button', { name: '重新读取模型' }));
        await Promise.resolve();
      });
      expect(deviceProvidersRef.prefetch).toHaveBeenCalledWith('dev-a');
    } finally {
      view.unmount();
      agentCapabilitiesRef.capabilities = originalCapabilities;
      agentCapabilitiesRef.error = null;
      visibleModelsRef.models = originalModels;
    }
  });

  it('orders local provider sections by the Settings display preference', () => {
    providersRef.providers = [
      ...providersRef.DEFAULT_PROVIDERS,
      {
        id: 'zeta',
        name: 'Zeta',
        source: 'user',
        connected: true,
        agents: ['claude-code'],
        routing: { 'claude-code': {} },
        models: {
          'claude-code': [
            {
              id: 'claude-zeta',
              name: 'Zeta Model',
              contextWindow: 100000,
              efforts: ['high'],
              defaultEffort: 'high',
            },
          ],
        },
      },
    ];
    providersRef.providerOrder = ['zeta', 'anthropic'];

    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'anthropic',
          onProviderChange: vi.fn(),
        }),
      );

      const modelRows = screen.getAllByRole('option');
      expect(modelRows[0]?.textContent).toContain('Zeta Model');
      expect(modelRows[1]?.textContent).toContain('Opus 4.8');
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
      providersRef.providerOrder = [];
    }
  });

  it('requests a silent refresh when a local selector opens, but not for a remote device', async () => {
    const local = render(
      React.createElement(ModelSelector, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
      }),
    );
    await clickTrigger();
    expect(requestProviderModelsAutoRefresh).toHaveBeenCalledWith('model-selector-open');
    await clickTrigger();
    await clickTrigger();
    expect(requestProviderModelsAutoRefresh).toHaveBeenCalledTimes(2);
    local.unmount();

    requestProviderModelsAutoRefresh.mockClear();
    render(
      React.createElement(ModelSelector, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        deviceId: 'remote-device',
      }),
    );
    await clickTrigger();
    expect(requestProviderModelsAutoRefresh).not.toHaveBeenCalled();
  });

  it('keeps short model discovery out of the morph opening geometry', async () => {
    vi.useFakeTimers();
    let resolveRefresh!: (value: { ok: true }) => void;
    const refresh = new Promise<{ ok: true }>((resolve) => {
      resolveRefresh = resolve;
    });
    requestProviderModelsAutoRefresh.mockImplementationOnce(() => refresh);

    try {
      render(
        React.createElement(ModelSelector, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          useMorphPopover: true,
        }),
      );

      act(() => {
        fireEvent.click(screen.getByRole('button', { name: /Current: Opus 4\.8/ }));
      });
      expect(requestProviderModelsAutoRefresh).toHaveBeenCalledOnce();
      expect(screen.queryByText('newChat.modelSelector.discovering')).toBeNull();

      await act(async () => {
        resolveRefresh({ ok: true });
        await refresh;
        await vi.runAllTimersAsync();
      });
      expect(screen.queryByText('newChat.modelSelector.discovering')).toBeNull();
    } finally {
      vi.useRealTimers();
    }
  });

  it('still explains a model discovery that remains in flight', async () => {
    vi.useFakeTimers();
    let resolveRefresh!: (value: { ok: true }) => void;
    const refresh = new Promise<{ ok: true }>((resolve) => {
      resolveRefresh = resolve;
    });
    requestProviderModelsAutoRefresh.mockImplementationOnce(() => refresh);

    try {
      render(
        React.createElement(ModelSelector, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          useMorphPopover: true,
        }),
      );

      act(() => {
        fireEvent.click(screen.getByRole('button', { name: /Current: Opus 4\.8/ }));
      });
      await act(async () => {
        await vi.runAllTimersAsync();
      });
      expect(screen.getByText('newChat.modelSelector.discovering')).toBeTruthy();

      await act(async () => {
        resolveRefresh({ ok: true });
        await refresh;
      });
      expect(screen.queryByText('newChat.modelSelector.discovering')).toBeNull();
    } finally {
      vi.useRealTimers();
    }
  });

  it('restarts the discovery delay after a row closes and reopens the picker', async () => {
    vi.useFakeTimers();
    requestProviderModelsAutoRefresh
      .mockImplementationOnce(() => new Promise(() => undefined))
      .mockImplementationOnce(() => new Promise(() => undefined));

    try {
      render(
        React.createElement(ModelSelector, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          useMorphPopover: true,
        }),
      );

      act(() => {
        fireEvent.click(screen.getByRole('button', { name: /Current: Opus 4\.8/ }));
      });
      await act(async () => {
        await vi.advanceTimersByTimeAsync(300);
      });
      expect(screen.getByText('newChat.modelSelector.discovering')).toBeTruthy();

      fireEvent.click(screen.getByRole('option', { name: /Sonnet 4\.6/ }));
      expect(screen.queryByText('newChat.modelSelector.discovering')).toBeNull();

      act(() => {
        fireEvent.click(screen.getByRole('button', { name: /Current: Opus 4\.8/ }));
      });
      expect(requestProviderModelsAutoRefresh).toHaveBeenCalledTimes(2);
      expect(screen.queryByText('newChat.modelSelector.discovering')).toBeNull();

      await act(async () => {
        await vi.advanceTimersByTimeAsync(299);
      });
      expect(screen.queryByText('newChat.modelSelector.discovering')).toBeNull();

      await act(async () => {
        await vi.advanceTimersByTimeAsync(1);
      });
      expect(screen.getByText('newChat.modelSelector.discovering')).toBeTruthy();
    } finally {
      vi.useRealTimers();
    }
  });

  it('keeps row-count caps finite and within the shared 300px ceiling', () => {
    expect(modelListMaxHeightForRows()).toBeUndefined();
    expect(modelListMaxHeightForRows(Number.NaN)).toBeUndefined();
    expect(modelListMaxHeightForRows(Number.POSITIVE_INFINITY)).toBeUndefined();
    expect(modelListMaxHeightForRows(0)).toBe(36);
    expect(modelListMaxHeightForRows(6)).toBe(226);
    expect(modelListMaxHeightForRows(7)).toBe(264);
    expect(modelListMaxHeightForRows(8)).toBe(300);
    expect(modelListMaxHeightForRows(100)).toBe(300);
  });

  it('bounds the default-session trigger in wide, narrow and ultra-narrow composers', () => {
    const props = {
      modelId: 'claude-opus-4-8',
      effort: 'xhigh' as Effort,
      onModelChange: vi.fn(),
      onEffortChange: vi.fn(),
      vendorKey: 'cc' as const,
      compactToolbar: true,
    };
    const view = render(React.createElement(ModelSelector, { ...props, compactToolbar: false }));

    const wideTrigger = screen.getByRole('button', {
      name: /Current: Opus 4\.8, effort: 超高/,
    });
    expect(wideTrigger.className).toContain('max-w-[min(320px,100%)]');
    expect(within(wideTrigger).getByText('Opus 4.8').className).toContain('truncate');
    expect(wideTrigger.getAttribute('title')).toContain('Opus 4.8');

    view.rerender(React.createElement(ModelSelector, props));

    let trigger = screen.getByRole('button', {
      name: /Current: Opus 4\.8, effort: 超高/,
    });
    expect(trigger.className).toContain('w-[148px]');
    expect(trigger.className).toContain('min-w-[72px]');
    expect(within(trigger).getByText('Opus 4.8').className).toContain('truncate');
    expect(trigger.textContent).not.toContain('超高');

    view.rerender(
      React.createElement(ModelSelector, {
        ...props,
        ultraCompactToolbar: true,
      }),
    );
    trigger = screen.getByRole('button', {
      name: /Current: Opus 4\.8, effort: 超高/,
    });
    expect(trigger.className).toContain('w-[64px]');
    expect(trigger.className).toContain('min-w-[64px]');
    expect(within(trigger).getByText('Opus 4.8').className).toContain('hidden');
    // 可及名仍保留完整模型 + effort,视觉仅收起文字,不丢选择能力。
    expect(trigger.getAttribute('aria-label')).toContain('Opus 4.8');
    expect(trigger.getAttribute('aria-label')).toContain('超高');
  });

  it('caps the toolbar panel while field panels still follow their field width', () => {
    const props = {
      modelId: 'claude-opus-4-8',
      effort: 'high' as Effort,
      onModelChange: vi.fn(),
      onEffortChange: vi.fn(),
      vendorKey: 'cc' as const,
      unifiedPanel: true,
    };
    const view = render(React.createElement(ModelSelectorContent, props));
    let pane = view.container.querySelector('[data-unified-model-panel]') as HTMLElement;
    expect(UNIFIED_COMPACT_PANEL_WIDTH_CLASS).toContain(
      `max-w-[min(${UNIFIED_COMPACT_PANEL_MAX_WIDTH_PX}px,calc(100vw-48px))]`,
    );
    expect(pane.className).toContain(UNIFIED_COMPACT_PANEL_WIDTH_CLASS);

    view.rerender(React.createElement(ModelSelectorContent, { ...props, fluidWidth: true }));
    pane = view.container.querySelector('[data-unified-model-panel]') as HTMLElement;
    expect(pane.className).toContain('w-full min-w-0');
    expect(pane.className).not.toContain(UNIFIED_COMPACT_PANEL_WIDTH_CLASS);
    expect(pane.className).not.toContain(`${UNIFIED_COMPACT_PANEL_MAX_WIDTH_PX}px`);
  });

  it('keeps the session Agent explicit when Claude Code uses an OpenAI-branded model', () => {
    const model = {
      id: 'chatgpt/gpt-5.6-terra',
      displayName: 'GPT-5.6-Terra',
      contextWindow: 400000,
      efforts: ['low', 'medium', 'high'],
      defaultEffort: 'medium',
    };
    visibleModelsRef.models = [model];
    providersRef.providers = [
      {
        id: 'openai',
        name: 'OpenAI',
        source: 'builtin',
        agents: ['claude-code'],
        auth: { method: 'oauth' },
        routing: { 'claude-code': {} },
        connected: true,
        models: {
          'claude-code': [
            {
              id: model.id,
              name: model.displayName,
              contextWindow: model.contextWindow,
              efforts: model.efforts,
              defaultEffort: model.defaultEffort,
            },
          ],
        },
      },
    ];

    try {
      const props = {
        modelId: model.id,
        effort: 'medium' as Effort,
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc' as const,
        currentProviderId: 'openai',
        agentIdentity: { vendorKey: 'cc' as const, state: 'current' as const },
      };
      const view = render(React.createElement(ModelSelector, props));

      let trigger = screen.getByRole('button', {
        name: /Current: Claude Code · GPT-5\.6-Terra, effort: medium/,
      });
      expect(trigger.textContent).toContain('Claude Code');
      expect(trigger.textContent).toContain('GPT-5.6-Terra');
      expect(trigger.getAttribute('title')).toBe('Claude Code · GPT-5.6-Terra');

      view.rerender(
        React.createElement(ModelSelector, {
          ...props,
          compactToolbar: true,
        }),
      );
      trigger = screen.getByRole('button', {
        name: /Current: Claude Code · GPT-5\.6-Terra, effort: medium/,
      });
      expect(trigger.textContent).not.toContain('Claude Code');
      expect(trigger.getAttribute('aria-label')).toContain('Claude Code');
    } finally {
      visibleModelsRef.models = null;
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('does not infer a current Agent from the fallback vendor before session identity loads', () => {
    render(
      React.createElement(ModelSelector, {
        modelId: 'claude-opus-4-8',
        effort: 'high' as Effort,
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        agentIdentity: resolveModelSelectorAgentIdentity(null, null),
      }),
    );

    const trigger = screen.getByRole('button', { name: /Current: Opus 4\.8/ });
    expect(trigger.textContent).not.toContain('Claude Code');
    expect(trigger.getAttribute('aria-label')).not.toContain('Claude Code');
  });

  it.each([
    ['claude-code', false], ['claude-code', true], ['codex', false], ['codex', true],
  ] as const)('keeps target identity and current/next context in a narrow composer (current=%s, ultra=%s)', (currentAgent, ultra) => {
    providersRef.providers = [{
      id: 'openai', name: 'OpenAI', connected: true, agents: ['codex'], routing: { codex: {} },
      models: { codex: [{ id: 'gpt-6-astra', name: 'GPT-6 Astra', contextWindow: 1000000, efforts: ['high'], defaultEffort: 'high', supportsFastMode: true }] },
    }, {
      id: 'xd', name: 'Gateway', connected: true, agents: [currentAgent], routing: { [currentAgent]: {} },
      models: { [currentAgent]: [{ id: 'previous-model', name: 'Previous model', efforts: ['high'], supportsFastMode: true }] },
    }];
    try {
      const props = {
        modelId: 'gpt-6-astra', effort: 'high' as Effort, fastMode: false,
        onModelChange: vi.fn(), onEffortChange: vi.fn(), vendorKey: 'cc' as const,
        currentProviderId: 'openai', actualRoute: true,
        agentIdentity: resolveModelSelectorAgentIdentity(currentAgent, 'codex'),
        engineMarkVendor: 'codex' as const, compactToolbar: true, ultraCompactToolbar: ultra,
        currentSelection: { agentKind: currentAgent, model: 'previous-model', providerId: 'xd', effort: 'high' as const, fastMode: true },
      };
      const view = render(React.createElement(ModelSelector, props));
      const trigger = screen.getByRole('button', { name: /Current:.*Previous model/ });
      expect(trigger.title).not.toContain('previous-model');
      expect(trigger.title).toContain('Next message: Codex · GPT-6 Astra');
      expect(trigger.title.split('Next message:')[1]).not.toContain('快速');
      expect(trigger.querySelector('[data-model-selection-pending]')).not.toBeNull();
      expect(Boolean(trigger.querySelector('[data-composer-engine-mark="codex"]'))).toBe(!ultra);
      expect(trigger.querySelector('.lucide-zap')).toBeNull();
      view.rerender(React.createElement(ModelSelector, { ...props, agentIdentity: resolveModelSelectorAgentIdentity('codex', null) }));
      expect(screen.getByRole('button').title).not.toContain('Next message:');
      expect(screen.getByRole('button').querySelector('[data-model-selection-pending]')).toBeNull();
    } finally { providersRef.providers = providersRef.DEFAULT_PROVIDERS; }
  });

  it('keeps pending capabilities on a disconnected explicit source instead of borrowing another source', () => {
    providersRef.providers = [
      { id: 'openai', name: 'OpenAI', connected: false, agents: ['codex'], routing: { codex: {} }, models: { codex: [{ id: 'gpt-6-astra', name: 'GPT-6 Astra', contextWindow: 1000000, efforts: ['high'], supportsFastMode: true }] } },
      { id: 'xd', name: 'Gateway', connected: true, agents: ['codex'], routing: { codex: {} }, models: { codex: [{ id: 'gpt-6-astra', name: 'Gateway GPT-6', contextWindow: 200000, efforts: ['low'], supportsFastMode: false }] } },
    ];
    try {
      render(React.createElement(ModelSelector, {
        modelId: 'gpt-6-astra', effort: 'high' as Effort, fastMode: true,
        onModelChange: vi.fn(), onEffortChange: vi.fn(), vendorKey: 'codex',
        currentProviderId: 'openai', actualRoute: true, sourceDisconnected: true,
        agentIdentity: resolveModelSelectorAgentIdentity('codex', 'codex'),
        currentSelection: { agentKind: 'codex', model: 'gpt-6-astra', providerId: 'xd', effort: 'low', fastMode: false },
      }));
      const title = screen.getByRole('button').title;
      expect(title).toContain('Next message: Codex · GPT-6 Astra');
      expect(title.split('Next message:')[1]).toContain('快速');
      expect(title.split('Next message:')[1]).not.toContain('Gateway GPT-6');
    } finally { providersRef.providers = providersRef.DEFAULT_PROVIDERS; }
  });

  it.each([false, true])('keeps the chosen model and offers the appropriate recovery action (connected=%s)', async (connected) => {
    providersRef.providers = [{ id: 'openai', name: 'OpenAI', connected, agents: ['codex'], routing: { codex: {} }, models: { codex: connected ? [] : [{ id: 'gpt-6-astra', name: 'GPT-6 Astra', contextWindow: 1000000, efforts: ['high'], defaultEffort: 'high' }] } }];
    const navigate = vi.fn();
    try {
      render(React.createElement(ModelSelector, {
        modelId: 'gpt-6-astra', effort: 'high' as Effort, onModelChange: vi.fn(), onEffortChange: vi.fn(),
        vendorKey: 'codex', currentProviderId: 'openai', actualRoute: true, sourceDisconnected: true,
        onProviderChange: vi.fn(), onNavigateToProviders: vi.fn(), onReconnectSource: navigate, unifiedPanel: true,
      }));
      const trigger = screen.getByRole('button', { name: connected ? /模型不可用/ : /已断开/ });
      expect(trigger.textContent).toContain(connected ? '模型信息暂不可用' : 'GPT-6 Astra');
      expect(trigger.textContent).not.toContain('gpt-6-astra');
      fireEvent.click(trigger);
      const recovery = await screen.findByRole('button', { name: connected ? '管理来源' : '重新连接' });
      fireEvent.click(recovery);
      expect(navigate).toHaveBeenCalledOnce();
    } finally { providersRef.providers = providersRef.DEFAULT_PROVIDERS; }
  });

  it('keeps the disconnected status in the compact trigger title', () => {
    render(
      React.createElement(ModelSelector, {
        modelId: 'claude-opus-4-8',
        effort: 'xhigh' as Effort,
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        compactToolbar: true,
        currentProviderId: 'anthropic',
        sourceDisconnected: true,
      }),
    );

    const trigger = screen.getByRole('button', {
      name: /已断开: Opus 4\.8/,
    });
    expect(trigger.getAttribute('title')).toBe('已断开: Opus 4.8');
    // compact 隐藏冗余状态文案,但 Unplug 错误图标与悬停 title 仍保留。
    expect(trigger.textContent).not.toContain('已断开');
  });

  it('shows the intent model and its default source after registering an agent switch', () => {
    const sessionId = 'model-selector-agent-switch-intent';
    providersRef.providers = [
      {
        id: 'anthropic',
        name: 'Anthropic',
        connected: true,
        agents: ['claude-code'],
        routing: { 'claude-code': {} },
        models: {
          'claude-code': [
            {
              id: 'claude-opus-4-8',
              name: 'Opus 4.8',
              contextWindow: 200000,
              efforts: ['high'],
              defaultEffort: 'high',
            },
          ],
        },
      },
      {
        id: 'zeta-codex',
        name: 'Zeta Codex',
        connected: true,
        agents: ['codex'],
        routing: { codex: {} },
        models: {
          codex: [
            {
              id: 'gpt-5.5',
              name: 'GPT-5.5',
              contextWindow: 400000,
              efforts: ['medium'],
              defaultEffort: 'medium',
            },
          ],
        },
      },
    ];

    function IntentTrigger({ refresh }: { refresh: number }) {
      void refresh;
      const lightState = React.useSyncExternalStore(
        (onStoreChange) => makerChatStore.subscribeLight(sessionId, onStoreChange),
        () => makerChatStore.getLightSnapshot(sessionId),
      );
      // 复刻 CCAgentSessionView(订阅轻快照决定 vendor) + ChatInput(直接读 intent
      // 覆盖 model/provider)的组合窗口。refresh 模拟其它状态带来的无关重渲染。
      const intent = makerChatStore.getAgentSwitchIntent(sessionId);
      const displayAgent = lightState.agentSwitchIntent?.target ?? 'claude-code';
      return React.createElement(ModelSelector, {
        modelId: intent?.model ?? 'claude-opus-4-8',
        effort: (intent?.effort ?? 'high') as Effort,
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: displayAgent === 'codex' ? 'codex' : 'cc',
        // 稳态来自已加载的真实 runtime;intent 是下一条消息的明确目标,不能写成 Current。
        agentIdentity: resolveModelSelectorAgentIdentity('claude-code', intent?.target),
        currentProviderId: intent?.providerId ?? null,
        onProviderChange: vi.fn(),
        onNavigateToProviders: vi.fn(),
      });
    }

    const view = render(React.createElement(IntentTrigger, { refresh: 0 }));
    try {
      let trigger = screen.getByRole('button', {
        name: /Current: Claude Code · Opus 4\.8/,
      });
      expect(trigger.textContent).toContain('Claude Code');

      act(() => {
        makerChatStore.noteAgentSwitchIntent(sessionId, 'codex', {
          model: 'gpt-5.5',
          providerId: null,
          effort: 'medium',
        });
      });
      view.rerender(React.createElement(IntentTrigger, { refresh: 1 }));

      trigger = screen.getByRole('button', {
        name: /Next message: Codex · GPT-5\.5, effort: medium/,
      });
      expect(trigger.textContent).toContain('GPT-5.5');
      expect(trigger.textContent).toContain('Codex');
      expect(trigger.textContent).not.toContain('Next:');
      expect(trigger.getAttribute('aria-label')).not.toContain('Current');
      // 切换失败时 intent 会保留供重试;重复渲染仍明确标成“下条消息”,不会隐藏身份。
      view.rerender(React.createElement(IntentTrigger, { refresh: 2 }));
      expect(
        screen.getByRole('button', {
          name: /Next message: Codex · GPT-5\.5, effort: medium/,
        }),
      ).toBeTruthy();
      // providerId=null 仍应按目标模型的默认可连来源解析 icon。
      expect(trigger.textContent).toContain('Z');
      expect(trigger.textContent).not.toContain('newChat.modelSelector.source.connect');
    } finally {
      view.unmount();
      makerChatStore.purgeSession(sessionId);
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('renders the field trigger as a settings input and localizes effort before provider labels', () => {
    render(
      React.createElement(ModelSelector, {
        modelId: 'claude-opus-4-8',
        effort: 'xhigh',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        triggerVariant: 'field',
      }),
    );

    const trigger = screen.getByRole('button', {
      name: /Current: Opus 4\.8, effort: 超高/,
    });

    expect(trigger.className).toContain('w-full');
    expect(trigger.className).toContain('border-[var(--border-default)]');
    expect(trigger.className).toContain('bg-[var(--settings-input-bg)]');
    expect(trigger.textContent).toContain('Opus 4.8');
    expect(trigger.textContent).toContain('超高');
    expect(trigger.textContent).not.toContain('X-High');
    expect(trigger.querySelector('[data-model-promotion-badge]')).toBeNull();
  });

  it('keeps a long subscription-backed field menu bounded and wheel-scrollable', async () => {
    const models: VisibleModelFixture[] = Array.from({ length: 40 }, (_, index) => ({
      id: `subscription-model-${index + 1}`,
      displayName: `Subscription Model ${index + 1}`,
      contextWindow: 200000,
      efforts: ['high'],
      defaultEffort: 'high',
    }));
    const originalCapabilities = agentCapabilitiesRef.capabilities;
    visibleModelsRef.models = models;
    agentCapabilitiesRef.capabilities = {
      availableModels: models,
      effortLevels: [{ id: 'high', displayName: 'High' }],
      hasFastMode: false,
    };
    providersRef.providers = [
      {
        id: 'anthropic',
        name: 'Anthropic',
        source: 'builtin',
        agents: ['claude-code'],
        auth: { method: 'oauth' },
        routing: { 'claude-code': {} },
        connected: true,
        models: {
          'claude-code': models.map((model) => ({
            ...model,
            name: model.displayName,
          })),
        },
      },
    ];

    try {
      render(
        React.createElement(ModelSelector, {
          modelId: models[0].id,
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          triggerVariant: 'field',
          currentProviderId: 'anthropic',
          onProviderChange: vi.fn(),
        }),
      );

      await act(async () => {
        fireEvent.click(screen.getByRole('button', { name: /Current: Subscription Model 1/ }));
      });
      const list = screen.getByRole('listbox', { name: '模型列表' });

      expect(list.className).toContain('max-h-[300px]');
      expect(list.className).toContain('overflow-y-auto');
      expect(list.className).toContain('overscroll-contain');
      const options = within(list).getAllByRole('option');
      expect(options).toHaveLength(40);
      expect(options[0].textContent).toContain('Subscription Model 1');
      expect(options[39].textContent).toContain('Subscription Model 40');
    } finally {
      visibleModelsRef.models = null;
      agentCapabilitiesRef.capabilities = originalCapabilities;
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('keeps the user scroll position when selection changes', () => {
    const rect = (top: number, bottom: number): DOMRect =>
      ({
        top,
        bottom,
        left: 0,
        right: 320,
        width: 320,
        height: bottom - top,
        x: 0,
        y: top,
        toJSON: () => ({}),
      }) as DOMRect;
    const rafSpy = vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
      callback(0);
      return 0;
    });
    const rectSpy = vi
      .spyOn(HTMLElement.prototype, 'getBoundingClientRect')
      .mockImplementation(function (this: HTMLElement) {
        if (this.getAttribute('role') === 'listbox') return rect(0, 300);
        if (this.getAttribute('data-model-selected') === 'true') return rect(120, 160);
        return rect(0, 0);
      });

    try {
      const view = render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
        }),
      );
      const list = screen.getByRole('listbox', { name: '模型列表' });
      Object.defineProperty(list, 'scrollTop', { configurable: true, writable: true, value: 80 });

      view.rerender(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-sonnet-4-6',
          effort: 'medium',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
        }),
      );

      expect(list.scrollTop).toBe(80);
      view.unmount();
    } finally {
      rectSpy.mockRestore();
      rafSpy.mockRestore();
    }
  });

  it('reuses the parent pricing snapshot when the model content opens', async () => {
    pricingRef.renderCalls = 0;
    render(
      React.createElement(ModelSelector, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
      }),
    );
    expect(pricingRef.renderCalls).toBe(1);

    pricingRef.renderCalls = 0;
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: /Current: Opus 4\.8/ }));
    });
    // Opening and the discovery-pending settle each re-render the parent once. The content must
    // reuse that parent's pricing snapshot; calling useModelPricing inside it would double this.
    expect(pricingRef.renderCalls).toBe(2);
  });

  it('does not show Gateway promotions in the selected-model trigger', () => {
    providersRef.providers = [
      {
        id: 'xd',
        name: 'Cindy AI',
        connected: true,
        agents: ['claude-code'],
        routing: { 'claude-code': {} },
        models: {
          'claude-code': [
            {
              id: 'claude-opus-4-8',
              name: 'Opus 4.8',
              contextWindow: 200000,
              efforts: ['high'],
              defaultEffort: 'high',
              cost: { input: 6, output: 18, cacheRead: 1.2, cacheWrite: 7.5 },
            },
            {
              id: 'claude-sonnet-4-6',
              name: 'Sonnet 4.6',
              contextWindow: 200000,
              efforts: ['medium'],
              defaultEffort: 'medium',
              cost: { input: 0, output: 0 },
            },
          ],
        },
      },
    ];
    pricingRef.pricing = {
      xd: {
        'claude-opus-4-8': {
          providerId: 'xd',
          modelId: 'claude-opus-4-8',
          currency: 'CNY',
          source: 'gateway',
          approximate: false,
          inputPerMtok: 12,
          outputPerMtok: 36,
          cacheReadPerMtok: 2.4,
          cacheCreatePerMtok: 15,
        },
      },
    };

    try {
      const discounted = render(
        React.createElement(ModelSelector, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'xd',
          onProviderChange: vi.fn(),
        }),
      );
      const promotionTrigger = screen.getByRole('button', { name: /Current: Opus 4\.8/ });
      // 折扣和免费标签已从输入框 trigger 移除,仅在下拉菜单/详情里展示。
      expect(within(promotionTrigger).queryByText('立省 50%')).toBeNull();
      expect(within(promotionTrigger).queryByText('限时免费')).toBeNull();
      expect(promotionTrigger.querySelector('[data-model-promotion-badge]')).toBeNull();
      discounted.unmount();

      pricingRef.pricing = {};
      render(
        React.createElement(ModelSelector, {
          modelId: 'claude-sonnet-4-6',
          effort: 'medium',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'xd',
          onProviderChange: vi.fn(),
        }),
      );
      expect(
        within(screen.getByRole('button', { name: /Current: Sonnet 4\.6/ })).queryByText(
          '限时免费',
        ),
      ).toBeNull();
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
      pricingRef.pricing = pricingRef.DEFAULT_PRICING;
    }
  });

  it('does not mix controller prices with remote provider costs', () => {
    deviceProvidersRef.providers = [
      {
        id: 'xd',
        name: 'Cindy AI',
        connected: true,
        agents: ['claude-code'],
        routing: { 'claude-code': {} },
        models: {
          'claude-code': [
            {
              id: 'claude-opus-4-8',
              name: 'Opus 4.8',
              contextWindow: 200000,
              efforts: ['high'],
              defaultEffort: 'high',
              cost: { input: 6, output: 18 },
            },
          ],
        },
      },
    ];
    pricingRef.pricing = {
      xd: {
        'claude-opus-4-8': {
          providerId: 'xd',
          modelId: 'claude-opus-4-8',
          currency: 'CNY',
          source: 'gateway',
          approximate: false,
          inputPerMtok: 12,
          outputPerMtok: 36,
        },
      },
    };

    try {
      const triggerView = render(
        React.createElement(ModelSelector, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          deviceId: 'remote-device',
          currentProviderId: 'xd',
          onProviderChange: vi.fn(),
        }),
      );
      expect(
        screen
          .getByRole('button', { name: /Current: Opus 4\.8/ })
          .querySelector('[data-model-promotion-badge]'),
      ).toBeNull();
      triggerView.unmount();

      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          deviceId: 'remote-device',
          currentProviderId: 'xd',
          onProviderChange: vi.fn(),
        }),
      );
      const row = screen.getByRole('option', { name: /Opus 4\.8/ });
      expect(row.textContent).not.toContain('¥12 / ¥36');
      expect(row.textContent).not.toContain('¥6 / ¥18');
      expect(row.querySelector('[data-model-promotion-badge]')).toBeNull();
      expect(row.querySelector('[data-model-hidden-label]')).toBeNull();

      fireEvent.pointerEnter(row);
      expect(
        within(screen.getByRole('group', { name: /Opus 4\.8/ })).queryByText(
          'newChat.modelSelector.pricing.title',
        ),
      ).toBeNull();
    } finally {
      deviceProvidersRef.providers = [];
      pricingRef.pricing = pricingRef.DEFAULT_PRICING;
    }
  });

  it('uses model effort display names only as fallback when i18n has no translation', () => {
    const t = (key: string, options?: { defaultValue?: string }) =>
      key === 'effortLevels.xhigh' ? '超高' : (options?.defaultValue ?? key);

    expect(
      modelEffortLabel(t, { effortDisplayNames: { xhigh: 'Extra High' } }, 'xhigh', 'X-High'),
    ).toBe('超高');
    expect(modelEffortLabel(t, { effortDisplayNames: { xhigh: 'Extra High' } }, 'max', 'Max')).toBe(
      'Max',
    );
  });

  it('uses stable English effort ids for compact row and trigger labels', () => {
    const t = (key: string, options?: { defaultValue?: string }) =>
      key === 'effortLevels.xhigh' ? '超高' : (options?.defaultValue ?? key);

    expect(
      modelCompactEffortLabel(
        'en-US',
        t,
        { effortDisplayNames: { xhigh: 'Extra High' } },
        'xhigh',
        '特高',
      ),
    ).toBe('Extra');
    expect(modelCompactEffortLabel('en-US', t, null, 'medium', '中')).toBe('Medium');
    expect(modelCompactEffortLabel('zh-CN', t, null, 'xhigh', 'Extra High')).toBe('超高');
    expect(
      modelCompactEffortLabel(
        'en-US',
        t,
        { effortDisplayNames: { 'adaptive-fast': 'Adaptive Fast' } },
        'adaptive-fast',
        'Capability Fast',
      ),
    ).toBe('Adaptive Fast');
    expect(modelCompactEffortLabel('en-US', t, null, 'adaptive-safe', 'Adaptive Safe')).toBe(
      'Adaptive Safe',
    );
  });

  it.each([
    {
      agentKind: 'claude-code' as const,
      vendorKey: 'cc' as const,
      currentModel: {
        id: 'claude-opus-4-8',
        displayName: 'Opus 4.8',
        contextWindow: 200000,
        efforts: ['high'],
        defaultEffort: 'high',
        supportsFastMode: false,
      },
      seedEfforts: ['low', 'medium', 'high'],
      seedDefaultEffort: 'low',
      seedLabel: 'Low',
      glmEfforts: ['high', 'max'],
    },
    {
      agentKind: 'codex' as const,
      vendorKey: 'codex' as const,
      currentModel: {
        id: 'gpt-5.5',
        displayName: 'GPT-5.5',
        contextWindow: 400000,
        efforts: ['high'],
        defaultEffort: 'high',
        supportsFastMode: false,
      },
      seedEfforts: ['minimal', 'low', 'medium', 'high'],
      seedDefaultEffort: 'minimal',
      seedLabel: 'Minimal',
      glmEfforts: ['minimal', 'high', 'max'],
    },
  ])(
    'renders the corrected XD effort defaults without Fast markers for $agentKind',
    ({
      agentKind,
      vendorKey,
      currentModel,
      seedEfforts,
      seedDefaultEffort,
      seedLabel,
      glmEfforts,
    }) => {
      const targetModels: VisibleModelFixture[] = [
        {
          id: 'bytedance-seed/seed-2.1-pro',
          displayName: 'Seed 2.1 Pro',
          contextWindow: 256000,
          efforts: seedEfforts,
          defaultEffort: seedDefaultEffort,
          supportsFastMode: false,
        },
        {
          id: 'moonshotai/kimi-k3',
          displayName: 'Kimi K3',
          contextWindow: 1000000,
          efforts: ['low', 'high', 'max'],
          defaultEffort: 'max',
          supportsFastMode: false,
        },
        {
          id: 'qwen/qwen3.8-max-preview',
          displayName: 'Qwen 3.8 Max Preview',
          contextWindow: 983616,
          efforts: ['low', 'high', 'xhigh'],
          defaultEffort: 'xhigh',
          supportsFastMode: false,
        },
        {
          id: 'z-ai/glm-5.2',
          displayName: 'GLM-5.2',
          contextWindow: 1000000,
          efforts: glmEfforts,
          defaultEffort: 'max',
          supportsFastMode: false,
        },
        {
          id: 'deepseek/deepseek-v4-pro',
          displayName: 'DeepSeek V4 Pro',
          contextWindow: 1048576,
          efforts: ['high', 'max'],
          defaultEffort: 'high',
          supportsFastMode: false,
        },
        {
          id: 'deepseek/deepseek-v4-flash',
          displayName: 'DeepSeek V4 Flash',
          contextWindow: 1048576,
          efforts: ['high', 'max'],
          defaultEffort: 'high',
          supportsFastMode: false,
        },
      ];
      const originalCapabilities = agentCapabilitiesRef.capabilities;
      visibleModelsRef.models = [currentModel, ...targetModels];
      agentCapabilitiesRef.capabilities = {
        availableModels: visibleModelsRef.models,
        effortLevels: [
          { id: 'minimal', displayName: 'Minimal' },
          { id: 'low', displayName: 'Low' },
          { id: 'medium', displayName: 'Medium' },
          { id: 'high', displayName: 'High' },
          { id: 'xhigh', displayName: 'X-High' },
          { id: 'max', displayName: 'Max' },
        ],
        hasFastMode: true,
      };
      providersRef.providers = [
        {
          id: 'xd',
          name: 'Cindy',
          connected: true,
          agents: [agentKind],
          routing: { [agentKind]: {} },
          models: {
            [agentKind]: visibleModelsRef.models.map((model) => ({
              ...model,
              name: model.displayName,
            })),
          },
        },
      ];
      const modelMemory = {
        getEffort: vi.fn(),
        setEffort: vi.fn(),
        // Even a stale persisted Fast=true must not render when the model capability is false.
        getFast: vi.fn(() => true),
        setFast: vi.fn(),
      };

      try {
        render(
          React.createElement(ModelSelectorContent, {
            modelId: currentModel.id,
            effort: 'high',
            fastMode: false,
            onModelChange: vi.fn(),
            onEffortChange: vi.fn(),
            onFastModeChange: vi.fn(),
            vendorKey,
            currentProviderId: 'xd',
            onProviderChange: vi.fn(),
            modelMemory,
          }),
        );

        expect(screen.getByRole('option', { name: /Seed 2\.1 Pro/ }).textContent).toContain(
          seedLabel,
        );
        expect(screen.getByRole('option', { name: /Kimi K3/ }).textContent).toContain('Max');
        expect(screen.getByRole('option', { name: /Qwen 3\.8 Max Preview/ }).textContent).toContain(
          '超高',
        );
        expect(screen.getByRole('option', { name: /GLM-5\.2/ }).textContent).toContain('Max');
        expect(screen.getByRole('option', { name: /DeepSeek V4 Pro/ }).textContent).toContain(
          'High',
        );
        expect(screen.getByRole('option', { name: /DeepSeek V4 Flash/ }).textContent).toContain(
          'High',
        );
        expect(screen.queryByLabelText('newChat.modelSelector.meta.fastBadge')).toBeNull();
      } finally {
        visibleModelsRef.models = null;
        agentCapabilitiesRef.capabilities = originalCapabilities;
        providersRef.providers = providersRef.DEFAULT_PROVIDERS;
      }
    },
  );

  it('renders an active fallback option without model effort metadata', () => {
    render(
      React.createElement(ModelSelector, {
        modelId: '',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        triggerVariant: 'field',
        fallbackOption: {
          active: true,
          label: '不指定(跟随原逻辑)',
          onSelect: vi.fn(),
        },
      }),
    );

    const trigger = screen.getByRole('button', { name: /不指定(跟随原逻辑)/ });
    expect(trigger.textContent).toContain('不指定(跟随原逻辑)');
    expect(trigger.textContent).not.toContain('high');
  });

  it('localizes missing model metadata without presenting an empty selection', () => {
    render(
      React.createElement(ModelSelector, {
        modelId: 'missing-model',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        triggerVariant: 'field',
      }),
    );

    expect(screen.getByRole('button', { name: /模型信息暂不可用/ }).textContent).toContain('模型信息暂不可用');
  });

  it('can hide model effort and Fast editing controls for model-id-only settings', () => {
    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        configurationEnabled: false,
      }),
    );

    fireEvent.pointerEnter(screen.getByRole('option', { name: /Opus 4\.8/ }));
    const information = screen.getByRole('group', { name: /Opus 4\.8/ });
    expect(within(information).getByText('适合复杂分析、编程与细致写作。')).toBeTruthy();
    expect(within(information).queryByRole('option')).toBeNull();
  });

  it.each([
    {
      label: 'OpenAI Chat → Responses',
      providerProtocol: 'openai-chat',
      modelProtocol: undefined,
      visible: true,
    },
    {
      label: 'Anthropic Messages → Responses',
      providerProtocol: 'anthropic-messages',
      modelProtocol: undefined,
      visible: true,
    },
    {
      label: 'Cindy AI 模型级 Anthropic bridge',
      providerProtocol: 'openai-responses',
      modelProtocol: 'anthropic-messages',
      visible: true,
    },
    {
      label: '原生 Responses',
      providerProtocol: 'openai-responses',
      modelProtocol: undefined,
      visible: false,
    },
  ] as const)(
    '$label 的模型详情兼容模式标记 visible=$visible',
    ({ providerProtocol, modelProtocol, visible }) => {
      const currentModel: VisibleModelFixture = {
        id: 'bridge-fixture-model',
        displayName: 'Bridge Fixture',
        contextWindow: 1_000_000,
        efforts: ['high'],
        defaultEffort: 'high',
        ...(modelProtocol ? { codexCompatibilityWireProtocol: modelProtocol } : {}),
      };
      const originalCapabilities = agentCapabilitiesRef.capabilities;
      visibleModelsRef.models = [currentModel];
      agentCapabilitiesRef.capabilities = {
        availableModels: [currentModel],
        effortLevels: [{ id: 'high', displayName: 'High' }],
        hasFastMode: false,
      };
      providersRef.providers = [
        {
          id: modelProtocol ? 'xd' : 'fixture',
          name: modelProtocol ? 'Cindy AI' : 'Fixture',
          source: modelProtocol ? 'builtin' : 'user',
          connected: true,
          agents: ['codex'],
          auth: { method: 'none' },
          routing: {
            codex: {
              upstream: 'https://example.test',
              authStrategy: 'none',
              wireProtocol: providerProtocol,
            },
          },
          models: {
            codex: [
              {
                ...currentModel,
                name: currentModel.displayName,
              },
            ],
          },
        },
      ];

      try {
        render(
          React.createElement(ModelSelectorContent, {
            modelId: currentModel.id,
            effort: 'high',
            onModelChange: vi.fn(),
            onEffortChange: vi.fn(),
            vendorKey: 'codex',
            currentProviderId: modelProtocol ? 'xd' : 'fixture',
            onProviderChange: vi.fn(),
          }),
        );

        fireEvent.pointerEnter(screen.getByRole('option', { name: /Bridge Fixture/ }));
        const details = screen.getByRole('group', { name: /Bridge Fixture/ });
        const compatibilityLabel = within(details).queryByText('Codex compatibility mode');
        if (visible) {
          expect(compatibilityLabel).toBeTruthy();
          const detailText = details.textContent ?? '';
          const sourceText = modelProtocol ? 'Source: Cindy AI' : 'Source: Fixture';
          expect(detailText.indexOf(sourceText)).toBeLessThan(detailText.indexOf('1M context'));
          expect(detailText.indexOf('1M context')).toBeLessThan(
            detailText.indexOf('Codex compatibility mode'),
          );
          expect(compatibilityLabel).not.toBe(within(details).getByText(sourceText).parentElement);
          expect(compatibilityLabel).not.toBe(
            within(details).getByText('1M context').parentElement,
          );
        } else {
          expect(compatibilityLabel).toBeNull();
        }
      } finally {
        visibleModelsRef.models = null;
        agentCapabilitiesRef.capabilities = originalCapabilities;
        providersRef.providers = providersRef.DEFAULT_PROVIDERS;
      }
    },
  );

  it('filters provider-ignored models from flat model-only selectors', () => {
    modelVisibilityRef.isEnabled = (_agent, _providerId, model) => model.id !== 'claude-sonnet-4-6';
    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: '',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          configurationEnabled: false,
        }),
      );

      expect(screen.getByRole('option', { name: /Opus 4\.8/ })).toBeTruthy();
      expect(screen.queryByRole('option', { name: /Sonnet 4\.6/ })).toBeNull();
    } finally {
      modelVisibilityRef.isEnabled = () => true;
    }
  });

  it('forwards an overlay-specific z-index to the model information panel', () => {
    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        overlayContentClassName: 'z-[10020]',
      }),
    );

    fireEvent.pointerEnter(screen.getByRole('option', { name: /Opus 4\.8/ }));
    expect(screen.getByTestId('model-options-popover').className).toContain('z-[10020]');
  });

  it('keeps non-Gateway prices in model details without repeating them in the primary row', () => {
    vi.useFakeTimers();
    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
      }),
    );

    const row = screen.getByRole('option', { name: /Opus 4\.8/ });
    expect(screen.queryByRole('group', { name: /Opus 4\.8/ })).toBeNull();
    expect(screen.queryByText('newChat.modelSelector.edit')).toBeNull();

    fireEvent.pointerEnter(row);
    const options = screen.getByRole('group', { name: /Opus 4\.8/ });
    expect(screen.getByTestId('model-options-popover').getAttribute('data-align')).toBe('center');
    expect(screen.getByTestId('model-options-popover').getAttribute('data-side-offset')).toBe('8');
    expect(options).toBeTruthy();
    expect(within(options).getByText('适合复杂分析、编程与细致写作。')).toBeTruthy();
    expect(within(options).getByText('Source: Anthropic')).toBeTruthy();
    expect(within(options).getByText('200K context')).toBeTruthy();
    const priceTitle = within(options).getByText('newChat.modelSelector.pricing.title');
    expect(row.textContent).not.toContain('$3 / $15');
    expect(row.textContent).not.toContain('¥');
    expect(row.textContent).not.toContain('≈');
    expect(within(options).getByText('$3')).toBeTruthy();
    expect(within(options).getByText('$15')).toBeTruthy();
    expect(within(options).getByText('$0.3')).toBeTruthy();
    expect(within(options).getByText('$3.75')).toBeTruthy();
    expect(
      within(options).getByText('newChat.modelSelector.pricing.subscriptionEstimate'),
    ).toBeTruthy();
    const firstChoice = within(options).getByRole('option', { name: 'low' });
    const description = within(options).getByText('适合复杂分析、编程与细致写作。');
    expect(
      description.compareDocumentPosition(firstChoice) & Node.DOCUMENT_POSITION_FOLLOWING,
    ).toBe(Node.DOCUMENT_POSITION_FOLLOWING);
    expect(firstChoice.compareDocumentPosition(priceTitle) & Node.DOCUMENT_POSITION_FOLLOWING).toBe(
      Node.DOCUMENT_POSITION_FOLLOWING,
    );
    expect(row.getAttribute('data-model-options-active')).toBe('true');

    fireEvent.pointerLeave(row);
    act(() => vi.advanceTimersByTime(79));
    expect(screen.getByRole('group', { name: /Opus 4\.8/ })).toBeTruthy();
    act(() => vi.advanceTimersByTime(1));
    expect(screen.queryByRole('group', { name: /Opus 4\.8/ })).toBeNull();

    fireEvent.focus(row);
    expect(screen.getByRole('group', { name: /Opus 4\.8/ })).toBeTruthy();

    // 列表滚动不派发 pointerleave,浮层会跟着滚出视口的锚点行跑到菜单外 → 用户滚动必须立即收起。
    fireEvent.scroll(screen.getByRole('listbox', { name: '模型列表' }));
    expect(screen.queryByRole('group', { name: /Opus 4\.8/ })).toBeNull();
    vi.useRealTimers();
  });

  it('keeps non-price access labels in the primary model row', () => {
    providersRef.providers = [
      {
        ...(providersRef.DEFAULT_PROVIDERS[0] as Record<string, unknown>),
        access: { kind: 'subscription', product: 'Claude Pro' },
      },
    ];

    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'anthropic',
          onProviderChange: vi.fn(),
        }),
      );

      const row = screen.getByRole('option', { name: /Opus 4\.8/ });
      const tags = row.querySelector('[data-model-tags]');
      expect(tags).not.toBeNull();
      expect(
        within(tags as HTMLElement).getByText('settings.providers.models.subscription'),
      ).toBeTruthy();
      expect(row.querySelector('[data-model-hidden-label]')).toBeNull();
      expect(row.textContent).not.toContain('$3 / $15');
      expect(row.querySelector('[data-model-promotion-badge]')).toBeNull();
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('renders selected hidden status before its subscription label', () => {
    providersRef.providers = [
      {
        ...(providersRef.DEFAULT_PROVIDERS[0] as Record<string, unknown>),
        access: { kind: 'subscription', product: 'Claude Pro' },
      },
    ];
    modelVisibilityRef.isEnabled = () => false;

    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'anthropic',
          onProviderChange: vi.fn(),
          fluidWidth: true,
        }),
      );

      const row = screen.getByRole('option', { name: /Opus 4\.8/ });
      const tags = row.querySelector('[data-model-tags]');
      expect(tags).not.toBeNull();
      const hidden = within(tags as HTMLElement).getByText('已隐藏');
      const subscription = within(tags as HTMLElement).getByText(
        'settings.providers.models.subscription',
      );
      expect(hidden.compareDocumentPosition(subscription) & Node.DOCUMENT_POSITION_FOLLOWING).toBe(
        Node.DOCUMENT_POSITION_FOLLOWING,
      );
      expect(row.querySelector('[data-model-hidden-label]')).toBe(hidden);
      expect(screen.queryByRole('option', { name: /Sonnet 4\.6/ })).toBeNull();
    } finally {
      modelVisibilityRef.isEnabled = () => true;
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('keeps only the selected hidden model in the flat picker', () => {
    providersRef.providers = [
      {
        ...(providersRef.DEFAULT_PROVIDERS[0] as Record<string, unknown>),
        access: { kind: 'subscription', product: 'Claude Pro' },
      },
    ];
    modelVisibilityRef.isEnabled = () => false;

    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        currentProviderId: 'anthropic',
        fluidWidth: true,
      }),
    );

    const selected = screen.getByRole('option', { name: /Opus 4\.8/ });
    expect(selected.querySelector('[data-model-hidden-label]')?.textContent).toBe('已隐藏');
    expect(within(selected).getByText('settings.providers.models.subscription')).toBeTruthy();
    expect(screen.queryByRole('option', { name: /Sonnet 4\.6/ })).toBeNull();
    expect(screen.queryByRole('option', { name: /Haiku 4\.5/ })).toBeNull();
  });

  it('prioritizes the full selected model name in the fixed 320px picker', () => {
    providersRef.providers = [
      {
        ...(providersRef.DEFAULT_PROVIDERS[0] as Record<string, unknown>),
        access: { kind: 'subscription', product: 'Claude Pro' },
      },
    ];
    modelVisibilityRef.isEnabled = (_agent: string, _providerId: string, model: { id: string }) =>
      model.id !== 'claude-opus-4-8';

    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'anthropic',
          onProviderChange: vi.fn(),
        }),
      );

      const selected = screen.getByRole('option', { name: /Opus 4\.8/ });
      expect(selected.querySelector('[data-model-hidden-label]')?.textContent).toBe('已隐藏');
      expect(selected.textContent).not.toContain('settings.providers.models.subscription');
      expect(
        within(screen.getByRole('option', { name: /Sonnet 4\.6/ })).getByText(
          'settings.providers.models.subscription',
        ),
      ).toBeTruthy();
    } finally {
      modelVisibilityRef.isEnabled = () => true;
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('uses the remote visibility snapshot for the selected hidden status', () => {
    deviceProvidersRef.providers = [
      {
        ...(providersRef.DEFAULT_PROVIDERS[0] as Record<string, unknown>),
        access: { kind: 'subscription', product: 'Claude Pro' },
      },
    ];
    deviceProvidersRef.modelVisibilityOverrides = {
      'claude-code:anthropic:claude-opus-4-8': false,
    };

    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          deviceId: 'remote-device',
          currentProviderId: 'anthropic',
        }),
      );

      const row = screen.getByRole('option', { name: /Opus 4\.8/ });
      expect(row.querySelector('[data-model-hidden-label]')?.textContent).toBe('已隐藏');
    } finally {
      deviceProvidersRef.providers = [];
      deviceProvidersRef.modelVisibilityOverrides = undefined;
    }
  });

  it('binds the pane observer when providers arrive after the empty state', async () => {
    type ObserverInstance = {
      callback: ResizeObserverCallback;
      observe: ReturnType<typeof vi.fn>;
      disconnect: ReturnType<typeof vi.fn>;
    };
    const instances: ObserverInstance[] = [];
    const originalResizeObserver = globalThis.ResizeObserver;
    class MockResizeObserver {
      readonly callback: ResizeObserverCallback;
      readonly observe = vi.fn();
      readonly unobserve = vi.fn();
      readonly disconnect = vi.fn();

      constructor(callback: ResizeObserverCallback) {
        this.callback = callback;
        instances.push(this);
      }
    }
    Object.defineProperty(globalThis, 'ResizeObserver', {
      configurable: true,
      writable: true,
      value: MockResizeObserver,
    });
    const rectSpy = vi.spyOn(HTMLElement.prototype, 'getBoundingClientRect').mockImplementation(
      () =>
        ({
          top: 0,
          bottom: 100,
          left: 0,
          right: 500,
          width: 500,
          height: 100,
          x: 0,
          y: 0,
          toJSON: () => ({}),
        }) as DOMRect,
    );
    providersRef.providers = [];

    try {
      const props = {
        modelId: 'claude-opus-4-8',
        effort: 'high' as Effort,
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc' as const,
        currentProviderId: 'anthropic',
        onProviderChange: vi.fn(),
        fluidWidth: true,
      };
      const view = render(React.createElement(ModelSelectorContent, props));

      expect(screen.getByText('newChat.modelSelector.source.emptyTitle')).toBeTruthy();
      expect(instances).toHaveLength(0);

      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
      view.rerender(React.createElement(ModelSelectorContent, props));

      await waitFor(() => expect(instances).toHaveLength(1));
      const firstPane = document.querySelector<HTMLElement>('[data-model-tag-density]');
      expect(firstPane).not.toBeNull();
      expect(instances[0].observe).toHaveBeenCalledWith(firstPane);
      expect(firstPane?.getAttribute('data-model-tag-density')).toBe('full');

      act(() => {
        instances[0].callback(
          [
            {
              target: firstPane,
              contentRect: { width: 320 },
            } as unknown as ResizeObserverEntry,
          ],
          instances[0] as unknown as ResizeObserver,
        );
      });
      expect(firstPane?.getAttribute('data-model-tag-density')).toBe('hidden');

      providersRef.providers = [];
      view.rerender(React.createElement(ModelSelectorContent, props));
      await waitFor(() => expect(instances[0].disconnect).toHaveBeenCalledTimes(1));

      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
      view.rerender(React.createElement(ModelSelectorContent, props));
      await waitFor(() => expect(instances).toHaveLength(2));
      const secondPane = document.querySelector<HTMLElement>('[data-model-tag-density]');
      expect(secondPane).not.toBeNull();
      expect(instances[1].observe).toHaveBeenCalledWith(secondPane);

      view.unmount();
      expect(instances[1].disconnect).toHaveBeenCalledTimes(1);
    } finally {
      rectSpy.mockRestore();
      Object.defineProperty(globalThis, 'ResizeObserver', {
        configurable: true,
        writable: true,
        value: originalResizeObserver,
      });
    }
  });

  it('keeps discounted Gateway prices in details while retaining the primary-row label', () => {
    providersRef.providers = [
      {
        id: 'xd',
        name: 'Cindy AI',
        connected: true,
        agents: ['claude-code'],
        routing: { 'claude-code': {} },
        models: {
          'claude-code': [
            {
              id: 'qwen-3.7',
              name: 'Qwen 3.7',
              contextWindow: 200000,
              efforts: ['high'],
              defaultEffort: 'high',
              cost: { input: 6, output: 18, cacheRead: 1.2, cacheWrite: 7.5 },
            },
          ],
        },
      },
    ];
    pricingRef.pricing = {
      xd: {
        'qwen-3.7': {
          providerId: 'xd',
          modelId: 'qwen-3.7',
          currency: 'CNY',
          source: 'gateway',
          approximate: false,
          inputPerMtok: 12,
          outputPerMtok: 36,
          cacheReadPerMtok: 2.4,
          cacheCreatePerMtok: 15,
        },
      },
    };

    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'qwen-3.7',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'xd',
          onProviderChange: vi.fn(),
          maxVisibleModelRows: 6,
        }),
      );

      // 一级菜单保持单行并保留折价标签;折后价和标准价只在完整详情展示。
      const row = screen.getByRole('option', { name: /Qwen 3\.7/ });
      expect(row.className).toContain('min-h-9');
      expect(within(row).getByText('Qwen 3.7').className).toContain('leading-5');
      expect(screen.getByRole('listbox', { name: '模型列表' }).style.maxHeight).toBe('226px');
      expect(row.textContent).not.toContain('¥6 / ¥18');
      expect(row.textContent).not.toContain('¥12 / ¥36');
      const rowBadge = within(row).getByText('立省 50%');
      expect(rowBadge.hasAttribute('data-model-promotion-badge')).toBe(true);
      expect(rowBadge.parentElement?.hasAttribute('data-model-tags')).toBe(true);
      expect(row.querySelector('[data-model-price-stack]')).toBeNull();

      fireEvent.pointerEnter(row);
      const details = screen.getByRole('group', { name: /Qwen 3\.7/ });
      expect(within(details).getByText('¥6')).toBeTruthy();
      expect(within(details).getByText('¥18')).toBeTruthy();
      expect(within(details).getByText('¥12').className).toContain('line-through');
      expect(within(details).getByText('¥36').className).toContain('line-through');
      // 缓存价同样按折后价展示,标准缓存价并排划线。
      expect(within(details).getByText('¥1.2')).toBeTruthy();
      expect(within(details).getByText('¥2.4').className).toContain('line-through');
      expect(within(details).getByText('¥7.5')).toBeTruthy();
      expect(within(details).getByText('¥15').className).toContain('line-through');
      const detailsBadge = within(details).getByText('立省 50%');
      expect(detailsBadge.parentElement?.hasAttribute('data-model-tags')).toBe(true);
      expect(detailsBadge.parentElement?.className).toContain('ml-auto');
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
      pricingRef.pricing = pricingRef.DEFAULT_PRICING;
    }
  });

  it('keeps explicit free labels in the row while leaving full information in details', () => {
    providersRef.providers = [
      {
        id: 'xd',
        name: 'Cindy AI',
        connected: true,
        agents: ['claude-code'],
        routing: { 'claude-code': {} },
        models: {
          'claude-code': [
            {
              id: 'free-gateway-model',
              name: 'Free Gateway Model',
              contextWindow: 200000,
              efforts: ['high'],
              defaultEffort: 'high',
              cost: { input: 0, output: 0 },
            },
          ],
        },
      },
    ];
    pricingRef.pricing = null;

    try {
      const loading = render(
        React.createElement(ModelSelectorContent, {
          modelId: 'free-gateway-model',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'xd',
          onProviderChange: vi.fn(),
        }),
      );
      expect(
        within(screen.getByRole('option', { name: /Free Gateway Model/ })).queryByText('限时免费'),
      ).toBeNull();
      loading.unmount();

      pricingRef.pricing = {};
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'free-gateway-model',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'xd',
          onProviderChange: vi.fn(),
        }),
      );

      const row = screen.getByRole('option', { name: /Free Gateway Model/ });
      const rowBadge = within(row).getByText('限时免费');
      expect(rowBadge.hasAttribute('data-model-promotion-badge')).toBe(true);
      expect(rowBadge.parentElement?.hasAttribute('data-model-tags')).toBe(true);
      expect(row.querySelectorAll('[data-model-promotion-badge]')).toHaveLength(1);

      fireEvent.pointerEnter(row);
      const details = screen.getByRole('group', { name: /Free Gateway Model/ });
      const detailsBadge = within(details).getByText('限时免费');
      expect(detailsBadge.parentElement?.hasAttribute('data-model-tags')).toBe(true);
      expect(detailsBadge.parentElement?.className).toContain('ml-auto');
      expect(within(details).queryByText('newChat.modelSelector.pricing.perMillion')).toBeNull();
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
      pricingRef.pricing = pricingRef.DEFAULT_PRICING;
    }
  });

  it('shows model information even when a model has no configurable options', () => {
    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
      }),
    );

    fireEvent.pointerEnter(screen.getByRole('option', { name: /Haiku 4\.5/ }));
    const information = screen.getByRole('group', { name: /Haiku 4\.5/ });
    expect(within(information).getByText('适合简短问答、摘要与短文写作。')).toBeTruthy();
    expect(within(information).getByText('200K context')).toBeTruthy();
    expect(within(information).queryByRole('option')).toBeNull();
  });

  it('opens the selected model configuration when the caller opts into click access', () => {
    const onEffortChange = vi.fn();
    const onDismiss = vi.fn();

    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange,
        onDismiss,
        vendorKey: 'cc',
        selectedRowClickOpensConfiguration: true,
      }),
    );

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

    const options = screen.getByRole('group', { name: /Opus 4\.8/ });
    fireEvent.click(within(options).getByRole('option', { name: 'low' }));

    expect(onEffortChange).toHaveBeenCalledWith('low');
    expect(onDismiss).not.toHaveBeenCalled();
  });

  it('selects an inactive provider row after its effort preset is clicked', () => {
    const onProviderChange = vi.fn();
    const onDismiss = vi.fn();
    const setEffort = vi.fn();
    const modelMemory = {
      getEffort: vi.fn(() => 'high'),
      setEffort,
      getFast: vi.fn(),
      setFast: vi.fn(),
    };

    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        currentProviderId: 'anthropic',
        onProviderChange,
        onDismiss,
        modelMemory,
      }),
    );

    const opusRow = screen.getByRole('option', { name: /Opus 4\.8/ });
    const sonnetRow = screen.getByRole('option', { name: /Sonnet 4\.6/ });
    fireEvent.pointerEnter(opusRow);
    expect(screen.getByRole('group', { name: /Opus 4\.8/ })).toBeTruthy();

    fireEvent.pointerEnter(sonnetRow);
    expect(screen.queryByRole('group', { name: /Opus 4\.8/ })).toBeNull();
    const options = screen.getByRole('group', { name: /Sonnet 4\.6/ });
    expect(sonnetRow.getAttribute('data-model-options-active')).toBe('true');
    expect(opusRow.getAttribute('data-model-options-active')).toBeNull();
    fireEvent.click(within(options).getByRole('option', { name: 'high' }));

    expect(setEffort).toHaveBeenCalledWith('claude-code', 'anthropic', 'claude-sonnet-4-6', 'high');
    expect(onProviderChange).toHaveBeenCalledWith('anthropic', 'claude-sonnet-4-6', 'high');
    expect(onDismiss).not.toHaveBeenCalled();
    expect(setEffort.mock.invocationCallOrder[0]).toBeLessThan(
      onProviderChange.mock.invocationCallOrder[0],
    );
  });

  it('lets provider-based callers choose inactive-row effort without a global memory store', () => {
    const onProviderChange = vi.fn();
    const onDismiss = vi.fn();

    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        currentProviderId: 'anthropic',
        onProviderChange,
        onDismiss,
      }),
    );

    const sonnetRow = screen.getByRole('option', { name: /Sonnet 4\.6/ });
    fireEvent.pointerEnter(sonnetRow);

    const options = screen.getByRole('group', { name: /Sonnet 4\.6/ });
    expect(within(options).getByRole('option', { name: 'high' })).toBeTruthy();
    fireEvent.click(within(options).getByRole('option', { name: 'high' }));

    expect(onProviderChange).toHaveBeenCalledWith('anthropic', 'claude-sonnet-4-6', 'high');
    expect(onDismiss).not.toHaveBeenCalled();
  });

  it('selects an inactive provider row after its Fast toggle is clicked', () => {
    const onProviderChange = vi.fn();
    const onDismiss = vi.fn();
    const setFast = vi.fn();
    const modelMemory = {
      getEffort: vi.fn(),
      setEffort: vi.fn(),
      getFast: vi.fn(() => false),
      setFast,
    };
    agentCapabilitiesRef.capabilities = {
      ...agentCapabilitiesRef.DEFAULT_CAPABILITIES,
      hasFastMode: true,
    };
    providersRef.providers = [
      {
        ...(providersRef.DEFAULT_PROVIDERS[0] as Record<string, unknown>),
        models: {
          'claude-code': (
            providersRef.DEFAULT_PROVIDERS[0] as { models: { 'claude-code': unknown[] } }
          ).models['claude-code'].map((model) =>
            (model as { id: string }).id === 'claude-sonnet-4-6'
              ? { ...(model as Record<string, unknown>), supportsFastMode: true }
              : model,
          ),
        },
      },
    ];

    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          fastMode: false,
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          onFastModeChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'anthropic',
          onProviderChange,
          onDismiss,
          modelMemory,
        }),
      );

      fireEvent.pointerEnter(screen.getByRole('option', { name: /Sonnet 4\.6/ }));
      fireEvent.click(screen.getByRole('button', { name: 'Fast Mode' }));

      expect(setFast).toHaveBeenCalledWith('claude-code', 'anthropic', 'claude-sonnet-4-6', true);
      expect(onProviderChange).toHaveBeenCalledWith('anthropic', 'claude-sonnet-4-6', 'medium');
      expect(onDismiss).not.toHaveBeenCalled();
      expect(setFast.mock.invocationCallOrder[0]).toBeLessThan(
        onProviderChange.mock.invocationCallOrder[0],
      );
    } finally {
      agentCapabilitiesRef.capabilities = agentCapabilitiesRef.DEFAULT_CAPABILITIES;
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('keeps the model picker open after an inactive row configuration selects that model', async () => {
    const modelMemory = {
      getEffort: vi.fn(),
      setEffort: vi.fn(),
      getFast: vi.fn(),
      setFast: vi.fn(),
    };

    function Harness() {
      const [selection, setSelection] = React.useState({
        providerId: 'anthropic',
        modelId: 'claude-opus-4-8',
      });
      return React.createElement(ModelSelector, {
        modelId: selection.modelId,
        effort: 'high',
        onModelChange: (modelId: string) => setSelection((current) => ({ ...current, modelId })),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        currentProviderId: selection.providerId,
        onProviderChange: (providerId: string | null, modelId?: string) => {
          if (providerId && modelId) setSelection({ providerId, modelId });
        },
        modelMemory,
      });
    }

    render(React.createElement(Harness));
    await clickTrigger();

    fireEvent.pointerEnter(screen.getByRole('option', { name: /Sonnet 4\.6/ }));
    const options = screen.getByRole('group', { name: /Sonnet 4\.6/ });
    fireEvent.click(within(options).getByRole('option', { name: 'high' }));

    expect(screen.getByRole('option', { name: /Sonnet 4\.6/ }).getAttribute('aria-selected')).toBe(
      'true',
    );
    expect(screen.getByRole('option', { name: /Opus 4\.8/ })).toBeTruthy();
  });

  it('locks an open remote picker while its configuration selection is in flight', async () => {
    const onProviderChange = vi.fn();
    const modelMemory = {
      getEffort: vi.fn(),
      setEffort: vi.fn(),
      getFast: vi.fn(),
      setFast: vi.fn(),
    };
    function Harness() {
      const [switching, setSwitching] = React.useState(false);
      return React.createElement(ModelSelector, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        currentProviderId: 'anthropic',
        onProviderChange: (providerId: string | null, modelId?: string) => {
          onProviderChange(providerId, modelId);
          setSwitching(true);
        },
        modelMemory,
        switching,
      });
    }

    render(React.createElement(Harness));
    await clickTrigger();

    fireEvent.pointerEnter(screen.getByRole('option', { name: /Sonnet 4\.6/ }));
    fireEvent.click(
      within(screen.getByRole('group', { name: /Sonnet 4\.6/ })).getByRole('option', {
        name: 'high',
      }),
    );

    expect(onProviderChange).toHaveBeenCalledTimes(1);
    expect(
      screen.getByRole('button', { name: /Current: Opus 4\.8/ }).hasAttribute('disabled'),
    ).toBe(true);
    const opusRow = screen.getByRole('option', { name: /Opus 4\.8/ });
    expect(opusRow.getAttribute('aria-disabled')).toBe('true');
    expect(screen.queryByRole('group', { name: /Sonnet 4\.6/ })).toBeNull();
    const searchInput = screen.getByRole('textbox', {
      name: 'newChat.modelSelector.search.placeholderAll',
    });
    expect(searchInput.hasAttribute('disabled')).toBe(true);
    expect(searchInput.className).toContain('cursor-not-allowed');
    expect(searchInput.className).toContain('text-[var(--text-disabled)]');
    expect(searchInput.className).toContain('placeholder:text-[var(--text-disabled)]');
    expect(searchInput.parentElement?.className).toContain('bg-[var(--surface-elevated-soft)]');

    fireEvent.click(opusRow);
    fireEvent.pointerEnter(opusRow);
    expect(onProviderChange).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole('group', { name: /Opus 4\.8/ })).toBeNull();
  });

  it('keeps target-agent provider rows and effort memory configurable while browsing Codex', async () => {
    providersRef.providers = [
      ...providersRef.DEFAULT_PROVIDERS,
      {
        id: 'zeta-codex',
        name: 'Zeta Codex',
        connected: true,
        agents: ['codex'],
        routing: { codex: {} },
        models: {
          codex: [
            {
              id: 'gpt-5.5',
              name: 'GPT-5.5',
              contextWindow: 400000,
              efforts: ['low', 'medium', 'high'],
              defaultEffort: 'medium',
            },
          ],
        },
      },
    ];
    let rememberedEffort: Effort = 'high';
    const setEffort = vi.fn(
      (_agent: string, _providerId: string, _modelId: string, nextEffort: Effort) => {
        rememberedEffort = nextEffort;
      },
    );
    const onDismiss = vi.fn();
    const confirmBrowseSwitch = vi.fn(async () => true);
    let releaseFirstSwitch!: () => void;
    const firstSwitch = new Promise<void>((resolve) => {
      releaseFirstSwitch = resolve;
    });
    const observedSwitchEfforts: Effort[] = [];
    const onSwitch = vi
      .fn()
      .mockImplementationOnce(async () => {
        observedSwitchEfforts.push(rememberedEffort);
        await firstSwitch;
      })
      .mockImplementationOnce(() => {
        observedSwitchEfforts.push(rememberedEffort);
      });
    const modelMemory = {
      getEffort: vi.fn((agent: string, providerId: string, modelId: string) =>
        agent === 'codex' && providerId === 'zeta-codex' && modelId === 'gpt-5.5'
          ? rememberedEffort
          : undefined,
      ),
      setEffort,
      getFast: vi.fn(),
      setFast: vi.fn(),
    };

    try {
      render(
        React.createElement(ModelSelectorContent, {
          modelId: 'claude-opus-4-8',
          effort: 'medium',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
          currentProviderId: 'anthropic',
          onProviderChange: vi.fn(),
          onDismiss,
          modelMemory,
          agentSwitch: { currentVendor: 'cc', confirmBrowseSwitch, onSwitch },
        }),
      );

      fireEvent.click(screen.getByRole('tab', { name: /Codex/ }));
      const row = await screen.findByRole('option', { name: /GPT-5\.5/ });
      expect(confirmBrowseSwitch).toHaveBeenCalledTimes(1);
      // 确认门收**本次目标引擎**(Chris 2026-08-19):调用方靠它判「已有指向该目标的意图」,
      // 不传目标会让确认框在任何残留意图之后永久静默。
      expect(confirmBrowseSwitch).toHaveBeenCalledWith('codex');
      // 来源 mark 存在说明目标 Agent 仍走 provider sections,而不是退化成 flat。
      expect(row.textContent).toContain('Z');
      // 行尾与悬浮面板同读目标 Agent 的 per-(来源,模型) 记忆,不落模型默认 medium。
      expect(row.textContent).toContain('high');
      expect(row.textContent).not.toContain('medium');

      fireEvent.pointerEnter(row);
      const options = screen.getByRole('group', { name: /GPT-5\.5/ });
      expect(
        within(options).getByRole('option', { name: 'high' }).getAttribute('aria-selected'),
      ).toBe('true');
      fireEvent.click(within(options).getByRole('option', { name: 'low' }));
      expect(setEffort).toHaveBeenCalledWith('codex', 'zeta-codex', 'gpt-5.5', 'low');
      expect(confirmBrowseSwitch).toHaveBeenCalledTimes(1);
      await waitFor(() => expect(onSwitch).toHaveBeenCalledWith('codex', 'gpt-5.5', 'zeta-codex'));
      expect(onDismiss).not.toHaveBeenCalled();
      // 配置点击同时选中目标模型;确认门仍只在 Agent 分段切换。
      expect(confirmBrowseSwitch).toHaveBeenCalledTimes(1);

      fireEvent.click(
        within(screen.getByRole('group', { name: /GPT-5\.5/ })).getByRole('option', {
          name: 'high',
        }),
      );
      await act(async () => {
        await Promise.resolve();
      });
      // 第一笔事务仍在途时,后一次配置也立即交给调用方;调用方会同步登记目标
      // session 的 pending token,再由 session 级协调器保证同会话顺序。
      expect(onSwitch).toHaveBeenCalledTimes(2);
      expect(setEffort).toHaveBeenNthCalledWith(2, 'codex', 'zeta-codex', 'gpt-5.5', 'high');

      await act(async () => {
        releaseFirstSwitch();
        await firstSwitch;
      });
      expect(observedSwitchEfforts).toEqual(['low', 'high']);

      fireEvent.click(screen.getByRole('tab', { name: /Claude/ }));
      await waitFor(() =>
        expect(screen.getByRole('tab', { name: /Claude/ }).getAttribute('aria-selected')).toBe(
          'true',
        ),
      );
      // 返回当前引擎直接切分段,不重复确认。
      expect(confirmBrowseSwitch).toHaveBeenCalledTimes(1);
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('keeps the current Agent tab when pre-browse confirmation is canceled', async () => {
    const confirmBrowseSwitch = vi.fn(async () => false);
    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        agentSwitch: { currentVendor: 'cc', confirmBrowseSwitch, onSwitch: vi.fn() },
      }),
    );

    fireEvent.click(screen.getByRole('tab', { name: /Codex/ }));
    await waitFor(() => expect(confirmBrowseSwitch).toHaveBeenCalledTimes(1));
    expect(screen.getByRole('tab', { name: /Claude/ }).getAttribute('aria-selected')).toBe('true');
    expect(screen.getByRole('tab', { name: /Codex/ }).getAttribute('aria-selected')).toBe('false');
    expect(screen.queryByText('newChat.modelSelector.agentSwitch.hint')).toBeNull();
  });

  it('keeps the expanded model panel open while Agent browse confirmation is shown', async () => {
    let resolveConfirmation!: (confirmed: boolean) => void;
    const confirmBrowseSwitch = vi.fn(
      () =>
        new Promise<boolean>((resolve) => {
          resolveConfirmation = resolve;
        }),
    );
    render(
      React.createElement(ModelSelector, {
        modelId: 'claude-opus-4-8',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        agentSwitch: { currentVendor: 'cc', confirmBrowseSwitch, onSwitch: vi.fn() },
      }),
    );

    fireEvent.click(screen.getByRole('button', { name: /Current: Opus 4\.8/ }));
    fireEvent.click(screen.getByRole('tab', { name: /Codex/ }));
    await waitFor(() => expect(confirmBrowseSwitch).toHaveBeenCalledTimes(1));

    // 模拟 AlertDialog 被 Popover 判成外部交互而发出的 close 请求;确认未结束时
    // 面板仍留在原 Agent 页签,取消后也不发生关闭再打开的闪烁。
    fireEvent.click(screen.getByTestId('mock-popover-dismiss'));
    expect(screen.getByTestId('model-options-popover')).toBeTruthy();
    expect(screen.getByRole('tab', { name: /Claude/ }).getAttribute('aria-selected')).toBe('true');

    await act(async () => resolveConfirmation(false));
    await waitFor(() => expect(screen.getByTestId('model-options-popover')).toBeTruthy());
    expect(screen.getByRole('tab', { name: /Claude/ }).getAttribute('aria-selected')).toBe('true');
  });

  it('shares inactive model presets across conversations while protecting an active model', () => {
    const efforts = new Map<string, Effort>();
    const keyOf = (providerId: string, modelId: string) => `${providerId}:${modelId}`;
    const modelMemory = {
      getEffort: vi.fn((_agent: string, providerId: string, modelId: string) =>
        efforts.get(keyOf(providerId, modelId)),
      ),
      setEffort: vi.fn((_agent: string, providerId: string, modelId: string, effort: Effort) => {
        efforts.set(keyOf(providerId, modelId), effort);
      }),
      getFast: vi.fn(),
      setFast: vi.fn(),
    };

    // 对话 A 当前用 Sonnet,把非当前的 Opus 全局预设改成 High。
    const conversationA = render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-sonnet-4-6',
        effort: 'medium',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        currentProviderId: 'anthropic',
        onProviderChange: vi.fn(),
        modelMemory,
      }),
    );
    fireEvent.pointerEnter(screen.getByRole('option', { name: /Opus 4\.8/ }));
    fireEvent.click(
      within(screen.getByRole('group', { name: /Opus 4\.8/ })).getByRole('option', {
        name: 'high',
      }),
    );
    expect(efforts.get('anthropic:claude-opus-4-8')).toBe('high');
    conversationA.unmount();

    // 对话 B 当前用别的模型,其 Opus 非当前行立即读取同一份 High 预设。
    const conversationB = render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-haiku-4-5',
        effort: 'medium',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        currentProviderId: 'anthropic',
        onProviderChange: vi.fn(),
        modelMemory,
      }),
    );
    fireEvent.pointerEnter(screen.getByRole('option', { name: /Opus 4\.8/ }));
    expect(
      within(screen.getByRole('group', { name: /Opus 4\.8/ }))
        .getByRole('option', { name: 'high' })
        .getAttribute('aria-selected'),
    ).toBe('true');
    conversationB.unmount();

    // 对话 C 正在用 Opus/Medium:选中行以 live 值为准,不被全局 High 覆盖。
    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'claude-opus-4-8',
        effort: 'medium',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        vendorKey: 'cc',
        currentProviderId: 'anthropic',
        onProviderChange: vi.fn(),
        modelMemory,
      }),
    );
    fireEvent.pointerEnter(screen.getByRole('option', { name: /Opus 4\.8/ }));
    const activeOptions = screen.getByRole('group', { name: /Opus 4\.8/ });
    expect(
      within(activeOptions).getByRole('option', { name: 'medium' }).getAttribute('aria-selected'),
    ).toBe('true');
    expect(
      within(activeOptions).getByRole('option', { name: 'high' }).getAttribute('aria-selected'),
    ).toBe('false');
  });

  it('renders the routed source mark on the trigger instead of guessing a model brand', () => {
    // claude-* 模型经自定义网关路由时,trigger 必须显示该来源的 monogram,
    // 不能按 model id 猜成 Claude 厂牌图标(否则订阅直连与网关来源同貌,用户无法自查)。
    providersRef.providers = [
      {
        id: 'zeta-gw',
        name: 'Zeta',
        connected: true,
        agents: ['claude-code'],
        routing: { 'claude-code': {} },
        models: {
          'claude-code': [
            {
              id: 'claude-opus-4-8',
              name: 'Opus 4.8',
              contextWindow: 200000,
              efforts: ['high'],
              defaultEffort: 'high',
            },
          ],
        },
      },
    ];
    try {
      render(
        React.createElement(ModelSelector, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
        }),
      );

      const trigger = screen.getByRole('button', { name: /Current: Opus 4\.8/ });
      // ProviderMark 自定义供应商分支渲染 name 首字母 monogram。
      expect(trigger.textContent).toContain('Z');
      expect(trigger.textContent).toContain('Opus 4.8');
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });

  it('honors the gateway-configured model icon over the source mark fallback', () => {
    // 统一规则:模型条目带 icon(AI Gateway / 目录设定)→ 渲染厂牌 mark(此处 Claude svg),
    // 不再显示来源 monogram;缺省才回落来源标(上一个用例)。
    providersRef.providers = [
      {
        id: 'zeta-gw',
        name: 'Zeta',
        connected: true,
        agents: ['claude-code'],
        routing: { 'claude-code': {} },
        models: {
          'claude-code': [
            {
              id: 'claude-opus-4-8',
              name: 'Opus 4.8',
              contextWindow: 200000,
              efforts: ['high'],
              defaultEffort: 'high',
              icon: 'claude',
            },
          ],
        },
      },
    ];
    try {
      render(
        React.createElement(ModelSelector, {
          modelId: 'claude-opus-4-8',
          effort: 'high',
          onModelChange: vi.fn(),
          onEffortChange: vi.fn(),
          vendorKey: 'cc',
        }),
      );

      const trigger = screen.getByRole('button', { name: /Current: Opus 4\.8/ });
      expect(trigger.textContent).not.toContain('Z');
      expect(trigger.textContent).toContain('Opus 4.8');
    } finally {
      providersRef.providers = providersRef.DEFAULT_PROVIDERS;
    }
  });
});