mcp-ts-template 2.2.4 → 2.2.7

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.5",
   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,7 +117619,7 @@ var package_default = {
     jose: "^6.1.0",
     "js-yaml": "^4.1.0",
     "node-cron": "^4.2.1",
-    openai: "^5.23.1",
+    openai: "^5.23.2",
     papaparse: "^5.5.3",
     "partial-json": "^0.1.7",
     pino: "^9.12.0",
@@ -117848,7 +117848,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 +117934,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 +119348,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 +119549,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 +119783,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 = "5.23.2";
 
 // node_modules/openai/internal/detect-platform.mjs
 var isRunningInBrowser = () => {
@@ -125145,8 +125184,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.", {
@@ -125174,26 +125583,43 @@ class StorageService2 {
     const tenantId = requireTenantId(context);
     return this.provider.delete(tenantId, key, context);
   }
-  list(prefix, context) {
+  list(prefix, context, options) {
+    const tenantId = requireTenantId(context);
+    return this.provider.list(tenantId, prefix, context, options);
+  }
+  getMany(keys, context) {
+    const tenantId = requireTenantId(context);
+    return this.provider.getMany(tenantId, keys, context);
+  }
+  setMany(entries, context, options) {
     const tenantId = requireTenantId(context);
-    return this.provider.list(tenantId, prefix, context);
+    return this.provider.setMany(tenantId, entries, context, options);
+  }
+  deleteMany(keys, context) {
+    const tenantId = requireTenantId(context);
+    return this.provider.deleteMany(tenantId, keys, context);
+  }
+  clear(context) {
+    const tenantId = requireTenantId(context);
+    return this.provider.clear(tenantId, context);
   }
 }
 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";
 import { readFile, readdir, rm, writeFile } from "fs/promises";
 import path2 from "path";
+var DEFAULT_LIST_LIMIT = 1000;
 var FILE_ENVELOPE_VERSION = 1;
 
 class FileSystemProvider {
@@ -125321,7 +125747,7 @@ class FileSystemProvider {
     }
     return results;
   }
-  async list(tenantId, prefix, context) {
+  async list(tenantId, prefix, context, options) {
     return ErrorHandler.tryCatch(async () => {
       const tenantPath = this.getTenantPath(tenantId);
       const allKeys = await this.listFilesRecursively(tenantPath, tenantPath);
@@ -125339,16 +125765,93 @@ class FileSystemProvider {
           continue;
         }
       }
-      return validKeys;
+      validKeys.sort();
+      const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT;
+      let startIndex = 0;
+      if (options?.cursor) {
+        const cursorIndex = validKeys.indexOf(options.cursor);
+        if (cursorIndex !== -1) {
+          startIndex = cursorIndex + 1;
+        }
+      }
+      const paginatedKeys = validKeys.slice(startIndex, startIndex + limit2);
+      const nextCursor = startIndex + limit2 < validKeys.length ? paginatedKeys[paginatedKeys.length - 1] : undefined;
+      return {
+        keys: paginatedKeys,
+        nextCursor
+      };
     }, {
       operation: "FileSystemProvider.list",
       context,
       input: { tenantId, prefix }
     });
   }
+  async getMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const results = new Map;
+      for (const key of keys) {
+        const value = await this.get(tenantId, key, context);
+        if (value !== null) {
+          results.set(key, value);
+        }
+      }
+      return results;
+    }, {
+      operation: "FileSystemProvider.getMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async setMany(tenantId, entries, context, options) {
+    return ErrorHandler.tryCatch(async () => {
+      for (const [key, value] of entries.entries()) {
+        await this.set(tenantId, key, value, context, options);
+      }
+    }, {
+      operation: "FileSystemProvider.setMany",
+      context,
+      input: { tenantId, entryCount: entries.size }
+    });
+  }
+  async deleteMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      let deletedCount = 0;
+      for (const key of keys) {
+        const deleted = await this.delete(tenantId, key, context);
+        if (deleted) {
+          deletedCount++;
+        }
+      }
+      return deletedCount;
+    }, {
+      operation: "FileSystemProvider.deleteMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async clear(tenantId, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const tenantPath = this.getTenantPath(tenantId);
+      const allKeys = await this.listFilesRecursively(tenantPath, tenantPath);
+      let deletedCount = 0;
+      for (const key of allKeys) {
+        const deleted = await this.delete(tenantId, key, context);
+        if (deleted) {
+          deletedCount++;
+        }
+      }
+      return deletedCount;
+    }, {
+      operation: "FileSystemProvider.clear",
+      context,
+      input: { tenantId }
+    });
+  }
 }
 
 // src/storage/providers/inMemory/inMemoryProvider.ts
+var DEFAULT_LIST_LIMIT2 = 1000;
+
 class InMemoryProvider {
   store = new Map;
   getTenantStore(tenantId) {
@@ -125388,28 +125891,79 @@ class InMemoryProvider {
     const tenantStore = this.getTenantStore(tenantId);
     return Promise.resolve(tenantStore.delete(key));
   }
-  list(tenantId, prefix, context) {
-    logger.debug(`[InMemoryProvider] Listing keys with prefix: ${prefix} for tenant: ${tenantId}`, context);
+  list(tenantId, prefix, context, options) {
+    logger.debug(`[InMemoryProvider] Listing keys with prefix: ${prefix} for tenant: ${tenantId}`, { ...context, options });
     const tenantStore = this.getTenantStore(tenantId);
     const now = Date.now();
-    const keys = [];
+    const allKeys = [];
     for (const [key, entry] of tenantStore.entries()) {
       if (key.startsWith(prefix)) {
         if (entry.expiresAt && now > entry.expiresAt) {
           tenantStore.delete(key);
         } else {
-          keys.push(key);
+          allKeys.push(key);
         }
       }
     }
-    return Promise.resolve(keys);
+    allKeys.sort();
+    const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT2;
+    let startIndex = 0;
+    if (options?.cursor) {
+      const cursorIndex = allKeys.indexOf(options.cursor);
+      if (cursorIndex !== -1) {
+        startIndex = cursorIndex + 1;
+      }
+    }
+    const paginatedKeys = allKeys.slice(startIndex, startIndex + limit2);
+    const nextCursor = startIndex + limit2 < allKeys.length ? paginatedKeys[paginatedKeys.length - 1] : undefined;
+    return Promise.resolve({
+      keys: paginatedKeys,
+      nextCursor
+    });
+  }
+  async getMany(tenantId, keys, context) {
+    logger.debug(`[InMemoryProvider] Getting ${keys.length} keys for tenant: ${tenantId}`, context);
+    const results = new Map;
+    for (const key of keys) {
+      const value = await this.get(tenantId, key, context);
+      if (value !== null) {
+        results.set(key, value);
+      }
+    }
+    return results;
+  }
+  async setMany(tenantId, entries, context, options) {
+    logger.debug(`[InMemoryProvider] Setting ${entries.size} keys for tenant: ${tenantId}`, context);
+    for (const [key, value] of entries.entries()) {
+      await this.set(tenantId, key, value, context, options);
+    }
+  }
+  async deleteMany(tenantId, keys, context) {
+    logger.debug(`[InMemoryProvider] Deleting ${keys.length} keys for tenant: ${tenantId}`, context);
+    let deletedCount = 0;
+    for (const key of keys) {
+      const deleted = await this.delete(tenantId, key, context);
+      if (deleted) {
+        deletedCount++;
+      }
+    }
+    return deletedCount;
+  }
+  clear(tenantId, context) {
+    logger.debug(`[InMemoryProvider] Clearing all keys for tenant: ${tenantId}`, context);
+    const tenantStore = this.getTenantStore(tenantId);
+    const count = tenantStore.size;
+    tenantStore.clear();
+    logger.info(`[InMemoryProvider] Cleared ${count} keys for tenant: ${tenantId}`, context);
+    return Promise.resolve(count);
   }
 }
 
 // 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;
 
 class SupabaseProvider {
   client;
@@ -125469,23 +126023,107 @@ class SupabaseProvider {
       input: { tenantId, key }
     });
   }
-  async list(tenantId, prefix, context) {
+  async list(tenantId, prefix, context, options) {
     return ErrorHandler.tryCatch(async () => {
       const now = new Date().toISOString();
-      const { data, error: error2 } = await this.getClient().from(TABLE_NAME).select("key").eq("tenant_id", tenantId).like("key", `${prefix}%`).or(`expires_at.is.null,expires_at.gt.${now}`);
+      const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT3;
+      let query = this.getClient().from(TABLE_NAME).select("key").eq("tenant_id", tenantId).like("key", `${prefix}%`).or(`expires_at.is.null,expires_at.gt.${now}`).order("key", { ascending: true }).limit(limit2 + 1);
+      if (options?.cursor) {
+        query = query.gt("key", options.cursor);
+      }
+      const { data, error: error2 } = await query;
       if (error2)
         throw error2;
-      return data?.map((item) => item.key) ?? [];
+      const keys = data?.map((item) => item.key) ?? [];
+      const hasMore = keys.length > limit2;
+      const resultKeys = hasMore ? keys.slice(0, limit2) : keys;
+      const nextCursor = hasMore ? resultKeys[resultKeys.length - 1] : undefined;
+      return {
+        keys: resultKeys,
+        nextCursor
+      };
     }, {
       operation: "SupabaseProvider.list",
       context,
-      input: { tenantId, prefix }
+      input: { tenantId, prefix, options }
+    });
+  }
+  async getMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      if (keys.length === 0) {
+        return new Map;
+      }
+      const { data, error: error2 } = await this.getClient().from(TABLE_NAME).select("key, value, expires_at").eq("tenant_id", tenantId).in("key", keys);
+      if (error2)
+        throw error2;
+      const results = new Map;
+      for (const row of data ?? []) {
+        if (!row.expires_at || new Date(row.expires_at).getTime() >= Date.now()) {
+          results.set(row.key, row.value);
+        } else {
+          await this.delete(tenantId, row.key, context);
+        }
+      }
+      return results;
+    }, {
+      operation: "SupabaseProvider.getMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async setMany(tenantId, entries, context, options) {
+    return ErrorHandler.tryCatch(async () => {
+      if (entries.size === 0) {
+        return;
+      }
+      const expires_at = options?.ttl ? new Date(Date.now() + options.ttl * 1000).toISOString() : null;
+      const rows = Array.from(entries.entries()).map(([key, value]) => ({
+        tenant_id: tenantId,
+        key,
+        value,
+        expires_at
+      }));
+      const { error: error2 } = await this.getClient().from(TABLE_NAME).upsert(rows);
+      if (error2)
+        throw error2;
+    }, {
+      operation: "SupabaseProvider.setMany",
+      context,
+      input: { tenantId, entryCount: entries.size }
+    });
+  }
+  async deleteMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      if (keys.length === 0) {
+        return 0;
+      }
+      const { error: error2, count } = await this.getClient().from(TABLE_NAME).delete({ count: "exact" }).eq("tenant_id", tenantId).in("key", keys);
+      if (error2)
+        throw error2;
+      return count ?? 0;
+    }, {
+      operation: "SupabaseProvider.deleteMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async clear(tenantId, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const { error: error2, count } = await this.getClient().from(TABLE_NAME).delete({ count: "exact" }).eq("tenant_id", tenantId);
+      if (error2)
+        throw error2;
+      logger.info(`[SupabaseProvider] Cleared ${count ?? 0} keys for tenant: ${tenantId}`, context);
+      return count ?? 0;
+    }, {
+      operation: "SupabaseProvider.clear",
+      context,
+      input: { tenantId }
     });
   }
 }
 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
   ])
@@ -125493,10 +126131,14 @@ SupabaseProvider = __legacyDecorateClassTS([
 
 // src/storage/providers/cloudflare/r2Provider.ts
 var R2_ENVELOPE_VERSION = 1;
+var DEFAULT_LIST_LIMIT4 = 1000;
 
 class R2Provider {
   bucket;
   constructor(bucket) {
+    if (!bucket) {
+      throw new McpError(-32008 /* ConfigurationError */, "R2Provider requires a valid R2Bucket instance.");
+    }
     this.bucket = bucket;
   }
   getR2Key(tenantId, key) {
@@ -125581,27 +126223,115 @@ class R2Provider {
       input: { tenantId, key }
     });
   }
-  async list(tenantId, prefix, context) {
+  async list(tenantId, prefix, context, options) {
     const r2Prefix = this.getR2Key(tenantId, prefix);
     return ErrorHandler.tryCatch(async () => {
-      logger.debug(`[R2Provider] Listing keys with prefix: ${r2Prefix}`, context);
-      const listed = await this.bucket.list({ prefix: r2Prefix });
+      logger.debug(`[R2Provider] Listing keys with prefix: ${r2Prefix}`, {
+        ...context,
+        options
+      });
+      const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT4;
+      const listOptions = {
+        prefix: r2Prefix,
+        limit: limit2 + 1
+      };
+      if (options?.cursor) {
+        listOptions.cursor = options.cursor;
+      }
+      const listed = await this.bucket.list(listOptions);
       const tenantPrefix = `${tenantId}:`;
       const keys = listed.objects.map((obj) => obj.key.startsWith(tenantPrefix) ? obj.key.substring(tenantPrefix.length) : obj.key);
-      logger.debug(`[R2Provider] Found ${keys.length} keys with prefix: ${r2Prefix}`, context);
-      return keys;
+      const hasMore = keys.length > limit2;
+      const resultKeys = hasMore ? keys.slice(0, limit2) : keys;
+      const nextCursor = "cursor" in listed && listed.truncated ? listed.cursor : undefined;
+      logger.debug(`[R2Provider] Found ${resultKeys.length} keys with prefix: ${r2Prefix}`, context);
+      return {
+        keys: resultKeys,
+        nextCursor
+      };
     }, {
       operation: "R2Provider.list",
       context,
-      input: { tenantId, prefix }
+      input: { tenantId, prefix, options }
+    });
+  }
+  async getMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const results = new Map;
+      for (const key of keys) {
+        const value = await this.get(tenantId, key, context);
+        if (value !== null) {
+          results.set(key, value);
+        }
+      }
+      return results;
+    }, {
+      operation: "R2Provider.getMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async setMany(tenantId, entries, context, options) {
+    return ErrorHandler.tryCatch(async () => {
+      const promises = Array.from(entries.entries()).map(([key, value]) => this.set(tenantId, key, value, context, options));
+      await Promise.all(promises);
+    }, {
+      operation: "R2Provider.setMany",
+      context,
+      input: { tenantId, entryCount: entries.size }
+    });
+  }
+  async deleteMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const promises = keys.map((key) => this.delete(tenantId, key, context));
+      const results = await Promise.all(promises);
+      return results.filter((deleted) => deleted).length;
+    }, {
+      operation: "R2Provider.deleteMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async clear(tenantId, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const r2Prefix = `${tenantId}:`;
+      let deletedCount = 0;
+      let cursor;
+      let hasMore = true;
+      while (hasMore) {
+        const listOpts = {
+          prefix: r2Prefix,
+          limit: 1000
+        };
+        if (cursor) {
+          listOpts.cursor = cursor;
+        }
+        const listed = await this.bucket.list(listOpts);
+        const deletePromises = listed.objects.map((obj) => this.bucket.delete(obj.key));
+        await Promise.all(deletePromises);
+        deletedCount += listed.objects.length;
+        hasMore = listed.truncated;
+        cursor = "cursor" in listed ? listed.cursor : undefined;
+      }
+      logger.info(`[R2Provider] Cleared ${deletedCount} keys for tenant: ${tenantId}`, context);
+      return deletedCount;
+    }, {
+      operation: "R2Provider.clear",
+      context,
+      input: { tenantId }
     });
   }
 }
 
 // src/storage/providers/cloudflare/kvProvider.ts
+var DEFAULT_LIST_LIMIT5 = 1000;
+
 class KvProvider {
   kv;
   constructor(kv) {
+    if (!kv) {
+      throw new McpError(-32008 /* ConfigurationError */, "KvProvider requires a valid KVNamespace instance.");
+    }
     this.kv = kv;
   }
   getKvKey(tenantId, key) {
@@ -125661,19 +126391,100 @@ class KvProvider {
       input: { tenantId, key }
     });
   }
-  async list(tenantId, prefix, context) {
+  async list(tenantId, prefix, context, options) {
     const kvPrefix = this.getKvKey(tenantId, prefix);
     return ErrorHandler.tryCatch(async () => {
-      logger.debug(`[KvProvider] Listing keys with prefix: ${kvPrefix}`, context);
-      const listed = await this.kv.list({ prefix: kvPrefix });
+      logger.debug(`[KvProvider] Listing keys with prefix: ${kvPrefix}`, {
+        ...context,
+        options
+      });
+      const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT5;
+      const listOptions = {
+        prefix: kvPrefix,
+        limit: limit2
+      };
+      if (options?.cursor) {
+        listOptions.cursor = options.cursor;
+      }
+      const listed = await this.kv.list(listOptions);
       const tenantPrefix = `${tenantId}:`;
       const keys = listed.keys.map((keyInfo) => keyInfo.name.startsWith(tenantPrefix) ? keyInfo.name.substring(tenantPrefix.length) : keyInfo.name);
+      const nextCursor = "cursor" in listed && !listed.list_complete ? listed.cursor : undefined;
       logger.debug(`[KvProvider] Found ${keys.length} keys with prefix: ${kvPrefix}`, context);
-      return keys;
+      return {
+        keys,
+        nextCursor
+      };
     }, {
       operation: "KvProvider.list",
       context,
-      input: { tenantId, prefix }
+      input: { tenantId, prefix, options }
+    });
+  }
+  async getMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const results = new Map;
+      for (const key of keys) {
+        const value = await this.get(tenantId, key, context);
+        if (value !== null) {
+          results.set(key, value);
+        }
+      }
+      return results;
+    }, {
+      operation: "KvProvider.getMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async setMany(tenantId, entries, context, options) {
+    return ErrorHandler.tryCatch(async () => {
+      const promises = Array.from(entries.entries()).map(([key, value]) => this.set(tenantId, key, value, context, options));
+      await Promise.all(promises);
+    }, {
+      operation: "KvProvider.setMany",
+      context,
+      input: { tenantId, entryCount: entries.size }
+    });
+  }
+  async deleteMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const promises = keys.map((key) => this.delete(tenantId, key, context));
+      const results = await Promise.all(promises);
+      return results.filter((deleted) => deleted).length;
+    }, {
+      operation: "KvProvider.deleteMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async clear(tenantId, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const kvPrefix = `${tenantId}:`;
+      let deletedCount = 0;
+      let cursor;
+      let listComplete = false;
+      while (!listComplete) {
+        const listOpts = {
+          prefix: kvPrefix,
+          limit: 1000
+        };
+        if (cursor) {
+          listOpts.cursor = cursor;
+        }
+        const listed = await this.kv.list(listOpts);
+        const deletePromises = listed.keys.map((keyInfo) => this.kv.delete(keyInfo.name));
+        await Promise.all(deletePromises);
+        deletedCount += listed.keys.length;
+        listComplete = listed.list_complete;
+        cursor = "cursor" in listed ? listed.cursor : undefined;
+      }
+      logger.info(`[KvProvider] Cleared ${deletedCount} keys for tenant: ${tenantId}`, context);
+      return deletedCount;
+    }, {
+      operation: "KvProvider.clear",
+      context,
+      input: { tenantId }
     });
   }
 }
@@ -125705,7 +126516,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;
@@ -125728,9 +126539,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) {
@@ -125741,22 +126552,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) {
@@ -129151,8 +129997,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
   ])
@@ -129164,10 +130010,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";
@@ -129259,15 +130105,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) {
@@ -129282,15 +130128,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";
@@ -129853,8 +130699,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
   ])
@@ -129893,13 +130739,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) {
@@ -129914,7 +130760,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 {
@@ -132582,7 +133428,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;
@@ -134100,7 +134946,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;
@@ -134203,9 +135049,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
@@ -134213,7 +135059,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;
@@ -134330,9 +135176,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
@@ -134340,8 +135186,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",
@@ -134351,10 +135197,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;
@@ -134868,10 +135714,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,
@@ -134881,14 +135727,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.");
 };
 
@@ -134902,7 +135748,7 @@ function composeContainer() {
   registerMcpServices();
   isContainerComposed = true;
 }
-var container_default = import_tsyringe17.container;
+var container_default = import_tsyringe19.container;
 
 // src/index.ts
 var config2;