@charming_groot/agent 0.1.0

package/tests/sub-agent-tool.test.ts

@@ -0,0 +1,198 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SubAgentTool } from '../src/sub-agent-tool.js';
+import type { ILlmProvider, ITool, LlmResponse, AgentConfig } from '@charming_groot/core';
+import { Registry, RunContext } from '@charming_groot/core';
+
+const TEST_CONFIG: AgentConfig = {
+  provider: { providerId: 'test', model: 'test', auth: { type: 'api-key' as const, apiKey: 'test' }, maxTokens: 4096, temperature: 0.7 },
+  maxIterations: 10,
+  workingDirectory: '/tmp',
+};
+
+function createMockProvider(content: string): ILlmProvider {
+  const response: LlmResponse = {
+    content,
+    stopReason: 'end_turn',
+    toolCalls: [],
+    usage: { inputTokens: 10, outputTokens: 5 },
+  };
+  return {
+    providerId: 'mock',
+    chat: vi.fn().mockResolvedValue(response),
+    stream: vi.fn() as unknown as ILlmProvider['stream'],
+  };
+}
+
+describe('SubAgentTool', () => {
+  it('should describe itself with a task parameter', () => {
+    const tool = new SubAgentTool({
+      name: 'researcher',
+      description: 'Research a topic',
+      provider: createMockProvider(''),
+      toolRegistry: new Registry<ITool>('Tool'),
+    });
+
+    const desc = tool.describe();
+    expect(desc.name).toBe('researcher');
+    expect(desc.parameters).toHaveLength(1);
+    expect(desc.parameters[0]?.name).toBe('task');
+    expect(desc.parameters[0]?.required).toBe(true);
+  });
+
+  it('should execute sub-agent and return result', async () => {
+    const provider = createMockProvider('Research complete: found 3 papers');
+    const tool = new SubAgentTool({
+      name: 'researcher',
+      description: 'Research a topic',
+      provider,
+      toolRegistry: new Registry<ITool>('Tool'),
+      systemPrompt: 'You are a researcher.',
+    });
+
+    const context = new RunContext(TEST_CONFIG);
+    const result = await tool.execute({ task: 'Find papers on transformers' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.output).toBe('Research complete: found 3 papers');
+    expect(provider.chat).toHaveBeenCalled();
+  });
+
+  it('should return error for missing task parameter', async () => {
+    const tool = new SubAgentTool({
+      name: 'researcher',
+      description: 'Research',
+      provider: createMockProvider(''),
+      toolRegistry: new Registry<ITool>('Tool'),
+    });
+
+    const context = new RunContext(TEST_CONFIG);
+    const result = await tool.execute({}, context);
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Missing or empty "task"');
+  });
+
+  it('should return error for empty task', async () => {
+    const tool = new SubAgentTool({
+      name: 'researcher',
+      description: 'Research',
+      provider: createMockProvider(''),
+      toolRegistry: new Registry<ITool>('Tool'),
+    });
+
+    const context = new RunContext(TEST_CONFIG);
+    const result = await tool.execute({ task: '  ' }, context);
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Missing or empty "task"');
+  });
+
+  it('should catch sub-agent errors gracefully', async () => {
+    const provider: ILlmProvider = {
+      providerId: 'mock',
+      chat: vi.fn().mockRejectedValue(new Error('API rate limit')),
+      stream: vi.fn() as unknown as ILlmProvider['stream'],
+    };
+
+    const tool = new SubAgentTool({
+      name: 'researcher',
+      description: 'Research',
+      provider,
+      toolRegistry: new Registry<ITool>('Tool'),
+    });
+
+    const context = new RunContext(TEST_CONFIG);
+    const result = await tool.execute({ task: 'do something' }, context);
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('API rate limit');
+  });
+
+  it('should propagate parent abort to child', async () => {
+    // Provider that takes a while — simulated by never resolving until abort
+    let chatCallCount = 0;
+    const provider: ILlmProvider = {
+      providerId: 'mock',
+      chat: vi.fn().mockImplementation(async () => {
+        chatCallCount++;
+        // First call returns tool_use to trigger iteration loop
+        if (chatCallCount === 1) {
+          return {
+            content: 'Working...',
+            stopReason: 'end_turn',
+            toolCalls: [],
+            usage: { inputTokens: 10, outputTokens: 5 },
+          };
+        }
+        return {
+          content: 'Done',
+          stopReason: 'end_turn',
+          toolCalls: [],
+          usage: { inputTokens: 10, outputTokens: 5 },
+        };
+      }),
+      stream: vi.fn() as unknown as ILlmProvider['stream'],
+    };
+
+    const tool = new SubAgentTool({
+      name: 'worker',
+      description: 'Do work',
+      provider,
+      toolRegistry: new Registry<ITool>('Tool'),
+    });
+
+    const context = new RunContext(TEST_CONFIG);
+    // Sub-agent completes before abort in this case — just verify no crash
+    const result = await tool.execute({ task: 'work' }, context);
+    expect(result.success).toBe(true);
+  });
+
+  it('should use parent workingDirectory', async () => {
+    const provider = createMockProvider('done');
+    const tool = new SubAgentTool({
+      name: 'worker',
+      description: 'Work',
+      provider,
+      toolRegistry: new Registry<ITool>('Tool'),
+    });
+
+    const config: AgentConfig = { ...TEST_CONFIG, workingDirectory: '/custom/dir' };
+    const context = new RunContext(config);
+    const result = await tool.execute({ task: 'check dir' }, context);
+    expect(result.success).toBe(true);
+  });
+
+  it('should respect custom maxIterations', async () => {
+    // Create a provider that always returns tool calls to exhaust iterations
+    const toolResponse: LlmResponse = {
+      content: 'calling tool',
+      stopReason: 'tool_use',
+      toolCalls: [{ id: 'tc-1', name: 'noop', arguments: '{}' }],
+      usage: { inputTokens: 10, outputTokens: 10 },
+    };
+    const provider: ILlmProvider = {
+      providerId: 'mock',
+      chat: vi.fn().mockResolvedValue(toolResponse),
+      stream: vi.fn() as unknown as ILlmProvider['stream'],
+    };
+
+    const toolRegistry = new Registry<ITool>('Tool');
+    const noopTool: ITool = {
+      name: 'noop',
+      requiresPermission: false,
+      describe: () => ({ name: 'noop', description: 'noop', parameters: [] }),
+      execute: vi.fn().mockResolvedValue({ success: true, output: 'ok' }),
+    };
+    toolRegistry.register('noop', noopTool);
+
+    const tool = new SubAgentTool({
+      name: 'worker',
+      description: 'Work',
+      provider,
+      toolRegistry,
+      maxIterations: 3,
+    });
+
+    const context = new RunContext(TEST_CONFIG);
+    const result = await tool.execute({ task: 'loop' }, context);
+    // Should stop after 3 iterations (maxIterations)
+    expect(provider.chat).toHaveBeenCalledTimes(3);
+  });
+});

package/tests/token-counter.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import {
+  countTextTokens,
+  countMessageTokens,
+  countHistoryTokens,
+} from '../src/token-counter.js';
+import type { Message } from '@charming_groot/core';
+
+describe('countTextTokens', () => {
+  it('빈 문자열은 0을 반환한다', () => {
+    expect(countTextTokens('')).toBe(0);
+  });
+
+  it('짧은 텍스트에서 양수를 반환한다', () => {
+    expect(countTextTokens('hello world')).toBeGreaterThan(0);
+  });
+
+  it('긴 텍스트일수록 토큰 수가 많다', () => {
+    const short = countTextTokens('hello');
+    const long  = countTextTokens('hello world this is a longer sentence with many more tokens in it');
+    expect(long).toBeGreaterThan(short);
+  });
+
+  it('동일한 입력에 대해 일관된 결과를 반환한다', () => {
+    const text = 'consistent token count test';
+    expect(countTextTokens(text)).toBe(countTextTokens(text));
+  });
+});
+
+describe('countMessageTokens', () => {
+  it('content가 있는 user 메시지를 카운트한다', () => {
+    const msg: Message = { role: 'user', content: 'hello there' };
+    expect(countMessageTokens(msg)).toBeGreaterThan(0);
+  });
+
+  it('tool call이 있는 assistant 메시지는 더 많은 토큰을 가진다', () => {
+    const withoutTools: Message = {
+      role: 'assistant',
+      content: 'I will call a tool',
+    };
+    const withTools: Message = {
+      role: 'assistant',
+      content: 'I will call a tool',
+      toolCalls: [{ id: 'tc1', name: 'get_schema', arguments: '{}' }],
+    };
+    expect(countMessageTokens(withTools)).toBeGreaterThan(countMessageTokens(withoutTools));
+  });
+
+  it('tool result가 있는 메시지를 카운트한다', () => {
+    const msg: Message = {
+      role: 'user',
+      content: '',
+      toolResults: [{ toolCallId: 'tc1', content: '{"table": "users"}' }],
+    };
+    expect(countMessageTokens(msg)).toBeGreaterThan(0);
+  });
+
+  it('overhead(4)가 항상 포함된다', () => {
+    const empty: Message = { role: 'user', content: '' };
+    expect(countMessageTokens(empty)).toBeGreaterThanOrEqual(4);
+  });
+});
+
+describe('countHistoryTokens', () => {
+  it('빈 배열은 reply overhead(3)만 반환한다', () => {
+    expect(countHistoryTokens([])).toBe(3);
+  });
+
+  it('메시지가 많을수록 토큰 수가 많다', () => {
+    const msgs: Message[] = [
+      { role: 'user',      content: 'first message with some content' },
+      { role: 'assistant', content: 'response to the first message' },
+      { role: 'user',      content: 'second message with more content' },
+    ];
+    expect(countHistoryTokens(msgs)).toBeGreaterThan(countHistoryTokens([msgs[0]]));
+  });
+});

package/tests/tool-dispatcher.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ToolDispatcher } from '../src/tool-dispatcher.js';
+import { PermissionManager } from '../src/permission.js';
+import type { ITool, ToolCall, AgentConfig } from '@charming_groot/core';
+import { Registry, RunContext, PermissionDeniedError } from '@charming_groot/core';
+
+const TEST_CONFIG: AgentConfig = {
+  provider: { providerId: 'test', model: 'test', auth: { type: 'api-key' as const, apiKey: 'test' }, maxTokens: 4096, temperature: 0.7 },
+  maxIterations: 50,
+  workingDirectory: '/tmp',
+};
+
+function createMockTool(name: string, requiresPermission = false): ITool {
+  return {
+    name,
+    requiresPermission,
+    describe: () => ({ name, description: 'Mock tool', parameters: [] }),
+    execute: vi.fn().mockResolvedValue({ success: true, output: `${name} result` }),
+  };
+}
+
+describe('ToolDispatcher', () => {
+  let toolRegistry: Registry<ITool>;
+  let permissionManager: PermissionManager;
+  let dispatcher: ToolDispatcher;
+  let context: RunContext;
+
+  beforeEach(() => {
+    toolRegistry = new Registry<ITool>('Tool');
+    permissionManager = new PermissionManager();
+    dispatcher = new ToolDispatcher(toolRegistry, permissionManager);
+    context = new RunContext(TEST_CONFIG);
+  });
+
+  it('should dispatch a tool call', async () => {
+    const tool = createMockTool('file_read');
+    toolRegistry.register('file_read', tool);
+
+    const toolCall: ToolCall = {
+      id: 'tc-1',
+      name: 'file_read',
+      arguments: '{"path":"test.txt"}',
+    };
+
+    const result = await dispatcher.dispatch(toolCall, context);
+    expect(result.success).toBe(true);
+    expect(result.output).toBe('file_read result');
+    expect(tool.execute).toHaveBeenCalled();
+  });
+
+  it('should return error for unknown tool', async () => {
+    const toolCall: ToolCall = {
+      id: 'tc-1',
+      name: 'unknown_tool',
+      arguments: '{}',
+    };
+
+    const result = await dispatcher.dispatch(toolCall, context);
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Unknown tool');
+  });
+
+  it('should return error for invalid JSON arguments', async () => {
+    const tool = createMockTool('file_read');
+    toolRegistry.register('file_read', tool);
+
+    const toolCall: ToolCall = {
+      id: 'tc-1',
+      name: 'file_read',
+      arguments: 'not json',
+    };
+
+    const result = await dispatcher.dispatch(toolCall, context);
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Invalid tool arguments');
+  });
+
+  it('should throw PermissionDeniedError when denied', async () => {
+    const handler = vi.fn().mockResolvedValue(false);
+    const pm = new PermissionManager(handler);
+    const d = new ToolDispatcher(toolRegistry, pm);
+
+    const tool = createMockTool('shell_exec', true);
+    toolRegistry.register('shell_exec', tool);
+
+    const toolCall: ToolCall = {
+      id: 'tc-1',
+      name: 'shell_exec',
+      arguments: '{"command":"ls"}',
+    };
+
+    await expect(d.dispatch(toolCall, context)).rejects.toThrow(PermissionDeniedError);
+    // Handler should receive parsed params
+    expect(handler).toHaveBeenCalledWith('shell_exec', { command: 'ls' });
+  });
+
+  it('should dispatch all tool calls', async () => {
+    toolRegistry.register('tool_a', createMockTool('tool_a'));
+    toolRegistry.register('tool_b', createMockTool('tool_b'));
+
+    const toolCalls: ToolCall[] = [
+      { id: 'tc-1', name: 'tool_a', arguments: '{}' },
+      { id: 'tc-2', name: 'tool_b', arguments: '{}' },
+    ];
+
+    const results = await dispatcher.dispatchAll(toolCalls, context);
+    expect(results.size).toBe(2);
+    expect(results.get('tc-1')?.success).toBe(true);
+    expect(results.get('tc-2')?.success).toBe(true);
+  });
+
+  it('should emit tool:start and tool:end events', async () => {
+    const tool = createMockTool('file_read');
+    toolRegistry.register('file_read', tool);
+
+    const startHandler = vi.fn();
+    const endHandler = vi.fn();
+    context.eventBus.on('tool:start', startHandler);
+    context.eventBus.on('tool:end', endHandler);
+
+    const toolCall: ToolCall = {
+      id: 'tc-1',
+      name: 'file_read',
+      arguments: '{}',
+    };
+
+    await dispatcher.dispatch(toolCall, context);
+    expect(startHandler).toHaveBeenCalledOnce();
+    expect(endHandler).toHaveBeenCalledOnce();
+  });
+
+  it('should truncate oversized tool output', async () => {
+    const bigOutput = 'x'.repeat(100_000);
+    const tool: ITool = {
+      name: 'big_tool',
+      requiresPermission: false,
+      describe: () => ({ name: 'big_tool', description: 'test', parameters: [] }),
+      execute: vi.fn().mockResolvedValue({ success: true, output: bigOutput }),
+    };
+    toolRegistry.register('big_tool', tool);
+
+    const toolCall: ToolCall = { id: 'tc-1', name: 'big_tool', arguments: '{}' };
+    const result = await dispatcher.dispatch(toolCall, context);
+
+    expect(result.success).toBe(true);
+    expect(result.output.length).toBeLessThan(bigOutput.length);
+    expect(result.output).toContain('output truncated');
+  });
+
+  it('should not truncate output within limit', async () => {
+    const normalOutput = 'x'.repeat(1000);
+    const tool: ITool = {
+      name: 'small_tool',
+      requiresPermission: false,
+      describe: () => ({ name: 'small_tool', description: 'test', parameters: [] }),
+      execute: vi.fn().mockResolvedValue({ success: true, output: normalOutput }),
+    };
+    toolRegistry.register('small_tool', tool);
+
+    const toolCall: ToolCall = { id: 'tc-1', name: 'small_tool', arguments: '{}' };
+    const result = await dispatcher.dispatch(toolCall, context);
+
+    expect(result.output).toBe(normalOutput);
+  });
+
+  it('should abort remaining tools when context is aborted', async () => {
+    toolRegistry.register('tool_a', createMockTool('tool_a'));
+    toolRegistry.register('tool_b', createMockTool('tool_b'));
+
+    context.abort();
+
+    const toolCalls: ToolCall[] = [
+      { id: 'tc-1', name: 'tool_a', arguments: '{}' },
+      { id: 'tc-2', name: 'tool_b', arguments: '{}' },
+    ];
+
+    const results = await dispatcher.dispatchAll(toolCalls, context);
+    expect(results.get('tc-1')?.error).toContain('aborted');
+    expect(results.get('tc-2')?.error).toContain('aborted');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'node:path';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@charming_groot/core': resolve(__dirname, '../core/src/index.ts'),
+      '@charming_groot/providers': resolve(__dirname, '../providers/src/index.ts'),
+      '@charming_groot/tools': resolve(__dirname, '../tools/src/index.ts'),
+    },
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+});