@zhin.js/core 1.0.25 → 1.0.26

package/tests/ai/output.test.ts

@@ -0,0 +1,128 @@
+/**
+ * AI Output 模块测试
+ */
+import { describe, it, expect } from 'vitest';
+import { parseOutput, renderToPlainText, renderToSatori } from '../../src/ai/output.js';
+
+describe('parseOutput', () => {
+  it('纯文本应返回单个 TextElement', () => {
+    const result = parseOutput('Hello, world!');
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({ type: 'text', content: 'Hello, world!', format: 'markdown' });
+  });
+
+  it('空字符串应返回空白 TextElement', () => {
+    const result = parseOutput('');
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({ type: 'text', content: '', format: 'plain' });
+  });
+
+  it('应解析图片 ![alt](url)', () => {
+    const result = parseOutput('看看这张图 ![cat](https://example.com/cat.png)');
+    expect(result).toHaveLength(2);
+    expect(result[0]).toMatchObject({ type: 'text', content: '看看这张图' });
+    expect(result[1]).toMatchObject({ type: 'image', url: 'https://example.com/cat.png', alt: 'cat' });
+  });
+
+  it('应解析音频 [audio](url)', () => {
+    const result = parseOutput('[audio](https://example.com/song.mp3)');
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({ type: 'audio', url: 'https://example.com/song.mp3' });
+  });
+
+  it('应解析视频 [video](url)', () => {
+    const result = parseOutput('这是视频 [video](https://example.com/video.mp4)');
+    expect(result).toHaveLength(2);
+    expect(result[1]).toMatchObject({ type: 'video', url: 'https://example.com/video.mp4' });
+  });
+
+  it('应解析文件 [file:name](url)', () => {
+    const result = parseOutput('[file:report.pdf](https://example.com/report.pdf)');
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({ type: 'file', url: 'https://example.com/report.pdf', name: 'report.pdf' });
+  });
+
+  it('应解析 card 代码块', () => {
+    const raw = '```card\n{"title":"天气","description":"晴天"}\n```';
+    const result = parseOutput(raw);
+    expect(result.some(el => el.type === 'card')).toBe(true);
+    const card = result.find(el => el.type === 'card')!;
+    expect(card).toMatchObject({ type: 'card', title: '天气', description: '晴天' });
+  });
+
+  it('无效 card JSON 应降级为文本', () => {
+    const raw = '```card\n{invalid json}\n```';
+    const result = parseOutput(raw);
+    expect(result.some(el => el.type === 'text')).toBe(true);
+  });
+
+  it('应处理混合内容', () => {
+    const raw = '看看这个 ![](https://img.png) 更多文字';
+    const result = parseOutput(raw);
+    expect(result.length).toBeGreaterThanOrEqual(2);
+    expect(result.some(el => el.type === 'image')).toBe(true);
+  });
+});
+
+describe('renderToPlainText', () => {
+  it('应渲染文本元素', () => {
+    expect(renderToPlainText([{ type: 'text', content: 'Hello' }])).toBe('Hello');
+  });
+
+  it('应渲染图片为 [图片: alt]', () => {
+    const result = renderToPlainText([{ type: 'image', url: 'url', alt: '猫' }]);
+    expect(result).toBe('[图片: 猫]');
+  });
+
+  it('应渲染音频的 fallbackText', () => {
+    const result = renderToPlainText([{ type: 'audio', url: 'url', fallbackText: '一段音乐' }]);
+    expect(result).toBe('一段音乐');
+  });
+
+  it('应渲染卡片标题和字段', () => {
+    const result = renderToPlainText([{
+      type: 'card',
+      title: '天气',
+      description: '晴天',
+      fields: [{ label: '温度', value: '25°C' }],
+    }]);
+    expect(result).toContain('天气');
+    expect(result).toContain('晴天');
+    expect(result).toContain('温度: 25°C');
+  });
+
+  it('应渲染文件为 [文件: name]', () => {
+    const result = renderToPlainText([{ type: 'file', url: 'url', name: 'report.pdf' }]);
+    expect(result).toContain('[文件: report.pdf]');
+  });
+});
+
+describe('renderToSatori', () => {
+  it('应将文本包裹在 <p> 标签中', () => {
+    const result = renderToSatori([{ type: 'text', content: 'Hello' }]);
+    expect(result).toBe('<p>Hello</p>');
+  });
+
+  it('应生成 <img> 标签', () => {
+    const result = renderToSatori([{ type: 'image', url: 'https://img.png', alt: '猫' }]);
+    expect(result).toContain('<img');
+    expect(result).toContain('alt="猫"');
+  });
+
+  it('应转义 HTML 特殊字符', () => {
+    const result = renderToSatori([{ type: 'text', content: '<script>alert("xss")</script>' }]);
+    expect(result).not.toContain('<script>');
+    expect(result).toContain('&lt;script&gt;');
+  });
+
+  it('应渲染卡片结构', () => {
+    const result = renderToSatori([{
+      type: 'card',
+      title: '标题',
+      description: '描述',
+    }]);
+    expect(result).toContain('<div class="card">');
+    expect(result).toContain('<h3>标题</h3>');
+    expect(result).toContain('<p>描述</p>');
+  });
+});

package/tests/ai/providers.integration.test.ts

@@ -0,0 +1,227 @@
+/**
+ * AI Providers 集成测试（真实 API 调用）
+ * 
+ * 使用 test-bot 的环境配置进行真实 API 测试
+ * 
+ * 运行方式（需要网络权限）：
+ * pnpm test packages/ai/tests/providers.integration.test.ts
+ * 
+ * 注意：此测试需要网络访问，在 sandbox 中会自动跳过
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import { OllamaProvider } from '../../src/ai/providers/ollama.js';
+import type { ChatMessage } from '@zhin.js/core';
+
+// Ollama 配置
+const OLLAMA_CONFIG = {
+  baseUrl: 'https://ollama.l2cl.link',
+  models: ['qwen2.5:7b', 'qwen3:8b'],
+};
+
+// 全局状态
+let canRun = false;
+let provider: OllamaProvider | null = null;
+
+// 跳过检查
+const skipIfNoNetwork = (ctx: any) => {
+  if (!canRun) {
+    ctx.skip();
+    return true;
+  }
+  return false;
+};
+
+beforeAll(async () => {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const response = await globalThis.fetch(`${OLLAMA_CONFIG.baseUrl}/api/tags`, {
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+    canRun = response.ok;
+    
+    if (canRun) {
+      provider = new OllamaProvider({
+        baseUrl: OLLAMA_CONFIG.baseUrl,
+        models: OLLAMA_CONFIG.models,
+      });
+      console.log('✅ Ollama 服务可用');
+    }
+  } catch {
+    canRun = false;
+    console.log('⚠️ 网络不可用，跳过集成测试');
+  }
+});
+
+describe('Ollama Provider 集成测试', () => {
+  describe('基本聊天', () => {
+    it('应该能进行简单对话', async (ctx) => {
+      if (skipIfNoNetwork(ctx)) return;
+      
+      const response = await provider!.chat({
+        model: OLLAMA_CONFIG.models[0],
+        messages: [{ role: 'user', content: '你好，一句话介绍自己' }],
+        max_tokens: 100,
+      });
+
+      expect(response.choices[0].message.content).toBeTruthy();
+      console.log('📝 AI 回复:', response.choices[0].message.content);
+    }, 30000);
+
+    it('应该能处理多轮对话', async (ctx) => {
+      if (skipIfNoNetwork(ctx)) return;
+      
+      const messages: ChatMessage[] = [
+        { role: 'user', content: '记住：我叫小明。简短回复。' },
+      ];
+
+      const r1 = await provider!.chat({
+        model: OLLAMA_CONFIG.models[0],
+        messages,
+        max_tokens: 30,
+      });
+
+      messages.push({ role: 'assistant', content: r1.choices[0].message.content as string });
+      messages.push({ role: 'user', content: '我叫什么？' });
+
+      const r2 = await provider!.chat({
+        model: OLLAMA_CONFIG.models[0],
+        messages,
+        max_tokens: 30,
+      });
+
+      const reply = r2.choices[0].message.content as string;
+      console.log('📝 多轮对话:', reply);
+      expect(reply.toLowerCase()).toContain('小明');
+    }, 120000);
+  });
+
+  describe('工具调用', () => {
+    it('应该能调用计算器工具', async (ctx) => {
+      if (skipIfNoNetwork(ctx)) return;
+      
+      const response = await provider!.chat({
+        model: OLLAMA_CONFIG.models[0],
+        messages: [
+          { role: 'system', content: '使用 calculator 工具计算。' },
+          { role: 'user', content: '计算 15 * 8' },
+        ],
+        tools: [{
+          type: 'function',
+          function: {
+            name: 'calculator',
+            description: '计算数学表达式',
+            parameters: {
+              type: 'object',
+              properties: { expression: { type: 'string' } },
+              required: ['expression'],
+            },
+          },
+        }],
+        tool_choice: 'auto',
+        max_tokens: 200,
+      });
+
+      console.log('📝 工具调用:', JSON.stringify(response.choices[0].message, null, 2));
+      expect(response.choices[0].message).toBeDefined();
+    }, 30000);
+
+    it('应该能调用天气工具', async (ctx) => {
+      if (skipIfNoNetwork(ctx)) return;
+      
+      const response = await provider!.chat({
+        model: OLLAMA_CONFIG.models[0],
+        messages: [
+          { role: 'system', content: '使用 get_weather 工具查天气。' },
+          { role: 'user', content: '上海天气？' },
+        ],
+        tools: [{
+          type: 'function',
+          function: {
+            name: 'get_weather',
+            description: '查询天气',
+            parameters: {
+              type: 'object',
+              properties: { city: { type: 'string' } },
+              required: ['city'],
+            },
+          },
+        }],
+        tool_choice: 'auto',
+        max_tokens: 200,
+      });
+
+      console.log('📝 天气工具测试');
+      expect(response.choices[0].message).toBeDefined();
+    }, 30000);
+  });
+
+  describe('流式输出', () => {
+    it('应该能进行流式对话', async (ctx) => {
+      if (skipIfNoNetwork(ctx)) return;
+      
+      const stream = await provider!.chatStream({
+        model: OLLAMA_CONFIG.models[0],
+        messages: [{ role: 'user', content: '写4行诗' }],
+        max_tokens: 100,
+        stream: true,
+      });
+
+      let content = '';
+      let chunks = 0;
+
+      console.log('📝 流式输出:');
+      for await (const chunk of stream) {
+        const c = chunk.choices?.[0]?.delta?.content;
+        if (c) {
+          content += c;
+          chunks++;
+          process.stdout.write(c);
+        }
+      }
+      console.log(`\n  (${chunks} chunks)`);
+
+      expect(content.length).toBeGreaterThan(0);
+    }, 60000);
+  });
+
+  describe('错误处理', () => {
+    it('应该处理无效模型', async (ctx) => {
+      if (skipIfNoNetwork(ctx)) return;
+      
+      await expect(
+        provider!.chat({
+          model: 'invalid-model-xyz',
+          messages: [{ role: 'user', content: 'test' }],
+        })
+      ).rejects.toThrow();
+    }, 60000); // Ollama 拉取模型可能需要较长时间才会失败
+  });
+
+  describe('健康检查', () => {
+    it('应该返回健康状态', async (ctx) => {
+      if (skipIfNoNetwork(ctx)) return;
+      
+      const healthy = await provider!.healthCheck();
+      console.log('📝 健康:', healthy ? '✅' : '❌');
+      expect(typeof healthy).toBe('boolean');
+    }, 10000);
+  });
+});
+
+describe('性能测试', () => {
+  it('应该快速响应', async (ctx) => {
+    if (skipIfNoNetwork(ctx)) return;
+    
+    const start = Date.now();
+    await provider!.chat({
+      model: OLLAMA_CONFIG.models[0],
+      messages: [{ role: 'user', content: '1+1' }],
+      max_tokens: 10,
+    });
+    const ms = Date.now() - start;
+    console.log(`📝 响应: ${ms}ms`);
+    expect(ms).toBeLessThan(30000);
+  }, 35000);
+});

package/tests/ai/rate-limiter.test.ts

@@ -0,0 +1,108 @@
+/**
+ * RateLimiter 测试
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { RateLimiter } from '../../src/ai/rate-limiter.js';
+
+describe('RateLimiter', () => {
+  let limiter: RateLimiter;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    limiter?.dispose();
+    vi.useRealTimers();
+  });
+
+  it('应允许正常请求', () => {
+    limiter = new RateLimiter({ maxRequestsPerMinute: 5 });
+    const result = limiter.check('user1');
+    expect(result.allowed).toBe(true);
+    expect(result.message).toBeUndefined();
+  });
+
+  it('应在超过限制后拒绝请求', () => {
+    limiter = new RateLimiter({ maxRequestsPerMinute: 3, cooldownSeconds: 5 });
+
+    // 发送 3 个请求（达到限制）
+    limiter.check('user1');
+    limiter.check('user1');
+    limiter.check('user1');
+
+    // 第 4 个请求应被拒绝
+    const result = limiter.check('user1');
+    expect(result.allowed).toBe(false);
+    expect(result.message).toBeDefined();
+    expect(result.retryAfterSeconds).toBe(5);
+  });
+
+  it('冷却期结束后应允许请求', () => {
+    limiter = new RateLimiter({ maxRequestsPerMinute: 2, cooldownSeconds: 5 });
+
+    limiter.check('user1');
+    limiter.check('user1');
+    limiter.check('user1'); // 触发冷却
+
+    // 推进 6 秒
+    vi.advanceTimersByTime(6000);
+
+    // 推进超过 1 分钟让滑动窗口清空旧记录
+    vi.advanceTimersByTime(60000);
+
+    const result = limiter.check('user1');
+    expect(result.allowed).toBe(true);
+  });
+
+  it('不同用户应独立计数', () => {
+    limiter = new RateLimiter({ maxRequestsPerMinute: 2 });
+
+    limiter.check('user1');
+    limiter.check('user1');
+    const user1Result = limiter.check('user1'); // 超限
+
+    const user2Result = limiter.check('user2'); // 新用户
+    expect(user1Result.allowed).toBe(false);
+    expect(user2Result.allowed).toBe(true);
+  });
+
+  it('滑动窗口应在 1 分钟后清理旧记录', () => {
+    limiter = new RateLimiter({ maxRequestsPerMinute: 2 });
+
+    limiter.check('user1');
+    limiter.check('user1');
+
+    // 推进 61 秒
+    vi.advanceTimersByTime(61000);
+
+    // 旧记录清理后应允许
+    const result = limiter.check('user1');
+    expect(result.allowed).toBe(true);
+  });
+
+  it('dispose 应清理所有资源', () => {
+    limiter = new RateLimiter();
+    limiter.check('user1');
+    limiter.dispose();
+
+    // dispose 后内部 buckets 应清空
+    const result = limiter.check('user1');
+    expect(result.allowed).toBe(true); // 重新开始计数
+  });
+
+  it('在冷却期内请求应返回等待秒数', () => {
+    limiter = new RateLimiter({ maxRequestsPerMinute: 1, cooldownSeconds: 10 });
+
+    limiter.check('user1');
+    limiter.check('user1'); // 触发冷却
+
+    // 推进 3 秒
+    vi.advanceTimersByTime(3000);
+
+    const result = limiter.check('user1');
+    expect(result.allowed).toBe(false);
+    expect(result.retryAfterSeconds).toBeLessThanOrEqual(10);
+    expect(result.retryAfterSeconds).toBeGreaterThan(0);
+  });
+});