@renxqoo/renx-code 0.0.4 → 0.0.6

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

@@ -0,0 +1,505 @@
+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

@@ -0,0 +1,55 @@
+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');
+  });
+});