@framers/agentos-ext-voice-synthesis 2.0.0 → 2.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@framers/agentos-ext-voice-synthesis",
-  "version": "2.0.0",
-  "description": "Multi-provider text-to-speech synthesis tool for AgentOS via OpenAI, ElevenLabs, and local Ollama-compatible runtimes",
+  "version": "2.1.0",
+  "description": "Voice synthesis and transcription tools for AgentOS via OpenAI, ElevenLabs, Deepgram, and local Ollama/Whisper-compatible runtimes",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -18,10 +18,14 @@
     "agentos",
     "extension",
     "tts",
+    "stt",
     "voice",
+    "transcription",
     "openai",
     "elevenlabs",
+    "deepgram",
     "ollama",
+    "whisper",
     "speech",
     "media"
   ],
@@ -40,29 +44,37 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/framersai/agentos-extensions.git",
+    "url": "git+https://github.com/framerslab/agentos-extensions.git",
     "directory": "registry/curated/media/voice-synthesis"
   },
   "publishConfig": {
     "access": "public"
   },
   "peerDependencies": {
-    "@framers/agentos": "^0.1.0"
+    "@framers/agentos": ">=0.10.40"
   },
   "devDependencies": {
-    "@framers/agentos": "^0.1.0",
     "@types/node": "^20.12.12",
-    "@vitest/coverage-v8": "^1.6.0",
+    "@vitest/coverage-v8": "^3.2.7",
     "rimraf": "^5.0.7",
     "typescript": "^5.4.5",
-    "vitest": "^1.6.0"
+    "vitest": "^3.2.7",
+    "@framers/agentos": "^0.10.40"
   },
+  "homepage": "https://github.com/framerslab/agentos-extensions/tree/master/registry/curated/media/voice-synthesis#readme",
+  "bugs": {
+    "url": "https://github.com/framerslab/agentos-extensions/issues"
+  },
+  "files": [
+    "dist",
+    "manifest.json",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc",
-    "test": "vitest run",
+    "test": "vitest run --passWithNoTests",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src --ext .ts",
     "typecheck": "tsc --noEmit",
     "clean": "rimraf dist"
   }

package/src/index.ts

@@ -1,61 +0,0 @@
-/**
- * Voice Synthesis Extension Pack — multi-provider TTS for agents.
- *
- * Supports: OpenAI TTS, ElevenLabs, Ollama (local).
- * Auto-detects available provider from API keys.
- */
-
-import { TextToSpeechTool, type TTSConfig, type TTSProvider } from './tools/textToSpeech.js';
-
-export interface VoiceSynthesisExtensionOptions {
-  elevenLabsApiKey?: string;
-  openaiApiKey?: string;
-  openaiBaseUrl?: string;
-  ollamaBaseUrl?: string;
-  defaultProvider?: TTSProvider;
-  priority?: number;
-}
-
-export function createExtensionPack(context: any) {
-  const options = (context.options || {}) as VoiceSynthesisExtensionOptions;
-
-  const config: TTSConfig = {
-    openaiApiKey: options.openaiApiKey || context.getSecret?.('openai.apiKey') || process.env.OPENAI_API_KEY,
-    openaiBaseUrl: options.openaiBaseUrl || process.env.OPENAI_BASE_URL,
-    elevenLabsApiKey: options.elevenLabsApiKey || context.getSecret?.('elevenlabs.apiKey') || process.env.ELEVENLABS_API_KEY,
-    ollamaBaseUrl: options.ollamaBaseUrl || process.env.OLLAMA_BASE_URL,
-    defaultProvider: options.defaultProvider || (process.env.TTS_PROVIDER as TTSProvider) || 'auto',
-  };
-
-  const tool = new TextToSpeechTool(config);
-
-  // Determine which providers are available for the activation message
-  const providers: string[] = [];
-  if (config.openaiApiKey) providers.push('OpenAI');
-  if (config.elevenLabsApiKey) providers.push('ElevenLabs');
-  providers.push('Ollama (local fallback)');
-
-  return {
-    name: '@framers/agentos-ext-voice-synthesis',
-    version: '2.0.0',
-    descriptors: [
-      {
-        id: tool.name,
-        kind: 'tool' as const,
-        priority: options.priority || 50,
-        payload: tool,
-        requiredSecrets: [],
-      },
-    ],
-    onActivate: async () => {
-      context.logger?.info?.(`Voice Synthesis activated — providers: ${providers.join(', ')}`);
-    },
-    onDeactivate: async () => {
-      context.logger?.info?.('Voice Synthesis deactivated');
-    },
-  };
-}
-
-export { TextToSpeechTool };
-export type { TTSInput, TTSOutput, TTSConfig, TTSProvider } from './tools/textToSpeech.js';
-export default createExtensionPack;

package/src/tools/textToSpeech.ts

@@ -1,287 +0,0 @@
-/**
- * Multi-provider TTS Tool — text-to-speech synthesis.
- *
- * Supports: OpenAI TTS, ElevenLabs, Ollama (local), any OpenAI-compatible TTS API.
- * Auto-detects available provider from API keys in environment.
- */
-
-import type { ITool, ToolExecutionContext, ToolExecutionResult, JSONSchemaObject } from '@framers/agentos';
-
-export type TTSProvider = 'openai' | 'elevenlabs' | 'ollama' | 'auto';
-
-export interface TTSInput {
-  text: string;
-  voice?: string;
-  model?: string;
-  provider?: TTSProvider;
-  /** ElevenLabs-specific */
-  stability?: number;
-  /** ElevenLabs-specific */
-  similarity_boost?: number;
-  /** OpenAI-specific: speed 0.25-4.0 */
-  speed?: number;
-  /** Output format: mp3, opus, aac, flac, wav */
-  format?: string;
-}
-
-export interface TTSOutput {
-  text: string;
-  voice: string;
-  model: string;
-  provider: string;
-  audioBase64: string;
-  contentType: string;
-  durationEstimateMs: number;
-}
-
-// ── ElevenLabs voice name → ID mapping ──
-const ELEVENLABS_VOICES: Record<string, string> = {
-  rachel: '21m00Tcm4TlvDq8ikWAM',
-  domi: 'AZnzlk1XvdvUeBnXmlld',
-  bella: 'EXAVITQu4vr4xnSDxMaL',
-  antoni: 'ErXwobaYiN019PkySvjV',
-  josh: 'TxGEqnHWrfWFTfGW9XjX',
-  arnold: 'VR6AewLTigWG4xSOukaG',
-  adam: 'pNInz6obpgDQGcFmaJgB',
-  sam: 'yoZ06aMxZJJ28mfd3POQ',
-};
-
-// ── OpenAI voice options ──
-const OPENAI_VOICES = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'];
-
-export interface TTSConfig {
-  openaiApiKey?: string;
-  openaiBaseUrl?: string;
-  elevenLabsApiKey?: string;
-  ollamaBaseUrl?: string;
-  defaultProvider?: TTSProvider;
-}
-
-export class TextToSpeechTool implements ITool<TTSInput, TTSOutput> {
-  readonly id = 'tts-multi-provider-v1';
-  readonly name = 'text_to_speech';
-  readonly displayName = 'Text to Speech';
-  readonly description =
-    'Convert text to speech audio. Supports multiple providers: OpenAI TTS (alloy/echo/fable/onyx/nova/shimmer), ' +
-    'ElevenLabs (rachel/domi/bella/antoni/josh/arnold/adam/sam), or local Ollama TTS. ' +
-    'Auto-detects available provider from API keys. Returns base64-encoded audio.';
-  readonly category = 'media';
-  readonly version = '2.0.0';
-  readonly hasSideEffects = false;
-
-  readonly inputSchema: JSONSchemaObject = {
-    type: 'object',
-    properties: {
-      text: { type: 'string', description: 'Text to convert to speech. Max 5000 chars.' },
-      voice: {
-        type: 'string',
-        description:
-          'Voice name. OpenAI: alloy, echo, fable, onyx, nova (default), shimmer. ' +
-          'ElevenLabs: rachel (default), domi, bella, antoni, josh, arnold, adam, sam. ' +
-          'Or a custom voice ID.',
-      },
-      model: {
-        type: 'string',
-        description: 'TTS model. OpenAI: tts-1 (default), tts-1-hd. ElevenLabs: eleven_monolingual_v1 (default), eleven_multilingual_v2.',
-      },
-      provider: {
-        type: 'string',
-        enum: ['openai', 'elevenlabs', 'ollama', 'auto'],
-        description: 'TTS provider. Default: auto (detects from available API keys).',
-      },
-      speed: { type: 'number', minimum: 0.25, maximum: 4.0, description: 'OpenAI speed multiplier (0.25-4.0).' },
-      stability: { type: 'number', minimum: 0, maximum: 1, description: 'ElevenLabs voice stability (0-1).' },
-      similarity_boost: { type: 'number', minimum: 0, maximum: 1, description: 'ElevenLabs similarity boost (0-1).' },
-      format: { type: 'string', enum: ['mp3', 'opus', 'aac', 'flac', 'wav'], description: 'Output audio format.' },
-    },
-    required: ['text'],
-  };
-
-  readonly requiredCapabilities = ['capability:tts'];
-
-  private config: TTSConfig;
-
-  constructor(config?: TTSConfig) {
-    this.config = {
-      openaiApiKey: config?.openaiApiKey || process.env.OPENAI_API_KEY || '',
-      openaiBaseUrl: config?.openaiBaseUrl || process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1',
-      elevenLabsApiKey: config?.elevenLabsApiKey || process.env.ELEVENLABS_API_KEY || '',
-      ollamaBaseUrl: config?.ollamaBaseUrl || process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
-      defaultProvider: config?.defaultProvider || (process.env.TTS_PROVIDER as TTSProvider) || 'auto',
-    };
-  }
-
-  private resolveProvider(requested?: TTSProvider): TTSProvider | null {
-    const pref = requested || this.config.defaultProvider || 'auto';
-    if (pref !== 'auto') {
-      // Verify the requested provider has credentials
-      if (pref === 'openai' && this.config.openaiApiKey) return 'openai';
-      if (pref === 'elevenlabs' && this.config.elevenLabsApiKey) return 'elevenlabs';
-      if (pref === 'ollama') return 'ollama';
-      // Fall through to auto if requested provider isn't configured
-    }
-
-    // Auto-detect: prefer OpenAI (cheaper, faster), then ElevenLabs, then Ollama
-    if (this.config.openaiApiKey) return 'openai';
-    if (this.config.elevenLabsApiKey) return 'elevenlabs';
-    return 'ollama'; // Local fallback — may or may not have TTS model
-  }
-
-  async execute(args: TTSInput, _context: ToolExecutionContext): Promise<ToolExecutionResult<TTSOutput>> {
-    const text = args.text.slice(0, 5000);
-    const provider = this.resolveProvider(args.provider);
-
-    if (!provider) {
-      return {
-        success: false,
-        error:
-          'No TTS provider available. Set one of: OPENAI_API_KEY, ELEVENLABS_API_KEY, or configure Ollama with a TTS model. ' +
-          'Get an OpenAI key at https://platform.openai.com/api-keys or ElevenLabs at https://elevenlabs.io',
-      };
-    }
-
-    try {
-      switch (provider) {
-        case 'openai':
-          return await this.synthesizeOpenAI(text, args);
-        case 'elevenlabs':
-          return await this.synthesizeElevenLabs(text, args);
-        case 'ollama':
-          return await this.synthesizeOllama(text, args);
-        default:
-          return { success: false, error: `Unknown TTS provider: ${provider}` };
-      }
-    } catch (err: any) {
-      return { success: false, error: `TTS failed (${provider}): ${err.message}` };
-    }
-  }
-
-  // ── OpenAI TTS ──
-
-  private async synthesizeOpenAI(text: string, args: TTSInput): Promise<ToolExecutionResult<TTSOutput>> {
-    const voice = args.voice && OPENAI_VOICES.includes(args.voice) ? args.voice : 'nova';
-    const model = args.model || 'tts-1';
-    const format = args.format || 'mp3';
-
-    const response = await fetch(`${this.config.openaiBaseUrl}/audio/speech`, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${this.config.openaiApiKey}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        model,
-        voice,
-        input: text,
-        response_format: format,
-        speed: args.speed,
-      }),
-    });
-
-    if (!response.ok) {
-      const err = await response.text();
-      return { success: false, error: `OpenAI TTS error (${response.status}): ${err.slice(0, 300)}` };
-    }
-
-    const buf = await response.arrayBuffer();
-    const audioBase64 = Buffer.from(buf).toString('base64');
-    const contentType = format === 'opus' ? 'audio/opus' : format === 'wav' ? 'audio/wav' : 'audio/mpeg';
-    const durationEstimateMs = Math.round((text.split(/\s+/).length / 150) * 60 * 1000);
-
-    return {
-      success: true,
-      output: { text, voice, model, provider: 'openai', audioBase64, contentType, durationEstimateMs },
-      contentType,
-    };
-  }
-
-  // ── ElevenLabs TTS ──
-
-  private async synthesizeElevenLabs(text: string, args: TTSInput): Promise<ToolExecutionResult<TTSOutput>> {
-    const voiceId = ELEVENLABS_VOICES[(args.voice || 'rachel').toLowerCase()] || args.voice || ELEVENLABS_VOICES.rachel;
-    const model = args.model || 'eleven_monolingual_v1';
-
-    const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`, {
-      method: 'POST',
-      headers: {
-        'xi-api-key': this.config.elevenLabsApiKey!,
-        'Content-Type': 'application/json',
-        Accept: 'audio/mpeg',
-      },
-      body: JSON.stringify({
-        text,
-        model_id: model,
-        voice_settings: {
-          stability: args.stability ?? 0.5,
-          similarity_boost: args.similarity_boost ?? 0.75,
-        },
-      }),
-    });
-
-    if (!response.ok) {
-      const err = await response.text();
-      return { success: false, error: `ElevenLabs error (${response.status}): ${err.slice(0, 300)}` };
-    }
-
-    const buf = await response.arrayBuffer();
-    const audioBase64 = Buffer.from(buf).toString('base64');
-    const durationEstimateMs = Math.round((text.split(/\s+/).length / 150) * 60 * 1000);
-
-    return {
-      success: true,
-      output: {
-        text,
-        voice: args.voice || 'rachel',
-        model,
-        provider: 'elevenlabs',
-        audioBase64,
-        contentType: 'audio/mpeg',
-        durationEstimateMs,
-      },
-      contentType: 'audio/mpeg',
-    };
-  }
-
-  // ── Ollama TTS (local, experimental) ──
-
-  private async synthesizeOllama(text: string, args: TTSInput): Promise<ToolExecutionResult<TTSOutput>> {
-    // Ollama doesn't natively support TTS yet, but some models (e.g., bark, piper)
-    // can be served via OpenAI-compatible endpoints. Try the OpenAI-compat path.
-    const voice = args.voice || 'default';
-    const model = args.model || 'tts'; // User must have a TTS model loaded
-
-    try {
-      const response = await fetch(`${this.config.ollamaBaseUrl}/v1/audio/speech`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ model, voice, input: text }),
-      });
-
-      if (!response.ok) {
-        return {
-          success: false,
-          error:
-            `Ollama TTS not available (${response.status}). Ollama doesn't natively support TTS yet. ` +
-            'Set OPENAI_API_KEY or ELEVENLABS_API_KEY for cloud TTS, or use a dedicated local TTS server.',
-        };
-      }
-
-      const buf = await response.arrayBuffer();
-      const audioBase64 = Buffer.from(buf).toString('base64');
-      const durationEstimateMs = Math.round((text.split(/\s+/).length / 150) * 60 * 1000);
-
-      return {
-        success: true,
-        output: { text, voice, model, provider: 'ollama', audioBase64, contentType: 'audio/mpeg', durationEstimateMs },
-        contentType: 'audio/mpeg',
-      };
-    } catch {
-      return {
-        success: false,
-        error:
-          'Ollama TTS endpoint not reachable. Ollama doesn\'t natively support TTS yet. ' +
-          'Set OPENAI_API_KEY or ELEVENLABS_API_KEY for cloud TTS.',
-      };
-    }
-  }
-}

package/test/textToSpeech.spec.ts

@@ -1,189 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-
-// Clear env vars that affect provider detection
-const savedEnv: Record<string, string | undefined> = {};
-const envKeys = ['OPENAI_API_KEY', 'ELEVENLABS_API_KEY', 'OPENAI_BASE_URL', 'OLLAMA_BASE_URL', 'TTS_PROVIDER'];
-
-const { TextToSpeechTool } = await import('../src/tools/textToSpeech.js');
-const { createExtensionPack } = await import('../src/index.js');
-
-describe('TextToSpeechTool', () => {
-  const ctx = {} as any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Save and clear env
-    for (const key of envKeys) {
-      savedEnv[key] = process.env[key];
-      delete process.env[key];
-    }
-  });
-
-  afterEach(() => {
-    // Restore env
-    for (const key of envKeys) {
-      if (savedEnv[key] !== undefined) process.env[key] = savedEnv[key];
-      else delete process.env[key];
-    }
-  });
-
-  describe('metadata', () => {
-    it('has correct id and name', () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test' });
-      expect(tool.id).toBe('tts-multi-provider-v1');
-      expect(tool.name).toBe('text_to_speech');
-    });
-
-    it('has valid input schema with text required', () => {
-      const tool = new TextToSpeechTool({});
-      expect(tool.inputSchema.type).toBe('object');
-      expect(tool.inputSchema.required).toContain('text');
-    });
-
-    it('has no side effects', () => {
-      const tool = new TextToSpeechTool({});
-      expect(tool.hasSideEffects).toBe(false);
-    });
-
-    it('describes multiple providers', () => {
-      const tool = new TextToSpeechTool({});
-      expect(tool.description).toContain('OpenAI');
-      expect(tool.description).toContain('ElevenLabs');
-    });
-  });
-
-  describe('provider resolution', () => {
-    it('falls back to Ollama when no API keys set', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: '', elevenLabsApiKey: '' });
-      mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
-      const result = await tool.execute({ text: 'Hello' }, ctx);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Ollama');
-    });
-
-    it('auto-detects OpenAI when key provided', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test', elevenLabsApiKey: '' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(100) });
-      const result = await tool.execute({ text: 'Hello' }, ctx);
-      expect(result.success).toBe(true);
-      expect(result.output!.provider).toBe('openai');
-    });
-
-    it('auto-detects ElevenLabs when only that key set', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: '', elevenLabsApiKey: 'el-test' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(100) });
-      const result = await tool.execute({ text: 'Hello' }, ctx);
-      expect(result.success).toBe(true);
-      expect(result.output!.provider).toBe('elevenlabs');
-    });
-
-    it('respects explicit provider override', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test', elevenLabsApiKey: 'el-test' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(100) });
-      const result = await tool.execute({ text: 'Hello', provider: 'elevenlabs' }, ctx);
-      expect(result.success).toBe(true);
-      expect(result.output!.provider).toBe('elevenlabs');
-    });
-  });
-
-  describe('OpenAI TTS', () => {
-    it('synthesizes with default voice (nova)', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test', elevenLabsApiKey: '' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(100) });
-      const result = await tool.execute({ text: 'Hello world' }, ctx);
-      expect(result.success).toBe(true);
-      expect(result.output!.voice).toBe('nova');
-      expect(result.output!.provider).toBe('openai');
-      expect(result.output!.contentType).toBe('audio/mpeg');
-      expect(result.output!.audioBase64).toBeTruthy();
-    });
-
-    it('sends correct request to OpenAI API', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test', elevenLabsApiKey: '' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(10) });
-      await tool.execute({ text: 'Test', voice: 'shimmer', model: 'tts-1-hd' }, ctx);
-      const [url, opts] = mockFetch.mock.calls[0];
-      expect(url).toContain('/audio/speech');
-      const body = JSON.parse(opts.body);
-      expect(body.voice).toBe('shimmer');
-      expect(body.model).toBe('tts-1-hd');
-    });
-
-    it('handles API errors', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test', elevenLabsApiKey: '' });
-      mockFetch.mockResolvedValueOnce({ ok: false, status: 401, text: async () => 'Unauthorized' });
-      const result = await tool.execute({ text: 'Test' }, ctx);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('401');
-    });
-  });
-
-  describe('ElevenLabs TTS', () => {
-    it('synthesizes with default voice (rachel)', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: '', elevenLabsApiKey: 'el-test' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(100) });
-      const result = await tool.execute({ text: 'Hello world' }, ctx);
-      expect(result.success).toBe(true);
-      expect(result.output!.voice).toBe('rachel');
-      expect(result.output!.provider).toBe('elevenlabs');
-    });
-
-    it('uses correct voice ID for named voice (josh)', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: '', elevenLabsApiKey: 'el-test' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(10) });
-      await tool.execute({ text: 'Test', voice: 'josh' }, ctx);
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.stringContaining('TxGEqnHWrfWFTfGW9XjX'),
-        expect.any(Object)
-      );
-    });
-
-    it('sends ElevenLabs API key header', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: '', elevenLabsApiKey: 'el-test' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(10) });
-      await tool.execute({ text: 'Test' }, ctx);
-      const [, opts] = mockFetch.mock.calls[0];
-      expect(opts.headers['xi-api-key']).toBe('el-test');
-    });
-  });
-
-  describe('common behavior', () => {
-    it('truncates text to 5000 chars', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test', elevenLabsApiKey: '' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(10) });
-      const result = await tool.execute({ text: 'a'.repeat(6000) }, ctx);
-      expect(result.success).toBe(true);
-      expect(result.output!.text.length).toBe(5000);
-    });
-
-    it('estimates duration from word count', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test', elevenLabsApiKey: '' });
-      mockFetch.mockResolvedValueOnce({ ok: true, arrayBuffer: async () => new ArrayBuffer(10) });
-      const result = await tool.execute({ text: 'one two three four five' }, ctx);
-      expect(result.success).toBe(true);
-      expect(result.output!.durationEstimateMs).toBeGreaterThan(0);
-    });
-
-    it('handles network errors gracefully', async () => {
-      const tool = new TextToSpeechTool({ openaiApiKey: 'sk-test', elevenLabsApiKey: '' });
-      mockFetch.mockRejectedValueOnce(new Error('ECONNREFUSED'));
-      const result = await tool.execute({ text: 'Test' }, ctx);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('TTS failed');
-    });
-  });
-});
-
-describe('createExtensionPack', () => {
-  it('creates pack with correct metadata', () => {
-    const pack = createExtensionPack({ options: { elevenLabsApiKey: 'test' }, logger: { info: vi.fn() } });
-    expect(pack.name).toBe('@framers/agentos-ext-voice-synthesis');
-    expect(pack.version).toBe('2.0.0');
-    expect(pack.descriptors).toHaveLength(1);
-    expect(pack.descriptors[0].kind).toBe('tool');
-    expect(pack.descriptors[0].id).toBe('text_to_speech');
-  });
-});

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noEmitOnError": false,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "Bundler",
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "test"]
-}

package/vitest.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['test/**/*.spec.ts'],
-    testTimeout: 10000,
-  },
-});