@renxqoo/renx-code 0.0.8 → 0.0.10

package/vendor/agent-root/src/agent/agent/__test__/fault-injection.test.ts

@@ -1,295 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getEventListeners } from 'node:events';
-import { StatelessAgent } from '../index';
-import type { AgentMetric, Message, StreamEvent } from '../../types';
-import type { ToolManager } from '../../tool/tool-manager';
-import type { Chunk, LLMProvider } from '../../../providers';
-
-type ChunkDelta = NonNullable<NonNullable<Chunk['choices']>[number]>['delta'];
-type TestDelta = Partial<ChunkDelta> & { finish_reason?: string };
-type TestChunk = Omit<Chunk, 'choices'> & {
-  choices?: Array<{
-    index: number;
-    delta: TestDelta;
-  }>;
-};
-
-function toStream(chunks: TestChunk[]): AsyncGenerator<Chunk> {
-  return (async function* () {
-    for (const chunk of chunks) {
-      yield chunk as Chunk;
-    }
-  })();
-}
-
-async function collectEvents(generator: AsyncGenerator<StreamEvent>): Promise<StreamEvent[]> {
-  const events: StreamEvent[] = [];
-  for await (const event of generator) {
-    events.push(event);
-  }
-  return events;
-}
-
-function createProvider() {
-  return {
-    config: {} as Record<string, unknown>,
-    generate: vi.fn(),
-    generateStream: vi.fn(),
-    getTimeTimeout: vi.fn(() => 1),
-    getLLMMaxTokens: vi.fn(() => 1),
-    getMaxOutputTokens: vi.fn(() => 1),
-  } as unknown as LLMProvider;
-}
-
-function createToolManager() {
-  return {
-    execute: vi.fn(),
-    registerTool: vi.fn(),
-    getTools: vi.fn(() => []),
-    getConcurrencyPolicy: vi.fn(() => ({ mode: 'exclusive' as const })),
-  } as unknown as ToolManager;
-}
-
-function createInput(executionId = 'exec_fault_1') {
-  const message: Message = {
-    messageId: 'u1',
-    type: 'user',
-    role: 'user',
-    content: 'hello',
-    timestamp: Date.now(),
-  };
-  return {
-    executionId,
-    conversationId: 'conv_fault_1',
-    messages: [message],
-    maxSteps: 4,
-  };
-}
-
-describe('StatelessAgent fault injection', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.useRealTimers();
-  });
-
-  it('auto-retries plain transient network errors without requiring onError callback', async () => {
-    vi.useFakeTimers();
-    const provider = createProvider();
-    const manager = createToolManager();
-    let attempt = 0;
-    provider.generateStream = vi.fn().mockImplementation(() => {
-      attempt += 1;
-      if (attempt <= 2) {
-        return (async function* () {
-          yield* [] as Chunk[];
-          throw new Error('transient network');
-        })();
-      }
-      return toStream([
-        {
-          index: 0,
-          choices: [{ index: 0, delta: { content: 'recovered' } }],
-        },
-        {
-          index: 0,
-          choices: [{ index: 0, delta: { finish_reason: 'stop' } as unknown as ChunkDelta }],
-        },
-      ]);
-    });
-
-    const agent = new StatelessAgent(provider, manager, {
-      maxRetryCount: 5,
-      backoffConfig: { initialDelayMs: 5, maxDelayMs: 5, base: 2, jitter: false },
-    });
-
-    const eventsPromise = collectEvents(agent.runStream(createInput()));
-    await vi.advanceTimersByTimeAsync(20);
-    const events = await eventsPromise;
-
-    expect(provider.generateStream).toHaveBeenCalledTimes(3);
-    expect(events.filter((event) => event.type === 'error')).toHaveLength(2);
-    expect(events.at(-1)).toMatchObject({
-      type: 'done',
-      data: { finishReason: 'stop' },
-    });
-  });
-
-  it('auto-retries when the post-tool llm turn only emits empty chunks', async () => {
-    vi.useFakeTimers();
-    const provider = createProvider();
-    const manager = createToolManager();
-
-    provider.generateStream = vi
-      .fn()
-      .mockReturnValueOnce(
-        toStream([
-          {
-            index: 0,
-            choices: [
-              {
-                index: 0,
-                delta: {
-                  tool_calls: [
-                    {
-                      id: 'call_1',
-                      type: 'function',
-                      index: 0,
-                      function: {
-                        name: 'bash',
-                        arguments: JSON.stringify({ command: 'echo ProviderType' }),
-                      },
-                    },
-                  ],
-                  finish_reason: 'tool_calls',
-                } as unknown as ChunkDelta,
-              },
-            ],
-          },
-        ])
-      )
-      .mockReturnValueOnce(
-        toStream([
-          {
-            index: 0,
-            choices: [{ index: 0, delta: { content: '' } }],
-          },
-          {
-            index: 0,
-            choices: [{ index: 0, delta: { content: '' } }],
-          },
-          {
-            index: 0,
-            choices: [{ index: 0, delta: { finish_reason: 'stop' } as unknown as ChunkDelta }],
-          },
-        ])
-      )
-      .mockReturnValueOnce(
-        toStream([
-          {
-            index: 0,
-            choices: [{ index: 0, delta: { content: 'Recovered after empty response' } }],
-          },
-          {
-            index: 0,
-            choices: [{ index: 0, delta: { finish_reason: 'stop' } as unknown as ChunkDelta }],
-          },
-        ])
-      );
-    manager.execute = vi.fn().mockResolvedValue({
-      success: true,
-      output: "src/providers/index.ts:export type { ProviderType, ModelId } from './registry';",
-    });
-
-    const agent = new StatelessAgent(provider, manager, {
-      maxRetryCount: 3,
-      backoffConfig: { initialDelayMs: 5, maxDelayMs: 5, base: 2, jitter: false },
-    });
-
-    const eventsPromise = collectEvents(agent.runStream(createInput()));
-    await vi.advanceTimersByTimeAsync(20);
-    const events = await eventsPromise;
-
-    expect(events.filter((event) => event.type === 'error')).toHaveLength(1);
-    expect(events.at(-1)).toMatchObject({
-      type: 'done',
-      data: { finishReason: 'stop' },
-    });
-    expect(provider.generateStream).toHaveBeenCalledTimes(3);
-  });
-
-  it('does not leak abort listeners after repeated timeout-budgeted runs', async () => {
-    const provider = createProvider();
-    const manager = createToolManager();
-    provider.generateStream = vi.fn().mockImplementation(() =>
-      toStream([
-        {
-          index: 0,
-          choices: [{ index: 0, delta: { content: 'ok' } }],
-        },
-        {
-          index: 0,
-          choices: [{ index: 0, delta: { finish_reason: 'stop' } as unknown as ChunkDelta }],
-        },
-      ])
-    );
-
-    const controller = new AbortController();
-    const agent = new StatelessAgent(provider, manager, {
-      maxRetryCount: 2,
-      timeoutBudgetMs: 500,
-      llmTimeoutRatio: 0.7,
-    });
-
-    for (let i = 0; i < 20; i++) {
-      const events = await collectEvents(
-        agent.runStream(
-          {
-            ...createInput(`exec_soak_${i}`),
-            abortSignal: controller.signal,
-          },
-          { onMessage: vi.fn(), onCheckpoint: vi.fn() }
-        )
-      );
-      expect(events.at(-1)).toMatchObject({
-        type: 'done',
-        data: { finishReason: 'stop' },
-      });
-    }
-
-    expect(getEventListeners(controller.signal, 'abort')).toHaveLength(0);
-  });
-
-  it('marks tool stage metrics as failed when chaos tool crash happens', async () => {
-    const provider = createProvider();
-    const manager = createToolManager();
-    provider.generateStream = vi.fn().mockReturnValue(
-      toStream([
-        {
-          index: 0,
-          choices: [
-            {
-              index: 0,
-              delta: {
-                tool_calls: [
-                  {
-                    id: 'tool_fault_1',
-                    type: 'function',
-                    index: 0,
-                    function: { name: 'bash', arguments: '{"command":"echo fault"}' },
-                  },
-                ],
-                finish_reason: 'tool_calls',
-              } as unknown as ChunkDelta,
-            },
-          ],
-        },
-      ])
-    );
-    manager.execute = vi.fn().mockRejectedValue(new Error('chaos tool crash'));
-    const onMetric = vi.fn(async (_metric: AgentMetric) => undefined);
-
-    const agent = new StatelessAgent(provider, manager, { maxRetryCount: 2 });
-    const events = await collectEvents(
-      agent.runStream(createInput('exec_fault_tool'), {
-        onMessage: vi.fn(),
-        onCheckpoint: vi.fn(),
-        onError: async () => ({ retry: false }),
-        onMetric,
-      })
-    );
-
-    expect(events.at(-1)).toMatchObject({
-      type: 'error',
-      data: { message: 'chaos tool crash' },
-    });
-
-    const metrics = onMetric.mock.calls.map((call) => call[0] as AgentMetric);
-    const toolStageMetric = metrics.find(
-      (metric) => metric.name === 'agent.tool.stage.duration_ms'
-    );
-    const toolMetric = metrics.find((metric) => metric.name === 'agent.tool.duration_ms');
-
-    expect(toolStageMetric?.tags?.success).toBe('false');
-    expect(toolMetric?.tags?.success).toBe('false');
-  });
-});