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。

23.6 KB
Raw Blame
// @vitest-environment jsdom
/**
 * 远程控制的被控电脑上的任务也能选到第三台电脑的远程供应商(2026-10-09 用户反馈:A 远控 B 的
 * 任务时选不到 C 的远程供应商,而手机远控 B 能选到)。
 *
 * 场景:同账号 A(本机,控制端)、B(被控电脑,任务在这台)、C(开了「允许被远程调用」的电脑)。
 * 锁住模型面板的几件事:
 *   1. 任务所在电脑那一格列 B 的目录(照远程控制列全部供应商),不拿 A 本机的目录顶替;
 *   2. 其他电脑一段列 C 开放了远程调用的供应商,没开放的不列;
 *   3. 点 C 的格浏览 C 的目录,选中那里的模型 = 带着 C 换 Agent 位置;
 *   4. 不传 homeDeviceId 的本机任务照旧用本机目录。
 */
import { act, cleanup, fireEvent, render, screen, within } from '@testing-library/react';
import React from 'react';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';

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

vi.mock('react-i18next', async (importOriginal) => ({
  ...(await importOriginal<typeof import('react-i18next')>()),
  useTranslation: () => ({
    t: (key: string, options?: Record<string, string>) => {
      const table: Record<string, string> = {
        'newChat.modelSelector.modelListAria': '模型列表',
        'newChat.modelSelector.search.placeholderAll': '搜索模型…',
        'newChat.modelSelector.unified.favoritesGroup': '收藏',
        'newChat.modelSelector.unified.customize': '自定义',
        'newChat.modelSelector.unified.railAll': '全部',
        'newChat.modelSelector.unified.railRemoteProvider': `${options?.provider ?? ''} · ${options?.device ?? ''}`,
        'effortLevels.low': '低',
        'effortLevels.high': '高',
      };
      return table[key] ?? options?.defaultValue ?? key;
    },
  }),
}));

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

vi.mock('@/hooks/useAgentCapabilities', () => ({
  evictDeviceCapabilities: vi.fn(),
  prefetchDeviceCapabilities: vi.fn(async () => {}),
  useAgentCapabilities: (agent: string) => ({
    capabilities: { hasFastMode: agent === 'codex', effortLevels: [], availableModels: [] },
    loading: false,
    error: null,
  }),
}));
vi.mock('@/hooks/useApiKey', () => ({ useApiKey: () => ({ hasSavedKey: true }) }));
vi.mock('@/hooks/useConnectedSource', () => ({
  useConnectedSource: () => ({ hasConnectedSource: true, loading: false }),
}));
vi.mock('@/hooks/useModelPricing', () => ({
  useGatewayModelPricing: () => null,
  useReferenceModelPricing: () => null,
}));

const catalogs = vi.hoisted(() => {
  const provider = (
    id: string,
    name: string,
    models: readonly (readonly [string, string])[],
    extra: Record<string, unknown> = {},
  ) => ({
    id,
    name,
    source: 'user',
    agents: ['claude-code'],
    auth: { method: 'api-key' },
    routing: { 'claude-code': {} },
    connected: true,
    models: {
      'claude-code': models.map(([modelId, modelName]) => ({
        id: modelId,
        name: modelName,
        contextWindow: 200000,
        efforts: ['low', 'high'],
        defaultEffort: 'high',
      })),
    },
    ...extra,
  });
  return {
    /** 读不到目录的电脑(离线)。 */
    offline: new Set<string>(),
    /** A:本机(控制端)自己的目录。 */
    local: [provider('a-local', 'A Local', [['a-model', 'A Model']])] as unknown[],
    byDevice: {
      // B:被控电脑。远程控制照常看到全部供应商,有没有开放远程调用都列。
      'device-b': [
        provider('b-main', 'B Main', [['b-model', 'B Model']]),
        provider('b-closed', 'B Closed', [['b-closed-model', 'B Closed Model']], {
          remoteInvocationEnabled: false,
        }),
      ],
      // C:开了「允许被远程调用」的电脑,只有一个供应商开放。
      'device-c': [
        provider('c-open', 'C Open', [['c-model', 'C Model']], { remoteInvocationEnabled: true }),
        provider('c-closed', 'C Closed', [['c-hidden-model', 'C Hidden Model']], {
          remoteInvocationEnabled: false,
        }),
      ],
      // 分享来的供应商:控制端经自己的分享通道读到的目录(分享者已收窄到被分享的供应商)。
      'share:abc': [
        provider('s-shared', 'S Shared', [['s-model', 'S Model']], { remoteInvocationEnabled: true }),
      ],
      'memory-device': [provider('memory-provider', 'Remembered', [], {
        remoteInvocationEnabled: true,
        agents: ['codex'],
        routing: { codex: {} },
        models: { codex: [{
          id: 'memory-model', name: 'Remembered Model', contextWindow: 200000,
          efforts: ['low', 'high'], defaultEffort: 'high', supportsFastMode: true,
        }] },
      })],
    } as Record<string, unknown[]>,
  };
});

vi.mock('@/hooks/useProviders', () => ({
  useProviders: () => ({ providers: catalogs.local, providerOrder: [] }),
}));
vi.mock('@/hooks/useDeviceProviders', () => ({
  evictDeviceProviders: vi.fn(),
  prefetchDeviceProviders: vi.fn(async () => {}),
  useDeviceProviders: (deviceId?: string) =>
    deviceId && catalogs.offline.has(deviceId)
      ? { providers: [], loading: false, error: 'DEVICE_LINK_UNREACHABLE', unsupported: false }
      : {
          providers: deviceId ? (catalogs.byDevice[deviceId] ?? []) : [],
          loading: false,
          error: null,
          unsupported: false,
        },
}));
vi.mock('@/hooks/useDevicesProviders', () => ({
  useDevicesProviders: (deviceIds: readonly string[]) =>
    new Map(
      deviceIds.map((deviceId) => [
        deviceId,
        catalogs.offline.has(deviceId)
          ? { providers: [], loading: false, error: 'DEVICE_LINK_UNREACHABLE' }
          : { providers: catalogs.byDevice[deviceId] ?? [], loading: false, error: null },
      ]),
    ),
}));
vi.mock('@/state/modelVisibilityPrefs', () => ({
  isModelEnabled: () => true,
  useModelVisibilityVersion: () => 0,
}));
vi.mock('@/state/deviceLinkModelMirror', () => ({
  useDeviceLinkModelMirrorVersion: () => 0,
}));
vi.mock('@/hooks/useRemoteDeviceUsage', () => ({
  useRemoteCodexAccountUsage: () => null,
  useRemoteXaiSubscriptionUsage: () => null,
}));
vi.mock('@/hooks/useRemoteClaudeSubscriptionUsage', () => ({
  useRemoteClaudeSubscriptionUsage: () => null,
}));
vi.mock('@/hooks/useModelRouteDevices', () => ({
  useModelRouteDevices: ({ leadAgentDeviceId }: { leadAgentDeviceId?: string | null }) => ({
    leadAgentDeviceId: leadAgentDeviceId ?? null,
    devices: [{ deviceId: 'memory-device', name: 'Remote' }],
  }),
}));

import { ModelSelectorContent } from '@/components/new-chat/ModelSelector';
import { ModelRouteSelectorContent } from '@/components/new-chat/ModelRouteSelector';
import {
  agentDeviceModelMemoryAccessors,
  __resetForTest as resetDeviceMemory,
} from '@/state/agentDeviceModelMemory';
import { __resetForTest as resetEnginePrefs } from '@/state/modelEnginePrefs';
import { __resetForTest as resetFavorites } from '@/state/modelFavorites';
import { __resetForTest as resetRecentModels, listRecentModels } from '@/state/recentModels';

const devices = [{ deviceId: 'device-c', name: 'Studio' }];

function renderControlledTaskPanel(
  remoteAgent: Partial<React.ComponentProps<typeof ModelSelectorContent>['remoteAgent']> = {},
  props: Partial<React.ComponentProps<typeof ModelSelectorContent>> = {},
) {
  const onRelocate = vi.fn(async () => true);
  const onProviderChange = vi.fn();
  render(
    React.createElement(ModelSelectorContent, {
      modelId: 'b-model',
      effort: 'high',
      onModelChange: vi.fn(),
      onEffortChange: vi.fn(),
      currentProviderId: 'b-main',
      onProviderChange,
      actualRoute: true,
      vendorKey: 'cc',
      // 被控电脑上的任务:ChatInput 传的 deviceId 是模型目录所在电脑(此处 Agent 在 B)。
      deviceId: 'device-b',
      remoteAgent: {
        devices,
        selectedDeviceId: null,
        homeDeviceId: 'device-b',
        onRelocate,
        ...remoteAgent,
      },
      ...props,
    }),
  );
  return { onRelocate, onProviderChange };
}

const list = () => screen.getByRole('listbox');

beforeEach(() => {
  resetEnginePrefs();
  resetFavorites();
  resetDeviceMemory();
  resetRecentModels();
});

afterEach(() => {
  cleanup();
});

// PR #6830 / Greptile r4359506145: existing panel cases inject remoteAgent directly,
// so they missed the route wrapper dropping remembered effort/Fast. Exercise the
// real wrapper and model selection callback (unit/jsdom), with an override that
// differs from the catalog, both while browsing and when reopening that source.
describe('统一入口保留远程模型偏好', () => {
  it.each([null, 'memory-device'])('当前来源为 %s 时选择远程模型沿用其偏好', async (agentDeviceId) => {
    const memory = agentDeviceModelMemoryAccessors('memory-device');
    memory.setEffort('codex', 'memory-provider', 'memory-model', 'low');
    memory.setFast('codex', 'memory-provider', 'memory-model', true);
    // A matching local provider/model must not borrow this device's memory.
    memory.setEffort('claude-code', 'a-local', 'a-model', 'low');
    const onUnifiedSelect = vi.fn(async () => true);
    render(<ModelRouteSelectorContent
      agentDeviceId={agentDeviceId}
      vendorKey="codex" modelId="" effort="high" fastMode={false}
      onModelChange={vi.fn()} onEffortChange={vi.fn()}
      onUnifiedSelect={onUnifiedSelect}
    />);
    if (!agentDeviceId) {
      await act(async () => {
        fireEvent.click(screen.getByRole('button', { name: 'Remembered · Remote' }));
      });
    }
    await act(async () => {
      fireEvent.click(within(list()).getByText('Remembered Model').closest('[data-unified-anchor]')!);
    });
    expect(onUnifiedSelect).toHaveBeenLastCalledWith(expect.objectContaining({
      modelId: 'memory-model', providerId: 'memory-provider', engine: 'codex',
      effort: 'low', fast: true, agentDevice: { deviceId: 'memory-device', name: 'Remote' },
    }));
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'A Local' }));
    });
    await act(async () => {
      fireEvent.click(within(list()).getByText('A Model').closest('[data-unified-anchor]')!);
    });
    expect(onUnifiedSelect).toHaveBeenLastCalledWith(expect.objectContaining({
      modelId: 'a-model', providerId: 'a-local', effort: 'high', fast: false,
    }));
  });
});

describe('被控电脑上的任务:模型面板列出第三台电脑的远程供应商', () => {
  it('任务所在电脑那一格列被控电脑的全部供应商,不拿本机目录顶替', () => {
    renderControlledTaskPanel();
    expect(screen.getByRole('button', { name: 'B Main' })).toBeTruthy();
    // 远程控制不按「允许被远程调用」裁剪被控电脑自己的目录。
    expect(screen.getByRole('button', { name: 'B Closed' })).toBeTruthy();
    expect(screen.queryByRole('button', { name: 'A Local' })).toBeNull();
    expect(within(list()).getByText('B Model')).toBeTruthy();
    expect(within(list()).queryByText('A Model')).toBeNull();
  });

  it('其他电脑一段只列开放了远程调用的供应商', () => {
    renderControlledTaskPanel();
    const remote = screen.getByRole('button', { name: 'C Open · Studio' });
    expect(remote.querySelector('[data-remote-source-mark]')).not.toBeNull();
    expect(screen.queryByRole('button', { name: 'C Closed · Studio' })).toBeNull();
  });

  it('任务仍用 B 本机模型、没有第三台电脑时,也能选择尚未用过的分享供应商', async () => {
    const shareDevice = { deviceId: 'share:abc', name: '来自 Magi 的分享' };
    const { onRelocate, onProviderChange } = renderControlledTaskPanel({ devices: [shareDevice] });
    expect(within(list()).getByText('B Model')).toBeTruthy();
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'S Shared · 来自 Magi 的分享' }));
    });
    expect(within(list()).queryByText('B Model')).toBeNull();
    await act(async () => {
      fireEvent.click(within(list()).getByText('S Model').closest('[data-unified-anchor]')!);
    });
    expect(onRelocate).toHaveBeenCalledWith(expect.objectContaining({
      providerId: 's-shared', modelId: 's-model', agent: 'claude-code', agentDevice: shareDevice,
    }));
    expect(onProviderChange).not.toHaveBeenCalled();
  });

  it('浏览第三台电脑的目录,选中那里的模型 = 带着那台电脑换 Agent 位置', async () => {
    const { onRelocate, onProviderChange } = renderControlledTaskPanel();
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'C Open · Studio' }));
    });
    expect(within(list()).getByText('C Model')).toBeTruthy();
    expect(within(list()).queryByText('C Hidden Model')).toBeNull();
    expect(within(list()).queryByText('B Model')).toBeNull();

    const row = within(list()).getByText('C Model').closest('[data-unified-anchor]') as HTMLElement;
    await act(async () => {
      fireEvent.click(row);
    });
    expect(onRelocate).toHaveBeenCalledWith(
      expect.objectContaining({
        providerId: 'c-open',
        modelId: 'c-model',
        agent: 'claude-code',
        agentDevice: { deviceId: 'device-c', name: 'Studio' },
      }),
    );
    // 不经同一台电脑内换模型的链路(那条会把 C 的模型塞给被控电脑)。
    expect(onProviderChange).not.toHaveBeenCalled();
  });

  it('Agent 已在第三台电脑:打开时停在那台的目录,任务所在电脑一格仍是被控电脑', () => {
    renderControlledTaskPanel(
      { selectedDeviceId: 'device-c' },
      { deviceId: 'device-c', modelId: 'c-model', currentProviderId: 'c-open' },
    );
    expect(within(list()).getByText('C Model')).toBeTruthy();
    expect(screen.getByRole('button', { name: 'C Open · Studio' }).getAttribute('aria-pressed')).toBe(
      'true',
    );
    expect(screen.getByRole('button', { name: 'B Main' })).toBeTruthy();
    expect(screen.queryByRole('button', { name: 'A Local' })).toBeNull();
  });

  // 2026-10-10 用户反馈:A 远控 B 上 Agent 在分享上的任务,模型显示「模型信息暂不可用」。
  // 会话视图把本机也收到的那条分享并进候选、目录指向 `share:abc`(判定见 controlledTaskAgentLocation)。
  it('Agent 在本机也收到了的分享上:打开时停在分享的目录,不显示被控电脑的模型', async () => {
    const shareDevice = { deviceId: 'share:abc', name: 'Mac Mini · 来自 Magi 的分享' };
    const { onRelocate } = renderControlledTaskPanel(
      { devices: [...devices, shareDevice], selectedDeviceId: 'share:abc' },
      { deviceId: 'share:abc', modelId: 's-model', currentProviderId: 's-shared' },
    );
    expect(within(list()).getByText('S Model')).toBeTruthy();
    expect(within(list()).queryByText('B Model')).toBeNull();
    expect(
      screen
        .getByRole('button', { name: 'S Shared · Mac Mini · 来自 Magi 的分享' })
        .getAttribute('aria-pressed'),
    ).toBe('true');
    // 被控电脑那一格还在,选它的模型 = 改回被控电脑运行。
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'B Main' }));
    });
    const row = within(list()).getByText('B Model').closest('[data-unified-anchor]') as HTMLElement;
    await act(async () => {
      fireEvent.click(row);
    });
    expect(onRelocate).toHaveBeenCalledWith(
      expect.objectContaining({ providerId: 'b-main', modelId: 'b-model', agentDevice: null }),
    );
  });

  it('Agent 所在的第三台电脑离线:仍能回到被控电脑的目录,选中即改回被控电脑运行', async () => {
    catalogs.offline.add('device-c');
    try {
      const { onRelocate } = renderControlledTaskPanel(
        { selectedDeviceId: 'device-c' },
        { deviceId: 'device-c', modelId: 'c-model', currentProviderId: 'c-open' },
      );
      // 那台的目录读不到:它的供应商格不出现,但被控电脑那一格还在。
      expect(screen.queryByRole('button', { name: 'C Open · Studio' })).toBeNull();
      await act(async () => {
        fireEvent.click(screen.getByRole('button', { name: 'B Main' }));
      });
      const row = within(list()).getByText('B Model').closest('[data-unified-anchor]') as HTMLElement;
      await act(async () => {
        fireEvent.click(row);
      });
      expect(onRelocate).toHaveBeenCalledWith(
        expect.objectContaining({ providerId: 'b-main', modelId: 'b-model', agentDevice: null }),
      );
    } finally {
      catalogs.offline.clear();
    }
  });
});

// 2026-10-09 用户反馈:远程控制下新建任务(选了另一台电脑当任务电脑)时模型列表里选不到远程供应商,
// 只有选本机才选得到。草稿走 onUnifiedSelect 直通,不经 onRelocate。
describe('远程控制下新建任务:草稿的模型面板同样列出第三台电脑的远程供应商', () => {
  function renderControlledDraftPanel(
    remoteAgent: Partial<React.ComponentProps<typeof ModelSelectorContent>['remoteAgent']> = {},
    props: Partial<React.ComponentProps<typeof ModelSelectorContent>> = {},
  ) {
    const onUnifiedSelect = vi.fn(async () => true);
    const onProviderChange = vi.fn();
    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'b-model',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        currentProviderId: 'b-main',
        onProviderChange,
        actualRoute: false,
        vendorKey: 'cc',
        deviceId: 'device-b',
        onUnifiedSelect,
        remoteAgent: {
          devices,
          selectedDeviceId: null,
          homeDeviceId: 'device-b',
          ...remoteAgent,
        },
        ...props,
      }),
    );
    return { onUnifiedSelect, onProviderChange };
  }

  it('先列被控电脑的全部供应商,再列第三台电脑开放了远程调用的供应商', () => {
    renderControlledDraftPanel();
    expect(screen.getByRole('button', { name: 'B Main' })).toBeTruthy();
    expect(screen.getByRole('button', { name: 'B Closed' })).toBeTruthy();
    expect(screen.queryByRole('button', { name: 'A Local' })).toBeNull();
    expect(screen.getByRole('button', { name: 'C Open · Studio' })).toBeTruthy();
    expect(screen.queryByRole('button', { name: 'C Closed · Studio' })).toBeNull();
  });

  it('选中第三台电脑的模型:把那台电脑交给草稿层,不走换位置', async () => {
    const { onUnifiedSelect, onProviderChange } = renderControlledDraftPanel();
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'C Open · Studio' }));
    });
    const row = within(list()).getByText('C Model').closest('[data-unified-anchor]') as HTMLElement;
    await act(async () => {
      fireEvent.click(row);
    });
    expect(onUnifiedSelect).toHaveBeenCalledWith(
      expect.objectContaining({
        providerId: 'c-open',
        modelId: 'c-model',
        engine: 'cc',
        agentDevice: { deviceId: 'device-c', name: 'Studio' },
      }),
    );
    expect(onProviderChange).not.toHaveBeenCalled();
  });

  it('新建到 B 的任务可直接选分享模型,提交分享身份供 B 创建远程 Agent', async () => {
    const shareDevice = { deviceId: 'share:abc', name: '来自 Magi 的分享' };
    const { onUnifiedSelect, onProviderChange } = renderControlledDraftPanel({ devices: [shareDevice] });
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'S Shared · 来自 Magi 的分享' }));
    });
    await act(async () => {
      fireEvent.click(within(list()).getByText('S Model').closest('[data-unified-anchor]')!);
    });
    expect(onUnifiedSelect).toHaveBeenCalledWith(expect.objectContaining({
      providerId: 's-shared', modelId: 's-model', engine: 'cc', agentDevice: shareDevice,
    }));
    expect(onProviderChange).not.toHaveBeenCalled();
  });

  it('Agent 已选在第三台电脑:选回被控电脑的模型带 agentDevice: null', async () => {
    const { onUnifiedSelect } = renderControlledDraftPanel(
      { selectedDeviceId: 'device-c' },
      { deviceId: 'device-c', modelId: 'c-model', currentProviderId: 'c-open' },
    );
    await act(async () => {
      fireEvent.click(screen.getByRole('button', { name: 'B Main' }));
    });
    const row = within(list()).getByText('B Model').closest('[data-unified-anchor]') as HTMLElement;
    await act(async () => {
      fireEvent.click(row);
    });
    expect(onUnifiedSelect).toHaveBeenCalledWith(
      expect.objectContaining({ providerId: 'b-main', modelId: 'b-model', agentDevice: null }),
    );
  });
});

describe('本机任务不受影响', () => {
  it('不传 homeDeviceId 时任务所在电脑一格仍是本机目录', () => {
    renderControlledTaskPanel(
      { homeDeviceId: undefined },
      { deviceId: undefined, modelId: 'a-model', currentProviderId: 'a-local' },
    );
    expect(screen.getByRole('button', { name: 'A Local' })).toBeTruthy();
    expect(screen.queryByRole('button', { name: 'B Main' })).toBeNull();
    expect(within(list()).getByText('A Model')).toBeTruthy();
    expect(screen.getByRole('button', { name: 'C Open · Studio' })).toBeTruthy();
  });
});

// 「最近使用」记录没有设备字段:浏览其他电脑的目录时选中不得写进本机流水(2026-10-08 review P1)。
// 任务归属判不出草稿 —— 本机草稿的 deviceLinkDeviceId 是 null,所以按**当前浏览的目录**再禁一次。
describe('本机草稿:浏览其他电脑的目录后选中不写本机「最近」', () => {
  function renderLocalDraftPanel(
    remoteAgent: Partial<React.ComponentProps<typeof ModelSelectorContent>['remoteAgent']> = {},
    props: Partial<React.ComponentProps<typeof ModelSelectorContent>> = {},
  ) {
    const onUnifiedSelect = vi.fn(async () => true);
    render(
      React.createElement(ModelSelectorContent, {
        modelId: 'a-model',
        effort: 'high',
        onModelChange: vi.fn(),
        onEffortChange: vi.fn(),
        currentProviderId: 'a-local',
        onProviderChange: vi.fn(),
        onUnifiedSelect,
        // 对话入口开的记录开关(草稿 / 已建任务 / 任务内切换都开;定时任务 / IM 等不开)。
        recordRecentUsage: true,
        remoteAgent: { devices, selectedDeviceId: null, ...remoteAgent },
        ...props,
      }),
    );
    return { onUnifiedSelect };
  }

  it('Agent 落在第三台电脑:浏览那台的目录并选中不记本机历史', async () => {
    // Agent 在那台电脑 = 目录也跟着那台(deviceId 指向被浏览的电脑)。
    const { onUnifiedSelect } = renderLocalDraftPanel({ selectedDeviceId: 'device-c' }, {
      deviceId: 'device-c',
      modelId: 'c-model',
      currentProviderId: 'c-open',
    });
    expect(within(list()).getByText('C Model')).toBeTruthy();
    const row = within(list()).getByText('C Model').closest('[data-unified-anchor]') as HTMLElement;
    await act(async () => {
      fireEvent.click(row);
    });
    // 选择本身照常生效(那条模型就在那台电脑跑),只是不落本机「最近」:两台电脑若有同来源
    // 同模型 id,回到本机会把这条远程记录解析成本机模型,点击就用错运行位置。
    expect(onUnifiedSelect).toHaveBeenCalledWith(
      expect.objectContaining({
        providerId: 'c-open',
        modelId: 'c-model',
        agentDevice: { deviceId: 'device-c', name: 'Studio' },
      }),
    );
    expect(listRecentModels()).toEqual([]);
  });

  it('对照:Agent 在本机,选本机目录里的模型照常记(禁记只针对浏览的远程目录)', async () => {
    renderLocalDraftPanel({ selectedDeviceId: null });
    const row = within(list()).getByText('A Model').closest('[data-unified-anchor]') as HTMLElement;    await act(async () => {
      fireEvent.click(row);
    });
    expect(listRecentModels().map((item) => `${item.providerId}:${item.modelId}`)).toEqual([
      'a-local:a-model',
    ]);
  });
});