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

opc-agent 2.0.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 (156) hide show

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/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 +712 -11
package/dist/core/a2a.d.ts +17 -0
package/dist/core/a2a.js +43 -1
package/dist/core/agent.d.ts +16 -0
package/dist/core/agent.js +108 -0
package/dist/core/runtime.d.ts +6 -0
package/dist/core/runtime.js +161 -2
package/dist/core/sandbox.d.ts +26 -0
package/dist/core/sandbox.js +117 -0
package/dist/core/workflow-graph.d.ts +93 -0
package/dist/core/workflow-graph.js +247 -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 +30 -6
package/dist/index.js +60 -4
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/publish/index.d.ts +45 -0
package/dist/publish/index.js +350 -0
package/dist/schema/oad.d.ts +682 -65
package/dist/schema/oad.js +36 -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/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/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/websocket.ts +399 -87
package/src/channels/wechat.ts +329 -149
package/src/cli.ts +783 -12
package/src/core/a2a.ts +60 -0
package/src/core/agent.ts +125 -0
package/src/core/runtime.ts +127 -0
package/src/core/sandbox.ts +143 -0
package/src/core/workflow-graph.ts +365 -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 +54 -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/publish/index.ts +376 -0
package/src/schema/oad.ts +39 -2
package/src/security/approval.ts +131 -0
package/src/security/index.ts +3 -0
package/src/security/keys.ts +87 -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/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/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/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 +63 -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 CHANGED Viewed

@@ -115,6 +115,69 @@ describe('SubAgentManager', () => {
     });
     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', () => {

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);
+  });
+});

package/tests/tools/builtin-extended.test.ts ADDED Viewed

@@ -0,0 +1,138 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { getBuiltinTools, getBuiltinToolsByName, fileTool, datetimeTool, shellTool, webTool } from '../../src/tools/builtin';
+describe('getBuiltinTools', () => {
+  it('returns 4 tools', () => {
+    const tools = getBuiltinTools();
+    expect(tools).toHaveLength(4);
+  });
+  it('returns copies (not same array)', () => {
+    const a = getBuiltinTools();
+    const b = getBuiltinTools();
+    expect(a).not.toBe(b);
+  });
+  it('contains file_operations tool', () => {
+    const tools = getBuiltinTools();
+    expect(tools.some(t => t.name === 'file_operations')).toBe(true);
+  });
+  it('contains datetime tool', () => {
+    const tools = getBuiltinTools();
+    expect(tools.some(t => t.name === 'datetime')).toBe(true);
+  });
+});
+describe('getBuiltinToolsByName', () => {
+  it('returns all when no names given', () => {
+    expect(getBuiltinToolsByName()).toHaveLength(4);
+    expect(getBuiltinToolsByName([])).toHaveLength(4);
+  });
+  it('filters by name correctly', () => {
+    const tools = getBuiltinToolsByName(['datetime']);
+    expect(tools).toHaveLength(1);
+    expect(tools[0].name).toBe('datetime');
+  });
+  it('returns empty for unknown names', () => {
+    const tools = getBuiltinToolsByName(['nonexistent']);
+    expect(tools).toHaveLength(0);
+  });
+  it('returns multiple matching tools', () => {
+    const tools = getBuiltinToolsByName(['datetime', 'file_operations']);
+    expect(tools).toHaveLength(2);
+  });
+});
+describe('fileTool', () => {
+  let tmpDir: string;
+  let origCwd: string;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'builtin-test-'));
+    origCwd = process.cwd();
+    process.chdir(tmpDir);
+  });
+  afterEach(() => {
+    process.chdir(origCwd);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+  it('has name file_operations', () => {
+    expect(fileTool.name).toBe('file_operations');
+  });
+  it('read existing file', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'test.txt'), 'hello world');
+    const result = await fileTool.execute({ action: 'read', path: 'test.txt' });
+    expect(result.content).toContain('hello world');
+    expect(result.isError).toBeFalsy();
+  });
+  it('read non-existent returns error', async () => {
+    const result = await fileTool.execute({ action: 'read', path: 'nonexistent.txt' });
+    expect(result.isError).toBe(true);
+  });
+  it('write creates file', async () => {
+    const result = await fileTool.execute({ action: 'write', path: 'out.txt', content: 'data' });
+    expect(result.isError).toBeFalsy();
+    expect(fs.readFileSync(path.join(tmpDir, 'out.txt'), 'utf-8')).toBe('data');
+  });
+  it('list directory', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'a.txt'), 'a');
+    fs.writeFileSync(path.join(tmpDir, 'b.txt'), 'b');
+    const result = await fileTool.execute({ action: 'list', path: '.' });
+    expect(result.content).toContain('a.txt');
+    expect(result.content).toContain('b.txt');
+  });
+  it('exists returns true for existing file', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'exists.txt'), 'yes');
+    const result = await fileTool.execute({ action: 'exists', path: 'exists.txt' });
+    expect(result.content).toContain('true');
+  });
+  it('exists returns false for missing file', async () => {
+    const result = await fileTool.execute({ action: 'exists', path: 'nope.txt' });
+    expect(result.content).toContain('false');
+  });
+  it('path escape blocked (../)', async () => {
+    const result = await fileTool.execute({ action: 'read', path: '../../../etc/passwd' });
+    expect(result.isError).toBe(true);
+  });
+});
+describe('datetimeTool', () => {
+  it('has name datetime', () => {
+    expect(datetimeTool.name).toBe('datetime');
+  });
+  it('returns valid ISO string', async () => {
+    const result = await datetimeTool.execute({});
+    expect(result.isError).toBeFalsy();
+    // Should contain a date-like string
+    expect(result.content).toMatch(/\d{4}/);
+  });
+});
+describe('shellTool', () => {
+  it('has name shell_exec', () => {
+    expect(shellTool.name).toBe('shell_exec');
+  });
+});
+describe('webTool', () => {
+  it('has name web_fetch', () => {
+    expect(webTool.name).toBe('web_fetch');
+  });
+});