@renxqoo/renx-code 0.0.9 → 0.0.12

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

@@ -1,505 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { z } from 'zod';
-import { BaseTool, ToolResult } from '../base-tool';
-import { DefaultToolManager } from '../tool-manager';
-import {
-  EmptyToolNameError,
-  InvalidArgumentsError,
-  ToolDeniedError,
-  ToolExecutionError,
-  ToolNotFoundError,
-  ToolPolicyDeniedError,
-  ToolValidationError,
-} from '../error';
-import type { ToolExecutionContext } from '../types';
-
-const schema = z.object({
-  input: z.string().min(1),
-});
-
-class EchoTool extends BaseTool<typeof schema> {
-  name = 'echo';
-  description = 'echo input';
-  parameters = schema;
-
-  shouldConfirm(): boolean {
-    return false;
-  }
-
-  async execute(
-    args: z.infer<typeof schema>,
-    _context?: ToolExecutionContext
-  ): Promise<ToolResult> {
-    return {
-      success: true,
-      output: args.input,
-    };
-  }
-}
-
-class ConfirmEchoTool extends EchoTool {
-  override name = 'confirm-echo';
-
-  override shouldConfirm(): boolean {
-    return true;
-  }
-}
-
-class ThrowingTool extends EchoTool {
-  override async execute(): Promise<ToolResult> {
-    throw new Error('run failed');
-  }
-}
-
-class ParallelReadTool extends EchoTool {
-  override name = 'parallel-echo';
-
-  override getConcurrencyMode(): 'parallel-safe' {
-    return 'parallel-safe';
-  }
-
-  override getConcurrencyLockKey(args: z.infer<typeof schema>): string | undefined {
-    return `resource:${args.input}`;
-  }
-}
-
-class ParallelNoLockTool extends EchoTool {
-  override name = 'parallel-no-lock';
-
-  override getConcurrencyMode(): 'parallel-safe' {
-    return 'parallel-safe';
-  }
-}
-
-const bashSchema = z.object({
-  command: z.string().min(1),
-});
-
-class SafeBashTool extends BaseTool<typeof bashSchema> {
-  name = 'bash';
-  description = 'bash command';
-  parameters = bashSchema;
-
-  async execute(
-    args: z.infer<typeof bashSchema>,
-    _context?: ToolExecutionContext
-  ): Promise<ToolResult> {
-    return {
-      success: true,
-      output: args.command,
-    };
-  }
-}
-
-function createContext(partial?: Partial<ToolExecutionContext>): ToolExecutionContext {
-  return {
-    toolCallId: 'call_1',
-    loopIndex: 1,
-    agent: {},
-    ...partial,
-  };
-}
-
-describe('DefaultToolManager', () => {
-  const originalConfirmationMode = process.env.AGENT_TOOL_CONFIRMATION_MODE;
-
-  afterEach(() => {
-    if (originalConfirmationMode === undefined) {
-      delete process.env.AGENT_TOOL_CONFIRMATION_MODE;
-      return;
-    }
-    process.env.AGENT_TOOL_CONFIRMATION_MODE = originalConfirmationMode;
-  });
-
-  it('returns EmptyToolNameError when tool name is empty', async () => {
-    const manager = new DefaultToolManager();
-
-    const result = await manager.execute(
-      {
-        id: 't1',
-        type: 'function',
-        index: 0,
-        function: { name: '', arguments: '{}' },
-      },
-      createContext()
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(EmptyToolNameError);
-    expect(result.output).toBe('Tool name is empty');
-  });
-
-  it('returns InvalidArgumentsError when arguments are invalid json', async () => {
-    const manager = new DefaultToolManager();
-
-    const result = await manager.execute(
-      {
-        id: 't2',
-        type: 'function',
-        index: 0,
-        function: { name: 'echo', arguments: '{bad' },
-      },
-      createContext()
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(InvalidArgumentsError);
-    expect(result.output).toContain('Invalid arguments format for tool echo');
-  });
-
-  it('returns ToolNotFoundError for missing handler', async () => {
-    const manager = new DefaultToolManager();
-
-    const result = await manager.execute(
-      {
-        id: 't3',
-        type: 'function',
-        index: 0,
-        function: { name: 'missing', arguments: '{}' },
-      },
-      createContext()
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(ToolNotFoundError);
-    expect(result.output).toBe('Tool missing not found');
-  });
-
-  it('returns ToolValidationError for invalid parameters', async () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new EchoTool());
-
-    const result = await manager.execute(
-      {
-        id: 't4',
-        type: 'function',
-        index: 0,
-        function: { name: 'echo', arguments: '{}' },
-      },
-      createContext()
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(ToolValidationError);
-    expect(result.output).toContain('expected string');
-  });
-
-  it('returns ToolPolicyDeniedError when policy check rejects execution', async () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new EchoTool());
-
-    const onPolicyCheck = vi.fn().mockResolvedValue({
-      allowed: false,
-      code: 'PATH_NOT_ALLOWED',
-      message: 'outside workspace',
-    });
-    const result = await manager.execute(
-      {
-        id: 't4_policy',
-        type: 'function',
-        index: 0,
-        function: { name: 'echo', arguments: '{"input":"abc"}' },
-      },
-      createContext({ onPolicyCheck })
-    );
-
-    expect(onPolicyCheck).toHaveBeenCalledOnce();
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(ToolPolicyDeniedError);
-    expect(result.output).toContain('[PATH_NOT_ALLOWED]');
-  });
-
-  it('blocks dangerous bash command with built-in policy and includes audit details', async () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new SafeBashTool());
-
-    const result = await manager.execute(
-      {
-        id: 't4_builtin_policy',
-        type: 'function',
-        index: 0,
-        function: { name: 'bash', arguments: '{"command":"rm -rf /"}' },
-      },
-      createContext()
-    );
-
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(ToolPolicyDeniedError);
-    expect(result.output).toContain('[DANGEROUS_COMMAND]');
-    expect((result.error as ToolPolicyDeniedError).details).toMatchObject({
-      toolName: 'bash',
-      reasonCode: 'DANGEROUS_COMMAND',
-      audit: {
-        toolCallId: 't4_builtin_policy',
-        toolName: 'bash',
-        source: 'builtin',
-      },
-    });
-  });
-
-  it('executes when policy check allows and receives parsed arguments', async () => {
-    const manager = new DefaultToolManager();
-    const tool = new EchoTool();
-    const executeSpy = vi.spyOn(tool, 'execute');
-    manager.registerTool(tool);
-
-    const onPolicyCheck = vi.fn().mockResolvedValue({
-      allowed: true,
-    });
-    const result = await manager.execute(
-      {
-        id: 't4_policy_allow',
-        type: 'function',
-        index: 0,
-        function: { name: 'echo', arguments: '{"input":"abc"}' },
-      },
-      createContext({ onPolicyCheck })
-    );
-
-    expect(onPolicyCheck).toHaveBeenCalledWith({
-      toolCallId: 't4_policy_allow',
-      toolName: 'echo',
-      arguments: '{"input":"abc"}',
-      parsedArguments: { input: 'abc' },
-    });
-    expect(executeSpy).toHaveBeenCalledOnce();
-    expect(result.success).toBe(true);
-    expect(result.output).toBe('abc');
-  });
-
-  it('returns ToolDeniedError when user rejects confirmation', async () => {
-    const manager = new DefaultToolManager({ confirmationMode: 'manual' });
-    manager.registerTool(new ConfirmEchoTool());
-
-    const onConfirm = vi.fn().mockResolvedValue({ approved: false, message: 'deny' });
-    const result = await manager.execute(
-      {
-        id: 't5',
-        type: 'function',
-        index: 0,
-        function: { name: 'confirm-echo', arguments: '{"input":"abc"}' },
-      },
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).toHaveBeenCalledOnce();
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(ToolDeniedError);
-    expect(result.output).toBe('Tool confirm-echo denied: deny');
-  });
-
-  it('executes after confirmation approval', async () => {
-    const manager = new DefaultToolManager({ confirmationMode: 'manual' });
-    const tool = new ConfirmEchoTool();
-    const execSpy = vi.spyOn(tool, 'execute');
-    manager.registerTool(tool);
-
-    const onConfirm = vi.fn().mockResolvedValue({ approved: true });
-    const result = await manager.execute(
-      {
-        id: 't6',
-        type: 'function',
-        index: 0,
-        function: { name: 'confirm-echo', arguments: '{"input":"abc"}' },
-      },
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).toHaveBeenCalledOnce();
-    expect(execSpy).toHaveBeenCalledOnce();
-    expect(result.success).toBe(true);
-    expect(result.output).toBe('abc');
-  });
-
-  it('executes directly when confirm callback is not provided', async () => {
-    const manager = new DefaultToolManager();
-    const tool = new ConfirmEchoTool();
-    const execSpy = vi.spyOn(tool, 'execute');
-    manager.registerTool(tool);
-
-    const result = await manager.execute(
-      {
-        id: 't7',
-        type: 'function',
-        index: 0,
-        function: { name: 'confirm-echo', arguments: '{"input":"no-confirm"}' },
-      },
-      createContext()
-    );
-
-    expect(execSpy).toHaveBeenCalledOnce();
-    expect(result.success).toBe(true);
-    expect(result.output).toBe('no-confirm');
-  });
-
-  it('auto-approves confirmations from env without invoking callback', async () => {
-    process.env.AGENT_TOOL_CONFIRMATION_MODE = 'auto-approve';
-    const manager = new DefaultToolManager();
-    const tool = new ConfirmEchoTool();
-    const execSpy = vi.spyOn(tool, 'execute');
-    manager.registerTool(tool);
-
-    const onConfirm = vi.fn();
-    const result = await manager.execute(
-      {
-        id: 't7_auto_approve',
-        type: 'function',
-        index: 0,
-        function: { name: 'confirm-echo', arguments: '{"input":"approved-by-env"}' },
-      },
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).not.toHaveBeenCalled();
-    expect(execSpy).toHaveBeenCalledOnce();
-    expect(execSpy.mock.calls[0]?.[1]?.confirmationApproved).toBe(true);
-    expect(result.success).toBe(true);
-    expect(result.output).toBe('approved-by-env');
-  });
-
-  it('auto-denies confirmations from env before invoking callback', async () => {
-    process.env.AGENT_TOOL_CONFIRMATION_MODE = 'auto-deny';
-    const manager = new DefaultToolManager();
-    manager.registerTool(new ConfirmEchoTool());
-
-    const onConfirm = vi.fn();
-    const result = await manager.execute(
-      {
-        id: 't7_auto_deny',
-        type: 'function',
-        index: 0,
-        function: { name: 'confirm-echo', arguments: '{"input":"denied-by-env"}' },
-      },
-      createContext({ onConfirm })
-    );
-
-    expect(onConfirm).not.toHaveBeenCalled();
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(ToolDeniedError);
-    expect(result.output).toBe(
-      'Tool confirm-echo denied: Denied by AGENT_TOOL_CONFIRMATION_MODE=auto-deny'
-    );
-  });
-
-  it('throws for invalid confirmation mode env values', () => {
-    process.env.AGENT_TOOL_CONFIRMATION_MODE = 'sometimes';
-
-    expect(() => new DefaultToolManager()).toThrow(
-      'Invalid AGENT_TOOL_CONFIRMATION_MODE: "sometimes" (expected "manual", "auto-approve", or "auto-deny")'
-    );
-  });
-
-  it('wraps handler execution error with ToolExecutionError and emits stderr chunk', async () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new ThrowingTool());
-
-    const onChunk = vi.fn();
-    const result = await manager.execute(
-      {
-        id: 't8',
-        type: 'function',
-        index: 0,
-        function: { name: 'echo', arguments: '{"input":"x"}' },
-      },
-      createContext({ onChunk })
-    );
-
-    expect(onChunk).toHaveBeenCalledWith({ type: 'stderr', data: 'run failed' });
-    expect(result.success).toBe(false);
-    expect(result.error).toBeInstanceOf(ToolExecutionError);
-    expect(result.output).toBe('run failed');
-  });
-
-  it('registerTool and getTools returns all tools', () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new EchoTool());
-    manager.registerTool(new ConfirmEchoTool());
-
-    const tools = manager.getTools();
-    expect(tools).toHaveLength(2);
-    expect(tools.map((t) => t.name)).toEqual(['echo', 'confirm-echo']);
-  });
-
-  it('toToolsSchema maps registered handlers to LLM tool schemas', () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new EchoTool());
-
-    const schemas = manager.toToolsSchema();
-    expect(schemas).toHaveLength(1);
-    expect(schemas[0]).toMatchObject({
-      type: 'function',
-      function: { name: 'echo' },
-    });
-  });
-
-  it('getConcurrencyPolicy returns exclusive for unknown tool', () => {
-    const manager = new DefaultToolManager();
-    const policy = manager.getConcurrencyPolicy({
-      id: 'c1',
-      type: 'function',
-      index: 0,
-      function: { name: 'missing', arguments: '{}' },
-    });
-
-    expect(policy).toEqual({ mode: 'exclusive' });
-  });
-
-  it('getConcurrencyPolicy reads mode and lockKey from tool handler', () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new ParallelReadTool());
-
-    const policy = manager.getConcurrencyPolicy({
-      id: 'c2',
-      type: 'function',
-      index: 0,
-      function: { name: 'parallel-echo', arguments: '{"input":"abc"}' },
-    });
-
-    expect(policy).toEqual({
-      mode: 'parallel-safe',
-      lockKey: 'resource:abc',
-    });
-  });
-
-  it('getConcurrencyPolicy returns mode-only when handler has no lock key', () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new ParallelNoLockTool());
-
-    const policy = manager.getConcurrencyPolicy({
-      id: 'c5',
-      type: 'function',
-      index: 0,
-      function: { name: 'parallel-no-lock', arguments: '{"input":"abc"}' },
-    });
-
-    expect(policy).toEqual({ mode: 'parallel-safe' });
-  });
-
-  it('getConcurrencyPolicy falls back to exclusive for invalid json args', () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new ParallelReadTool());
-
-    const policy = manager.getConcurrencyPolicy({
-      id: 'c3',
-      type: 'function',
-      index: 0,
-      function: { name: 'parallel-echo', arguments: '{bad' },
-    });
-
-    expect(policy).toEqual({ mode: 'exclusive' });
-  });
-
-  it('getConcurrencyPolicy falls back to exclusive for validation failure', () => {
-    const manager = new DefaultToolManager();
-    manager.registerTool(new ParallelReadTool());
-
-    const policy = manager.getConcurrencyPolicy({
-      id: 'c4',
-      type: 'function',
-      index: 0,
-      function: { name: 'parallel-echo', arguments: '{}' },
-    });
-
-    expect(policy).toEqual({ mode: 'exclusive' });
-  });
-});

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

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AGENT_TOOL_TYPES_MODULE } from '../types';
-import type {
-  Tool,
-  ToolCall,
-  ToolConfirmInfo,
-  ToolDecision,
-  ToolExecutionContext,
-  ToolPolicyDecision,
-  ToolStreamEventInput,
-} from '../types';
-
-describe('tool/types runtime contract', () => {
-  it('accepts representative typed objects', () => {
-    const tool: Tool = {
-      name: 'bash',
-      description: 'run shell command',
-      parameters: { type: 'object' },
-    };
-
-    const call: ToolCall = {
-      id: 'call_1',
-      type: 'function',
-      index: 0,
-      function: {
-        name: 'bash',
-        arguments: '{"command":"echo ok"}',
-      },
-    };
-
-    const info: ToolConfirmInfo = {
-      toolCallId: call.id,
-      toolName: tool.name,
-      arguments: call.function.arguments,
-    };
-
-    const decision: ToolDecision = { approved: true };
-    const policyDecision: ToolPolicyDecision = { allowed: true };
-    const chunk: ToolStreamEventInput = { type: 'stdout', content: 'ok' };
-    const context: ToolExecutionContext = {
-      toolCallId: call.id,
-      loopIndex: 1,
-      agent: {},
-      onChunk: () => undefined,
-      onConfirm: async () => decision,
-      onPolicyCheck: async () => policyDecision,
-    };
-
-    expect(tool.name).toBe('bash');
-    expect(info.toolName).toBe('bash');
-    expect(chunk.type).toBe('stdout');
-    expect(context.loopIndex).toBe(1);
-    expect(AGENT_TOOL_TYPES_MODULE).toBe('renx-tool-types');
-  });
-});