opc-agent 2.0.2 → 3.0.0

package/tests/mcp-servers.test.ts

@@ -0,0 +1,260 @@
+import { describe, it, expect } from 'vitest';
+import { listMCPServers, getMCPServer } from '../src/mcp/servers';
+import { createFilesystemServer } from '../src/mcp/servers/filesystem';
+import { createDatabaseServer } from '../src/mcp/servers/database-mcp';
+import { createMemoryServer } from '../src/mcp/servers/memory-mcp';
+import { createCalculatorServer } from '../src/mcp/servers/calculator-mcp';
+import { createDateTimeServer } from '../src/mcp/servers/datetime-mcp';
+import { createJsonServer } from '../src/mcp/servers/json-mcp';
+import { createRegexServer } from '../src/mcp/servers/regex-mcp';
+import { createCryptoServer } from '../src/mcp/servers/crypto-mcp';
+import { generateChatWidget } from '../src/ui/components';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// ─── Registry Tests ─────────────────────────────────
+describe('MCP Server Registry', () => {
+  it('lists 10 servers', () => {
+    const servers = listMCPServers();
+    expect(servers).toHaveLength(10);
+  });
+
+  it('each server has name, description, version, toolCount', () => {
+    for (const s of listMCPServers()) {
+      expect(s.name).toBeTruthy();
+      expect(s.description).toBeTruthy();
+      expect(s.version).toBeTruthy();
+      expect(s.toolCount).toBeGreaterThan(0);
+    }
+  });
+
+  it('getMCPServer returns valid config', () => {
+    const config = getMCPServer('calculator');
+    expect(config.name).toBe('calculator');
+    expect(config.tools!.length).toBeGreaterThan(0);
+  });
+
+  it('getMCPServer throws for unknown', () => {
+    expect(() => getMCPServer('nonexistent')).toThrow('not found');
+  });
+});
+
+// ─── Filesystem Server ──────────────────────────────
+describe('Filesystem MCP', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-fs-'));
+  const server = createFilesystemServer(tmpDir);
+
+  it('tools/list returns 5 tools', () => {
+    expect(server.tools).toHaveLength(5);
+    expect(server.tools!.map(t => t.name)).toContain('fs_read');
+  });
+
+  it('fs_write + fs_read round-trip', async () => {
+    const write = server.tools!.find(t => t.name === 'fs_write')!;
+    const read = server.tools!.find(t => t.name === 'fs_read')!;
+    await write.handler({ path: 'test.txt', content: 'hello mcp' });
+    const result = await read.handler({ path: 'test.txt' });
+    expect(result.content).toBe('hello mcp');
+  });
+
+  it('fs_list returns entries', async () => {
+    const list = server.tools!.find(t => t.name === 'fs_list')!;
+    const result = await list.handler({});
+    expect(result.entries.length).toBeGreaterThan(0);
+  });
+});
+
+// ─── Database MCP ───────────────────────────────────
+describe('Database MCP', () => {
+  const server = createDatabaseServer();
+
+  it('tools/list returns 5 tools', () => {
+    expect(server.tools).toHaveLength(5);
+  });
+
+  it('create table, insert, query', async () => {
+    const create = server.tools!.find(t => t.name === 'db_create_table')!;
+    const insert = server.tools!.find(t => t.name === 'db_insert')!;
+    const query = server.tools!.find(t => t.name === 'db_query')!;
+    await create.handler({ table: 'users', columns: ['name', 'age'] });
+    await insert.handler({ table: 'users', values: { name: 'Alice', age: 30 } });
+    const result = await query.handler({ table: 'users' });
+    expect(result.count).toBe(1);
+    expect(result.rows[0].name).toBe('Alice');
+  });
+});
+
+// ─── Memory MCP ─────────────────────────────────────
+describe('Memory MCP', () => {
+  const server = createMemoryServer();
+
+  it('store and recall', async () => {
+    const store = server.tools!.find(t => t.name === 'memory_store')!;
+    const recall = server.tools!.find(t => t.name === 'memory_recall')!;
+    await store.handler({ key: 'foo', value: 'bar', tags: ['test'] });
+    const result = await recall.handler({ key: 'foo' });
+    expect(result.found).toBe(true);
+    expect(result.value).toBe('bar');
+  });
+
+  it('search by tag', async () => {
+    const search = server.tools!.find(t => t.name === 'memory_search')!;
+    const result = await search.handler({ tag: 'test' });
+    expect(result.count).toBeGreaterThan(0);
+  });
+});
+
+// ─── Calculator MCP ─────────────────────────────────
+describe('Calculator MCP', () => {
+  const server = createCalculatorServer();
+
+  it('evaluate expression', async () => {
+    const calc = server.tools!.find(t => t.name === 'calc_evaluate')!;
+    const result = await calc.handler({ expression: '2 + 3 * 4' });
+    expect(result.result).toBe(14);
+  });
+
+  it('convert temperature', async () => {
+    const conv = server.tools!.find(t => t.name === 'calc_convert')!;
+    const result = await conv.handler({ value: 100, from: 'C', to: 'F' });
+    expect(result.result).toBe(212);
+  });
+});
+
+// ─── DateTime MCP ───────────────────────────────────
+describe('DateTime MCP', () => {
+  const server = createDateTimeServer();
+
+  it('dt_now returns iso string', async () => {
+    const now = server.tools!.find(t => t.name === 'dt_now')!;
+    const result = await now.handler({});
+    expect(result.iso).toBeTruthy();
+  });
+
+  it('dt_diff calculates correctly', async () => {
+    const diff = server.tools!.find(t => t.name === 'dt_diff')!;
+    const result = await diff.handler({ from: '2024-01-01', to: '2024-01-02', unit: 'days' });
+    expect(result.difference).toBe(1);
+  });
+});
+
+// ─── JSON MCP ───────────────────────────────────────
+describe('JSON MCP', () => {
+  const server = createJsonServer();
+
+  it('json_query dot-notation', async () => {
+    const query = server.tools!.find(t => t.name === 'json_query')!;
+    const result = await query.handler({ data: { users: [{ name: 'Alice' }] }, path: 'users.0.name' });
+    expect(result.results).toContain('Alice');
+  });
+
+  it('json_validate', async () => {
+    const validate = server.tools!.find(t => t.name === 'json_validate')!;
+    expect((await validate.handler({ data: '{"a":1}' })).valid).toBe(true);
+    expect((await validate.handler({ data: 'not json' })).valid).toBe(false);
+  });
+
+  it('json_diff finds differences', async () => {
+    const diff = server.tools!.find(t => t.name === 'json_diff')!;
+    const result = await diff.handler({ a: { x: 1 }, b: { x: 2 } });
+    expect(result.equal).toBe(false);
+    expect(result.differences).toHaveLength(1);
+  });
+});
+
+// ─── Regex MCP ──────────────────────────────────────
+describe('Regex MCP', () => {
+  const server = createRegexServer();
+
+  it('regex_test', async () => {
+    const test = server.tools!.find(t => t.name === 'regex_test')!;
+    expect((await test.handler({ pattern: '\\d+', text: 'abc123' })).matches).toBe(true);
+    expect((await test.handler({ pattern: '\\d+', text: 'abc' })).matches).toBe(false);
+  });
+
+  it('regex_match finds all', async () => {
+    const match = server.tools!.find(t => t.name === 'regex_match')!;
+    const result = await match.handler({ pattern: '\\d+', text: 'a1b22c333' });
+    expect(result.count).toBe(3);
+  });
+
+  it('regex_replace', async () => {
+    const replace = server.tools!.find(t => t.name === 'regex_replace')!;
+    const result = await replace.handler({ pattern: '\\d', text: 'a1b2', replacement: 'X' });
+    expect(result.result).toBe('aXbX');
+  });
+});
+
+// ─── Crypto MCP ─────────────────────────────────────
+describe('Crypto MCP', () => {
+  const server = createCryptoServer();
+
+  it('crypto_hash sha256', async () => {
+    const hash = server.tools!.find(t => t.name === 'crypto_hash')!;
+    const result = await hash.handler({ text: 'hello' });
+    expect(result.hash).toBeTruthy();
+    expect(result.algorithm).toBe('sha256');
+  });
+
+  it('crypto_random uuid', async () => {
+    const random = server.tools!.find(t => t.name === 'crypto_random')!;
+    const result = await random.handler({ type: 'uuid' });
+    expect(result.value).toMatch(/^[0-9a-f-]{36}$/);
+  });
+
+  it('crypto_encrypt + decrypt round-trip', async () => {
+    const encrypt = server.tools!.find(t => t.name === 'crypto_encrypt')!;
+    const decrypt = server.tools!.find(t => t.name === 'crypto_decrypt')!;
+    const enc = await encrypt.handler({ text: 'secret', password: 'pass123' });
+    const dec = await decrypt.handler({ encrypted: enc.encrypted, password: 'pass123', iv: enc.iv, tag: enc.tag });
+    expect(dec.decrypted).toBe('secret');
+  });
+});
+
+// ─── Chat Widget ────────────────────────────────────
+describe('Chat Widget', () => {
+  it('generates valid HTML string', () => {
+    const html = generateChatWidget({ endpoint: '/api/chat' });
+    expect(html).toContain('<!DOCTYPE html>');
+    expect(html).toContain('/api/chat');
+    expect(html).toContain('OPC Chat');
+  });
+
+  it('respects custom title and theme', () => {
+    const html = generateChatWidget({ endpoint: '/chat', theme: 'light', title: 'My Bot' });
+    expect(html).toContain('My Bot');
+    expect(html).toContain('#ffffff');
+  });
+
+  it('dark theme uses dark colors', () => {
+    const html = generateChatWidget({ endpoint: '/chat', theme: 'dark' });
+    expect(html).toContain('#1a1a2e');
+  });
+});
+
+// ─── Playground API (static check) ──────────────────
+describe('Playground page', () => {
+  it('studio-ui index.html contains playground page', () => {
+    const html = fs.readFileSync(path.join(__dirname, '../src/studio-ui/index.html'), 'utf-8');
+    expect(html).toContain('id="page-playground"');
+    expect(html).toContain('pg-model');
+    expect(html).toContain('pgSend');
+  });
+});
+
+// ─── All MCP servers have proper tool schemas ───────
+describe('MCP tool schemas', () => {
+  it('every tool has name, description, inputSchema, handler', () => {
+    const servers = listMCPServers();
+    for (const info of servers) {
+      const config = getMCPServer(info.name);
+      for (const tool of config.tools || []) {
+        expect(tool.name).toBeTruthy();
+        expect(tool.description).toBeTruthy();
+        expect(tool.inputSchema).toBeTruthy();
+        expect(typeof tool.handler).toBe('function');
+      }
+    }
+  });
+});

package/tests/voice-enhanced.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi } from 'vitest';
+import { VoiceChannel, createVoiceProviders, EdgeTTSProvider, WhisperSTTProvider, OpenAITTSProvider } from '../src/channels/voice';
+import type { STTProvider, TTSProvider, VoiceConfig } from '../src/channels/voice';
+
+describe('VoiceChannel Enhanced', () => {
+  // ── VoiceConfig Parsing ───────────────────────────────────
+
+  it('should parse VoiceConfig with edge-tts', () => {
+    const config: VoiceConfig = {
+      sttProvider: 'whisper',
+      ttsProvider: 'edge-tts',
+      voice: 'en-US-GuyNeural',
+      language: 'en',
+    };
+    const { stt, tts } = createVoiceProviders(config);
+    expect(stt).toBeUndefined(); // no API key
+    expect(tts).toBeDefined();
+    expect(tts!.name).toBe('edge-tts');
+  });
+
+  it('should parse VoiceConfig with whisper + openai-tts', () => {
+    const config: VoiceConfig = {
+      sttProvider: 'whisper',
+      ttsProvider: 'openai-tts',
+      sttApiKey: 'sk-test',
+      ttsApiKey: 'sk-test',
+      voice: 'nova',
+    };
+    const { stt, tts } = createVoiceProviders(config);
+    expect(stt).toBeDefined();
+    expect(stt!.name).toBe('whisper');
+    expect(tts).toBeDefined();
+    expect(tts!.name).toBe('openai-tts');
+  });
+
+  it('should return undefined for web-speech (node-only)', () => {
+    const { stt } = createVoiceProviders({
+      sttProvider: 'web-speech',
+      ttsProvider: 'edge-tts',
+    });
+    expect(stt).toBeUndefined();
+  });
+
+  // ── Transcribe (mock) ─────────────────────────────────────
+
+  it('should transcribe audio with mock STT provider', async () => {
+    const mockSTT: STTProvider = {
+      name: 'mock-stt',
+      transcribe: vi.fn().mockResolvedValue('Hello world'),
+    };
+    const channel = new VoiceChannel({ sttProvider: mockSTT });
+    const text = await channel.transcribe(Buffer.from('audio-data'));
+    expect(text).toBe('Hello world');
+    expect(mockSTT.transcribe).toHaveBeenCalled();
+  });
+
+  it('should throw if no STT provider for transcribe', async () => {
+    const channel = new VoiceChannel();
+    await expect(channel.transcribe(Buffer.from('audio'))).rejects.toThrow('No STT provider');
+  });
+
+  // ── Synthesize (mock) ─────────────────────────────────────
+
+  it('should synthesize text with mock TTS provider', async () => {
+    const mockTTS: TTSProvider = {
+      name: 'mock-tts',
+      synthesize: vi.fn().mockResolvedValue(Buffer.from('audio-output')),
+    };
+    const channel = new VoiceChannel({ ttsProvider: mockTTS });
+    const audio = await channel.synthesize('Hello world');
+    expect(audio).toEqual(Buffer.from('audio-output'));
+    expect(mockTTS.synthesize).toHaveBeenCalledWith('Hello world', { voice: undefined });
+  });
+
+  it('should throw if no TTS provider for synthesize', async () => {
+    const channel = new VoiceChannel();
+    await expect(channel.synthesize('Hello')).rejects.toThrow('No TTS provider');
+  });
+
+  // ── Conversation Mode ─────────────────────────────────────
+
+  it('should start and stop conversation mode', async () => {
+    const channel = new VoiceChannel();
+    await channel.startConversation(async (text) => `Echo: ${text}`);
+    expect(channel.isConversationActive()).toBe(true);
+    channel.stopConversation();
+    expect(channel.isConversationActive()).toBe(false);
+  });
+
+  // ── processConversationTurn ───────────────────────────────
+
+  it('should process a conversation turn', async () => {
+    const mockSTT: STTProvider = {
+      name: 'mock-stt',
+      transcribe: vi.fn().mockResolvedValue('What time is it?'),
+    };
+    const mockTTS: TTSProvider = {
+      name: 'mock-tts',
+      synthesize: vi.fn().mockResolvedValue(Buffer.from('audio-response')),
+    };
+    const channel = new VoiceChannel({ sttProvider: mockSTT, ttsProvider: mockTTS });
+
+    const result = await channel.processConversationTurn(
+      Buffer.from('audio'),
+      async (text) => `It is 3pm, you said: ${text}`,
+    );
+
+    expect(result.text).toBe('What time is it?');
+    expect(result.response).toContain('3pm');
+    expect(result.audioResponse).toBeDefined();
+  });
+
+  // ── processAudio with handler ─────────────────────────────
+
+  it('should process audio end-to-end', async () => {
+    const mockSTT: STTProvider = {
+      name: 'mock-stt',
+      transcribe: vi.fn().mockResolvedValue('Hello agent'),
+    };
+    const mockTTS: TTSProvider = {
+      name: 'mock-tts',
+      synthesize: vi.fn().mockResolvedValue(Buffer.from('tts-audio')),
+    };
+    const channel = new VoiceChannel({ sttProvider: mockSTT, ttsProvider: mockTTS });
+    channel.onMessage(async (msg) => ({
+      id: 'r1',
+      role: 'assistant' as const,
+      content: `Reply to: ${msg.content}`,
+      timestamp: Date.now(),
+    }));
+
+    const result = await channel.processAudio(Buffer.from('raw-audio'));
+    expect(result.text).toBe('Hello agent');
+    expect(result.response).toBe('Reply to: Hello agent');
+    expect(result.audioResponse).toBeDefined();
+  });
+
+  // ── Provider instances ────────────────────────────────────
+
+  it('should create EdgeTTSProvider with default voice', () => {
+    const provider = new EdgeTTSProvider();
+    expect(provider.name).toBe('edge-tts');
+  });
+
+  it('should create EdgeTTSProvider with custom voice', () => {
+    const provider = new EdgeTTSProvider('zh-CN-XiaoxiaoNeural');
+    expect(provider.name).toBe('edge-tts');
+  });
+
+  // ── Channel lifecycle ─────────────────────────────────────
+
+  it('should start and stop channel', async () => {
+    const channel = new VoiceChannel();
+    expect(channel.isRunning()).toBe(false);
+    await channel.start();
+    expect(channel.isRunning()).toBe(true);
+    await channel.stop();
+    expect(channel.isRunning()).toBe(false);
+  });
+
+  it('should set STT/TTS providers dynamically', () => {
+    const channel = new VoiceChannel();
+    const mockSTT: STTProvider = { name: 'test-stt', transcribe: vi.fn() };
+    const mockTTS: TTSProvider = { name: 'test-tts', synthesize: vi.fn() };
+    channel.setSTTProvider(mockSTT);
+    channel.setTTSProvider(mockTTS);
+    // No error means success
+  });
+});

package/dist/dtv/data.d.ts

@@ -1,18 +0,0 @@
-export interface DataSource {
-    readonly name: string;
-    readonly type: string;
-    read(key: string): Promise<unknown>;
-}
-/**
- * MRGConfig reader — read-only data layer for agents.
- * Agents can read business data but cannot modify source systems.
- */
-export declare class MRGConfigReader implements DataSource {
-    readonly name = "mrg-config";
-    readonly type = "config";
-    private data;
-    constructor(initial?: Record<string, unknown>);
-    read(key: string): Promise<unknown>;
-    load(data: Record<string, unknown>): void;
-}
-//# sourceMappingURL=data.d.ts.map

package/dist/dtv/data.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MRGConfigReader = void 0;
-/**
- * MRGConfig reader — read-only data layer for agents.
- * Agents can read business data but cannot modify source systems.
- */
-class MRGConfigReader {
-    name = 'mrg-config';
-    type = 'config';
-    data;
-    constructor(initial) {
-        this.data = new Map(Object.entries(initial ?? {}));
-    }
-    async read(key) {
-        return this.data.get(key);
-    }
-    load(data) {
-        for (const [k, v] of Object.entries(data)) {
-            this.data.set(k, v);
-        }
-    }
-}
-exports.MRGConfigReader = MRGConfigReader;
-//# sourceMappingURL=data.js.map

package/dist/dtv/trust.d.ts

@@ -1,19 +0,0 @@
-import type { TrustLevelType } from '../schema/oad';
-/**
- * Trust levels: sandbox → verified → certified → listed
- *
- * - sandbox:   No network, no file system, limited capabilities
- * - verified:  Identity verified, basic capabilities
- * - certified: Passed security audit, full capabilities
- * - listed:    Published in OPC marketplace
- */
-export declare class TrustManager {
-    private level;
-    constructor(level?: TrustLevelType);
-    getLevel(): TrustLevelType;
-    canAccessNetwork(): boolean;
-    canAccessFileSystem(): boolean;
-    canPublish(): boolean;
-    upgrade(to: TrustLevelType): void;
-}
-//# sourceMappingURL=trust.d.ts.map

package/dist/dtv/trust.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrustManager = void 0;
-/**
- * Trust levels: sandbox → verified → certified → listed
- *
- * - sandbox:   No network, no file system, limited capabilities
- * - verified:  Identity verified, basic capabilities
- * - certified: Passed security audit, full capabilities
- * - listed:    Published in OPC marketplace
- */
-class TrustManager {
-    level;
-    constructor(level = 'sandbox') {
-        this.level = level;
-    }
-    getLevel() {
-        return this.level;
-    }
-    canAccessNetwork() {
-        return this.level !== 'sandbox';
-    }
-    canAccessFileSystem() {
-        return this.level === 'certified' || this.level === 'listed';
-    }
-    canPublish() {
-        return this.level === 'listed';
-    }
-    upgrade(to) {
-        const order = ['sandbox', 'verified', 'certified', 'listed'];
-        const currentIdx = order.indexOf(this.level);
-        const targetIdx = order.indexOf(to);
-        if (targetIdx <= currentIdx) {
-            throw new Error(`Cannot downgrade trust from ${this.level} to ${to}`);
-        }
-        this.level = to;
-    }
-}
-exports.TrustManager = TrustManager;
-//# sourceMappingURL=trust.js.map

package/dist/dtv/value.d.ts

@@ -1,23 +0,0 @@
-/**
- * Value tracking — metrics and ROI for agent operations.
- */
-export interface ValueMetric {
-    name: string;
-    value: number;
-    unit: string;
-    timestamp: number;
-}
-export declare class ValueTracker {
-    private metrics;
-    private trackedNames;
-    constructor(metricNames?: string[]);
-    record(name: string, value: number, unit?: string): void;
-    getMetrics(name: string): ValueMetric[];
-    getAverage(name: string): number;
-    getSummary(): Record<string, {
-        count: number;
-        average: number;
-        last: number;
-    }>;
-}
-//# sourceMappingURL=value.d.ts.map

package/dist/dtv/value.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueTracker = void 0;
-class ValueTracker {
-    metrics = new Map();
-    trackedNames;
-    constructor(metricNames = []) {
-        this.trackedNames = new Set(metricNames);
-    }
-    record(name, value, unit = '') {
-        if (!this.metrics.has(name)) {
-            this.metrics.set(name, []);
-        }
-        this.metrics.get(name).push({ name, value, unit, timestamp: Date.now() });
-    }
-    getMetrics(name) {
-        return this.metrics.get(name) ?? [];
-    }
-    getAverage(name) {
-        const m = this.getMetrics(name);
-        if (m.length === 0)
-            return 0;
-        return m.reduce((sum, v) => sum + v.value, 0) / m.length;
-    }
-    getSummary() {
-        const result = {};
-        for (const [name, values] of this.metrics) {
-            result[name] = {
-                count: values.length,
-                average: this.getAverage(name),
-                last: values[values.length - 1]?.value ?? 0,
-            };
-        }
-        return result;
-    }
-}
-exports.ValueTracker = ValueTracker;
-//# sourceMappingURL=value.js.map

package/dist/marketplace/index.d.ts

@@ -1,34 +0,0 @@
-export interface AgentManifest {
-    name: string;
-    version: string;
-    description: string;
-    author: string;
-    license: string;
-    oadVersion: string;
-    channels: string[];
-    skills: string[];
-    files: string[];
-    checksum: string;
-    publishedAt: string;
-    homepage?: string;
-    repository?: string;
-    tags?: string[];
-}
-export interface PublishOptions {
-    oadPath: string;
-    outputDir?: string;
-    includeKnowledge?: boolean;
-}
-export interface InstallOptions {
-    source: string;
-    targetDir?: string;
-}
-export declare function publishAgent(options: PublishOptions): Promise<{
-    archivePath: string;
-    manifest: AgentManifest;
-}>;
-export declare function installAgent(options: InstallOptions): Promise<{
-    dir: string;
-    manifest: AgentManifest;
-}>;
-//# sourceMappingURL=index.d.ts.map