@zhin.js/core 1.0.36 → 1.0.38

package/tests/ai/subagent.test.ts

@@ -1,270 +0,0 @@
-/**
- * SubagentManager 测试
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { SubagentManager } from '../../src/ai/subagent.js';
-import type { SubagentOrigin, SpawnOptions } from '../../src/ai/subagent.js';
-import type { AgentTool, ChatResponse } from '../../src/ai/types.js';
-
-// Mock Logger
-vi.mock('@zhin.js/logger', () => ({
-  Logger: class {
-    debug = vi.fn();
-    info = vi.fn();
-    warn = vi.fn();
-    error = vi.fn();
-  },
-}));
-
-const baseOrigin: SubagentOrigin = {
-  platform: 'test',
-  botId: 'bot1',
-  sceneId: 'scene1',
-  senderId: 'user1',
-  sceneType: 'private',
-};
-
-function createMockProvider(response: string = '任务完成') {
-  return {
-    name: 'mock',
-    models: ['mock-model'],
-    chat: vi.fn(async () => ({
-      choices: [{ message: { role: 'assistant', content: response }, finish_reason: 'stop' }],
-      usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 },
-    } as ChatResponse)),
-    listModels: vi.fn(async () => ['mock-model']),
-  };
-}
-
-function createMockTools(): AgentTool[] {
-  return [
-    {
-      name: 'read_file',
-      description: '读取文件',
-      parameters: { type: 'object', properties: { file_path: { type: 'string' } } },
-      execute: vi.fn(async () => 'file content'),
-    },
-    {
-      name: 'write_file',
-      description: '写入文件',
-      parameters: { type: 'object', properties: { file_path: { type: 'string' } } },
-      execute: vi.fn(async () => 'ok'),
-    },
-    {
-      name: 'web_search',
-      description: '搜索',
-      parameters: { type: 'object', properties: { query: { type: 'string' } } },
-      execute: vi.fn(async () => 'search result'),
-    },
-    // 不应进入子 agent 的工具
-    {
-      name: 'spawn_task',
-      description: '派生子任务',
-      parameters: { type: 'object', properties: { task: { type: 'string' } } },
-      execute: vi.fn(async () => 'should not be called'),
-    },
-    {
-      name: 'activate_skill',
-      description: '激活技能',
-      parameters: { type: 'object', properties: { name: { type: 'string' } } },
-      execute: vi.fn(async () => 'should not be called'),
-    },
-    {
-      name: 'todo_write',
-      description: '写计划',
-      parameters: { type: 'object', properties: {} },
-      execute: vi.fn(async () => 'should not be called'),
-    },
-  ];
-}
-
-describe('SubagentManager', () => {
-  let manager: SubagentManager;
-  let provider: ReturnType<typeof createMockProvider>;
-  let mockTools: AgentTool[];
-
-  beforeEach(() => {
-    provider = createMockProvider();
-    mockTools = createMockTools();
-    manager = new SubagentManager({
-      provider: provider as any,
-      workspace: '/tmp/test-workspace',
-      createTools: () => mockTools,
-      maxIterations: 5,
-    });
-  });
-
-  afterEach(() => {
-    manager.dispose();
-  });
-
-  describe('spawn', () => {
-    it('应返回确认文本并包含任务标签', async () => {
-      const result = await manager.spawn({
-        task: '分析项目结构',
-        label: '结构分析',
-        origin: baseOrigin,
-      });
-
-      expect(result).toContain('结构分析');
-      expect(result).toContain('已启动');
-    });
-
-    it('无 label 时应自动截取 task 前30字符', async () => {
-      const result = await manager.spawn({
-        task: '这是一个非常长的任务描述用于测试自动截取功能',
-        origin: baseOrigin,
-      });
-
-      expect(result).toContain('已启动');
-      expect(result).toContain('这是一个非常长的任务描述用于测试自动截取功能');
-    });
-
-    it('应递增 runningTasks 计数', async () => {
-      // 让 provider 永不返回，模拟长时间运行
-      provider.chat.mockImplementation(() => new Promise(() => {}));
-
-      expect(manager.getRunningCount()).toBe(0);
-
-      await manager.spawn({ task: '任务1', origin: baseOrigin });
-
-      // 异步启动后应有 1 个运行中的任务
-      expect(manager.getRunningCount()).toBe(1);
-    });
-  });
-
-  describe('工具过滤', () => {
-    it('子 agent 应只获得白名单内的工具', async () => {
-      const sender = vi.fn();
-      manager.setSender(sender);
-
-      await manager.spawn({ task: '测试', origin: baseOrigin });
-
-      // 等待子 agent 完成
-      await vi.waitFor(() => expect(sender).toHaveBeenCalled(), { timeout: 2000 });
-
-      // 验证 provider.chat 被调用时传入的工具列表
-      const chatCall = provider.chat.mock.calls[0][0] ?? provider.chat.mock.calls[0];
-      // createAgent 调用 provider.chat({ model, messages, tools, ... })
-      // 查找 tools 参数
-      const callArgs = provider.chat.mock.calls[0];
-      // 接口是 chat(request) 形式
-      const request = callArgs[0] as any;
-      if (request?.tools) {
-        const toolNames = request.tools.map((t: any) => t.function?.name || t.name);
-        expect(toolNames).toContain('read_file');
-        expect(toolNames).toContain('write_file');
-        expect(toolNames).toContain('web_search');
-        expect(toolNames).not.toContain('spawn_task');
-        expect(toolNames).not.toContain('activate_skill');
-        expect(toolNames).not.toContain('todo_write');
-      }
-    });
-  });
-
-  describe('结果回告', () => {
-    it('完成后应通过 sender 发送结果', async () => {
-      const sender = vi.fn();
-      manager.setSender(sender);
-
-      await manager.spawn({ task: '读取 README', label: '读README', origin: baseOrigin });
-
-      // 等待异步子 agent 完成
-      await vi.waitFor(() => expect(sender).toHaveBeenCalled(), { timeout: 2000 });
-
-      expect(sender).toHaveBeenCalledTimes(1);
-      const [origin, content] = sender.mock.calls[0];
-      expect(origin).toEqual(baseOrigin);
-      expect(content).toContain('读README');
-      expect(content).toContain('已完成');
-    });
-
-    it('provider 错误时 Agent 内部兜底，结果仍应送达', async () => {
-      provider.chat.mockRejectedValue(new Error('API 调用失败'));
-      const sender = vi.fn();
-      manager.setSender(sender);
-
-      await manager.spawn({ task: '会失败的任务', label: '失败测试', origin: baseOrigin });
-
-      await vi.waitFor(() => expect(sender).toHaveBeenCalled(), { timeout: 2000 });
-
-      const [_origin, content] = sender.mock.calls[0];
-      // Agent.run() 内部兜底返回友好文本，SubagentManager 视为成功完成
-      expect(content).toContain('失败测试');
-      expect(content).toContain('API 调用失败');
-    });
-
-    it('无 sender 时不应崩溃', async () => {
-      // 不设置 sender
-      await manager.spawn({ task: '测试', origin: baseOrigin });
-
-      // 等待子 agent 完成（不应抛错）
-      await new Promise(r => setTimeout(r, 200));
-      expect(manager.getRunningCount()).toBe(0);
-    });
-  });
-
-  describe('完成后清理', () => {
-    it('完成后应从 runningTasks 移除', async () => {
-      const sender = vi.fn();
-      manager.setSender(sender);
-
-      await manager.spawn({ task: '快速任务', origin: baseOrigin });
-
-      // 等待完成
-      await vi.waitFor(() => expect(sender).toHaveBeenCalled(), { timeout: 2000 });
-
-      expect(manager.getRunningCount()).toBe(0);
-    });
-
-    it('失败后也应从 runningTasks 移除', async () => {
-      provider.chat.mockRejectedValue(new Error('boom'));
-      const sender = vi.fn();
-      manager.setSender(sender);
-
-      await manager.spawn({ task: '会失败', origin: baseOrigin });
-
-      await vi.waitFor(() => expect(sender).toHaveBeenCalled(), { timeout: 2000 });
-
-      expect(manager.getRunningCount()).toBe(0);
-    });
-  });
-
-  describe('dispose', () => {
-    it('应清空 runningTasks', () => {
-      manager.dispose();
-      expect(manager.getRunningCount()).toBe(0);
-    });
-  });
-});
-
-describe('ZhinAgent spawn_task 集成', () => {
-  it('spawn_task 工具应在关键词匹配时被注入', async () => {
-    // 这部分在 zhin-agent.test.ts 中已有 process 的集成测试框架
-    // 此处仅验证关键词正则匹配逻辑
-    const patterns = [
-      '帮我在后台分析一下代码',
-      '异步搜索一下文件',
-      '把这个交给子任务处理',
-      'spawn a background task',
-      '用background方式执行',
-      '并行处理这个任务',
-      '独立处理这个问题',
-    ];
-
-    const regex = /后台|子任务|spawn|异步|background|并行|独立处理/i;
-    for (const msg of patterns) {
-      expect(regex.test(msg), `"${msg}" 应匹配`).toBe(true);
-    }
-
-    const negativePatterns = [
-      '你好',
-      '帮我查天气',
-      '读取文件内容',
-      '提醒我喝水',
-    ];
-    for (const msg of negativePatterns) {
-      expect(regex.test(msg), `"${msg}" 不应匹配`).toBe(false);
-    }
-  });
-});

package/tests/ai/tone-detector.test.ts

@@ -1,80 +0,0 @@
-/**
- * ToneDetector 测试
- */
-import { describe, it, expect } from 'vitest';
-import { detectTone, type Tone } from '../../src/ai/tone-detector.js';
-
-describe('detectTone', () => {
-  it('空消息应返回 neutral', () => {
-    const result = detectTone('');
-    expect(result.tone).toBe('neutral');
-    expect(result.hint).toBe('');
-  });
-
-  it('普通消息应返回 neutral', () => {
-    const result = detectTone('你好，请帮我查一下天气');
-    expect(result.tone).toBe('neutral');
-  });
-
-  describe('frustrated（沮丧/受挫）', () => {
-    it('应检测负面关键词', () => {
-      expect(detectTone('这个bug怎么回事').tone).toBe('frustrated');
-      expect(detectTone('又错了，搞不定').tone).toBe('frustrated');
-      expect(detectTone('不行啊，还是不对').tone).toBe('frustrated');
-    });
-
-    it('应检测大量感叹号', () => {
-      expect(detectTone('到底怎么办!!!').tone).toBe('frustrated');
-    });
-
-    it('应检测大量大写字母', () => {
-      const result = detectTone('WHY IS THIS NOT WORKING');
-      expect(result.tone).toBe('frustrated');
-    });
-
-    it('hint 应包含共情建议', () => {
-      const result = detectTone('怎么回事啊');
-      expect(result.hint).toContain('耐心');
-    });
-  });
-
-  describe('urgent（紧急）', () => {
-    it('应检测紧急关键词', () => {
-      expect(detectTone('急！请马上帮我处理').tone).toBe('urgent');
-      expect(detectTone('赶紧看一下这个问题').tone).toBe('urgent');
-    });
-
-    it('hint 应建议直接给出方案', () => {
-      const result = detectTone('紧急情况，尽快');
-      expect(result.hint).toContain('效率');
-    });
-  });
-
-  describe('sad（悲伤/低落）', () => {
-    it('应检测悲伤关键词', () => {
-      expect(detectTone('好难过啊').tone).toBe('sad');
-      expect(detectTone('唉，不开心').tone).toBe('sad');
-    });
-
-    it('应检测省略号', () => {
-      expect(detectTone('算了吧......好吧...').tone).toBe('sad');
-    });
-  });
-
-  describe('excited（兴奋/开心）', () => {
-    it('应检测正面关键词', () => {
-      expect(detectTone('太好了！成功了！').tone).toBe('excited');
-      expect(detectTone('太棒了，完美！').tone).toBe('excited');
-    });
-  });
-
-  describe('questioning（提问）', () => {
-    it('应检测多个问号', () => {
-      expect(detectTone('这是什么？为什么？').tone).toBe('questioning');
-    });
-
-    it('短消息带问号应识别为提问', () => {
-      expect(detectTone('为什么？').tone).toBe('questioning');
-    });
-  });
-});

package/tests/ai/tools-builtin.test.ts

@@ -1,346 +0,0 @@
-/**
- * 内置工具测试
- * 
- * 测试内容：
- * 1. 计算器工具
- * 2. 时间工具
- * 3. 搜索工具
- * 4. 代码执行工具
- * 5. HTTP 请求工具
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { 
-  calculatorTool, 
-  timeTool,
-  searchTool,
-  codeRunnerTool,
-  httpTool,
-  getBuiltinTools,
-} from '../../src/ai/tools.js';
-import { ZhinTool } from '@zhin.js/core';
-
-describe('内置工具', () => {
-  describe('计算器工具', () => {
-    const calculator = calculatorTool.toTool();
-
-    it('应该有正确的元数据', () => {
-      expect(calculator.name).toBe('calculator');
-      expect(calculator.description).toContain('计算');
-      expect(calculator.parameters.properties).toHaveProperty('expression');
-      expect(calculator.parameters.required).toContain('expression');
-    });
-
-    it('应该计算简单加法', async () => {
-      const result = await calculator.execute({ expression: '2 + 3' });
-      expect(result.result).toBe(5);
-      expect(result.expression).toBe('2 + 3');
-    });
-
-    it('应该计算简单减法', async () => {
-      const result = await calculator.execute({ expression: '10 - 4' });
-      expect(result.result).toBe(6);
-    });
-
-    it('应该计算简单乘法', async () => {
-      const result = await calculator.execute({ expression: '6 * 7' });
-      expect(result.result).toBe(42);
-    });
-
-    it('应该计算简单除法', async () => {
-      const result = await calculator.execute({ expression: '20 / 4' });
-      expect(result.result).toBe(5);
-    });
-
-    it('应该计算复杂表达式', async () => {
-      const result = await calculator.execute({ expression: '(10 + 5) * 2' });
-      expect(result.result).toBe(30);
-    });
-
-    it('应该支持幂运算 (^)', async () => {
-      const result = await calculator.execute({ expression: '2 ^ 3' });
-      expect(result.result).toBe(8);
-    });
-
-    it('应该支持 sqrt 函数', async () => {
-      const result = await calculator.execute({ expression: 'sqrt(16)' });
-      expect(result.result).toBe(4);
-    });
-
-    it('应该支持 sin 函数', async () => {
-      const result = await calculator.execute({ expression: 'sin(0)' });
-      expect(result.result).toBe(0);
-    });
-
-    it('应该支持 cos 函数', async () => {
-      const result = await calculator.execute({ expression: 'cos(0)' });
-      expect(result.result).toBe(1);
-    });
-
-    it('应该支持 tan 函数', async () => {
-      const result = await calculator.execute({ expression: 'tan(0)' });
-      expect(result.result).toBe(0);
-    });
-
-    it('应该支持 log 函数', async () => {
-      const result = await calculator.execute({ expression: 'log(1)' });
-      expect(result.result).toBe(0);
-    });
-
-    it('应该支持 abs 函数', async () => {
-      const result = await calculator.execute({ expression: 'abs(-5)' });
-      expect(result.result).toBe(5);
-    });
-
-    it('应该支持 pow 函数（通过 ^ 运算符）', async () => {
-      // pow() 函数的逗号会被过滤，所以使用 ^ 运算符
-      const result = await calculator.execute({ expression: '2 ^ 10' });
-      expect(result.result).toBe(1024);
-    });
-
-    it('应该支持 PI 常量', async () => {
-      const result = await calculator.execute({ expression: 'PI' });
-      expect(result.result).toBeCloseTo(Math.PI);
-    });
-
-    it('应该支持 E 常量', async () => {
-      const result = await calculator.execute({ expression: 'E' });
-      expect(result.result).toBeCloseTo(Math.E);
-    });
-
-    it('应该处理无效表达式', async () => {
-      const result = await calculator.execute({ expression: 'invalid_expression' });
-      expect(result.error).toBeDefined();
-    });
-
-    it('应该处理除零', async () => {
-      const result = await calculator.execute({ expression: '1 / 0' });
-      expect(result.result).toBe(Infinity);
-    });
-
-    it('应该处理空表达式', async () => {
-      const result = await calculator.execute({ expression: '' });
-      // 空表达式会返回 undefined 或 error
-      expect(result.error || result.result === undefined).toBeTruthy();
-    });
-  });
-
-  describe('时间工具', () => {
-    const timeToolObj = timeTool.toTool();
-
-    it('应该有正确的元数据', () => {
-      expect(timeToolObj.name).toBe('get_time');
-      expect(timeToolObj.description).toContain('时间');
-      expect(timeToolObj.parameters.properties).toHaveProperty('timezone');
-      expect(timeToolObj.parameters.properties).toHaveProperty('format');
-    });
-
-    it('应该返回当前时间 (默认格式)', async () => {
-      const result = await timeToolObj.execute({});
-      
-      expect(result).toHaveProperty('timestamp');
-      expect(result).toHaveProperty('formatted');
-      expect(result).toHaveProperty('iso');
-      expect(typeof result.timestamp).toBe('number');
-      expect(typeof result.formatted).toBe('string');
-      expect(typeof result.iso).toBe('string');
-    });
-
-    it('应该支持 full 格式', async () => {
-      const result = await timeToolObj.execute({ format: 'full' });
-      
-      expect(result).toHaveProperty('formatted');
-      expect(result).toHaveProperty('timestamp');
-    });
-
-    it('应该支持 date 格式', async () => {
-      const result = await timeToolObj.execute({ format: 'date' });
-      
-      expect(result).toHaveProperty('formatted');
-      expect(result).toHaveProperty('timestamp');
-    });
-
-    it('应该支持 time 格式', async () => {
-      const result = await timeToolObj.execute({ format: 'time' });
-      
-      expect(result).toHaveProperty('formatted');
-      expect(result).toHaveProperty('timestamp');
-    });
-
-    it('应该支持 timestamp 格式', async () => {
-      const result = await timeToolObj.execute({ format: 'timestamp' });
-      
-      expect(result).toHaveProperty('timestamp');
-      expect(result).toHaveProperty('iso');
-      expect(result).not.toHaveProperty('formatted');
-    });
-
-    it('应该支持指定时区', async () => {
-      const result = await timeToolObj.execute({ timezone: 'UTC' });
-      
-      expect(result).toHaveProperty('formatted');
-      expect(result).toHaveProperty('timestamp');
-    });
-
-    it('时间戳应该是有效的数字', async () => {
-      const result = await timeToolObj.execute({});
-      const now = Date.now();
-      
-      // 时间戳应该在合理范围内（前后 1 秒）
-      expect(result.timestamp).toBeGreaterThan(now - 1000);
-      expect(result.timestamp).toBeLessThan(now + 1000);
-    });
-  });
-
-  describe('搜索工具', () => {
-    it('应该有正确的元数据', () => {
-      const searchToolObj = searchTool.toTool();
-      
-      expect(searchToolObj.name).toBe('web_search');
-      expect(searchToolObj.description).toContain('搜索');
-      expect(searchToolObj.parameters.properties).toHaveProperty('query');
-      expect(searchToolObj.parameters.required).toContain('query');
-    });
-
-    it('未配置搜索函数时应返回错误', async () => {
-      const searchToolObj = searchTool.toTool();
-      const result = await searchToolObj.execute({ query: 'test' });
-      
-      expect(result.error).toBeDefined();
-      expect(result.query).toBe('test');
-    });
-  });
-
-  describe('代码执行工具', () => {
-    const codeRunnerObj = codeRunnerTool.toTool();
-
-    it('应该有正确的元数据', () => {
-      expect(codeRunnerObj.name).toBe('run_code');
-      expect(codeRunnerObj.description).toContain('JavaScript');
-      expect(codeRunnerObj.parameters.properties).toHaveProperty('code');
-      expect(codeRunnerObj.parameters.required).toContain('code');
-    });
-
-    it('应该执行简单表达式', async () => {
-      const result = await codeRunnerObj.execute({ code: 'return 1 + 2' });
-      
-      expect(result.success).toBe(true);
-      expect(result.result).toBe('3');
-    });
-
-    it('应该执行字符串操作', async () => {
-      const result = await codeRunnerObj.execute({ code: 'return "hello".toUpperCase()' });
-      
-      expect(result.success).toBe(true);
-      expect(result.result).toBe('HELLO');
-    });
-
-    it('应该执行数组操作', async () => {
-      const result = await codeRunnerObj.execute({ code: 'return [1,2,3].map(x => x * 2)' });
-      
-      expect(result.success).toBe(true);
-      // 数组转字符串时会变成 "2,4,6"
-      expect(result.result).toContain('2,4,6');
-    });
-
-    it('应该处理 undefined 返回值', async () => {
-      const result = await codeRunnerObj.execute({ code: 'let x = 1' });
-      
-      expect(result.success).toBe(true);
-      expect(result.result).toBe('undefined');
-    });
-
-    it('应该处理语法错误', async () => {
-      const result = await codeRunnerObj.execute({ code: 'return {{{' });
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    it('应该处理运行时错误', async () => {
-      const result = await codeRunnerObj.execute({ code: 'throw new Error("test error")' });
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('test error');
-    });
-  });
-
-  describe('HTTP 请求工具', () => {
-    const httpToolObj = httpTool.toTool();
-
-    it('应该有正确的元数据', () => {
-      expect(httpToolObj.name).toBe('http_request');
-      expect(httpToolObj.description).toContain('HTTP');
-      expect(httpToolObj.parameters.properties).toHaveProperty('url');
-      expect(httpToolObj.parameters.properties).toHaveProperty('method');
-      expect(httpToolObj.parameters.required).toContain('url');
-    });
-
-    it('应该处理无效 URL', async () => {
-      const result = await httpToolObj.execute({ url: 'invalid-url' });
-      
-      expect(result.error).toBeDefined();
-    });
-
-    it('应该支持 method 参数', () => {
-      const methodProp = httpToolObj.parameters.properties?.method;
-      
-      expect(methodProp).toBeDefined();
-      expect(methodProp?.type).toBe('string');
-      // 描述中应该包含支持的方法
-      expect(methodProp?.description).toContain('GET');
-      expect(methodProp?.description).toContain('POST');
-      expect(methodProp?.description).toContain('PUT');
-      expect(methodProp?.description).toContain('DELETE');
-    });
-  });
-
-  describe('getBuiltinTools', () => {
-    it('应该返回内置工具列表', () => {
-      const tools = getBuiltinTools();
-      
-      expect(Array.isArray(tools)).toBe(true);
-      expect(tools.length).toBeGreaterThan(0);
-      
-      // tools 现在是 ZhinTool 实例
-      const names = tools.map(t => t.name);
-      expect(names).toContain('calculator');
-      expect(names).toContain('get_time');
-    });
-
-    it('所有工具应该是 ZhinTool 实例', () => {
-      const tools = getBuiltinTools();
-      
-      for (const tool of tools) {
-        expect(tool).toBeInstanceOf(ZhinTool);
-        expect(tool.name).toBeDefined();
-        expect(tool.description).toBeDefined();
-      }
-    });
-
-    it('工具名称应该唯一', () => {
-      const tools = getBuiltinTools();
-      const names = tools.map(t => t.name);
-      const uniqueNames = [...new Set(names)];
-      
-      expect(names.length).toBe(uniqueNames.length);
-    });
-
-    it('所有工具应该能转换为 Tool 对象', () => {
-      const tools = getBuiltinTools();
-      
-      for (const tool of tools) {
-        const toolObj = tool.toTool();
-        
-        expect(toolObj).toHaveProperty('name');
-        expect(toolObj).toHaveProperty('description');
-        expect(toolObj).toHaveProperty('parameters');
-        expect(toolObj).toHaveProperty('execute');
-        expect(typeof toolObj.name).toBe('string');
-        expect(typeof toolObj.description).toBe('string');
-        expect(typeof toolObj.execute).toBe('function');
-        expect(toolObj.parameters).toHaveProperty('type');
-        expect(toolObj.parameters.type).toBe('object');
-      }
-    });
-  });
-});