opc-agent 4.1.1 → 4.1.3

package/tests/v090-features.test.ts

@@ -1,254 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { DingTalkChannel } from '../src/channels/dingtalk';
-import { MattermostChannel } from '../src/channels/mattermost';
-import { GoogleChatChannel } from '../src/channels/googlechat';
-import { TwitchChannel } from '../src/channels/twitch';
-import { IRCChannel } from '../src/channels/irc';
-import { ContextDiscovery } from '../src/core/context-discovery';
-import { SessionManager } from '../src/core/session-manager';
-import { HeartbeatManager } from '../src/core/heartbeat';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-// ── Channel Tests (10) ──
-
-describe('DingTalkChannel', () => {
-  it('should require webhookUrl', () => {
-    expect(() => new DingTalkChannel({ webhookUrl: '' })).toThrow('webhookUrl');
-  });
-  it('should throw when sending before start', async () => {
-    const ch = new DingTalkChannel({ webhookUrl: 'https://example.com/hook' });
-    await expect(ch.send('chat', 'hi')).rejects.toThrow('not started');
-  });
-});
-
-describe('MattermostChannel', () => {
-  it('should require serverUrl and token', () => {
-    expect(() => new MattermostChannel({ serverUrl: '', token: '' })).toThrow('serverUrl');
-  });
-  it('should throw when sending before start', async () => {
-    const ch = new MattermostChannel({ serverUrl: 'https://mm.example.com', token: 'tok' });
-    await expect(ch.send('ch1', 'hi')).rejects.toThrow('not started');
-  });
-});
-
-describe('GoogleChatChannel', () => {
-  it('should require webhookUrl', () => {
-    expect(() => new GoogleChatChannel({ webhookUrl: '' })).toThrow('webhookUrl');
-  });
-  it('should throw when sending before start', async () => {
-    const ch = new GoogleChatChannel({ webhookUrl: 'https://chat.googleapis.com/v1/spaces/x/messages?key=y' });
-    await expect(ch.send('space', 'hi')).rejects.toThrow('not started');
-  });
-});
-
-describe('TwitchChannel', () => {
-  it('should require username, oauthToken, channels', () => {
-    expect(() => new TwitchChannel({ username: '', oauthToken: '', channels: [] })).toThrow('username');
-  });
-  it('should throw when starting without tmi.js', async () => {
-    const ch = new TwitchChannel({ username: 'bot', oauthToken: 'oauth:xxx', channels: ['#test'] });
-    await expect(ch.start()).rejects.toThrow('tmi.js');
-  });
-});
-
-describe('IRCChannel', () => {
-  it('should require host, nick, channels', () => {
-    expect(() => new IRCChannel({ host: '', nick: '', channels: [] })).toThrow('host');
-  });
-  it('should throw when starting without irc-framework', async () => {
-    const ch = new IRCChannel({ host: 'irc.libera.chat', nick: 'bot', channels: ['#test'] });
-    await expect(ch.start()).rejects.toThrow('irc-framework');
-  });
-});
-
-// ── Context Discovery Tests (8) ──
-
-describe('ContextDiscovery', () => {
-  let tmpDir: string;
-  let cd: ContextDiscovery;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ctx-'));
-    cd = new ContextDiscovery();
-  });
-
-  afterEach(() => {
-    cd.stopWatching();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('should discover AGENTS.md', () => {
-    fs.writeFileSync(path.join(tmpDir, 'AGENTS.md'), '# Agents');
-    const files = cd.discover(tmpDir);
-    expect(files.length).toBe(1);
-    expect(files[0].type).toBe('agents');
-  });
-
-  it('should discover multiple standard files', () => {
-    fs.writeFileSync(path.join(tmpDir, 'SOUL.md'), '# Soul');
-    fs.writeFileSync(path.join(tmpDir, 'USER.md'), '# User');
-    const files = cd.discover(tmpDir);
-    expect(files.length).toBe(2);
-  });
-
-  it('should return empty for no context files', () => {
-    expect(cd.discover(tmpDir)).toEqual([]);
-  });
-
-  it('should load and merge files into prompt', () => {
-    fs.writeFileSync(path.join(tmpDir, 'SOUL.md'), 'Be nice');
-    fs.writeFileSync(path.join(tmpDir, 'TOOLS.md'), 'Use web');
-    const files = cd.discover(tmpDir);
-    const prompt = cd.load(files);
-    expect(prompt).toContain('Be nice');
-    expect(prompt).toContain('Use web');
-  });
-
-  it('should add and discover custom files', () => {
-    const customPath = path.join(tmpDir, 'CUSTOM.md');
-    fs.writeFileSync(customPath, '# Custom');
-    cd.addCustomFile(customPath);
-    const files = cd.discover(tmpDir);
-    expect(files.some(f => f.type === 'custom' && f.content.includes('Custom'))).toBe(true);
-  });
-
-  it('should not duplicate custom files', () => {
-    cd.addCustomFile('test.md');
-    cd.addCustomFile('test.md');
-    // Internal check - discover won't find it but custom list should have 1
-    expect(cd.discover(tmpDir).filter(f => f.path.includes('test.md')).length).toBeLessThanOrEqual(1);
-  });
-
-  it('should assign correct types', () => {
-    fs.writeFileSync(path.join(tmpDir, 'MEMORY.md'), 'mem');
-    fs.writeFileSync(path.join(tmpDir, 'IDENTITY.md'), 'id');
-    const files = cd.discover(tmpDir);
-    expect(files.find(f => f.type === 'memory')).toBeTruthy();
-    expect(files.find(f => f.type === 'identity')).toBeTruthy();
-  });
-
-  it('should handle watch without errors', () => {
-    // Just ensure no throw
-    cd.watch(tmpDir, () => {});
-    cd.stopWatching();
-  });
-});
-
-// ── Session Manager Tests (8) ──
-
-describe('SessionManager', () => {
-  let sm: SessionManager;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sess-'));
-    sm = new SessionManager(tmpDir);
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('should create a session', () => {
-    const s = sm.create('agent1', 'telegram');
-    expect(s.id).toBeTruthy();
-    expect(s.agentId).toBe('agent1');
-  });
-
-  it('should get a session by id', () => {
-    const s = sm.create('agent1', 'telegram');
-    expect(sm.get(s.id)).toEqual(s);
-    expect(sm.get('nonexistent')).toBeNull();
-  });
-
-  it('should add messages', () => {
-    const s = sm.create('a', 'c');
-    sm.addMessage(s.id, { id: '1', role: 'user', content: 'hi', timestamp: Date.now() });
-    expect(sm.get(s.id)!.messages.length).toBe(1);
-  });
-
-  it('should list with filters', () => {
-    sm.create('a1', 'telegram');
-    sm.create('a2', 'discord');
-    expect(sm.list({ agentId: 'a1' }).length).toBe(1);
-    expect(sm.list({ channel: 'discord' }).length).toBe(1);
-  });
-
-  it('should compact sessions', async () => {
-    const s = sm.create('a', 'c');
-    for (let i = 0; i < 15; i++) {
-      sm.addMessage(s.id, { id: `${i}`, role: 'user', content: `msg ${i}`, timestamp: Date.now() });
-    }
-    await sm.compact(s.id);
-    expect(sm.get(s.id)!.messages.length).toBeLessThan(15);
-    expect(sm.get(s.id)!.compactedAt).toBeTruthy();
-  });
-
-  it('should prune old sessions', () => {
-    const s = sm.create('a', 'c');
-    // Manually set old lastActivity
-    (sm.get(s.id) as any).lastActivity = Date.now() - 999999;
-    expect(sm.prune(1000)).toBe(1);
-  });
-
-  it('should fork and get lineage', () => {
-    const parent = sm.create('a', 'c');
-    const child = sm.fork(parent.id);
-    expect(child.parentId).toBe(parent.id);
-    const lineage = sm.getLineage(child.id);
-    expect(lineage.length).toBe(2);
-    expect(lineage[0].id).toBe(parent.id);
-  });
-
-  it('should export as markdown and save/load', () => {
-    const s = sm.create('a', 'c');
-    sm.addMessage(s.id, { id: '1', role: 'user', content: 'hello', timestamp: Date.now() });
-    const md = sm.export(s.id);
-    expect(md).toContain('hello');
-    sm.save();
-    const sm2 = new SessionManager(tmpDir);
-    sm2.load();
-    expect(sm2.get(s.id)).toBeTruthy();
-  });
-});
-
-// ── Heartbeat Tests (4) ──
-
-describe('HeartbeatManager', () => {
-  it('should require valid config', () => {
-    expect(() => new HeartbeatManager({ interval: 0, checkFn: async () => 'ok' })).toThrow('interval');
-    expect(() => new HeartbeatManager({ interval: 1000, checkFn: null as any })).toThrow('checkFn');
-  });
-
-  it('should start and stop', () => {
-    const hb = new HeartbeatManager({ interval: 100, checkFn: async () => 'ok' });
-    hb.start();
-    hb.stop();
-    // Double stop should be safe
-    hb.stop();
-  });
-
-  it('should fire callbacks on beat', async () => {
-    const hb = new HeartbeatManager({ interval: 100, checkFn: async () => 'alive' });
-    const statuses: string[] = [];
-    hb.onBeat(s => statuses.push(s));
-    hb.start();
-    await new Promise(r => setTimeout(r, 350));
-    hb.stop();
-    expect(statuses.length).toBeGreaterThanOrEqual(2);
-    expect(statuses[0]).toBe('alive');
-  });
-
-  it('should report last beat', async () => {
-    const hb = new HeartbeatManager({ interval: 100, checkFn: async () => 'ok' });
-    expect(hb.getLastBeat()).toBeNull();
-    hb.start();
-    await new Promise(r => setTimeout(r, 200));
-    hb.stop();
-    const beat = hb.getLastBeat();
-    expect(beat).toBeTruthy();
-    expect(beat!.status).toBe('ok');
-  });
-});

package/tests/versioning.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { VersionManager } from '../src/core/versioning';
-import * as fs from 'fs';
-
-const TEST_STORE = '.test-versions.json';
-
-describe('VersionManager', () => {
-  let vm: VersionManager;
-
-  beforeEach(() => {
-    if (fs.existsSync(TEST_STORE)) fs.unlinkSync(TEST_STORE);
-    vm = new VersionManager(TEST_STORE);
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(TEST_STORE)) fs.unlinkSync(TEST_STORE);
-  });
-
-  it('should save and list versions', () => {
-    vm.snapshot('1.0.0', 'yaml-content-1', 'Initial');
-    vm.snapshot('1.1.0', 'yaml-content-2', 'Update');
-    const versions = vm.list();
-    expect(versions).toHaveLength(2);
-    expect(versions[0].version).toBe('1.0.0');
-  });
-
-  it('should get specific version', () => {
-    vm.snapshot('1.0.0', 'content', 'Test');
-    expect(vm.get('1.0.0')).toBeDefined();
-    expect(vm.get('9.9.9')).toBeUndefined();
-  });
-
-  it('should get current version', () => {
-    vm.snapshot('1.0.0', 'v1');
-    vm.snapshot('2.0.0', 'v2');
-    expect(vm.getCurrent()?.version).toBe('2.0.0');
-  });
-
-  it('should rollback to version', () => {
-    vm.snapshot('1.0.0', 'old-yaml');
-    vm.snapshot('2.0.0', 'new-yaml');
-    const rolled = vm.rollback('1.0.0');
-    expect(rolled).toBe('old-yaml');
-  });
-
-  it('should return null for unknown rollback', () => {
-    expect(vm.rollback('9.9.9')).toBeNull();
-  });
-
-  it('should run migrations', () => {
-    vm.registerMigration({
-      fromVersion: '1.0.0',
-      toVersion: '2.0.0',
-      migrate: (oad) => ({ ...oad, upgraded: true }),
-    });
-    const result = vm.migrate({ data: 'test' }, '1.0.0', '2.0.0');
-    expect((result as any).upgraded).toBe(true);
-  });
-
-  it('should throw on missing migration path', () => {
-    expect(() => vm.migrate({}, '1.0.0', '5.0.0')).toThrow('No migration path');
-  });
-
-  it('should clear all versions', () => {
-    vm.snapshot('1.0.0', 'content');
-    vm.clear();
-    expect(vm.list()).toHaveLength(0);
-  });
-
-  it('should persist to file', () => {
-    vm.snapshot('1.0.0', 'persisted');
-    const vm2 = new VersionManager(TEST_STORE);
-    expect(vm2.list()).toHaveLength(1);
-  });
-});

package/tests/vision.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { VisionManager, detectMimeType } from '../src/core/vision';
-import type { ImageInput, VisionResult } from '../src/core/vision';
-
-describe('VisionManager', () => {
-  it('should create VisionManager with defaults', () => {
-    const vm = new VisionManager();
-    expect(vm).toBeDefined();
-  });
-
-  it('should create VisionManager with custom config', () => {
-    const vm = new VisionManager({ model: 'gpt-4o-mini', maxImageSize: 5 * 1024 * 1024 });
-    expect(vm).toBeDefined();
-  });
-
-  it('should detect PNG mime type', () => {
-    const buf = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
-    expect(detectMimeType(buf)).toBe('image/png');
-  });
-
-  it('should detect JPEG mime type', () => {
-    const buf = Buffer.from([0xFF, 0xD8, 0xFF, 0xE0]);
-    expect(detectMimeType(buf)).toBe('image/jpeg');
-  });
-
-  it('should detect GIF mime type', () => {
-    const buf = Buffer.from([0x47, 0x49, 0x46, 0x38, 0x39, 0x61]);
-    expect(detectMimeType(buf)).toBe('image/gif');
-  });
-
-  it('should detect WebP mime type', () => {
-    const buf = Buffer.from([0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00]);
-    expect(detectMimeType(buf)).toBe('image/webp');
-  });
-
-  it('should return octet-stream for unknown', () => {
-    const buf = Buffer.from([0x00, 0x01, 0x02]);
-    expect(detectMimeType(buf)).toBe('application/octet-stream');
-  });
-
-  it('should prepare multimodal message with URL images', () => {
-    const vm = new VisionManager();
-    const images: ImageInput[] = [{ type: 'url', data: 'https://example.com/img.png' }];
-    const msgs = vm.prepareMessage(images, 'Describe this');
-    expect(msgs).toHaveLength(1);
-    expect((msgs[0] as any).content).toHaveLength(2);
-    expect((msgs[0] as any).content[0].type).toBe('text');
-    expect((msgs[0] as any).content[1].type).toBe('image_url');
-  });
-
-  it('should throw on analyze without API key', async () => {
-    const vm = new VisionManager({ apiKey: '' });
-    const input: ImageInput = { type: 'url', data: 'https://example.com/img.png' };
-    await expect(vm.analyze(input)).rejects.toThrow('Vision API key not configured');
-  });
-
-  it('should throw on compareImages with less than 2 images', async () => {
-    const vm = new VisionManager({ apiKey: 'test' });
-    await expect(vm.compareImages([{ type: 'url', data: 'https://example.com/1.png' }])).rejects.toThrow('at least 2');
-  });
-});

package/tests/voice-call.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { VoiceCallManager } from '../src/channels/voice-call';
-
-describe('VoiceCallManager', () => {
-  it('should create with config', () => {
-    const mgr = new VoiceCallManager({ provider: 'twilio', credentials: { sid: 'x', token: 'y' } });
-    expect(mgr).toBeInstanceOf(VoiceCallManager);
-  });
-
-  it('should throw without credentials on startCall', async () => {
-    const mgr = new VoiceCallManager({ provider: 'twilio' });
-    await expect(mgr.startCall('+1234')).rejects.toThrow('credentials');
-  });
-
-  it('should start and end a call', async () => {
-    const mgr = new VoiceCallManager({ provider: 'webrtc', credentials: { key: 'val' } });
-    const callId = await mgr.startCall('+1234');
-    expect(callId).toBeTruthy();
-    expect(mgr.getCallStatus(callId)).toBe('ringing');
-    await mgr.endCall(callId);
-    expect(mgr.getCallStatus(callId)).toBe('ended');
-  });
-
-  it('should handle incoming calls', async () => {
-    const mgr = new VoiceCallManager({ provider: 'sip', credentials: { key: 'val' } });
-    const result = await new Promise<{ callId: string; from: string }>((resolve) => {
-      mgr.onIncoming((callId, from) => resolve({ callId, from }));
-      mgr.simulateIncoming('+5678');
-    });
-    expect(result.callId).toBeTruthy();
-    expect(result.from).toBe('+5678');
-  });
-
-  it('should list active calls', async () => {
-    const mgr = new VoiceCallManager({ provider: 'twilio', credentials: { sid: 'x', token: 'y' } });
-    const id1 = await mgr.startCall('+111');
-    const id2 = await mgr.startCall('+222');
-    expect(mgr.listActiveCalls().length).toBe(2);
-    await mgr.endCall(id1);
-    expect(mgr.listActiveCalls().length).toBe(1);
-  });
-
-  it('should throw on unknown callId', () => {
-    const mgr = new VoiceCallManager({ provider: 'twilio', credentials: { sid: 'x' } });
-    expect(() => mgr.getCallStatus('unknown')).toThrow('not found');
-  });
-});

package/tests/voice-enhanced.test.ts

@@ -1,169 +0,0 @@
-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/tests/voice-interaction.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-/**
- * Voice interaction tests — browser-only APIs (Web Speech API).
- * These tests verify the integration logic rather than the browser APIs themselves.
- */
-describe('Voice Interaction', () => {
-  it('should define voice feature flags', () => {
-    // In a browser context, these would be available
-    // Here we just verify our integration assumptions
-    expect(typeof globalThis).toBe('object');
-  });
-
-  it('should handle missing SpeechRecognition gracefully', () => {
-    // Simulate no SpeechRecognition API
-    const SpeechRecognition = (globalThis as any).SpeechRecognition || (globalThis as any).webkitSpeechRecognition;
-    expect(SpeechRecognition).toBeUndefined(); // Not available in Node
-  });
-
-  it('should handle missing speechSynthesis gracefully', () => {
-    const synth = (globalThis as any).speechSynthesis;
-    expect(synth).toBeUndefined(); // Not available in Node
-  });
-});
-
-describe('Voice TTS button injection', () => {
-  it('should create a button element with correct attributes', () => {
-    // Simulate DOM creation logic
-    const btn = {
-      className: 'tts-btn',
-      textContent: '🔊',
-      title: 'Read aloud',
-    };
-    expect(btn.className).toBe('tts-btn');
-    expect(btn.textContent).toBe('🔊');
-    expect(btn.title).toBe('Read aloud');
-  });
-});