opc-agent 2.1.0 → 3.0.1

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

package/dist/marketplace/index.js

@@ -1,202 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.publishAgent = publishAgent;
-exports.installAgent = installAgent;
-/**
- * Agent Marketplace - Package, publish, and install agents
- */
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const crypto = __importStar(require("crypto"));
-const child_process_1 = require("child_process");
-function computeChecksum(filePath) {
-    const content = fs.readFileSync(filePath);
-    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
-}
-async function publishAgent(options) {
-    const { oadPath, outputDir = '.', includeKnowledge = false } = options;
-    const absOad = path.resolve(oadPath);
-    const baseDir = path.dirname(absOad);
-    if (!fs.existsSync(absOad)) {
-        throw new Error(`OAD file not found: ${absOad}`);
-    }
-    // Dynamic import yaml
-    const yaml = await Promise.resolve().then(() => __importStar(require('js-yaml')));
-    const oadContent = fs.readFileSync(absOad, 'utf-8');
-    const oad = yaml.load(oadContent);
-    const name = oad.metadata?.name ?? 'unnamed-agent';
-    const version = oad.metadata?.version ?? '0.0.0';
-    const safeName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-    // Collect files to package
-    const filesToPack = [
-        { rel: path.basename(absOad), abs: absOad },
-    ];
-    // Include common files
-    const extras = ['.env.example', 'README.md', 'package.json'];
-    for (const f of extras) {
-        const fp = path.join(baseDir, f);
-        if (fs.existsSync(fp)) {
-            filesToPack.push({ rel: f, abs: fp });
-        }
-    }
-    // Include knowledge base if requested
-    if (includeKnowledge) {
-        const kbFile = path.join(baseDir, '.opc-knowledge.json');
-        if (fs.existsSync(kbFile)) {
-            filesToPack.push({ rel: '.opc-knowledge.json', abs: kbFile });
-        }
-    }
-    // Include prompts directory if exists
-    const promptsDir = path.join(baseDir, 'prompts');
-    if (fs.existsSync(promptsDir) && fs.statSync(promptsDir).isDirectory()) {
-        const promptFiles = fs.readdirSync(promptsDir);
-        for (const pf of promptFiles) {
-            filesToPack.push({ rel: `prompts/${pf}`, abs: path.join(promptsDir, pf) });
-        }
-    }
-    // Build manifest
-    const manifest = {
-        name: safeName,
-        version,
-        description: oad.metadata?.description ?? '',
-        author: oad.metadata?.author ?? '',
-        license: oad.metadata?.license ?? 'Apache-2.0',
-        oadVersion: 'opc/v1',
-        channels: (oad.spec?.channels ?? []).map((c) => c.type),
-        skills: (oad.spec?.skills ?? []).map((s) => s.name),
-        files: filesToPack.map(f => f.rel),
-        checksum: '',
-        publishedAt: new Date().toISOString(),
-        tags: oad.metadata?.marketplace?.tags,
-    };
-    // Create staging directory
-    const stageDir = path.join(outputDir, `.opc-stage-${safeName}`);
-    fs.mkdirSync(stageDir, { recursive: true });
-    for (const f of filesToPack) {
-        const dest = path.join(stageDir, f.rel);
-        fs.mkdirSync(path.dirname(dest), { recursive: true });
-        fs.copyFileSync(f.abs, dest);
-    }
-    // Write manifest
-    fs.writeFileSync(path.join(stageDir, 'opc-manifest.json'), JSON.stringify(manifest, null, 2));
-    // Create tar.gz
-    const archiveName = `${safeName}-${version}.tar.gz`;
-    const archivePath = path.join(outputDir, archiveName);
-    try {
-        (0, child_process_1.execSync)(`tar -czf "${archivePath}" -C "${stageDir}" .`, { stdio: 'pipe' });
-    }
-    catch {
-        // Fallback: just zip the directory content list
-        // On Windows without tar, create a simple zip-like package
-        const packageData = {
-            manifest,
-            files: filesToPack.map(f => ({
-                path: f.rel,
-                content: fs.readFileSync(f.abs, 'utf-8'),
-            })),
-        };
-        fs.writeFileSync(archivePath.replace('.tar.gz', '.opc.json'), JSON.stringify(packageData, null, 2));
-    }
-    // Compute checksum
-    if (fs.existsSync(archivePath)) {
-        manifest.checksum = computeChecksum(archivePath);
-    }
-    // Cleanup staging
-    fs.rmSync(stageDir, { recursive: true, force: true });
-    // Write final manifest
-    fs.writeFileSync(path.join(outputDir, 'opc-manifest.json'), JSON.stringify(manifest, null, 2));
-    return { archivePath: fs.existsSync(archivePath) ? archivePath : archivePath.replace('.tar.gz', '.opc.json'), manifest };
-}
-async function installAgent(options) {
-    const { source, targetDir } = options;
-    const absSource = path.resolve(source);
-    if (!fs.existsSync(absSource)) {
-        throw new Error(`Package not found: ${absSource}`);
-    }
-    let manifest;
-    let installDir;
-    if (absSource.endsWith('.opc.json')) {
-        // JSON package format
-        const pkg = JSON.parse(fs.readFileSync(absSource, 'utf-8'));
-        manifest = pkg.manifest;
-        installDir = targetDir ?? path.join('.', manifest.name);
-        fs.mkdirSync(installDir, { recursive: true });
-        for (const f of pkg.files) {
-            const dest = path.join(installDir, f.path);
-            fs.mkdirSync(path.dirname(dest), { recursive: true });
-            fs.writeFileSync(dest, f.content, 'utf-8');
-        }
-        fs.writeFileSync(path.join(installDir, 'opc-manifest.json'), JSON.stringify(manifest, null, 2));
-    }
-    else {
-        // tar.gz format
-        const tmpDir = path.join(path.dirname(absSource), '.opc-extract-tmp');
-        fs.mkdirSync(tmpDir, { recursive: true });
-        try {
-            (0, child_process_1.execSync)(`tar -xzf "${absSource}" -C "${tmpDir}"`, { stdio: 'pipe' });
-        }
-        catch {
-            throw new Error('Failed to extract package. Ensure tar is available.');
-        }
-        const manifestPath = path.join(tmpDir, 'opc-manifest.json');
-        if (!fs.existsSync(manifestPath)) {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-            throw new Error('Invalid package: missing opc-manifest.json');
-        }
-        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-        installDir = targetDir ?? path.join('.', manifest.name);
-        // Move files
-        fs.mkdirSync(installDir, { recursive: true });
-        const copyRecursive = (src, dest) => {
-            const entries = fs.readdirSync(src, { withFileTypes: true });
-            for (const entry of entries) {
-                const srcPath = path.join(src, entry.name);
-                const destPath = path.join(dest, entry.name);
-                if (entry.isDirectory()) {
-                    fs.mkdirSync(destPath, { recursive: true });
-                    copyRecursive(srcPath, destPath);
-                }
-                else {
-                    fs.copyFileSync(srcPath, destPath);
-                }
-            }
-        };
-        copyRecursive(tmpDir, installDir);
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-    return { dir: installDir, manifest };
-}
-//# sourceMappingURL=index.js.map