npm - opc-agent - Versions diffs - 1.4.0 → 2.0.1 - Mend

opc-agent 1.4.0 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (198) hide show

package/CHANGELOG.md +25 -0
package/README.md +91 -32
package/dist/channels/email.d.ts +32 -26
package/dist/channels/email.js +239 -62
package/dist/channels/feishu.d.ts +21 -6
package/dist/channels/feishu.js +225 -126
package/dist/channels/telegram.d.ts +30 -9
package/dist/channels/telegram.js +125 -33
package/dist/channels/websocket.d.ts +46 -3
package/dist/channels/websocket.js +306 -37
package/dist/channels/wechat.d.ts +33 -13
package/dist/channels/wechat.js +229 -42
package/dist/cli.js +1127 -19
package/dist/core/a2a.d.ts +17 -0
package/dist/core/a2a.js +43 -1
package/dist/core/agent.d.ts +39 -0
package/dist/core/agent.js +228 -3
package/dist/core/runtime.d.ts +7 -0
package/dist/core/runtime.js +205 -2
package/dist/core/sandbox.d.ts +26 -0
package/dist/core/sandbox.js +117 -0
package/dist/core/scheduler.d.ts +52 -0
package/dist/core/scheduler.js +168 -0
package/dist/core/subagent.d.ts +28 -0
package/dist/core/subagent.js +65 -0
package/dist/core/workflow-graph.d.ts +93 -0
package/dist/core/workflow-graph.js +247 -0
package/dist/daemon.d.ts +3 -0
package/dist/daemon.js +134 -0
package/dist/doctor.d.ts +15 -0
package/dist/doctor.js +183 -0
package/dist/eval/index.d.ts +65 -0
package/dist/eval/index.js +191 -0
package/dist/index.d.ts +37 -6
package/dist/index.js +75 -3
package/dist/plugins/content-filter.d.ts +7 -0
package/dist/plugins/content-filter.js +25 -0
package/dist/plugins/index.d.ts +42 -0
package/dist/plugins/index.js +108 -2
package/dist/plugins/logger.d.ts +6 -0
package/dist/plugins/logger.js +20 -0
package/dist/plugins/rate-limiter.d.ts +7 -0
package/dist/plugins/rate-limiter.js +35 -0
package/dist/protocols/a2a/client.d.ts +25 -0
package/dist/protocols/a2a/client.js +115 -0
package/dist/protocols/a2a/index.d.ts +6 -0
package/dist/protocols/a2a/index.js +12 -0
package/dist/protocols/a2a/server.d.ts +41 -0
package/dist/protocols/a2a/server.js +295 -0
package/dist/protocols/a2a/types.d.ts +91 -0
package/dist/protocols/a2a/types.js +15 -0
package/dist/protocols/a2a/utils.d.ts +6 -0
package/dist/protocols/a2a/utils.js +47 -0
package/dist/protocols/agui/client.d.ts +10 -0
package/dist/protocols/agui/client.js +75 -0
package/dist/protocols/agui/index.d.ts +4 -0
package/dist/protocols/agui/index.js +25 -0
package/dist/protocols/agui/server.d.ts +37 -0
package/dist/protocols/agui/server.js +191 -0
package/dist/protocols/agui/types.d.ts +107 -0
package/dist/protocols/agui/types.js +17 -0
package/dist/protocols/index.d.ts +2 -0
package/dist/protocols/index.js +19 -0
package/dist/protocols/mcp/agent-tools.d.ts +11 -0
package/dist/protocols/mcp/agent-tools.js +129 -0
package/dist/protocols/mcp/index.d.ts +5 -0
package/dist/protocols/mcp/index.js +11 -0
package/dist/protocols/mcp/server.d.ts +31 -0
package/dist/protocols/mcp/server.js +248 -0
package/dist/protocols/mcp/types.d.ts +92 -0
package/dist/protocols/mcp/types.js +17 -0
package/dist/providers/index.d.ts +5 -1
package/dist/providers/index.js +16 -9
package/dist/publish/index.d.ts +45 -0
package/dist/publish/index.js +350 -0
package/dist/schema/oad.d.ts +859 -67
package/dist/schema/oad.js +47 -3
package/dist/security/approval.d.ts +36 -0
package/dist/security/approval.js +113 -0
package/dist/security/index.d.ts +4 -0
package/dist/security/index.js +8 -0
package/dist/security/keys.d.ts +16 -0
package/dist/security/keys.js +117 -0
package/dist/skills/auto-learn.d.ts +28 -0
package/dist/skills/auto-learn.js +257 -0
package/dist/studio/server.d.ts +63 -0
package/dist/studio/server.js +625 -0
package/dist/studio-ui/index.html +662 -0
package/dist/telemetry/index.d.ts +93 -0
package/dist/telemetry/index.js +285 -0
package/dist/tools/builtin/datetime.d.ts +3 -0
package/dist/tools/builtin/datetime.js +44 -0
package/dist/tools/builtin/file.d.ts +3 -0
package/dist/tools/builtin/file.js +151 -0
package/dist/tools/builtin/index.d.ts +15 -0
package/dist/tools/builtin/index.js +30 -0
package/dist/tools/builtin/shell.d.ts +3 -0
package/dist/tools/builtin/shell.js +43 -0
package/dist/tools/builtin/web.d.ts +3 -0
package/dist/tools/builtin/web.js +37 -0
package/dist/tools/mcp-client.d.ts +24 -0
package/dist/tools/mcp-client.js +119 -0
package/package.json +5 -3
package/scripts/install.ps1 +31 -0
package/scripts/install.sh +40 -0
package/src/channels/email.ts +351 -177
package/src/channels/feishu.ts +349 -236
package/src/channels/telegram.ts +212 -90
package/src/channels/websocket.ts +399 -87
package/src/channels/wechat.ts +329 -149
package/src/cli.ts +1201 -20
package/src/core/a2a.ts +60 -0
package/src/core/agent.ts +420 -152
package/src/core/runtime.ts +174 -0
package/src/core/sandbox.ts +143 -0
package/src/core/scheduler.ts +187 -0
package/src/core/subagent.ts +98 -0
package/src/core/workflow-graph.ts +365 -0
package/src/daemon.ts +96 -0
package/src/doctor.ts +156 -0
package/src/eval/index.ts +211 -0
package/src/eval/suites/basic.json +16 -0
package/src/eval/suites/memory.json +12 -0
package/src/eval/suites/safety.json +14 -0
package/src/index.ts +65 -6
package/src/plugins/content-filter.ts +23 -0
package/src/plugins/index.ts +133 -2
package/src/plugins/logger.ts +18 -0
package/src/plugins/rate-limiter.ts +38 -0
package/src/protocols/a2a/client.ts +132 -0
package/src/protocols/a2a/index.ts +8 -0
package/src/protocols/a2a/server.ts +333 -0
package/src/protocols/a2a/types.ts +88 -0
package/src/protocols/a2a/utils.ts +50 -0
package/src/protocols/agui/client.ts +83 -0
package/src/protocols/agui/index.ts +4 -0
package/src/protocols/agui/server.ts +218 -0
package/src/protocols/agui/types.ts +153 -0
package/src/protocols/index.ts +2 -0
package/src/protocols/mcp/agent-tools.ts +134 -0
package/src/protocols/mcp/index.ts +8 -0
package/src/protocols/mcp/server.ts +262 -0
package/src/protocols/mcp/types.ts +69 -0
package/src/providers/index.ts +354 -339
package/src/publish/index.ts +376 -0
package/src/schema/oad.ts +204 -154
package/src/security/approval.ts +131 -0
package/src/security/index.ts +3 -0
package/src/security/keys.ts +87 -0
package/src/skills/auto-learn.ts +262 -0
package/src/studio/server.ts +629 -0
package/src/studio-ui/index.html +662 -0
package/src/telemetry/index.ts +324 -0
package/src/tools/builtin/datetime.ts +41 -0
package/src/tools/builtin/file.ts +107 -0
package/src/tools/builtin/index.ts +28 -0
package/src/tools/builtin/shell.ts +43 -0
package/src/tools/builtin/web.ts +35 -0
package/src/tools/mcp-client.ts +131 -0
package/src/types/agent-workstation.d.ts +2 -0
package/tests/a2a-protocol.test.ts +285 -0
package/tests/agui-protocol.test.ts +246 -0
package/tests/auto-learn.test.ts +105 -0
package/tests/builtin-tools.test.ts +83 -0
package/tests/channels/discord.test.ts +79 -0
package/tests/channels/email.test.ts +148 -0
package/tests/channels/feishu.test.ts +123 -0
package/tests/channels/telegram.test.ts +129 -0
package/tests/channels/websocket.test.ts +53 -0
package/tests/channels/wechat.test.ts +170 -0
package/tests/chat-cli.test.ts +160 -0
package/tests/cli.test.ts +46 -0
package/tests/daemon.test.ts +135 -0
package/tests/deepbrain-wire.test.ts +234 -0
package/tests/doctor.test.ts +38 -0
package/tests/eval.test.ts +173 -0
package/tests/init-role.test.ts +124 -0
package/tests/mcp-client.test.ts +92 -0
package/tests/mcp-server.test.ts +178 -0
package/tests/plugin-a2a-enhanced.test.ts +230 -0
package/tests/publish.test.ts +231 -0
package/tests/scheduler.test.ts +200 -0
package/tests/security-enhanced.test.ts +233 -0
package/tests/skill-learner.test.ts +161 -0
package/tests/studio.test.ts +229 -0
package/tests/subagent.test.ts +193 -0
package/tests/telegram-discord.test.ts +60 -0
package/tests/telemetry.test.ts +186 -0
package/tests/tools/builtin-extended.test.ts +138 -0
package/tests/workflow-graph.test.ts +279 -0
package/tutorial/customer-service-agent/README.md +612 -0
package/tutorial/customer-service-agent/SOUL.md +26 -0
package/tutorial/customer-service-agent/agent.yaml +63 -0
package/tutorial/customer-service-agent/package.json +19 -0
package/tutorial/customer-service-agent/src/index.ts +69 -0
package/tutorial/customer-service-agent/src/skills/faq.ts +27 -0
package/tutorial/customer-service-agent/src/skills/ticket.ts +22 -0
package/tutorial/customer-service-agent/tsconfig.json +14 -0

package/tests/studio.test.ts ADDED Viewed

@@ -0,0 +1,229 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { StudioServer } from '../src/studio/server';
+import { createServer, IncomingMessage, ServerResponse } from 'http';
+import { join } from 'path';
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'fs';
+import * as http from 'http';
+const TEST_PORT = 14789;
+const TEST_DIR = join(__dirname, '__studio_test_fixture__');
+const STATIC_DIR = join(TEST_DIR, 'studio-ui');
+function fetch(path: string, method = 'GET', body?: string): Promise<{ status: number; headers: any; body: string }> {
+  return new Promise((resolve, reject) => {
+    const opts: http.RequestOptions = {
+      hostname: 'localhost',
+      port: TEST_PORT,
+      path,
+      method,
+      headers: body ? { 'Content-Type': 'application/json' } : {},
+    };
+    const req = http.request(opts, (res) => {
+      let data = '';
+      res.on('data', (c) => (data += c));
+      res.on('end', () => resolve({ status: res.statusCode!, headers: res.headers, body: data }));
+    });
+    req.on('error', reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+describe('StudioServer', () => {
+  let server: StudioServer;
+  beforeAll(async () => {
+    // Create test fixture
+    mkdirSync(STATIC_DIR, { recursive: true });
+    writeFileSync(join(STATIC_DIR, 'index.html'), '<html><body>OPC Studio</body></html>');
+    writeFileSync(join(STATIC_DIR, 'app.js'), 'console.log("hello")');
+    writeFileSync(join(STATIC_DIR, 'style.css'), 'body { margin: 0; }');
+    writeFileSync(join(STATIC_DIR, 'logo.png'), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+    writeFileSync(join(STATIC_DIR, 'icon.svg'), '<svg></svg>');
+    writeFileSync(join(TEST_DIR, 'package.json'), JSON.stringify({ name: 'test-agent', version: '1.2.3', description: 'Test agent' }));
+    server = new StudioServer({
+      port: TEST_PORT,
+      agentDir: TEST_DIR,
+      staticDir: STATIC_DIR,
+    });
+    await server.start();
+    // Give server time to bind
+    await new Promise((r) => setTimeout(r, 200));
+  });
+  afterAll(async () => {
+    await server.stop();
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+  // Test 1: Constructor defaults
+  it('should have default config values', () => {
+    const s = new StudioServer();
+    const cfg = s.getConfig();
+    expect(cfg.port).toBe(4000);
+    expect(cfg.agentDir).toBe(process.cwd());
+    expect(cfg.staticDir).toContain('studio-ui');
+  });
+  // Test 2: Constructor with custom port
+  it('should accept custom config', () => {
+    const s = new StudioServer({ port: 5555, agentDir: '/tmp/test' });
+    const cfg = s.getConfig();
+    expect(cfg.port).toBe(5555);
+    expect(cfg.agentDir).toBe('/tmp/test');
+  });
+  // Test 3: /api/agent/info returns agent info
+  it('GET /api/agent/info returns agent info', async () => {
+    const res = await fetch('/api/agent/info');
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(data.name).toBe('test-agent');
+    expect(data.version).toBe('1.2.3');
+    expect(data.status).toBe('running');
+  });
+  // Test 4: /api/tools/list returns tools
+  it('GET /api/tools/list returns tools array', async () => {
+    const res = await fetch('/api/tools/list');
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(data).toHaveProperty('tools');
+    expect(Array.isArray(data.tools)).toBe(true);
+  });
+  // Test 5: /api/doctor/check runs
+  it('GET /api/doctor/check returns result', async () => {
+    const res = await fetch('/api/doctor/check');
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(data).toBeDefined();
+  });
+  // Test 6: unknown API returns 404
+  it('GET /api/unknown returns 404', async () => {
+    const res = await fetch('/api/nonexistent/route');
+    expect(res.status).toBe(404);
+    const data = JSON.parse(res.body);
+    expect(data.error).toBe('Not found');
+  });
+  // Test 7: Static file serving - HTML
+  it('serves index.html at root', async () => {
+    const res = await fetch('/');
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toBe('text/html');
+    expect(res.body).toContain('OPC Studio');
+  });
+  // Test 8: Static file serving - JS with correct MIME
+  it('serves .js with correct MIME type', async () => {
+    const res = await fetch('/app.js');
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toBe('application/javascript');
+  });
+  // Test 9: Static file serving - CSS with correct MIME
+  it('serves .css with correct MIME type', async () => {
+    const res = await fetch('/style.css');
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toBe('text/css');
+  });
+  // Test 10: CORS headers present on API responses
+  it('API responses include CORS headers', async () => {
+    const res = await fetch('/api/agent/info');
+    expect(res.headers['access-control-allow-origin']).toBe('*');
+  });
+  // Test 11: SPA fallback for unknown static paths
+  it('falls back to index.html for unknown paths', async () => {
+    const res = await fetch('/some/deep/route');
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toBe('text/html');
+    expect(res.body).toContain('OPC Studio');
+  });
+  // Test 12: /api/analytics/overview
+  it('GET /api/analytics/overview returns analytics', async () => {
+    const res = await fetch('/api/analytics/overview');
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(data).toHaveProperty('totalMessages');
+    expect(data).toHaveProperty('totalSessions');
+  });
+  // Test 13: /api/security/approvals
+  it('GET /api/security/approvals returns empty approvals', async () => {
+    const res = await fetch('/api/security/approvals');
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(data.approvals).toEqual([]);
+  });
+  // Test 14: /api/logs/recent returns lines array
+  it('GET /api/logs/recent returns lines', async () => {
+    const res = await fetch('/api/logs/recent');
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(Array.isArray(data.lines)).toBe(true);
+  });
+  // Test 15: SVG MIME type
+  it('serves .svg with correct MIME type', async () => {
+    const res = await fetch('/icon.svg');
+    expect(res.status).toBe(200);
+    expect(res.headers['content-type']).toBe('image/svg+xml');
+  });
+  // Test 16: /api/modules returns module status
+  it('GET /api/modules returns module status', async () => {
+    const res = await fetch('/api/modules');
+    expect(res.status).toBe(200);
+    const data = JSON.parse(res.body);
+    expect(data).toHaveProperty('modules');
+    expect(data.modules).toHaveLength(3);
+    expect(data.modules[0]).toHaveProperty('name', 'DeepBrain');
+    expect(data.modules[0]).toHaveProperty('running');
+    expect(data.modules[0]).toHaveProperty('port', 4001);
+    expect(data.modules[1]).toHaveProperty('name', 'AgentKits');
+    expect(data.modules[2]).toHaveProperty('name', 'Workstation');
+  });
+  // Test 17: Proxy returns 502 when module not running
+  it('proxy returns 502 with friendly message when module not running', async () => {
+    const res = await fetch('/brain/');
+    expect(res.status).toBe(502);
+    expect(res.body).toContain('Module not running');
+    expect(res.body).toContain('DeepBrain');
+  });
+  // Test 18: Proxy routes are configured for all modules
+  it('proxy routes configured for all modules', async () => {
+    const brainRes = await fetch('/brain/');
+    const kitsRes = await fetch('/kits/');
+    const wsRes = await fetch('/workstation/');
+    // All should get 502 (not 200/SPA fallback) since no modules running
+    expect(brainRes.status).toBe(502);
+    expect(kitsRes.status).toBe(502);
+    expect(wsRes.status).toBe(502);
+  });
+  // Test 19: Module nav items in real index.html
+  it('real index.html contains module nav items', () => {
+    const realHtml = readFileSync(join(__dirname, '../src/studio-ui/index.html'), 'utf-8');
+    expect(realHtml).toContain('data-page="brain-module"');
+    expect(realHtml).toContain('data-page="kits-module"');
+    expect(realHtml).toContain('data-page="workstation-module"');
+    expect(realHtml).toContain('data-page="modules"');
+  });
+  // Test 20: Iframe src correct in real index.html
+  it('real index.html contains correct iframe srcs', () => {
+    const realHtml = readFileSync(join(__dirname, '../src/studio-ui/index.html'), 'utf-8');
+    expect(realHtml).toContain('src="/brain/"');
+    expect(realHtml).toContain('src="/kits/"');
+    expect(realHtml).toContain('src="/workstation/"');
+  });
+});

package/tests/subagent.test.ts ADDED Viewed

@@ -0,0 +1,193 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SubAgentManager } from '../src/core/subagent';
+import { BaseAgent } from '../src/core/agent';
+// Mock the provider so we don't need real API keys
+vi.mock('../src/providers', () => ({
+  createProvider: vi.fn(() => ({
+    name: 'mock',
+    chat: vi.fn().mockResolvedValue('mock response'),
+    chatStream: vi.fn(),
+  })),
+  SUPPORTED_PROVIDERS: ['openai'],
+}));
+describe('SubAgentManager', () => {
+  let manager: SubAgentManager;
+  beforeEach(() => {
+    manager = new SubAgentManager();
+  });
+  it('should spawn a sub-agent and return result', async () => {
+    const result = await manager.spawn({
+      name: 'test-agent',
+      task: 'Hello',
+    });
+    expect(result.name).toBe('test-agent');
+    expect(result.status).toBe('completed');
+    expect(result.result).toBe('mock response');
+    expect(result.duration).toBeGreaterThanOrEqual(0);
+    expect(result.id).toMatch(/^sub_/);
+  });
+  it('should track agents in list', async () => {
+    await manager.spawn({ name: 'agent-1', task: 'task 1' });
+    await manager.spawn({ name: 'agent-2', task: 'task 2' });
+    const list = manager.list();
+    expect(list).toHaveLength(2);
+    expect(list[0].status).toBe('completed');
+    expect(list[1].status).toBe('completed');
+  });
+  it('should spawn parallel agents', async () => {
+    const results = await manager.spawnParallel([
+      { name: 'p1', task: 'task 1' },
+      { name: 'p2', task: 'task 2' },
+      { name: 'p3', task: 'task 3' },
+    ]);
+    expect(results).toHaveLength(3);
+    results.forEach((r) => {
+      expect(r.status).toBe('completed');
+      expect(r.result).toBe('mock response');
+    });
+  });
+  it('should kill a sub-agent', async () => {
+    const result = await manager.spawn({ name: 'killable', task: 'task' });
+    expect(manager.kill(result.id)).toBe(true);
+    const list = manager.list();
+    const killed = list.find((a) => a.id === result.id);
+    expect(killed?.status).toBe('killed');
+  });
+  it('should return false when killing non-existent agent', () => {
+    expect(manager.kill('non-existent')).toBe(false);
+  });
+  it('should handle timeout', async () => {
+    const { createProvider } = await import('../src/providers');
+    (createProvider as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      name: 'mock-slow',
+      chat: () => new Promise((resolve) => setTimeout(() => resolve('late'), 5000)),
+      chatStream: vi.fn(),
+    });
+    const result = await manager.spawn({
+      name: 'slow-agent',
+      task: 'slow task',
+      timeout: 50,
+    });
+    expect(result.status).toBe('timeout');
+  });
+  it('should handle failed agents', async () => {
+    const { createProvider } = await import('../src/providers');
+    (createProvider as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      name: 'mock-fail',
+      chat: () => Promise.reject(new Error('provider error')),
+      chatStream: vi.fn(),
+    });
+    const result = await manager.spawn({
+      name: 'fail-agent',
+      task: 'fail task',
+    });
+    expect(result.status).toBe('failed');
+    expect(result.result).toBe('provider error');
+  });
+  it('should list empty when no agents spawned', () => {
+    expect(manager.list()).toEqual([]);
+  });
+  it('should use isolated memory by default', async () => {
+    const result = await manager.spawn({
+      name: 'isolated',
+      task: 'test',
+      isolated: true,
+    });
+    expect(result.status).toBe('completed');
+  });
+  it('should spawn with custom systemPrompt', async () => {
+    const result = await manager.spawn({
+      name: 'custom-prompt',
+      task: 'test',
+      systemPrompt: 'You are a custom assistant',
+    });
+    expect(result.status).toBe('completed');
+    expect(result.name).toBe('custom-prompt');
+  });
+  it('should spawn with custom model', async () => {
+    const result = await manager.spawn({
+      name: 'custom-model',
+      task: 'test',
+      model: 'gpt-4',
+    });
+    expect(result.status).toBe('completed');
+  });
+  it('spawnParallel returns all results even with mix', async () => {
+    const results = await manager.spawnParallel([
+      { name: 'a', task: 't1' },
+      { name: 'b', task: 't2' },
+    ]);
+    expect(results).toHaveLength(2);
+    expect(results.every(r => r.result === 'mock response')).toBe(true);
+  });
+  it('kill returns false for unknown id', () => {
+    expect(manager.kill('unknown-id-xyz')).toBe(false);
+  });
+  it('list shows correct status after completion', async () => {
+    await manager.spawn({ name: 'done', task: 'task' });
+    const list = manager.list();
+    expect(list.every(a => a.status === 'completed')).toBe(true);
+  });
+  it('sub-agent name is preserved in result', async () => {
+    const result = await manager.spawn({ name: 'my-special-name', task: 'x' });
+    expect(result.name).toBe('my-special-name');
+  });
+  it('multiple sequential spawns tracked correctly', async () => {
+    await manager.spawn({ name: 's1', task: 't' });
+    await manager.spawn({ name: 's2', task: 't' });
+    await manager.spawn({ name: 's3', task: 't' });
+    const list = manager.list();
+    expect(list).toHaveLength(3);
+    expect(new Set(list.map(a => a.id)).size).toBe(3);
+  });
+  it('each spawn gets unique id', async () => {
+    const r1 = await manager.spawn({ name: 'x', task: 't' });
+    const r2 = await manager.spawn({ name: 'x', task: 't' });
+    expect(r1.id).not.toBe(r2.id);
+  });
+  it('result duration is non-negative', async () => {
+    const result = await manager.spawn({ name: 'dur', task: 'test' });
+    expect(result.duration).toBeGreaterThanOrEqual(0);
+  });
+});
+describe('BaseAgent subagent methods', () => {
+  it('should have spawnSubAgent method', () => {
+    const agent = new BaseAgent({ name: 'parent' });
+    expect(typeof agent.spawnSubAgent).toBe('function');
+  });
+  it('should have spawnParallel method', () => {
+    const agent = new BaseAgent({ name: 'parent' });
+    expect(typeof agent.spawnParallel).toBe('function');
+  });
+});

package/tests/telegram-discord.test.ts ADDED Viewed

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { TelegramChannel } from '../src/channels/telegram';
+import { DiscordChannel } from '../src/channels/discord';
+describe('TelegramChannel', () => {
+  it('should create with default config (polling mode)', () => {
+    const channel = new TelegramChannel({ token: 'test-token' });
+    expect(channel.type).toBe('telegram');
+  });
+  it('should create with webhook mode', () => {
+    const channel = new TelegramChannel({
+      token: 'test-token',
+      mode: 'webhook',
+      webhookUrl: 'https://example.com',
+      port: 4000,
+    });
+    expect(channel.type).toBe('telegram');
+  });
+  it('should warn and return if no token on start', async () => {
+    const channel = new TelegramChannel({ token: '' });
+    // Should not throw, just warn
+    await channel.start();
+    await channel.stop();
+  });
+  it('should support onMessage handler', () => {
+    const channel = new TelegramChannel({ token: 'test-token' });
+    const handler = async (msg: any) => ({ ...msg, role: 'assistant' as const });
+    channel.onMessage(handler);
+    // No throw = success
+    expect(channel.type).toBe('telegram');
+  });
+});
+describe('DiscordChannel', () => {
+  it('should create with default config', () => {
+    const channel = new DiscordChannel({ botToken: 'test-token' });
+    expect(channel.type).toBe('discord');
+  });
+  it('should warn and return if no token on start', async () => {
+    const channel = new DiscordChannel({ botToken: '' });
+    await channel.start();
+    await channel.stop();
+  });
+  it('should support onMessage handler', () => {
+    const channel = new DiscordChannel({ botToken: 'test-token' });
+    const handler = async (msg: any) => ({ ...msg, role: 'assistant' as const });
+    channel.onMessage(handler);
+    expect(channel.type).toBe('discord');
+  });
+  it('should handle stop gracefully when not started', async () => {
+    const channel = new DiscordChannel({ botToken: 'test-token' });
+    await channel.stop(); // Should not throw
+  });
+});

package/tests/telemetry.test.ts ADDED Viewed

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  Tracer,
+  ConsoleExporter,
+  FileExporter,
+  generateTraceId,
+  generateSpanId,
+} from '../src/telemetry';
+import { BaseAgent } from '../src/core/agent';
+describe('Telemetry', () => {
+  let tracer: Tracer;
+  beforeEach(() => {
+    tracer = new Tracer({ maxSpans: 100 });
+  });
+  it('startSpan creates span with correct fields', () => {
+    const span = tracer.startSpan('test-op', {
+      attributes: { foo: 'bar' },
+      kind: 'server',
+    });
+    expect(span.name).toBe('test-op');
+    expect(span.kind).toBe('server');
+    expect(span.status).toBe('unset');
+    expect(span.traceId).toHaveLength(32);
+    expect(span.spanId).toHaveLength(16);
+    expect(span.attributes.foo).toBe('bar');
+    expect(span.events).toEqual([]);
+    expect(span.startTime).toBeGreaterThan(0);
+    expect(span.endTime).toBeUndefined();
+  });
+  it('endSpan sets endTime and status', () => {
+    const span = tracer.startSpan('op');
+    tracer.endSpan(span, 'ok');
+    expect(span.endTime).toBeGreaterThanOrEqual(span.startTime);
+    expect(span.status).toBe('ok');
+  });
+  it('endSpan defaults to ok status', () => {
+    const span = tracer.startSpan('op');
+    tracer.endSpan(span);
+    expect(span.status).toBe('ok');
+  });
+  it('addEvent adds to span events', () => {
+    const span = tracer.startSpan('op');
+    tracer.addEvent(span, 'checkpoint', { key: 'val' });
+    expect(span.events).toHaveLength(1);
+    expect(span.events[0].name).toBe('checkpoint');
+    expect(span.events[0].attributes?.key).toBe('val');
+    expect(span.events[0].timestamp).toBeGreaterThan(0);
+  });
+  it('getSpans with filters', () => {
+    const s1 = tracer.startSpan('alpha', { attributes: {} });
+    const s2 = tracer.startSpan('beta', { attributes: {} });
+    tracer.endSpan(s1);
+    tracer.endSpan(s2);
+    expect(tracer.getSpans({ name: 'alpha' })).toHaveLength(1);
+    expect(tracer.getSpans({ traceId: s1.traceId })).toHaveLength(1);
+    expect(tracer.getSpans({ limit: 1 })).toHaveLength(1);
+  });
+  it('getTrace returns all spans for traceId', () => {
+    const parent = tracer.startSpan('root');
+    const child = tracer.startSpan('child', { parent });
+    tracer.endSpan(child);
+    tracer.endSpan(parent);
+    const trace = tracer.getTrace(parent.traceId);
+    expect(trace).toHaveLength(2);
+    expect(trace[0].spanId).toBe(parent.spanId);
+    expect(trace[1].parentSpanId).toBe(parent.spanId);
+  });
+  it('getStats returns correct stats', () => {
+    const s1 = tracer.startSpan('op1');
+    tracer.endSpan(s1, 'ok');
+    const s2 = tracer.startSpan('op2');
+    tracer.endSpan(s2, 'error');
+    const stats = tracer.getStats();
+    expect(stats.totalSpans).toBe(2);
+    expect(stats.totalTraces).toBe(2);
+    expect(stats.errorRate).toBe(0.5);
+    expect(stats.spansByName).toEqual({ op1: 1, op2: 1 });
+    expect(stats.p50Latency).toBeGreaterThanOrEqual(0);
+    expect(stats.p95Latency).toBeGreaterThanOrEqual(0);
+    expect(stats.p99Latency).toBeGreaterThanOrEqual(0);
+  });
+  it('increment/gauge/histogram add metrics', () => {
+    tracer.increment('requests', 1, { method: 'GET' });
+    tracer.gauge('connections', 5);
+    tracer.histogram('latency', 42.5, { route: '/api' });
+    const metrics = tracer.getMetrics();
+    expect(metrics).toHaveLength(3);
+    expect(metrics[0]).toMatchObject({ name: 'requests', type: 'counter', value: 1 });
+    expect(metrics[1]).toMatchObject({ name: 'connections', type: 'gauge', value: 5 });
+    expect(metrics[2]).toMatchObject({ name: 'latency', type: 'histogram', value: 42.5 });
+  });
+  it('maxSpans eviction', () => {
+    const t = new Tracer({ maxSpans: 5 });
+    for (let i = 0; i < 10; i++) {
+      t.startSpan(`span-${i}`);
+    }
+    const spans = t.getSpans();
+    expect(spans.length).toBe(5);
+    // oldest evicted, newest 5 kept (span-5 through span-9)
+    const names = spans.map(s => s.name).sort();
+    expect(names).toEqual(['span-5', 'span-6', 'span-7', 'span-8', 'span-9']);
+  });
+  it('ConsoleExporter exports to console', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exporter = new ConsoleExporter();
+    const span = tracer.startSpan('test');
+    tracer.endSpan(span);
+    await exporter.export([span]);
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy.mock.calls[0][0]).toContain('[TRACE]');
+    consoleSpy.mockRestore();
+  });
+  it('FileExporter exports to file', async () => {
+    const fs = require('fs');
+    const tmpFile = require('path').join(require('os').tmpdir(), `opc-test-${Date.now()}.ndjson`);
+    const exporter = new FileExporter(tmpFile);
+    const span = tracer.startSpan('file-test');
+    tracer.endSpan(span);
+    await exporter.export([span]);
+    const content = fs.readFileSync(tmpFile, 'utf-8');
+    expect(content).toContain('file-test');
+    fs.unlinkSync(tmpFile);
+  });
+  it('generateTraceId returns 32 hex chars', () => {
+    const id = generateTraceId();
+    expect(id).toHaveLength(32);
+    expect(/^[0-9a-f]{32}$/.test(id)).toBe(true);
+  });
+  it('generateSpanId returns 16 hex chars', () => {
+    const id = generateSpanId();
+    expect(id).toHaveLength(16);
+    expect(/^[0-9a-f]{16}$/.test(id)).toBe(true);
+  });
+  it('exportOTLP produces OTel-compatible format', () => {
+    const span = tracer.startSpan('otlp-test', { attributes: { key: 'val' } });
+    tracer.endSpan(span);
+    const otlp = tracer.exportOTLP() as any;
+    expect(otlp.resourceSpans).toHaveLength(1);
+    expect(otlp.resourceSpans[0].scopeSpans[0].spans).toHaveLength(1);
+    const s = otlp.resourceSpans[0].scopeSpans[0].spans[0];
+    expect(s.name).toBe('otlp-test');
+    expect(s.traceId).toBe(span.traceId);
+  });
+  it('clear removes all spans and metrics', () => {
+    tracer.startSpan('x');
+    tracer.increment('m');
+    tracer.clear();
+    expect(tracer.getSpans()).toHaveLength(0);
+    expect(tracer.getMetrics()).toHaveLength(0);
+  });
+  it('agent integration: tracer on BaseAgent', () => {
+    const t = new Tracer();
+    const agent = new BaseAgent({ name: 'test', tracer: t });
+    expect(agent.getTracer()).toBe(t);
+  });
+  it('agent integration: setTracer works', () => {
+    const agent = new BaseAgent({ name: 'test' });
+    expect(agent.getTracer()).toBeUndefined();
+    const t = new Tracer();
+    agent.setTracer(t);
+    expect(agent.getTracer()).toBe(t);
+  });
+});