@renxqoo/renx-code 0.0.3 → 0.0.5

package/vendor/agent-root/src/agent/agent/__test__/timeout-budget.test.ts

@@ -0,0 +1,479 @@
+import { describe, expect, it } from 'vitest';
+import {
+  createTimeoutBudgetState,
+  createExecutionAbortScope,
+  createStageAbortScope,
+  combineAbortSignals,
+  getAbortReason,
+  getTotalRemainingBudgetMs,
+  consumeStageBudget,
+  createTimeoutBudgetReason,
+  isTimeoutBudgetReason,
+  timeoutBudgetReasonFromSignal,
+} from '../timeout-budget';
+
+describe('createTimeoutBudgetState', () => {
+  it('returns undefined when no valid timeout is provided', () => {
+    const result = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: undefined,
+      configTimeoutBudgetMs: undefined,
+      inputLlmTimeoutRatio: 0.5,
+      configLlmTimeoutRatio: 0.7,
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('returns undefined when timeout is zero or negative', () => {
+    // When inputTimeoutBudgetMs is 0, it should use configTimeoutBudgetMs
+    const result1 = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: 0,
+      configTimeoutBudgetMs: 1000,
+      inputLlmTimeoutRatio: 0.5,
+      configLlmTimeoutRatio: 0.7,
+    });
+    expect(result1).toBeDefined();
+    expect(result1!.totalMs).toBe(1000);
+
+    // When inputTimeoutBudgetMs is negative, it should use configTimeoutBudgetMs
+    const result2 = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: -100,
+      configTimeoutBudgetMs: 1000,
+      inputLlmTimeoutRatio: 0.5,
+      configLlmTimeoutRatio: 0.7,
+    });
+    expect(result2).toBeDefined();
+    expect(result2!.totalMs).toBe(1000);
+
+    // When both are invalid, return undefined
+    expect(
+      createTimeoutBudgetState({
+        inputTimeoutBudgetMs: 0,
+        configTimeoutBudgetMs: 0,
+        inputLlmTimeoutRatio: 0.5,
+        configLlmTimeoutRatio: 0.7,
+      })
+    ).toBeUndefined();
+  });
+
+  it('uses input timeout when provided', () => {
+    const result = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: 5000,
+      configTimeoutBudgetMs: 10000,
+      inputLlmTimeoutRatio: 0.6,
+      configLlmTimeoutRatio: 0.7,
+    });
+
+    expect(result).toBeDefined();
+    expect(result!.totalMs).toBe(5000);
+    expect(result!.llmRemainingMs).toBe(3000); // 5000 * 0.6
+    expect(result!.toolRemainingMs).toBe(2000); // 5000 - 3000
+  });
+
+  it('uses config timeout when input is invalid', () => {
+    const result = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: NaN,
+      configTimeoutBudgetMs: 10000,
+      inputLlmTimeoutRatio: NaN,
+      configLlmTimeoutRatio: 0.7,
+    });
+
+    expect(result).toBeDefined();
+    expect(result!.totalMs).toBe(10000);
+    // When inputLlmTimeoutRatio is NaN, it should use configLlmTimeoutRatio (0.7)
+    expect(result!.llmRemainingMs).toBe(7000); // 10000 * 0.7
+    expect(result!.toolRemainingMs).toBe(3000); // 10000 - 7000
+  });
+
+  it('clamps ratio between 0.05 and 0.95', () => {
+    const result1 = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: 10000,
+      configTimeoutBudgetMs: 10000,
+      inputLlmTimeoutRatio: 0.01, // below minimum
+      configLlmTimeoutRatio: 0.7,
+    });
+
+    expect(result1!.llmRemainingMs).toBe(500); // 10000 * 0.05 (clamped)
+
+    const result2 = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: 10000,
+      configTimeoutBudgetMs: 10000,
+      inputLlmTimeoutRatio: 0.99, // above maximum
+      configLlmTimeoutRatio: 0.7,
+    });
+
+    expect(result2!.llmRemainingMs).toBe(9500); // 10000 * 0.95 (clamped)
+  });
+
+  it('uses config ratio when input ratio is invalid', () => {
+    const result = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: 10000,
+      configTimeoutBudgetMs: 10000,
+      inputLlmTimeoutRatio: NaN,
+      configLlmTimeoutRatio: 0.8,
+    });
+
+    expect(result!.llmRemainingMs).toBe(8000); // 10000 * 0.8
+  });
+
+  it('ensures minimum llm remaining of 1ms', () => {
+    const result = createTimeoutBudgetState({
+      inputTimeoutBudgetMs: 10,
+      configTimeoutBudgetMs: 10,
+      inputLlmTimeoutRatio: 0.05,
+      configLlmTimeoutRatio: 0.7,
+    });
+
+    expect(result!.llmRemainingMs).toBe(1); // minimum 1ms
+    expect(result!.toolRemainingMs).toBe(9); // 10 - 1
+  });
+});
+
+describe('getTotalRemainingBudgetMs', () => {
+  it('returns remaining time correctly', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now() - 2000, // 2 seconds ago
+      llmRemainingMs: 7000,
+      toolRemainingMs: 3000,
+    };
+
+    const remaining = getTotalRemainingBudgetMs(budget);
+    expect(remaining).toBeLessThanOrEqual(8000);
+    expect(remaining).toBeGreaterThan(7900);
+  });
+
+  it('returns 0 when budget is exhausted', () => {
+    const budget = {
+      totalMs: 1000,
+      startedAt: Date.now() - 2000, // 2 seconds ago
+      llmRemainingMs: 700,
+      toolRemainingMs: 300,
+    };
+
+    const remaining = getTotalRemainingBudgetMs(budget);
+    expect(remaining).toBe(0);
+  });
+});
+
+describe('consumeStageBudget', () => {
+  it('consumes llm budget correctly', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now(),
+      llmRemainingMs: 5000,
+      toolRemainingMs: 5000,
+    };
+
+    consumeStageBudget(budget, 'llm', 1000);
+    expect(budget.llmRemainingMs).toBe(4000);
+    expect(budget.toolRemainingMs).toBe(5000);
+  });
+
+  it('consumes tool budget correctly', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now(),
+      llmRemainingMs: 5000,
+      toolRemainingMs: 5000,
+    };
+
+    consumeStageBudget(budget, 'tool', 2000);
+    expect(budget.llmRemainingMs).toBe(5000);
+    expect(budget.toolRemainingMs).toBe(3000);
+  });
+
+  it('does not go below zero', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now(),
+      llmRemainingMs: 1000,
+      toolRemainingMs: 1000,
+    };
+
+    consumeStageBudget(budget, 'llm', 2000);
+    expect(budget.llmRemainingMs).toBe(0);
+  });
+
+  it('handles negative elapsed time', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now(),
+      llmRemainingMs: 5000,
+      toolRemainingMs: 5000,
+    };
+
+    consumeStageBudget(budget, 'llm', -1000);
+    expect(budget.llmRemainingMs).toBe(5000); // no change
+  });
+});
+
+describe('createTimeoutBudgetReason', () => {
+  it('creates reason for total stage', () => {
+    const reason = createTimeoutBudgetReason('total', 5000);
+
+    expect(reason.type).toBe('agent-timeout-budget');
+    expect(reason.stage).toBe('total');
+    expect(reason.message).toContain('execution');
+    expect(reason.message).toContain('5000');
+  });
+
+  it('creates reason for llm stage', () => {
+    const reason = createTimeoutBudgetReason('llm', 3000);
+
+    expect(reason.type).toBe('agent-timeout-budget');
+    expect(reason.stage).toBe('llm');
+    expect(reason.message).toContain('llm');
+    expect(reason.message).toContain('3000');
+  });
+
+  it('creates reason for tool stage', () => {
+    const reason = createTimeoutBudgetReason('tool', 2000);
+
+    expect(reason.type).toBe('agent-timeout-budget');
+    expect(reason.stage).toBe('tool');
+    expect(reason.message).toContain('tool');
+    expect(reason.message).toContain('2000');
+  });
+});
+
+describe('isTimeoutBudgetReason', () => {
+  it('returns true for valid timeout budget reason', () => {
+    const reason = {
+      type: 'agent-timeout-budget',
+      stage: 'total',
+      message: 'Timeout budget exceeded',
+    };
+
+    expect(isTimeoutBudgetReason(reason)).toBe(true);
+  });
+
+  it('returns false for invalid objects', () => {
+    expect(isTimeoutBudgetReason(null)).toBe(false);
+    expect(isTimeoutBudgetReason(undefined)).toBe(false);
+    expect(isTimeoutBudgetReason('string')).toBe(false);
+    expect(isTimeoutBudgetReason(123)).toBe(false);
+    expect(isTimeoutBudgetReason({})).toBe(false);
+    expect(isTimeoutBudgetReason({ type: 'other' })).toBe(false);
+    expect(isTimeoutBudgetReason({ type: 'agent-timeout-budget' })).toBe(false);
+    expect(isTimeoutBudgetReason({ type: 'agent-timeout-budget', stage: 123 })).toBe(false);
+  });
+});
+
+describe('getAbortReason', () => {
+  it('returns reason from aborted signal', () => {
+    const controller = new AbortController();
+    const reason = { custom: 'reason' };
+    controller.abort(reason);
+
+    expect(getAbortReason(controller.signal)).toBe(reason);
+  });
+
+  it('returns undefined for non-aborted signal', () => {
+    const controller = new AbortController();
+    expect(getAbortReason(controller.signal)).toBeUndefined();
+  });
+});
+
+describe('combineAbortSignals', () => {
+  it('returns undefined signal when both are undefined', () => {
+    const scope = combineAbortSignals(undefined, undefined);
+    expect(scope.signal).toBeUndefined();
+    expect(typeof scope.release).toBe('function');
+  });
+
+  it('returns primary signal when secondary is undefined', () => {
+    const controller = new AbortController();
+    const scope = combineAbortSignals(controller.signal, undefined);
+
+    expect(scope.signal).toBe(controller.signal);
+  });
+
+  it('returns secondary signal when primary is undefined', () => {
+    const controller = new AbortController();
+    const scope = combineAbortSignals(undefined, controller.signal);
+
+    expect(scope.signal).toBe(controller.signal);
+  });
+
+  it('combines two signals correctly', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+    const scope = combineAbortSignals(controller1.signal, controller2.signal);
+
+    expect(scope.signal).toBeDefined();
+    expect(scope.signal!.aborted).toBe(false);
+
+    controller1.abort();
+    expect(scope.signal!.aborted).toBe(true);
+  });
+
+  it('handles already aborted primary signal', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+    controller1.abort();
+
+    const scope = combineAbortSignals(controller1.signal, controller2.signal);
+    expect(scope.signal!.aborted).toBe(true);
+  });
+
+  it('handles already aborted secondary signal', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+    controller2.abort();
+
+    const scope = combineAbortSignals(controller1.signal, controller2.signal);
+    expect(scope.signal!.aborted).toBe(true);
+  });
+
+  it('release function removes event listeners', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+    const scope = combineAbortSignals(controller1.signal, controller2.signal);
+
+    // Should not throw
+    expect(() => scope.release()).not.toThrow();
+  });
+});
+
+describe('timeoutBudgetReasonFromSignal', () => {
+  it('returns reason for aborted signal with timeout budget reason', () => {
+    const controller = new AbortController();
+    const reason = createTimeoutBudgetReason('total', 5000);
+    controller.abort(reason);
+
+    const result = timeoutBudgetReasonFromSignal(controller.signal);
+    expect(result).toBe(reason);
+  });
+
+  it('returns undefined for non-aborted signal', () => {
+    const controller = new AbortController();
+    expect(timeoutBudgetReasonFromSignal(controller.signal)).toBeUndefined();
+  });
+
+  it('returns undefined for aborted signal with non-timeout reason', () => {
+    const controller = new AbortController();
+    controller.abort('custom reason');
+
+    expect(timeoutBudgetReasonFromSignal(controller.signal)).toBeUndefined();
+  });
+
+  it('returns undefined for undefined signal', () => {
+    expect(timeoutBudgetReasonFromSignal(undefined)).toBeUndefined();
+  });
+});
+
+describe('createExecutionAbortScope', () => {
+  it('returns input signal when no timeout budget', () => {
+    const controller = new AbortController();
+    const scope = createExecutionAbortScope(controller.signal, undefined);
+
+    expect(scope.signal).toBe(controller.signal);
+  });
+
+  it('creates combined scope with timeout budget', () => {
+    const budget = {
+      totalMs: 1000,
+      startedAt: Date.now(),
+      llmRemainingMs: 700,
+      toolRemainingMs: 300,
+    };
+
+    const scope = createExecutionAbortScope(undefined, budget);
+
+    expect(scope.signal).toBeDefined();
+    expect(scope.signal!.aborted).toBe(false);
+
+    // Should abort after timeout
+    return new Promise<void>((resolve) => {
+      setTimeout(() => {
+        expect(scope.signal!.aborted).toBe(true);
+        scope.release();
+        resolve();
+      }, 1100);
+    });
+  });
+
+  it('combines input signal with timeout', () => {
+    const controller = new AbortController();
+    const budget = {
+      totalMs: 1000,
+      startedAt: Date.now(),
+      llmRemainingMs: 700,
+      toolRemainingMs: 300,
+    };
+
+    const scope = createExecutionAbortScope(controller.signal, budget);
+
+    expect(scope.signal).toBeDefined();
+
+    // Abort via input signal
+    controller.abort();
+    expect(scope.signal!.aborted).toBe(true);
+  });
+});
+
+describe('createStageAbortScope', () => {
+  it('returns base signal when no timeout budget', () => {
+    const controller = new AbortController();
+    const scope = createStageAbortScope(controller.signal, undefined, 'llm');
+
+    expect(scope.signal).toBe(controller.signal);
+  });
+
+  it('creates scope for llm stage', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now(),
+      llmRemainingMs: 5000,
+      toolRemainingMs: 5000,
+    };
+
+    const scope = createStageAbortScope(undefined, budget, 'llm');
+
+    expect(scope.signal).toBeDefined();
+    expect(scope.signal!.aborted).toBe(false);
+  });
+
+  it('creates scope for tool stage', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now(),
+      llmRemainingMs: 5000,
+      toolRemainingMs: 5000,
+    };
+
+    const scope = createStageAbortScope(undefined, budget, 'tool');
+
+    expect(scope.signal).toBeDefined();
+    expect(scope.signal!.aborted).toBe(false);
+  });
+
+  it('handles exhausted stage budget', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now(),
+      llmRemainingMs: 0,
+      toolRemainingMs: 5000,
+    };
+
+    const scope = createStageAbortScope(undefined, budget, 'llm');
+
+    expect(scope.signal).toBeDefined();
+    expect(scope.signal!.aborted).toBe(true);
+  });
+
+  it('uses minimum of stage and total remaining', () => {
+    const budget = {
+      totalMs: 10000,
+      startedAt: Date.now() - 8000, // 8 seconds ago
+      llmRemainingMs: 5000,
+      toolRemainingMs: 5000,
+    };
+
+    const scope = createStageAbortScope(undefined, budget, 'llm');
+
+    expect(scope.signal).toBeDefined();
+    // Should use total remaining (2000ms) instead of stage remaining (5000ms)
+  });
+});

package/vendor/agent-root/src/agent/agent/__test__/tool-call-merge.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { ToolCall } from '../../../providers';
+import { mergeToolCalls } from '../tool-call-merge';
+
+describe('tool-call-merge', () => {
+  it('merges fragmented tool call arguments and keeps stable ordering', async () => {
+    const existing: ToolCall[] = [
+      {
+        id: 'a',
+        type: 'function',
+        index: 0,
+        function: { name: '', arguments: '{"x":' },
+      },
+    ];
+    const incoming: ToolCall[] = [
+      {
+        id: 'a',
+        type: 'function',
+        index: 0,
+        function: { name: 'bash', arguments: '1}' },
+      },
+      {
+        id: 'b',
+        type: 'function',
+        index: 1,
+        function: { name: 'write_file', arguments: '{}' },
+      },
+    ];
+
+    const onArgumentsChunk = vi.fn(async () => undefined);
+    const merged = await mergeToolCalls({
+      existing,
+      incoming,
+      messageId: 'm1',
+      onArgumentsChunk,
+    });
+
+    expect(merged).toHaveLength(2);
+    expect(merged[0]).toMatchObject({
+      id: 'a',
+      function: { name: 'bash', arguments: '{"x":1}' },
+    });
+    expect(merged[1]).toMatchObject({ id: 'b' });
+    expect(onArgumentsChunk).toHaveBeenCalledTimes(2);
+  });
+
+  it('merges follow-up fragments by index when id/name are omitted', async () => {
+    const existing: ToolCall[] = [
+      {
+        id: 'call_1',
+        type: 'function',
+        index: 0,
+        function: { name: 'bash', arguments: '{' },
+      },
+    ];
+    const incoming = [
+      {
+        function: { arguments: '"command":"ls -la"}' },
+        index: 0,
+      },
+    ] as unknown as ToolCall[];
+
+    const onArgumentsChunk = vi.fn(async () => undefined);
+    const merged = await mergeToolCalls({
+      existing,
+      incoming,
+      messageId: 'm2',
+      onArgumentsChunk,
+    });
+
+    expect(merged).toHaveLength(1);
+    expect(merged[0]).toMatchObject({
+      id: 'call_1',
+      type: 'function',
+      index: 0,
+      function: { name: 'bash', arguments: '{"command":"ls -la"}' },
+    });
+    expect(onArgumentsChunk).toHaveBeenCalledTimes(1);
+  });
+});

package/vendor/agent-root/src/agent/agent/__test__/tool-execution-ledger.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import {
+  InMemoryToolExecutionLedger,
+  NoopToolExecutionLedger,
+  executeToolCallWithLedger,
+  type ToolExecutionLedgerRecord,
+} from '../tool-execution-ledger';
+
+function makeRecord(output: string): ToolExecutionLedgerRecord {
+  return {
+    success: true,
+    output,
+    summary: output || 'no output',
+    recordedAt: Date.now(),
+  };
+}
+
+describe('tool-execution-ledger', () => {
+  it('InMemoryToolExecutionLedger executeOnce deduplicates concurrent execution', async () => {
+    const ledger = new InMemoryToolExecutionLedger();
+    let executionCount = 0;
+
+    const run = () =>
+      ledger.executeOnce('exec_1', 'tool_1', async () => {
+        executionCount += 1;
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        return makeRecord('ok');
+      });
+
+    const [resultA, resultB] = await Promise.all([run(), run()]);
+    expect(resultA.record.output).toBe('ok');
+    expect(resultB.record.output).toBe('ok');
+    expect(executionCount).toBe(1);
+  });
+
+  it('NoopToolExecutionLedger executeOnce never caches', async () => {
+    const ledger = new NoopToolExecutionLedger();
+    let executionCount = 0;
+
+    const run = async () =>
+      ledger.executeOnce('exec_2', 'tool_2', async () => {
+        executionCount += 1;
+        return makeRecord(`ok_${executionCount}`);
+      });
+
+    const first = await run();
+    const second = await run();
+    expect(first.fromCache).toBe(false);
+    expect(second.fromCache).toBe(false);
+    expect(first.record.output).toBe('ok_1');
+    expect(second.record.output).toBe('ok_2');
+  });
+
+  it('executeToolCallWithLedger bypasses cache when executionId is empty', async () => {
+    const ledger = new InMemoryToolExecutionLedger();
+    let executionCount = 0;
+
+    const run = async () =>
+      executeToolCallWithLedger({
+        ledger,
+        executionId: '',
+        toolCallId: 'tool_3',
+        execute: async () => {
+          executionCount += 1;
+          return makeRecord(`result_${executionCount}`);
+        },
+      });
+
+    const first = await run();
+    const second = await run();
+    expect(first.fromCache).toBe(false);
+    expect(second.fromCache).toBe(false);
+    expect(first.record.output).toBe('result_1');
+    expect(second.record.output).toBe('result_2');
+  });
+});