loop-engine.test.ts

/**
 * loop-engine 单元测试
 *
 * 测试 ReAct Loop 引擎的核心功能：
 *   - 单轮执行 (runTurn)
 *   - 主循环 (runLoop) 退出条件
 *   - 退出摘要构建
 */

import { describe, it, expect, mock, beforeEach } from "bun:test";
import type { Message, LoopState, ApiResponse, ApiUsage } from "../src/types.js";
import type { LoopConfig } from "../src/config.js";

// 构造基础 config
function makeConfig(overrides: Partial<LoopConfig> = {}): LoopConfig {
  return {
    model: "deepseek-chat", maxTurns: 50, mode: "auto", endpoint: "native",
    api: { baseUrl: "https://api.deepseek.com", timeoutMs: 120000, maxRetries: 3, retryDelayMs: 1000 },
    thinking: { enabled: true, autoDisableThreshold: 0.95 },
    budget: { compactionThreshold: 0.90, hardStopThreshold: 0.98, budgetLimit: null },
    tools: { bashTimeoutMs: 60000, bashMaxOutputBytes: 51200, bashDeadlineMs: 2000, readMaxLines: 2000, globMaxResults: 500, grepMaxResults: 250 },
    guard: { enabled: true },
    convergence: { idleRoundsThreshold: 3, consecutiveErrorThreshold: 4, stagnantOutputHashWindow: 3, taskCompletionMinConfidence: 0.8 },
    output: { color: false, progressIntervalMs: 5000, summaryOnExit: true },
    ...overrides,
  };
}

function makeApiResponse(overrides: Partial<ApiResponse> = {}): ApiResponse {
  return {
    content: "hello", reasoningContent: "thinking...", toolCalls: [],
    finishReason: "stop",
    usage: { promptTokens: 100, completionTokens: 50, reasoningTokens: 200 },
    ...overrides,
  };
}

function makeState(overrides: Partial<LoopState> = {}): LoopState {
  return {
    turn: 1, maxTurns: 50,
    budget: { promptTokens: 0, completionTokens: 0, reasoningTokens: 0, maxContext: 128000, used: 0 },
    messages: [], interrupted: false, idleRoundsCounter: 0,
    consecutiveBashErrors: 0, recentOutputHashes: [], lastFinishReason: null,
    toolCallStatsThisTurn: { total: 0, blocked: 0, succeeded: 0 },
    ...overrides,
  };
}

describe("loop-engine", () => {
  describe("runTurn", () => {
    it("should call chatFn and return response", async () => {
      const chatFn = mock(async () => makeApiResponse());
      const { runTurn } = await import("../src/loop-engine.js");
      const messages: Message[] = [{ role: "user", content: "hello" }];
      const state = makeState();
      const config = makeConfig();

      const result = await runTurn(messages, state, config, chatFn);
      expect(result.response.content).toBe("hello");
      expect(chatFn).toHaveBeenCalledTimes(1);
      expect(result.terminate).toBe(false);
    });

    it("should increment idle counter when no tool calls", async () => {
      const chatFn = mock(async () => makeApiResponse());
      const { runTurn } = await import("../src/loop-engine.js");
      const state = makeState({ idleRoundsCounter: 0 });
      const result = await runTurn([{ role: "user", content: "hi" }], state, makeConfig(), chatFn);
      expect(state.idleRoundsCounter).toBe(1);
    });

    it("should update budget with usage from API response", async () => {
      const chatFn = mock(async () => makeApiResponse({
        usage: { promptTokens: 500, completionTokens: 300, reasoningTokens: 200 },
      }));
      const { runTurn } = await import("../src/loop-engine.js");
      const state = makeState();
      await runTurn([{ role: "user", content: "test" }], state, makeConfig(), chatFn);
      expect(state.budget.promptTokens).toBe(500);
      expect(state.budget.completionTokens).toBe(300);
      expect(state.budget.reasoningTokens).toBe(200);
      expect(state.budget.used).toBe(1000);
    });

    it("should set lastFinishReason from API response", async () => {
      const chatFn = mock(async () => makeApiResponse({ finishReason: "stop" }));
      const { runTurn } = await import("../src/loop-engine.js");
      const state = makeState();
      await runTurn([{ role: "user", content: "test" }], state, makeConfig(), chatFn);
      expect(state.lastFinishReason).toBe("stop");
    });

    it("should reset consecutiveBashErrors on non-bash-tool turn", async () => {
      const chatFn = mock(async () => makeApiResponse());
      const { runTurn } = await import("../src/loop-engine.js");
      const state = makeState({ consecutiveBashErrors: 3 });
      await runTurn([{ role: "user", content: "test" }], state, makeConfig(), chatFn);
      expect(state.consecutiveBashErrors).toBe(0);
    });

    it("should append tool_call messages to returned messages array", async () => {
      const chatFn = mock(async () => makeApiResponse({
        toolCalls: [
          { id: "call_1", type: "function" as const, index: 0, function: { name: "read", arguments: '{"file_path":"/tmp/test"}' } },
        ],
      }));
      const { runTurn } = await import("../src/loop-engine.js");
      const state = makeState();
      const result = await runTurn([{ role: "user", content: "read file" }], state, makeConfig(), chatFn);
      // Should have appended assistant message + tool result message
      expect(result.messages.length).toBe(3);
    });

    it("should track tool call stats per turn", async () => {
      const chatFn = mock(async () => makeApiResponse({
        toolCalls: [
          { id: "call_1", type: "function" as const, index: 0, function: { name: "read", arguments: '{"file_path":"/tmp/test"}' } },
          { id: "call_2", type: "function" as const, index: 1, function: { name: "grep", arguments: '{"pattern":"foo"}' } },
        ],
      }));
      const { runTurn } = await import("../src/loop-engine.js");
      const state = makeState();
      await runTurn([{ role: "user", content: "read and grep" }], state, makeConfig(), chatFn);
      expect(state.toolCallStatsThisTurn.total).toBe(2);
    });

    it("should return empty toolResults when no tool calls are present", async () => {
      const chatFn = mock(async () => makeApiResponse());
      const { runTurn } = await import("../src/loop-engine.js");
      const state = makeState();
      const result = await runTurn([{ role: "user", content: "hi" }], state, makeConfig(), chatFn);
      expect(result.toolResults).toEqual([]);
    });

    it("should record hash in recentOutputHashes for stagnant detection", async () => {
      const chatFn = mock(async () => makeApiResponse());
      const { runTurn } = await import("../src/loop-engine.js");
      const state = makeState();
      await runTurn([{ role: "user", content: "task" }], state, makeConfig(), chatFn);
      expect(state.recentOutputHashes.length).toBe(1);
    });
  });

  describe("runLoop", () => {
    it("should initialize state with turn=0 and empty budget", async () => {
      const chatFn = mock(async () => makeApiResponse({ finishReason: "stop" }));
      const { runLoop } = await import("../src/loop-engine.js");
      const messages: Message[] = [{ role: "user", content: "do something" }];
      const summary = await runLoop(messages, makeConfig({ maxTurns: 1 }), chatFn);
      expect(summary.totalTurns).toBe(1);
      expect(summary.status).toBe("task_completed");
    });

    it("should terminate on max_turns when limits exceeded", async () => {
      const chatFn = mock(async () => makeApiResponse());
      const { runLoop } = await import("../src/loop-engine.js");
      const messages: Message[] = [{ role: "user", content: "do something" }];
      const summary = await runLoop(messages, makeConfig({ maxTurns: 3 }), chatFn);
      expect(summary.status).toBe("task_completed");
      // Each turn with no tool calls = idle round, 3 idle rounds = no_progress termination
      expect(["task_completed", "no_progress", "max_turns"]).toContain(summary.status);
    });

    it("should include token and cost data in exit summary", async () => {
      const chatFn = mock(async () => makeApiResponse({
        usage: { promptTokens: 1000, completionTokens: 500, reasoningTokens: 2000 },
      }));
      const { runLoop } = await import("../src/loop-engine.js");
      const messages: Message[] = [{ role: "user", content: "task" }];
      const summary = await runLoop(messages, makeConfig({ maxTurns: 1 }), chatFn);
      expect(summary.tokens.prompt).toBe(1000);
      expect(summary.tokens.completion).toBe(500);
      expect(summary.tokens.reasoning).toBe(2000);
      expect(summary.tokens.total).toBe(3500);
      expect(summary.cost.total).toBeGreaterThan(0);
      expect(summary.guardBlocks).toBe(0);
      expect(summary.exitCode).toBe(0);
    });
  });
});