mcp-ts-template 2.2.5 → 2.2.8

package/dist/index.js

@@ -117536,7 +117536,7 @@ var ErrorSchema = z.object({
 // package.json
 var package_default = {
   name: "mcp-ts-template",
-  version: "2.2.4",
+  version: "2.2.7",
   mcpName: "io.github.cyanheads/mcp-ts-template",
   description: "The definitive, production-grade template for building powerful and scalable Model Context Protocol (MCP) servers with TypeScript, featuring built-in observability (OpenTelemetry), declarative tooling, robust error handling, and a modular, DI-driven architecture.",
   main: "dist/index.js",
@@ -117619,9 +117619,10 @@ var package_default = {
     jose: "^6.1.0",
     "js-yaml": "^4.1.0",
     "node-cron": "^4.2.1",
-    openai: "^5.23.1",
+    openai: "^6.0.0",
     papaparse: "^5.5.3",
     "partial-json": "^0.1.7",
+    "pdf-lib": "^1.17.1",
     pino: "^9.12.0",
     "reflect-metadata": "^0.2.2",
     repomix: "^1.6.0",
@@ -117665,7 +117666,7 @@ var package_default = {
     "pino-pretty": "^13.1.1",
     prettier: "^3.6.2",
     typedoc: "^0.28.13",
-    typescript: "^5.9.2",
+    typescript: "^5.9.3",
     "typescript-eslint": "8.45.0",
     vite: "^7.1.7",
     "vite-tsconfig-paths": "^5.1.4",
@@ -117848,7 +117849,26 @@ var ConfigSchema = z.object({
       }
       return str;
     }, z.enum(["NONE", "ERROR", "WARN", "INFO", "DEBUG", "VERBOSE", "ALL"])).default("INFO")
-  })
+  }),
+  speech: z.object({
+    tts: z.object({
+      enabled: z.coerce.boolean().default(false),
+      provider: z.enum(["elevenlabs"]).default("elevenlabs"),
+      apiKey: z.string().optional(),
+      baseUrl: z.string().url().optional(),
+      defaultVoiceId: z.string().optional(),
+      defaultModelId: z.string().optional(),
+      timeout: z.coerce.number().optional()
+    }).optional(),
+    stt: z.object({
+      enabled: z.coerce.boolean().default(false),
+      provider: z.enum(["openai-whisper"]).default("openai-whisper"),
+      apiKey: z.string().optional(),
+      baseUrl: z.string().url().optional(),
+      defaultModelId: z.string().optional(),
+      timeout: z.coerce.number().optional()
+    }).optional()
+  }).optional()
 });
 var parseConfig = () => {
   const env = process.env;
@@ -117915,6 +117935,25 @@ var parseConfig = () => {
       samplingRatio: env.OTEL_TRACES_SAMPLER_ARG,
       logLevel: env.OTEL_LOG_LEVEL
     },
+    speech: env.SPEECH_TTS_ENABLED || env.SPEECH_STT_ENABLED ? {
+      tts: env.SPEECH_TTS_ENABLED ? {
+        enabled: env.SPEECH_TTS_ENABLED,
+        provider: env.SPEECH_TTS_PROVIDER,
+        apiKey: env.SPEECH_TTS_API_KEY,
+        baseUrl: env.SPEECH_TTS_BASE_URL,
+        defaultVoiceId: env.SPEECH_TTS_DEFAULT_VOICE_ID,
+        defaultModelId: env.SPEECH_TTS_DEFAULT_MODEL_ID,
+        timeout: env.SPEECH_TTS_TIMEOUT
+      } : undefined,
+      stt: env.SPEECH_STT_ENABLED ? {
+        enabled: env.SPEECH_STT_ENABLED,
+        provider: env.SPEECH_STT_PROVIDER,
+        apiKey: env.SPEECH_STT_API_KEY,
+        baseUrl: env.SPEECH_STT_BASE_URL,
+        defaultModelId: env.SPEECH_STT_DEFAULT_MODEL_ID,
+        timeout: env.SPEECH_STT_TIMEOUT
+      } : undefined
+    } : undefined,
     mcpServerName: env.MCP_SERVER_NAME,
     mcpServerVersion: env.MCP_SERVER_VERSION,
     mcpServerDescription: env.MCP_SERVER_DESCRIPTION
@@ -119310,6 +119349,7 @@ var CreateMcpServerInstance = Symbol("CreateMcpServerInstance");
 var RateLimiterService = Symbol("RateLimiterService");
 var TransportManagerToken = Symbol("TransportManager");
 var SupabaseAdminClient = Symbol("SupabaseAdminClient");
+var SpeechService = Symbol("SpeechService");
 
 // src/utils/security/rateLimiter.ts
 class RateLimiter {
@@ -119510,10 +119550,10 @@ async function fetchWithTimeout(url, timeoutMs, context, options) {
 
 // src/container/index.ts
 var import_reflect_metadata = __toESM(require_Reflect(), 1);
-var import_tsyringe17 = __toESM(require_cjs3(), 1);
+var import_tsyringe19 = __toESM(require_cjs3(), 1);
 
 // src/container/registrations/core.ts
-var import_tsyringe6 = __toESM(require_cjs3(), 1);
+var import_tsyringe8 = __toESM(require_cjs3(), 1);
 var import_supabase_js2 = __toESM(require_main6(), 1);
 
 // node_modules/openai/internal/tslib.mjs
@@ -119744,7 +119784,7 @@ var safeJSON = (text) => {
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 // node_modules/openai/version.mjs
-var VERSION = "5.23.1";
+var VERSION = "6.0.0";
 
 // node_modules/openai/internal/detect-platform.mjs
 var isRunningInBrowser = () => {
@@ -125145,8 +125185,378 @@ OpenRouterProvider = __legacyDecorateClassTS([
   ])
 ], OpenRouterProvider);
 
-// src/storage/core/StorageService.ts
+// src/services/speech/providers/elevenlabs.provider.ts
 var import_tsyringe3 = __toESM(require_cjs3(), 1);
+class ElevenLabsProvider {
+  name = "elevenlabs";
+  supportsTTS = true;
+  supportsSTT = false;
+  apiKey;
+  baseUrl;
+  defaultVoiceId;
+  defaultModelId;
+  timeout;
+  constructor(config2) {
+    if (!config2.apiKey) {
+      throw new McpError(-32602 /* InvalidParams */, "ElevenLabs API key is required");
+    }
+    this.apiKey = config2.apiKey;
+    this.baseUrl = config2.baseUrl || "https://api.elevenlabs.io/v1";
+    this.defaultVoiceId = config2.defaultVoiceId || "EXAVITQu4vr4xnSDxMaL";
+    this.defaultModelId = config2.defaultModelId || "eleven_monolingual_v1";
+    this.timeout = config2.timeout || 30000;
+    logger.info(`ElevenLabs TTS provider initialized: ${this.baseUrl}, voice=${this.defaultVoiceId}`);
+  }
+  async textToSpeech(options) {
+    const context = requestContextService.createRequestContext({
+      operation: "elevenlabs-tts",
+      ...options.context || {}
+    });
+    const voiceId = options.voice?.voiceId || this.defaultVoiceId;
+    const modelId = options.modelId || this.defaultModelId;
+    logger.debug("Converting text to speech with ElevenLabs", context);
+    if (!options.text || options.text.trim().length === 0) {
+      throw new McpError(-32602 /* InvalidParams */, "Text cannot be empty", context);
+    }
+    if (options.text.length > 5000) {
+      throw new McpError(-32602 /* InvalidParams */, "Text exceeds maximum length of 5000 characters", context);
+    }
+    const url = `${this.baseUrl}/text-to-speech/${voiceId}`;
+    const voiceSettings = {
+      stability: options.voice?.stability ?? 0.5,
+      similarity_boost: options.voice?.similarityBoost ?? 0.75,
+      style: options.voice?.style ?? 0,
+      use_speaker_boost: true
+    };
+    const requestBody = {
+      text: options.text,
+      model_id: modelId,
+      voice_settings: voiceSettings
+    };
+    try {
+      const response = await fetchWithTimeout(url, this.timeout, context, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "xi-api-key": this.apiKey
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        logger.error(`ElevenLabs API error: ${response.status}`, context);
+        throw new McpError(-32603 /* InternalError */, `ElevenLabs API error: ${response.status} - ${errorText}`, context);
+      }
+      const audioBuffer = Buffer.from(await response.arrayBuffer());
+      logger.info(`Text-to-speech conversion successful (voice=${voiceId}, ${audioBuffer.length} bytes)`, context);
+      return {
+        audio: audioBuffer,
+        format: "mp3",
+        characterCount: options.text.length,
+        metadata: {
+          voiceId,
+          modelId,
+          provider: this.name
+        }
+      };
+    } catch (error2) {
+      if (error2 instanceof McpError) {
+        throw error2;
+      }
+      logger.error("Failed to convert text to speech", error2 instanceof Error ? error2 : new Error(String(error2)), context);
+      throw new McpError(-32603 /* InternalError */, `Failed to convert text to speech: ${error2 instanceof Error ? error2.message : "Unknown error"}`, context);
+    }
+  }
+  speechToText(_options) {
+    throw new McpError(-32601 /* MethodNotFound */, "Speech-to-text is not supported by ElevenLabs provider");
+  }
+  async getVoices() {
+    const context = requestContextService.createRequestContext({
+      operation: "elevenlabs-getVoices"
+    });
+    logger.debug("Fetching available voices from ElevenLabs", context);
+    const url = `${this.baseUrl}/voices`;
+    try {
+      const response = await fetchWithTimeout(url, this.timeout, context, {
+        method: "GET",
+        headers: {
+          "xi-api-key": this.apiKey
+        }
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        logger.error(`Failed to fetch voices: ${response.status}`, context);
+        throw new McpError(-32603 /* InternalError */, `Failed to fetch voices: ${response.status} - ${errorText}`);
+      }
+      const data = await response.json();
+      const voices = data.voices.map((v) => ({
+        id: v.voice_id,
+        name: v.name,
+        ...v.description !== undefined && { description: v.description },
+        ...v.category !== undefined && { category: v.category },
+        ...v.preview_url !== undefined && { previewUrl: v.preview_url },
+        ...v.labels?.gender !== undefined && {
+          gender: v.labels.gender
+        },
+        metadata: {
+          labels: v.labels
+        }
+      }));
+      logger.info(`Successfully fetched ${voices.length} voices`, context);
+      return voices;
+    } catch (error2) {
+      if (error2 instanceof McpError) {
+        throw error2;
+      }
+      logger.error("Failed to fetch voices", error2 instanceof Error ? error2 : new Error(String(error2)), context);
+      throw new McpError(-32603 /* InternalError */, `Failed to fetch voices: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+    }
+  }
+  async healthCheck() {
+    try {
+      await this.getVoices();
+      return true;
+    } catch (error2) {
+      const context = requestContextService.createRequestContext({
+        operation: "elevenlabs-healthCheck"
+      });
+      logger.error("ElevenLabs health check failed", error2 instanceof Error ? error2 : new Error(String(error2)), context);
+      return false;
+    }
+  }
+}
+ElevenLabsProvider = __legacyDecorateClassTS([
+  import_tsyringe3.injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof SpeechProviderConfig === "undefined" ? Object : SpeechProviderConfig
+  ])
+], ElevenLabsProvider);
+
+// src/services/speech/providers/whisper.provider.ts
+var import_tsyringe4 = __toESM(require_cjs3(), 1);
+class WhisperProvider {
+  name = "openai-whisper";
+  supportsTTS = false;
+  supportsSTT = true;
+  apiKey;
+  baseUrl;
+  defaultModelId;
+  timeout;
+  constructor(config2) {
+    if (!config2.apiKey) {
+      throw new McpError(-32602 /* InvalidParams */, "OpenAI API key is required");
+    }
+    this.apiKey = config2.apiKey;
+    this.baseUrl = config2.baseUrl || "https://api.openai.com/v1";
+    this.defaultModelId = config2.defaultModelId || "whisper-1";
+    this.timeout = config2.timeout || 60000;
+    logger.info(`OpenAI Whisper STT provider initialized: ${this.baseUrl}, model=${this.defaultModelId}`);
+  }
+  textToSpeech(_options) {
+    throw new McpError(-32601 /* MethodNotFound */, "Text-to-speech is not supported by Whisper provider");
+  }
+  async speechToText(options) {
+    const context = requestContextService.createRequestContext({
+      operation: "whisper-stt",
+      ...options.context || {}
+    });
+    const modelId = options.modelId || this.defaultModelId;
+    logger.debug("Converting speech to text with Whisper", context);
+    if (!options.audio) {
+      throw new McpError(-32602 /* InvalidParams */, "Audio data is required", context);
+    }
+    let audioBuffer;
+    if (typeof options.audio === "string") {
+      try {
+        audioBuffer = Buffer.from(options.audio, "base64");
+      } catch (_error) {
+        throw new McpError(-32602 /* InvalidParams */, "Invalid base64 audio data", context);
+      }
+    } else {
+      audioBuffer = options.audio;
+    }
+    const maxSize = 25 * 1024 * 1024;
+    if (audioBuffer.length > maxSize) {
+      throw new McpError(-32602 /* InvalidParams */, `Audio file exceeds maximum size of 25MB (got ${Math.round(audioBuffer.length / 1024 / 1024)}MB)`, context);
+    }
+    const url = `${this.baseUrl}/audio/transcriptions`;
+    const formData = new FormData;
+    const extension = this.getFileExtension(options.format);
+    const blob = new Blob([audioBuffer], {
+      type: this.getMimeType(options.format)
+    });
+    formData.append("file", blob, `audio.${extension}`);
+    formData.append("model", modelId);
+    if (options.language) {
+      formData.append("language", options.language);
+    }
+    if (options.temperature !== undefined) {
+      formData.append("temperature", options.temperature.toString());
+    }
+    if (options.prompt) {
+      formData.append("prompt", options.prompt);
+    }
+    formData.append("response_format", options.timestamps ? "verbose_json" : "json");
+    if (options.timestamps) {
+      formData.append("timestamp_granularities[]", "word");
+    }
+    try {
+      const response = await fetchWithTimeout(url, this.timeout, context, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: formData
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        logger.error(`Whisper API error: ${response.status}`, context);
+        throw new McpError(-32603 /* InternalError */, `Whisper API error: ${response.status} - ${errorText}`, context);
+      }
+      const data = await response.json();
+      const words = data.words?.map((w) => ({
+        word: w.word,
+        start: w.start,
+        end: w.end
+      }));
+      logger.info(`Speech-to-text transcription successful (${data.text.length} chars)`, context);
+      return {
+        text: data.text,
+        ...data.language !== undefined && { language: data.language },
+        ...data.duration !== undefined && { duration: data.duration },
+        ...words !== undefined && { words },
+        metadata: {
+          modelId,
+          provider: this.name,
+          ...data.task !== undefined && { task: data.task }
+        }
+      };
+    } catch (error2) {
+      if (error2 instanceof McpError) {
+        throw error2;
+      }
+      logger.error("Failed to transcribe audio", error2 instanceof Error ? error2 : new Error(String(error2)), context);
+      throw new McpError(-32603 /* InternalError */, `Failed to transcribe audio: ${error2 instanceof Error ? error2.message : "Unknown error"}`, context);
+    }
+  }
+  getVoices() {
+    throw new McpError(-32601 /* MethodNotFound */, "Voice listing is not supported by Whisper provider (STT only)");
+  }
+  async healthCheck() {
+    try {
+      const context = requestContextService.createRequestContext({
+        operation: "whisper-healthCheck"
+      });
+      const response = await fetchWithTimeout(`${this.baseUrl}/models`, 5000, context, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      return response.ok;
+    } catch (error2) {
+      const context = requestContextService.createRequestContext({
+        operation: "whisper-healthCheck"
+      });
+      logger.error("Whisper health check failed", error2 instanceof Error ? error2 : new Error(String(error2)), context);
+      return false;
+    }
+  }
+  getFileExtension(format) {
+    const formatMap = {
+      mp3: "mp3",
+      wav: "wav",
+      ogg: "ogg",
+      flac: "flac",
+      webm: "webm",
+      m4a: "m4a"
+    };
+    return format && formatMap[format] ? formatMap[format] : "mp3";
+  }
+  getMimeType(format) {
+    const mimeMap = {
+      mp3: "audio/mpeg",
+      wav: "audio/wav",
+      ogg: "audio/ogg",
+      flac: "audio/flac",
+      webm: "audio/webm",
+      m4a: "audio/mp4"
+    };
+    return format && mimeMap[format] ? mimeMap[format] : "audio/mpeg";
+  }
+}
+WhisperProvider = __legacyDecorateClassTS([
+  import_tsyringe4.injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof SpeechProviderConfig === "undefined" ? Object : SpeechProviderConfig
+  ])
+], WhisperProvider);
+
+// src/services/speech/index.ts
+function createSpeechProvider(config2) {
+  logger.debug(`Creating speech provider: ${config2.provider}`);
+  switch (config2.provider) {
+    case "elevenlabs":
+      return new ElevenLabsProvider(config2);
+    case "openai-whisper":
+      return new WhisperProvider(config2);
+    case "mock":
+      throw new McpError(-32602 /* InvalidParams */, "Mock provider not yet implemented");
+    default: {
+      const _exhaustive = config2.provider;
+      throw new McpError(-32602 /* InvalidParams */, `Unknown speech provider: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+class SpeechService2 {
+  ttsProvider;
+  sttProvider;
+  constructor(ttsConfig, sttConfig) {
+    if (ttsConfig) {
+      this.ttsProvider = createSpeechProvider(ttsConfig);
+      if (!this.ttsProvider.supportsTTS) {
+        logger.warning(`TTS provider ${ttsConfig.provider} does not support text-to-speech`);
+      }
+    }
+    if (sttConfig) {
+      this.sttProvider = createSpeechProvider(sttConfig);
+      if (!this.sttProvider.supportsSTT) {
+        logger.warning(`STT provider ${sttConfig.provider} does not support speech-to-text`);
+      }
+    }
+    logger.info(`Speech service initialized: TTS=${this.ttsProvider?.name ?? "none"}, STT=${this.sttProvider?.name ?? "none"}`);
+  }
+  getTTSProvider() {
+    if (!this.ttsProvider) {
+      throw new McpError(-32600 /* InvalidRequest */, "No TTS provider configured");
+    }
+    return this.ttsProvider;
+  }
+  getSTTProvider() {
+    if (!this.sttProvider) {
+      throw new McpError(-32600 /* InvalidRequest */, "No STT provider configured");
+    }
+    return this.sttProvider;
+  }
+  hasTTS() {
+    return this.ttsProvider?.supportsTTS ?? false;
+  }
+  hasSTT() {
+    return this.sttProvider?.supportsSTT ?? false;
+  }
+  async healthCheck() {
+    const ttsHealth = this.ttsProvider ? await this.ttsProvider.healthCheck() : false;
+    const sttHealth = this.sttProvider ? await this.sttProvider.healthCheck() : false;
+    return {
+      tts: ttsHealth,
+      stt: sttHealth
+    };
+  }
+}
+
+// src/storage/core/StorageService.ts
+var import_tsyringe5 = __toESM(require_cjs3(), 1);
 function requireTenantId(context) {
   if (!context.tenantId) {
     throw new McpError(-32603 /* InternalError */, "Tenant ID is required for storage operations but was not found in the request context.", {
@@ -125196,15 +125606,15 @@ class StorageService2 {
   }
 }
 StorageService2 = __legacyDecorateClassTS([
-  import_tsyringe3.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe3.inject(StorageProvider)),
+  import_tsyringe5.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe5.inject(StorageProvider)),
   __legacyMetadataTS("design:paramtypes", [
     typeof IStorageProvider === "undefined" ? Object : IStorageProvider
   ])
 ], StorageService2);
 
 // src/storage/core/storageFactory.ts
-var import_tsyringe5 = __toESM(require_cjs3(), 1);
+var import_tsyringe7 = __toESM(require_cjs3(), 1);
 
 // src/storage/providers/fileSystem/fileSystemProvider.ts
 import { existsSync, mkdirSync } from "fs";
@@ -125551,7 +125961,7 @@ class InMemoryProvider {
 }
 
 // src/storage/providers/supabase/supabaseProvider.ts
-var import_tsyringe4 = __toESM(require_cjs3(), 1);
+var import_tsyringe6 = __toESM(require_cjs3(), 1);
 var import_supabase_js = __toESM(require_main6(), 1);
 var TABLE_NAME = "kv_store";
 var DEFAULT_LIST_LIMIT3 = 1000;
@@ -125713,8 +126123,8 @@ class SupabaseProvider {
   }
 }
 SupabaseProvider = __legacyDecorateClassTS([
-  import_tsyringe4.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe4.inject(SupabaseAdminClient)),
+  import_tsyringe6.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe6.inject(SupabaseAdminClient)),
   __legacyMetadataTS("design:paramtypes", [
     typeof import_supabase_js.SupabaseClient === "undefined" ? Object : import_supabase_js.SupabaseClient
   ])
@@ -126107,7 +126517,7 @@ function createStorageProvider(config2, deps = {}) {
       if (deps.supabaseClient) {
         return new SupabaseProvider(deps.supabaseClient);
       }
-      return import_tsyringe5.container.resolve(SupabaseProvider);
+      return import_tsyringe7.container.resolve(SupabaseProvider);
     case "cloudflare-r2":
       if (isServerless3) {
         const bucket = deps.r2Bucket ?? globalThis.R2_BUCKET;
@@ -126130,9 +126540,9 @@ function createStorageProvider(config2, deps = {}) {
 // src/container/registrations/core.ts
 var registerCoreServices = () => {
   const config2 = parseConfig();
-  import_tsyringe6.container.register(AppConfig, { useValue: config2 });
-  import_tsyringe6.container.register(Logger2, { useValue: logger });
-  import_tsyringe6.container.register(SupabaseAdminClient, {
+  import_tsyringe8.container.register(AppConfig, { useValue: config2 });
+  import_tsyringe8.container.register(Logger2, { useValue: logger });
+  import_tsyringe8.container.register(SupabaseAdminClient, {
     useFactory: (c) => {
       const cfg = c.resolve(AppConfig);
       if (!cfg.supabase?.url || !cfg.supabase?.serviceRoleKey) {
@@ -126143,22 +126553,57 @@ var registerCoreServices = () => {
       });
     }
   });
-  import_tsyringe6.container.register(StorageProvider, {
+  import_tsyringe8.container.register(StorageProvider, {
     useFactory: (c) => createStorageProvider(c.resolve(AppConfig))
   });
-  import_tsyringe6.container.register(StorageService, { useClass: StorageService2 }, { lifecycle: import_tsyringe6.Lifecycle.Singleton });
-  import_tsyringe6.container.register(LlmProvider, {
+  import_tsyringe8.container.register(StorageService, { useClass: StorageService2 }, { lifecycle: import_tsyringe8.Lifecycle.Singleton });
+  import_tsyringe8.container.register(LlmProvider, {
     useClass: OpenRouterProvider
   });
-  import_tsyringe6.container.register(RateLimiterService, { useClass: RateLimiter }, { lifecycle: import_tsyringe6.Lifecycle.Singleton });
+  import_tsyringe8.container.register(RateLimiterService, { useClass: RateLimiter }, { lifecycle: import_tsyringe8.Lifecycle.Singleton });
+  import_tsyringe8.container.register(SpeechService, {
+    useFactory: (c) => {
+      const cfg = c.resolve(AppConfig);
+      const ttsConfig = cfg.speech?.tts?.enabled && cfg.speech.tts.apiKey ? {
+        provider: "elevenlabs",
+        apiKey: cfg.speech.tts.apiKey,
+        ...cfg.speech.tts.baseUrl && {
+          baseUrl: cfg.speech.tts.baseUrl
+        },
+        ...cfg.speech.tts.defaultVoiceId && {
+          defaultVoiceId: cfg.speech.tts.defaultVoiceId
+        },
+        ...cfg.speech.tts.defaultModelId && {
+          defaultModelId: cfg.speech.tts.defaultModelId
+        },
+        ...cfg.speech.tts.timeout && {
+          timeout: cfg.speech.tts.timeout
+        }
+      } : undefined;
+      const sttConfig = cfg.speech?.stt?.enabled && cfg.speech.stt.apiKey ? {
+        provider: "openai-whisper",
+        apiKey: cfg.speech.stt.apiKey,
+        ...cfg.speech.stt.baseUrl && {
+          baseUrl: cfg.speech.stt.baseUrl
+        },
+        ...cfg.speech.stt.defaultModelId && {
+          defaultModelId: cfg.speech.stt.defaultModelId
+        },
+        ...cfg.speech.stt.timeout && {
+          timeout: cfg.speech.stt.timeout
+        }
+      } : undefined;
+      return new SpeechService2(ttsConfig, sttConfig);
+    }
+  });
   logger.info("Core services registered with the DI container.");
 };
 
 // src/container/registrations/mcp.ts
-var import_tsyringe16 = __toESM(require_cjs3(), 1);
+var import_tsyringe18 = __toESM(require_cjs3(), 1);
 
 // src/mcp-server/resources/resource-registration.ts
-var import_tsyringe7 = __toESM(require_cjs3(), 1);
+var import_tsyringe9 = __toESM(require_cjs3(), 1);
 
 // src/mcp-server/transports/auth/lib/authUtils.ts
 function withRequiredScopes(requiredScopes) {
@@ -129553,8 +129998,8 @@ class ResourceRegistry {
   }
 }
 ResourceRegistry = __legacyDecorateClassTS([
-  import_tsyringe7.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe7.injectAll(ResourceDefinitions)),
+  import_tsyringe9.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe9.injectAll(ResourceDefinitions)),
   __legacyMetadataTS("design:paramtypes", [
     Array
   ])
@@ -129566,10 +130011,10 @@ var registerResources = (container3) => {
 };
 
 // src/mcp-server/server.ts
-var import_tsyringe11 = __toESM(require_cjs3(), 1);
+var import_tsyringe13 = __toESM(require_cjs3(), 1);
 
 // src/mcp-server/prompts/prompt-registration.ts
-var import_tsyringe8 = __toESM(require_cjs3(), 1);
+var import_tsyringe10 = __toESM(require_cjs3(), 1);
 
 // src/mcp-server/prompts/definitions/code-review.prompt.ts
 var PROMPT_NAME = "code_review";
@@ -129661,15 +130106,15 @@ class PromptRegistry {
   }
 }
 PromptRegistry = __legacyDecorateClassTS([
-  import_tsyringe8.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe8.inject(Logger2)),
+  import_tsyringe10.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe10.inject(Logger2)),
   __legacyMetadataTS("design:paramtypes", [
     Object
   ])
 ], PromptRegistry);
 
 // src/mcp-server/roots/roots-registration.ts
-var import_tsyringe9 = __toESM(require_cjs3(), 1);
+var import_tsyringe11 = __toESM(require_cjs3(), 1);
 class RootsRegistry {
   logger;
   constructor(logger2) {
@@ -129684,15 +130129,15 @@ class RootsRegistry {
   }
 }
 RootsRegistry = __legacyDecorateClassTS([
-  import_tsyringe9.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe9.inject(Logger2)),
+  import_tsyringe11.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe11.inject(Logger2)),
   __legacyMetadataTS("design:paramtypes", [
     Object
   ])
 ], RootsRegistry);
 
 // src/mcp-server/tools/tool-registration.ts
-var import_tsyringe10 = __toESM(require_cjs3(), 1);
+var import_tsyringe12 = __toESM(require_cjs3(), 1);
 
 // src/mcp-server/tools/definitions/template-cat-fact.tool.ts
 var TOOL_NAME = "template_cat_fact";
@@ -130255,8 +130700,8 @@ class ToolRegistry {
   }
 }
 ToolRegistry = __legacyDecorateClassTS([
-  import_tsyringe10.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe10.injectAll(ToolDefinitions)),
+  import_tsyringe12.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe12.injectAll(ToolDefinitions)),
   __legacyMetadataTS("design:paramtypes", [
     Array
   ])
@@ -130295,13 +130740,13 @@ async function createMcpServerInstance() {
   });
   try {
     logger.debug("Registering all MCP capabilities via registries...", context);
-    const toolRegistry = import_tsyringe11.container.resolve(ToolRegistry);
+    const toolRegistry = import_tsyringe13.container.resolve(ToolRegistry);
     await toolRegistry.registerAll(server);
-    const resourceRegistry = import_tsyringe11.container.resolve(ResourceRegistry);
+    const resourceRegistry = import_tsyringe13.container.resolve(ResourceRegistry);
     await resourceRegistry.registerAll(server);
-    const promptRegistry = import_tsyringe11.container.resolve(PromptRegistry);
+    const promptRegistry = import_tsyringe13.container.resolve(PromptRegistry);
     promptRegistry.registerAll(server);
-    const rootsRegistry = import_tsyringe11.container.resolve(RootsRegistry);
+    const rootsRegistry = import_tsyringe13.container.resolve(RootsRegistry);
     rootsRegistry.registerAll(server);
     logger.info("All MCP capabilities registered successfully", context);
   } catch (err) {
@@ -130316,7 +130761,7 @@ async function createMcpServerInstance() {
 }
 
 // src/mcp-server/transports/manager.ts
-var import_tsyringe15 = __toESM(require_cjs3(), 1);
+var import_tsyringe17 = __toESM(require_cjs3(), 1);
 
 // node_modules/hono/dist/http-exception.js
 var HTTPException = class extends Error {
@@ -132984,7 +133429,7 @@ var cors = (options) => {
 import http from "http";
 import { randomUUID } from "node:crypto";
 // src/mcp-server/transports/auth/authFactory.ts
-var import_tsyringe14 = __toESM(require_cjs3(), 1);
+var import_tsyringe16 = __toESM(require_cjs3(), 1);
 
 // node_modules/jose/dist/webapi/lib/buffer_utils.js
 var encoder = new TextEncoder;
@@ -134502,7 +134947,7 @@ function createRemoteJWKSet(url, options) {
   return remoteJWKSet;
 }
 // src/mcp-server/transports/auth/strategies/jwtStrategy.ts
-var import_tsyringe12 = __toESM(require_cjs3(), 1);
+var import_tsyringe14 = __toESM(require_cjs3(), 1);
 class JwtStrategy {
   config;
   logger;
@@ -134605,9 +135050,9 @@ class JwtStrategy {
   }
 }
 JwtStrategy = __legacyDecorateClassTS([
-  import_tsyringe12.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe12.inject(AppConfig)),
-  __legacyDecorateParamTS(1, import_tsyringe12.inject(Logger2)),
+  import_tsyringe14.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe14.inject(AppConfig)),
+  __legacyDecorateParamTS(1, import_tsyringe14.inject(Logger2)),
   __legacyMetadataTS("design:paramtypes", [
     Object,
     Object
@@ -134615,7 +135060,7 @@ JwtStrategy = __legacyDecorateClassTS([
 ], JwtStrategy);
 
 // src/mcp-server/transports/auth/strategies/oauthStrategy.ts
-var import_tsyringe13 = __toESM(require_cjs3(), 1);
+var import_tsyringe15 = __toESM(require_cjs3(), 1);
 class OauthStrategy {
   config;
   logger;
@@ -134732,9 +135177,9 @@ class OauthStrategy {
   }
 }
 OauthStrategy = __legacyDecorateClassTS([
-  import_tsyringe13.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe13.inject(AppConfig)),
-  __legacyDecorateParamTS(1, import_tsyringe13.inject(Logger2)),
+  import_tsyringe15.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe15.inject(AppConfig)),
+  __legacyDecorateParamTS(1, import_tsyringe15.inject(Logger2)),
   __legacyMetadataTS("design:paramtypes", [
     Object,
     Object
@@ -134742,8 +135187,8 @@ OauthStrategy = __legacyDecorateClassTS([
 ], OauthStrategy);
 
 // src/mcp-server/transports/auth/authFactory.ts
-import_tsyringe14.container.register(JwtStrategy, { useClass: JwtStrategy });
-import_tsyringe14.container.register(OauthStrategy, { useClass: OauthStrategy });
+import_tsyringe16.container.register(JwtStrategy, { useClass: JwtStrategy });
+import_tsyringe16.container.register(OauthStrategy, { useClass: OauthStrategy });
 function createAuthStrategy() {
   const context = requestContextService.createRequestContext({
     operation: "createAuthStrategy",
@@ -134753,10 +135198,10 @@ function createAuthStrategy() {
   switch (config.mcpAuthMode) {
     case "jwt":
       logger.debug("Resolving JWT strategy from container.", context);
-      return import_tsyringe14.container.resolve(JwtStrategy);
+      return import_tsyringe16.container.resolve(JwtStrategy);
     case "oauth":
       logger.debug("Resolving OAuth strategy from container.", context);
-      return import_tsyringe14.container.resolve(OauthStrategy);
+      return import_tsyringe16.container.resolve(OauthStrategy);
     case "none":
       logger.info("Authentication is disabled ('none' mode).", context);
       return null;
@@ -135270,10 +135715,10 @@ class TransportManager {
   }
 }
 TransportManager = __legacyDecorateClassTS([
-  import_tsyringe15.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe15.inject(AppConfig)),
-  __legacyDecorateParamTS(1, import_tsyringe15.inject(Logger2)),
-  __legacyDecorateParamTS(2, import_tsyringe15.inject(CreateMcpServerInstance)),
+  import_tsyringe17.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe17.inject(AppConfig)),
+  __legacyDecorateParamTS(1, import_tsyringe17.inject(Logger2)),
+  __legacyDecorateParamTS(2, import_tsyringe17.inject(CreateMcpServerInstance)),
   __legacyMetadataTS("design:paramtypes", [
     typeof AppConfigType === "undefined" ? Object : AppConfigType,
     Object,
@@ -135283,14 +135728,14 @@ TransportManager = __legacyDecorateClassTS([
 
 // src/container/registrations/mcp.ts
 var registerMcpServices = () => {
-  import_tsyringe16.container.registerSingleton(ToolRegistry);
-  import_tsyringe16.container.registerSingleton(ResourceRegistry);
-  registerTools(import_tsyringe16.container);
-  registerResources(import_tsyringe16.container);
-  import_tsyringe16.container.register(CreateMcpServerInstance, {
+  import_tsyringe18.container.registerSingleton(ToolRegistry);
+  import_tsyringe18.container.registerSingleton(ResourceRegistry);
+  registerTools(import_tsyringe18.container);
+  registerResources(import_tsyringe18.container);
+  import_tsyringe18.container.register(CreateMcpServerInstance, {
     useValue: createMcpServerInstance
   });
-  import_tsyringe16.container.registerSingleton(TransportManagerToken, TransportManager);
+  import_tsyringe18.container.registerSingleton(TransportManagerToken, TransportManager);
   logger.info("MCP services and factories registered with the DI container.");
 };
 
@@ -135304,7 +135749,7 @@ function composeContainer() {
   registerMcpServices();
   isContainerComposed = true;
 }
-var container_default = import_tsyringe17.container;
+var container_default = import_tsyringe19.container;
 
 // src/index.ts
 var config2;