metona-ai-desktop/electron/harness/agent-loop/__tests__/engine.test.ts

/**
 * AgentLoopEngine 单元测试（P1-14 测试基线）
 * 覆盖：完成终止、死循环检测、最大迭代、Provider 故障转移（P1）
 */

import { describe, it, expect, vi } from 'vitest';

vi.mock('electron-log', () => ({
  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
}));

import { AgentLoopEngine } from '../engine';
import { AgentLoopState, TerminationReason } from '../types';
import type { IMetonaProviderAdapter, MetonaResponse, MetonaStreamEvent } from '../../types';
import { MetonaStreamEventType } from '../../types';

/** 构造 Mock Adapter：sendStream 按脚本产出事件 */
function createMockAdapter(scripts: MetonaStreamEvent[][], opts?: { failWith?: Error }): IMetonaProviderAdapter {
  let call = 0;
  return {
    providerId: 'mock',
    supportedModels: ['mock-model'],
    supportsToolCalling: true,
    supportsThinking: false,
    getContextWindow: () => 1_000_000,
    send: vi.fn(async (): Promise<MetonaResponse> => ({
      meta: { requestId: 'r_test', provider: 'mock', model: 'mock-model', latencyMs: 1, timestamp: Date.now() },
      content: 'ok',
      usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
      finishReason: 'stop' as never,
    })),
    sendStream: vi.fn(async function* (): AsyncIterable<MetonaStreamEvent> {
      if (opts?.failWith) throw opts.failWith;
      const script = scripts[call % scripts.length];
      call++;
      for (const ev of script) yield ev;
    }),
    setAbortSignal: vi.fn(),
    healthCheck: async () => true,
  };
}

function textDoneEvent(text: string): MetonaStreamEvent[] {
  return [
    { type: MetonaStreamEventType.TEXT_DELTA, requestId: 'r1', sessionId: 's1', iteration: 1, seq: 0, timestamp: Date.now(), delta: text },
    { type: MetonaStreamEventType.DONE, requestId: 'r1', sessionId: 's1', iteration: 1, seq: 1, timestamp: Date.now() },
  ];
}

function toolCallEvent(name: string, args: Record<string, unknown>): MetonaStreamEvent[] {
  return [
    {
      type: MetonaStreamEventType.TOOL_CALL_COMPLETE,
      requestId: 'r1', sessionId: 's1', iteration: 1, seq: 0, timestamp: Date.now(),
      toolCall: { id: 'tc_test', name, args, iteration: 1, timestamp: Date.now() },
    },
    { type: MetonaStreamEventType.DONE, requestId: 'r1', sessionId: 's1', iteration: 1, seq: 1, timestamp: Date.now() },
  ];
}

const userMessage = { role: 'user' as const, content: 'hello', timestamp: Date.now() };
const systemPrompt = { roleDefinition: '', outputConstraints: '', safetyGuidelines: '' };

describe('AgentLoopEngine', () => {
  it('无工具调用时正常完成（COMPLETED）', async () => {
    const adapter = createMockAdapter([textDoneEvent('final answer')]);
    const engine = new AgentLoopEngine({}, adapter);
    const output = await engine.runStream(userMessage, 's1', [], systemPrompt);
    expect(output.terminationReason).toBe(TerminationReason.COMPLETED);
    expect(output.finalAnswer).toBe('final answer');
  });

  it('死循环检测：连续 3 轮相同工具调用触发 DEAD_LOOP', async () => {
    // 每轮都返回相同的工具调用（read_file + 相同参数）
    const adapter = createMockAdapter([toolCallEvent('read_file', { file_path: 'same.ts' })]);
    const engine = new AgentLoopEngine({ maxIterations: 10 }, adapter);
    const deadLoopEvents: unknown[] = [];
    engine.on('deadLoop', (d) => deadLoopEvents.push(d));
    const output = await engine.runStream(userMessage, 's1', [], systemPrompt);
    expect(output.terminationReason).toBe(TerminationReason.DEAD_LOOP);
    expect(deadLoopEvents.length).toBe(1);
  });

  it('参数不同的相同工具不触发死循环（签名不同）', async () => {
    const scripts = [
      toolCallEvent('read_file', { file_path: 'a.ts' }),
      toolCallEvent('read_file', { file_path: 'b.ts' }),
    ];
    const adapter = createMockAdapter(scripts);
    const engine = new AgentLoopEngine({ maxIterations: 3 }, adapter);
    const output = await engine.runStream(userMessage, 's1', [], systemPrompt);
    // 3 轮工具调用后达到 MAX_ITERATIONS（非 DEAD_LOOP）
    expect(output.terminationReason).toBe(TerminationReason.MAX_ITERATIONS);
  });

  it('达到最大迭代次数触发 MAX_ITERATIONS', async () => {
    // 交替不同的工具调用避免死循环
    const scripts = [
      toolCallEvent('read_file', { file_path: 'a.ts' }),
      toolCallEvent('read_file', { file_path: 'b.ts' }),
    ];
    const adapter = createMockAdapter(scripts);
    const engine = new AgentLoopEngine({ maxIterations: 2 }, adapter);
    const output = await engine.runStream(userMessage, 's1', [], systemPrompt);
    expect(output.terminationReason).toBe(TerminationReason.MAX_ITERATIONS);
    expect(output.iterations.length).toBe(2);
  });

  it('状态机经过 THINKING → PARSING → OBSERVING', async () => {
    const adapter = createMockAdapter([textDoneEvent('answer')]);
    const engine = new AgentLoopEngine({}, adapter);
    const states: string[] = [];
    engine.on('stateChange', (d: { current?: string }) => {
      if (d.current) states.push(d.current);
    });
    await engine.runStream(userMessage, 's1', [], systemPrompt);
    expect(states).toContain(AgentLoopState.THINKING);
    expect(states).toContain(AgentLoopState.PARSING);
    expect(states).toContain(AgentLoopState.OBSERVING);
    expect(states[states.length - 1]).toBe(AgentLoopState.TERMINATED);
  });

  it('不可重试错误直接 ERROR（无 fallback 时）', async () => {
    const adapter = createMockAdapter([], { failWith: Object.assign(new Error('401 unauthorized'), { status: 401 }) });
    const engine = new AgentLoopEngine({ retryCount: 0 }, adapter);
    const output = await engine.runStream(userMessage, 's1', [], systemPrompt);
    expect(output.terminationReason).toBe(TerminationReason.ERROR);
  });

  it('P1 故障转移：主 Provider 失败后切换到 fallback Provider', async () => {
    // 主 adapter 每次都失败（401 不可重试）
    const primary = createMockAdapter([], { failWith: Object.assign(new Error('401 invalid key'), { status: 401 }) });
    // fallback 正常返回
    const fallback = createMockAdapter([textDoneEvent('fallback answer')]);

    const engine = new AgentLoopEngine({ retryCount: 0 }, primary);
    engine.setFallbackAdapter(fallback);

    const switchEvents: Array<{ from?: string; to?: string }> = [];
    engine.on('providerSwitched', (d) => switchEvents.push(d));

    const output = await engine.runStream(userMessage, 's1', [], systemPrompt);

    expect(output.terminationReason).toBe(TerminationReason.COMPLETED);
    expect(output.finalAnswer).toBe('fallback answer');
    expect(switchEvents.length).toBe(1);
    expect(switchEvents[0].from).toBe('mock');
    expect(switchEvents[0].to).toBe('mock');
    // fallback 的 sendStream 被调用
    expect(fallback.sendStream).toHaveBeenCalled();
  });

  it('P1 故障转移仅触发一次（fallback 也失败不回切）', async () => {
    const primary = createMockAdapter([], { failWith: Object.assign(new Error('401'), { status: 401 }) });
    const fallback = createMockAdapter([], { failWith: Object.assign(new Error('500'), { status: 500 }) });

    const engine = new AgentLoopEngine({ retryCount: 0 }, primary);
    engine.setFallbackAdapter(fallback);

    const output = await engine.runStream(userMessage, 's1', [], systemPrompt);
    // fallback 失败 → ERROR（不回切 primary）
    expect(output.terminationReason).toBe(TerminationReason.ERROR);
  });
});