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。

26.5 KB
Raw Blame
import { beforeAll, describe, expect, it, vi } from 'vitest';
import { i18n } from '@/i18n';
import {
  archiveOrcaWorker,
  buildOrcaEnableOptions,
  convergeOrcaWorkerModel,
  createOrcaWorker,
  describeOrcaError,
  enableOrcaTeam,
  isOrcaCollabEligible,
  orcaWorkerFormFromPrefs,
  readOrcaCollabEntryStatus,
  rememberOrcaStartFailure,
  narrowOrcaWorkerProvider,
  orcaWorkerProvidersForLead,
  parseOrcaExecutionDevices,
  isAbsoluteOrcaWorkerDir,
  subscribeOrcaStartFailure,
  takeOrcaStartFailure,
} from '@/session/orcaTeam';
import type { ProviderView } from '@cindy/model-providers/registry';
import type { MobileMakerTransport } from '@/device-link/mobileMakerTransport';
import { defaultOrcaWorkerCreationPrefs } from '@/session/orcaWorkerPrefs';

beforeAll(async () => {
  await i18n.changeLanguage('zh-CN');
});

type OrcaFake = Partial<MobileMakerTransport['orca']>;

function fakeMaker(opts: {
  capabilities?: unknown;
  capabilitiesError?: Error;
  orca?: OrcaFake;
}): MobileMakerTransport {
  return {
    listAvailableAgents: vi.fn(async () => ['codex']),
    getCapabilities: vi.fn(async () => {
      if (opts.capabilitiesError) throw opts.capabilitiesError;
      return opts.capabilities ?? { supportsOrcaWorkerPermissionMode: true };
    }),
    orca: {
      getCollabPolicy: vi.fn(async () => ({ effectiveEnabled: true })),
      enable: vi.fn(async () => ({ workerSessionId: 'worker-1' })),
      disable: vi.fn(async () => ({ ok: true })),
      createWorker: vi.fn(async () => ({ ok: true, workerSessionId: 'worker-2' })),
      listWorkers: vi.fn(async () => []),
      getTeamByWorkerSession: vi.fn(async () => null),
      switchFocus: vi.fn(async () => ({ ok: true })),
      acknowledgeDone: vi.fn(async () => ({ ok: true })),
      archiveWorker: vi.fn(async () => ({ ok: true })),
      getCollaborationSettings: vi.fn(async () => ({})),
      ...opts.orca,
    },
  } as unknown as MobileMakerTransport;
}

const project = { orcaRole: null, workspaceKind: 'project' as const, workingDir: '/repo', remoteHostId: null };
const remoteLead = {
  leadDeviceId: 'lead-device', leadDeviceName: 'Lead computer', leadSessionId: 'lead-1',
  leadTitle: 'Lead task', workerLabel: 'tester',
};

describe('mobile Orca collaboration entry', () => {
  it('only offers collaboration to Lead-capable tasks', () => {
    expect(isOrcaCollabEligible(project)).toBe(true);
    expect(isOrcaCollabEligible({ ...project, workingDir: '' })).toBe(false);
    expect(isOrcaCollabEligible({ ...project, workspaceKind: 'dialogue', workingDir: null })).toBe(true);
    expect(isOrcaCollabEligible({ ...project, orcaRole: 'worker' })).toBe(false);
    expect(isOrcaCollabEligible(null)).toBe(false);
  });

  it('fails closed when the computer does not declare Worker permission support', async () => {
    const maker = fakeMaker({ capabilities: {} });
    await expect(readOrcaCollabEntryStatus(maker, project, 'codex')).resolves.toBe('unsupported');
    expect(maker.orca.getCollabPolicy).not.toHaveBeenCalled();
  });

  it('maps policy query results to entry states', async () => {
    await expect(readOrcaCollabEntryStatus(fakeMaker({}), project, 'codex')).resolves.toBe('ready');
    await expect(readOrcaCollabEntryStatus(fakeMaker({
      orca: { getCollabPolicy: vi.fn(async () => ({ effectiveEnabled: false })) },
    }), project, 'codex')).resolves.toBe('disabled');
    await expect(readOrcaCollabEntryStatus(fakeMaker({
      orca: { getCollabPolicy: vi.fn(async () => { throw new Error('[DEVICE_LINK_CHANNEL_NOT_ALLOWED] no'); }) },
    }), project, 'codex')).resolves.toBe('unsupported');
    await expect(readOrcaCollabEntryStatus(fakeMaker({
      orca: { getCollabPolicy: vi.fn(async () => { throw new Error('[NOT_CONNECTED] offline'); }) },
    }), project, 'codex')).resolves.toBe('unavailable');
  });

  it('skips the project policy query for SSH-remote sessions and existing Leads', async () => {
    const remote = fakeMaker({});
    await readOrcaCollabEntryStatus(remote, { ...project, remoteHostId: 'host-1' }, 'claude-code');
    expect(remote.orca.getCollabPolicy).toHaveBeenCalledWith(undefined, 'project');

    const lead = fakeMaker({});
    await expect(readOrcaCollabEntryStatus(lead, { ...project, orcaRole: 'lead' }, 'claude-code')).resolves.toBe('ready');
    expect(lead.orca.getCollabPolicy).not.toHaveBeenCalled();
  });
});

describe('mobile Orca collaboration mutations', () => {
  it('settles a timed-out Worker archive by rechecking the team once', async () => {
    const timeout = new Error('[INVOKE_TIMEOUT] timed out');
    const gone = fakeMaker({ orca: { archiveWorker: vi.fn(async () => { throw timeout; }), listWorkers: vi.fn(async () => []) } });
    await expect(archiveOrcaWorker(gone, 'lead-1', 'w-1')).resolves.toBeUndefined();
    const stillListed = fakeMaker({ orca: {
      archiveWorker: vi.fn(async () => { throw timeout; }),
      listWorkers: vi.fn(async () => [{ id: 'w-1', sessionId: 's-1' }]),
    } });
    await expect(archiveOrcaWorker(stillListed, 'lead-1', 'w-1')).rejects.toThrow('ORCA_ACTION_UNCONFIRMED');
    const recheckFailed = fakeMaker({ orca: {
      archiveWorker: vi.fn(async () => { throw timeout; }),
      listWorkers: vi.fn(async () => { throw new Error('[NOT_CONNECTED] offline'); }),
    } });
    await expect(archiveOrcaWorker(recheckFailed, 'lead-1', 'w-1')).rejects.toThrow('ORCA_ACTION_UNCONFIRMED');
    // 非超时错误是权威失败:原样抛出,不回查。
    const listWorkers = vi.fn(async () => []);
    const rejected = fakeMaker({ orca: { archiveWorker: vi.fn(async () => { throw new Error('[WORKER_NOT_FOUND] x'); }), listWorkers } });
    await expect(archiveOrcaWorker(rejected, 'lead-1', 'w-1')).rejects.toThrow('WORKER_NOT_FOUND');
    expect(listWorkers).not.toHaveBeenCalled();
  });

  const form = {
    ...orcaWorkerFormFromPrefs({ ...defaultOrcaWorkerCreationPrefs(), workerPermissionMode: 'auto' }, 'codex'),
    model: null,
    role: 'Reviewer',
    initialTask: 'check tests',
  };

  it('preserves the remote device for first and added Workers and sends a folder only in path mode', async () => {
    const remote = { ...form, executionDeviceId: 'device-b', remoteDirMode: 'dialogue' as const, remoteDir: '/stale' };
    expect(buildOrcaEnableOptions(remote)).toMatchObject({ executionDeviceId: 'device-b' });
    expect(buildOrcaEnableOptions(remote)).not.toHaveProperty('workingDir');
    const maker = fakeMaker({});
    await createOrcaWorker(maker, 'lead-1', remote, []);
    expect(maker.orca.createWorker).toHaveBeenCalledWith(expect.objectContaining({ executionDeviceId: 'device-b' }));
    expect(vi.mocked(maker.orca.createWorker).mock.calls[0]![0]).not.toHaveProperty('workingDir');
    const path = { ...remote, remoteDirMode: 'path' as const, remoteDir: '  D:\\projects\\worker  ' };
    expect(buildOrcaEnableOptions(path)).toMatchObject({ executionDeviceId: 'device-b', workingDir: 'D:\\projects\\worker' });
    await createOrcaWorker(maker, 'lead-1', path, []);
    expect(maker.orca.createWorker).toHaveBeenLastCalledWith(expect.objectContaining({ workingDir: 'D:\\projects\\worker' }));
    for (const remoteDir of ['', 'relative/path', 'C:relative']) {
      expect(() => buildOrcaEnableOptions({ ...path, remoteDir })).toThrow('INVALID_PARAMS');
      await expect(createOrcaWorker(maker, 'lead-1', { ...path, remoteDir }, [])).rejects.toThrow('INVALID_PARAMS');
    }
    expect(maker.orca.createWorker).toHaveBeenCalledTimes(2);
  });

  it.each(['project', 'dialogue'] as const)('hides collaboration for a real remote Worker in a %s workspace', async (workspaceKind) => {
    const maker = fakeMaker({});
    const session = { ...project, workspaceKind, orcaRemoteLead: remoteLead };
    expect(isOrcaCollabEligible(session)).toBe(false);
    await expect(readOrcaCollabEntryStatus(maker, session, 'codex')).resolves.toBe('ineligible');
    expect(maker.getCapabilities).not.toHaveBeenCalled();
    expect(maker.orca.getCollabPolicy).not.toHaveBeenCalled();
    // 与桌面一致:解除协同仍保留来源标记,不把历史 Worker 当作新的 Lead。
    expect(isOrcaCollabEligible({ ...session, orcaRemoteLead: { ...remoteLead, releasedAt: 1 } })).toBe(false);
    expect(isOrcaCollabEligible({ ...session, orcaRole: 'lead' })).toBe(false);
    expect(isOrcaCollabEligible({ ...session, orcaRemoteLead: null })).toBe(true);
  });

  it('parses device versions conservatively and recognizes cross-platform absolute folders', () => {
    expect(parseOrcaExecutionDevices({ devices: [null, {}, { deviceId: 'b', name: 'B', supported: true }, { deviceId: 'old', supported: 1 }] }))
      .toEqual([{ deviceId: 'b', name: 'B', platform: null, supported: true }, { deviceId: 'old', name: 'old', platform: null, supported: false }]);
    expect(parseOrcaExecutionDevices(null)).toEqual([]);
    expect(parseOrcaExecutionDevices({ devices: 'bad' })).toEqual([]);
    for (const path of ['/srv/worker', 'C:\\work', 'C:/work', '\\\\server\\share']) expect(isAbsoluteOrcaWorkerDir(path)).toBe(true);
  });

  it('checks the Lead host through its registered Agent when the remote Worker uses Pi', async () => {
    const maker = fakeMaker({});
    vi.mocked(maker.getCapabilities).mockImplementation(async (agent) => {
      if (agent !== 'codex') throw new Error(`Agent '${agent}' is not registered`);
      return { supportsOrcaWorkerPermissionMode: true };
    });
    const remote = { ...form, agent: 'pi' as const, executionDeviceId: 'device-b' };
    await expect(enableOrcaTeam(maker, 'lead-1', buildOrcaEnableOptions(remote)))
      .resolves.toEqual({ workerSessionId: 'worker-1' });
    await expect(createOrcaWorker(maker, 'lead-1', remote, []))
      .resolves.toEqual({ workerSessionId: 'worker-2' });
    expect(maker.getCapabilities).toHaveBeenCalledTimes(2);
    expect(maker.getCapabilities).toHaveBeenCalledWith('codex');
    expect(maker.getCapabilities).not.toHaveBeenCalledWith('pi');
    expect(maker.orca.enable).toHaveBeenCalledWith('lead-1', expect.objectContaining({ workerAgent: 'pi', executionDeviceId: 'device-b' }));
    expect(maker.orca.createWorker).toHaveBeenCalledWith(expect.objectContaining({ agent: 'pi', executionDeviceId: 'device-b' }));
  });

  it('still refuses remote creation when the Lead host has no Agent or no permission support', async () => {
    const remote = { ...form, agent: 'pi' as const, executionDeviceId: 'device-b' };
    const empty = fakeMaker({});
    vi.mocked(empty.listAvailableAgents).mockResolvedValue([]);
    for (const maker of [empty, fakeMaker({ capabilities: {} })]) {
      await expect(enableOrcaTeam(maker, 'lead-1', buildOrcaEnableOptions(remote))).rejects.toThrow('CHANNEL_NOT_ALLOWED');
      await expect(createOrcaWorker(maker, 'lead-1', remote, [])).rejects.toThrow('CHANNEL_NOT_ALLOWED');
      expect(maker.orca.enable).not.toHaveBeenCalled();
      expect(maker.orca.createWorker).not.toHaveBeenCalled();
    }
  });

  // 远程供应商与本机供应商一视同仁(2026-10-10):Worker 的 Agent 可以放到另一台电脑或分享上。
  it('sends the Worker Agent location only to a host that declares support', async () => {
    const elsewhere = {
      ...form,
      agent: 'pi' as const,
      agentDeviceId: 'share:s1',
      model: { id: 'spark/qwen', providerId: 'spark', effort: 'high', fast: false },
    };
    const supported = fakeMaker({ capabilities: { supportsOrcaWorkerPermissionMode: true, supportsOrcaWorkerAgentDevice: true } });
    await createOrcaWorker(supported, 'lead-1', elsewhere, []);
    expect(supported.orca.createWorker).toHaveBeenCalledWith(expect.objectContaining({
      agent: 'pi', agentDeviceId: 'share:s1', model: 'spark/qwen', providerId: 'spark',
    }));
    // Worker 的 Agent 不在被控电脑上:用 Lead 已注册的 Agent 查被控电脑的能力。
    expect(supported.getCapabilities).toHaveBeenCalledWith('codex');
    expect(buildOrcaEnableOptions({ ...form, agentDeviceId: null })).toMatchObject({ agentDeviceId: null });
    expect(buildOrcaEnableOptions(form)).not.toHaveProperty('agentDeviceId');

    // 旧被控端会静默丢掉这个字段:表单展示后被控端降级时 fail-closed。
    const legacy = fakeMaker({});
    await expect(createOrcaWorker(legacy, 'lead-1', elsewhere, [])).rejects.toThrow('CHANNEL_NOT_ALLOWED');
    await expect(enableOrcaTeam(legacy, 'lead-1', buildOrcaEnableOptions(elsewhere))).rejects.toThrow('CHANNEL_NOT_ALLOWED');
    expect(legacy.orca.createWorker).not.toHaveBeenCalled();
    expect(legacy.orca.enable).not.toHaveBeenCalled();
  });

  it("keeps another computer's source when narrowing against the controlled computer's catalog", () => {
    const elsewhere = { ...form, agentDeviceId: 'agent-pc', model: { id: 'spark/qwen', providerId: 'spark', effort: 'high', fast: false } };
    expect(narrowOrcaWorkerProvider(elsewhere, [])).toBe(elsewhere);
  });

  it('explains an unreachable Agent computer or share with the remote Agent wording', () => {
    expect(describeOrcaError(new Error('[REMOTE_AGENT_DEVICE_UNREACHABLE] offline'), null))
      .toBe(i18n.t('session.remoteError.REMOTE_AGENT_UNAVAILABLE'));
    expect(describeOrcaError(new Error('IPC_ERROR [REMOTE_AGENT_SHARE_PAUSED] paused'), null))
      .toBe(i18n.t('session.remoteError.REMOTE_AGENT_SHARE_PAUSED'));
  });

  it('builds enable options with a derived label and only the chosen model fields', () => {
    expect(buildOrcaEnableOptions(form, 'task')).toEqual({
      workerAgent: 'codex',
      role: 'Reviewer',
      label: 'reviewer',
      workerPermissionMode: 'auto',
      delegateTask: 'task',
    });
    expect(buildOrcaEnableOptions({
      ...form,
      model: { id: 'gpt-5.5', providerId: 'openai', effort: 'high', fast: true },
    }, '  ')).toEqual({
      workerAgent: 'codex',
      role: 'Reviewer',
      label: 'reviewer',
      model: 'gpt-5.5',
      effort: 'high',
      fast: true,
      providerId: 'openai',
      workerPermissionMode: 'auto',
    });
  });

  it('restores the remembered Worker choice like the desktop create panel', () => {
    const prefs = defaultOrcaWorkerCreationPrefs();
    expect(orcaWorkerFormFromPrefs(prefs, prefs.lastAgent)).toEqual({
      role: 'developer',
      agent: 'codex',
      model: { id: 'codex/gpt-5.5', providerId: null, effort: 'high', fast: false },
      permissionMode: 'bypassPermissions',
      initialTask: '',
    });
  });

  it('converges a remembered model to what the computer can run', () => {
    const capabilities = {
      hasFastMode: true,
      availableModels: [{
        id: 'gpt-5.5', label: 'GPT', efforts: ['low', 'medium'], effortDisplayNames: {},
        defaultEffort: 'medium', supportsFastMode: false,
      }],
    };
    expect(convergeOrcaWorkerModel({ id: 'gone', providerId: null, effort: 'high', fast: false }, capabilities)).toBeNull();
    expect(convergeOrcaWorkerModel({ id: 'gpt-5.5', providerId: null, effort: 'high', fast: true }, capabilities))
      .toEqual({ id: 'gpt-5.5', providerId: null, effort: 'medium', fast: false });
    const kept = { id: 'x', providerId: null, effort: 'high', fast: true };
    expect(convergeOrcaWorkerModel(kept, null)).toBe(kept);
    expect(convergeOrcaWorkerModel(null, capabilities)).toBeNull();
  });

  it('re-checks capabilities before enabling and refuses on downgraded hosts', async () => {
    const maker = fakeMaker({ capabilities: { supportsOrcaWorkerPermissionMode: false } });
    await expect(enableOrcaTeam(maker, 'lead-1', buildOrcaEnableOptions(form))).rejects.toThrow('CHANNEL_NOT_ALLOWED');
    expect(maker.orca.enable).not.toHaveBeenCalled();
  });

  it('treats a tunnel timeout as ambiguous and confirms the team from the Worker list', async () => {
    const maker = fakeMaker({
      orca: {
        enable: vi.fn(async () => { throw new Error('[INVOKE_TIMEOUT] timed out'); }),
        listWorkers: vi.fn(async () => [{ id: 'w-1', sessionId: 'worker-9' }]),
      },
    });
    await expect(enableOrcaTeam(maker, 'lead-1', buildOrcaEnableOptions(form))).resolves.toEqual({ workerSessionId: 'worker-9' });
    expect(maker.orca.enable).toHaveBeenCalledTimes(1);
  });

  it('confirms an already-existing team from the Worker list before treating it as started', async () => {
    const withWorker = fakeMaker({
      orca: {
        enable: vi.fn(async () => { throw new Error('[ALREADY_EXISTS] active team'); }),
        listWorkers: vi.fn(async () => [{ id: 'w-1', sessionId: 'worker-7' }]),
      },
    });
    await expect(enableOrcaTeam(withWorker, 'lead-1', buildOrcaEnableOptions(form))).resolves.toEqual({ workerSessionId: 'worker-7' });

    // 团队已建但首个 Worker 没落库:不能按成功处理。
    const teamOnly = fakeMaker({
      orca: {
        enable: vi.fn(async () => { throw new Error('[ALREADY_EXISTS] active team'); }),
        listWorkers: vi.fn(async () => []),
      },
    });
    vi.useFakeTimers();
    const pending = enableOrcaTeam(teamOnly, 'lead-1', buildOrcaEnableOptions(form));
    const assertion = expect(pending).rejects.toThrow('ALREADY_EXISTS');
    await vi.runAllTimersAsync();
    await assertion;
    vi.useRealTimers();
  });

  it('does not retry authoritative enable failures', async () => {
    const maker = fakeMaker({
      orca: { enable: vi.fn(async () => { throw new Error('[PRECONDITION_FAILED] disabled'); }) },
    });
    await expect(enableOrcaTeam(maker, 'lead-1', buildOrcaEnableOptions(form))).rejects.toThrow('PRECONDITION_FAILED');
    expect(maker.orca.listWorkers).not.toHaveBeenCalled();
  });

  it('skips labels still held by archived Workers instead of re-deriving the same one', async () => {
    // 已归档的 reviewer / reviewer-2 不在列表里,但 label 仍被占用。
    const createWorker = vi.fn()
      .mockRejectedValueOnce(new Error('[DUPLICATE_LABEL] taken'))
      .mockRejectedValueOnce(new Error('[DUPLICATE_LABEL] taken'))
      .mockResolvedValueOnce({ ok: true, workerSessionId: 'worker-3' });
    const maker = fakeMaker({ orca: { createWorker, listWorkers: vi.fn(async () => []) } });
    await expect(createOrcaWorker(maker, 'lead-1', form, [])).resolves.toEqual({ workerSessionId: 'worker-3' });
    expect(createWorker.mock.calls.map((call) => call[0].label)).toEqual(['reviewer', 'reviewer-2', 'reviewer-3']);
    expect(createWorker.mock.calls[2][0]).toMatchObject({ initialTask: 'check tests', agent: 'codex' });
  });

  it('refuses to create Workers on computers that would ignore the chosen permission', async () => {
    const maker = fakeMaker({ capabilities: {} });
    await expect(createOrcaWorker(maker, 'lead-1', form, [])).rejects.toThrow('CHANNEL_NOT_ALLOWED');
    expect(maker.orca.createWorker).not.toHaveBeenCalled();
  });

  it('confirms a timed-out Worker creation by its exact label instead of retrying', async () => {
    const createWorker = vi.fn(async () => { throw new Error('[INVOKE_TIMEOUT] timed out'); });
    const landed = fakeMaker({
      orca: {
        createWorker,
        listWorkers: vi.fn(async () => [
          { id: 'w-0', sessionId: 'old', role: 'reviewer', label: 'other' },
          { id: 'w-1', sessionId: 'new', role: 'Reviewer', label: 'reviewer' },
        ]),
      },
    });
    await expect(createOrcaWorker(landed, 'lead-1', form, [])).resolves.toEqual({ workerSessionId: 'new' });
    expect(createWorker).toHaveBeenCalledTimes(1);

    const lost = fakeMaker({
      orca: {
        createWorker: vi.fn(async () => { throw new Error('[INVOKE_TIMEOUT] timed out'); }),
        listWorkers: vi.fn(async () => []),
      },
    });
    vi.useFakeTimers();
    const pending = createOrcaWorker(lost, 'lead-1', form, []);
    const assertion = expect(pending).rejects.toThrow('ORCA_CREATE_UNCONFIRMED');
    await vi.runAllTimersAsync();
    await assertion;
    vi.useRealTimers();
    expect(lost.orca.createWorker).toHaveBeenCalledTimes(1);
    expect(describeOrcaError(new Error('[ORCA_CREATE_UNCONFIRMED] x'), 'session.collab.errors.createFailed'))
      .toContain('暂时无法确认是否成功');
  });

  it('describes known Orca errors in the interface language', () => {
    expect(describeOrcaError(new Error('[WORKER_LIMIT_HARD_EXCEEDED] full'), 'session.collab.errors.createFailed'))
      .toBe('已达 Worker 硬上限,请先归档现有 Worker。');
    expect(describeOrcaError(new Error('[DEVICE_LINK_CHANNEL_NOT_ALLOWED] old'), 'session.collab.errors.startFailed'))
      .toBe('电脑端版本过旧,暂不支持协同');
    expect(describeOrcaError(new Error('boom'), 'session.collab.errors.startFailed')).toContain('开启协同失败。');
  });

  it('hands a new-task start failure to the session page exactly once, including late failures', () => {
    rememberOrcaStartFailure('s-1', 'reason');
    expect(takeOrcaStartFailure('s-1')).toBe('reason');
    expect(takeOrcaStartFailure('s-1')).toBeNull();

    const seen: string[] = [];
    const unsubscribe = subscribeOrcaStartFailure((sessionId) => seen.push(sessionId));
    rememberOrcaStartFailure('s-2', 'late');
    unsubscribe();
    rememberOrcaStartFailure('s-3', 'after');
    expect(seen).toEqual(['s-2']);
  });

  it('bounds the timeout probe by an overall deadline', async () => {
    vi.useFakeTimers();
    const listWorkers = vi.fn(() => new Promise((resolve) => setTimeout(() => resolve([]), 20_000)));
    const maker = fakeMaker({
      orca: { enable: vi.fn(async () => { throw new Error('[INVOKE_TIMEOUT] timed out'); }), listWorkers },
    });
    const pending = enableOrcaTeam(maker, 'lead-1', buildOrcaEnableOptions(form));
    const assertion = expect(pending).rejects.toThrow('INVOKE_TIMEOUT');
    await vi.runAllTimersAsync();
    await assertion;
    vi.useRealTimers();
    // 20s 一次的探针在 30s 总时限内只来得及两次,不会跑满四次。
    expect(listWorkers.mock.calls.length).toBeLessThanOrEqual(2);
  });

  it('clears an explicit provider that no longer serves the chosen model before submitting', () => {
    const provider = (id: string, connected = true) => ({
      id, name: id, agents: ['codex'], connected, routing: { codex: {} }, models: { codex: [{ id: 'gpt-5.5' }] },
    }) as unknown as ProviderView;
    const chosen = { ...form, agent: 'codex' as const, model: { id: 'gpt-5.5', providerId: 'a', effort: 'high', fast: false } };
    // 来源 A 仍可路由 → 原样;A 断开、B 仍提供同名模型 → 清掉来源交给被控端默认路由。
    expect(narrowOrcaWorkerProvider(chosen, [provider('a'), provider('b')])).toBe(chosen);
    expect(narrowOrcaWorkerProvider(chosen, [provider('a', false), provider('b')]).model?.providerId).toBeNull();
    // 完整手动路线恢复后不可因旧来源断开而换凭证;原用例只覆盖旧版无位置的偏好。
    // unit:同模型另有可用来源时,创建边界仍收到用户原选来源并明确拒绝。
    const explicit = { ...chosen, modelSelectionExplicit: true };
    expect(narrowOrcaWorkerProvider(explicit, [provider('a', false), provider('b')])).toBe(explicit);
    // 目录未就绪时不猜。
    expect(narrowOrcaWorkerProvider(chosen, null)).toBe(chosen);
  });

  it('hides routes an SSH Lead cannot run for its Workers', () => {
    const gateway = {
      id: 'gateway', name: 'gateway', agents: ['codex'], connected: true, routing: { codex: {} },
      models: { codex: [{ id: 'gpt-5.5' }, { id: 'chatgpt/gpt-5.5' }] },
    } as unknown as ProviderView;
    const bridged = {
      id: 'bridged', name: 'bridged', agents: ['codex'], connected: true,
      routing: { codex: { wireProtocol: 'openai-chat' } }, models: { codex: [{ id: 'kimi' }] },
    } as unknown as ProviderView;
    const ssh = orcaWorkerProvidersForLead([gateway, bridged], true);
    expect(ssh[0]!.models.codex?.map((model) => model.id)).toEqual(['gpt-5.5']);
    expect(ssh[1]!.models.codex).toEqual([]);
    const local = [gateway, bridged];
    expect(orcaWorkerProvidersForLead(local, false)).toBe(local);
  });

  it('sends an explicit Fast off for a chosen model and leaves the default model to the computer', () => {
    const chosen = { ...form, agent: 'codex' as const, model: { id: 'gpt-5.5', providerId: null, effort: 'high', fast: false } };
    expect(buildOrcaEnableOptions(chosen)).toMatchObject({ model: 'gpt-5.5', fast: false });
    expect(buildOrcaEnableOptions({ ...chosen, model: null })).not.toHaveProperty('fast');
  });

  it('reconciles effort and Fast against the explicitly chosen provider, not the flattened list', () => {
    const provider = (id: string, efforts: string[], supportsFastMode: boolean) => ({
      id, name: id, agents: ['codex'], connected: true, routing: { codex: {} },
      models: { codex: [{ id: 'gpt-5.5', efforts, defaultEffort: efforts[0] ?? null, supportsFastMode }] },
    }) as unknown as ProviderView;
    const chosen = { ...form, agent: 'codex' as const, model: { id: 'gpt-5.5', providerId: 'a', effort: 'xhigh', fast: true } };
    // 拍平能力只有 low/high 且不支持 Fast:显式来源时不改 effort / Fast。
    const flat = { hasFastMode: true, availableModels: [{ id: 'gpt-5.5', efforts: ['low', 'high'], defaultEffort: 'low', supportsFastMode: false }] };
    expect(convergeOrcaWorkerModel(chosen.model, flat as never)).toEqual(chosen.model);
    // 来源 A 支持 xhigh 与 Fast → 原样;来源 A 不支持时按 A 自己的默认收敛。
    expect(narrowOrcaWorkerProvider(chosen, [provider('a', ['high', 'xhigh'], true)])).toBe(chosen);
    expect(narrowOrcaWorkerProvider(chosen, [provider('a', ['medium'], false)]).model)
      .toMatchObject({ providerId: 'a', effort: 'medium', fast: false });
  });

  it('reconciles an unpinned model against the default source it will actually route to', () => {
    const provider = (id: string, efforts: string[]) => ({
      id, name: id, agents: ['codex'], connected: true, routing: { codex: {} },
      models: { codex: [{ id: 'gpt-5.5', efforts, defaultEffort: efforts[0] ?? null, supportsFastMode: false }] },
    }) as unknown as ProviderView;
    const unpinned = { ...form, agent: 'codex' as const, model: { id: 'gpt-5.5', providerId: null, effort: 'xhigh', fast: true } };
    const result = narrowOrcaWorkerProvider(unpinned, [provider('only', ['low', 'medium'])]);
    // 仍不钉来源(交给被控端路由),但 effort / Fast 按该默认来源的条目收敛。
    expect(result.model).toMatchObject({ providerId: null, effort: 'low', fast: false });
  });

  it('omits effort when the routed provider has no effort levels for the model', () => {
    const provider = {
      id: 'a', name: 'a', agents: ['codex'], connected: true, routing: { codex: {} },
      models: { codex: [{ id: 'gpt-5.5', efforts: [], defaultEffort: null, supportsFastMode: false }] },
    } as unknown as ProviderView;
    const chosen = { ...form, agent: 'codex' as const, model: { id: 'gpt-5.5', providerId: 'a', effort: 'high', fast: false } };
    const narrowed = narrowOrcaWorkerProvider(chosen, [provider]);
    expect(narrowed.model?.effort).toBeNull();
    expect(buildOrcaEnableOptions(narrowed)).not.toHaveProperty('effort');
  });
});