mcp-ts-template 2.2.3 → 2.2.5

package/dist/index.js

@@ -117536,7 +117536,7 @@ var ErrorSchema = z.object({
 // package.json
 var package_default = {
   name: "mcp-ts-template",
-  version: "2.2.2",
+  version: "2.2.4",
   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",
@@ -117782,6 +117782,7 @@ var ConfigSchema = z.object({
   oauthAudience: z.string().optional(),
   oauthJwksCooldownMs: z.coerce.number().default(300000),
   oauthJwksTimeoutMs: z.coerce.number().default(5000),
+  mcpServerResourceIdentifier: z.string().url().optional(),
   devMcpClientId: z.string().optional(),
   devMcpScopes: z.array(z.string()).optional(),
   openrouterAppUrl: z.string().default("http://localhost:3000"),
@@ -117876,6 +117877,7 @@ var parseConfig = () => {
     oauthAudience: env.OAUTH_AUDIENCE,
     oauthJwksCooldownMs: env.OAUTH_JWKS_COOLDOWN_MS,
     oauthJwksTimeoutMs: env.OAUTH_JWKS_TIMEOUT_MS,
+    mcpServerResourceIdentifier: env.MCP_SERVER_RESOURCE_IDENTIFIER,
     devMcpClientId: env.DEV_MCP_CLIENT_ID,
     devMcpScopes: env.DEV_MCP_SCOPES?.split(",").map((s) => s.trim()),
     openrouterAppUrl: env.OPENROUTER_APP_URL,
@@ -119508,7 +119510,7 @@ async function fetchWithTimeout(url, timeoutMs, context, options) {
 
 // src/container/index.ts
 var import_reflect_metadata = __toESM(require_Reflect(), 1);
-var import_tsyringe15 = __toESM(require_cjs3(), 1);
+var import_tsyringe17 = __toESM(require_cjs3(), 1);
 
 // src/container/registrations/core.ts
 var import_tsyringe6 = __toESM(require_cjs3(), 1);
@@ -125172,9 +125174,25 @@ 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.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.list(tenantId, prefix, context);
+    return this.provider.clear(tenantId, context);
   }
 }
 StorageService2 = __legacyDecorateClassTS([
@@ -125192,6 +125210,7 @@ var import_tsyringe5 = __toESM(require_cjs3(), 1);
 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 {
@@ -125319,7 +125338,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);
@@ -125337,16 +125356,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) {
@@ -125386,21 +125482,71 @@ 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);
   }
 }
 
@@ -125408,6 +125554,7 @@ class InMemoryProvider {
 var import_tsyringe4 = __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;
@@ -125467,17 +125614,101 @@ 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 }
     });
   }
 }
@@ -125491,10 +125722,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) {
@@ -125579,27 +125814,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) {
@@ -125659,19 +125982,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 }
     });
   }
 }
@@ -125751,7 +126155,7 @@ var registerCoreServices = () => {
 };
 
 // src/container/registrations/mcp.ts
-var import_tsyringe14 = __toESM(require_cjs3(), 1);
+var import_tsyringe16 = __toESM(require_cjs3(), 1);
 
 // src/mcp-server/resources/resource-registration.ts
 var import_tsyringe7 = __toESM(require_cjs3(), 1);
@@ -129162,10 +129566,133 @@ var registerResources = (container3) => {
 };
 
 // src/mcp-server/server.ts
+var import_tsyringe11 = __toESM(require_cjs3(), 1);
+
+// src/mcp-server/prompts/prompt-registration.ts
+var import_tsyringe8 = __toESM(require_cjs3(), 1);
+
+// src/mcp-server/prompts/definitions/code-review.prompt.ts
+var PROMPT_NAME = "code_review";
+var PROMPT_DESCRIPTION = "Generates a structured code review prompt for analyzing code quality, security, and performance.";
+var ArgumentsSchema = z.object({
+  language: z.string().optional().describe("Programming language of the code to review."),
+  focus: z.string().optional().describe("The primary focus area for the code review ('security' | 'performance' | 'style' | 'general'). Defaults to 'general'."),
+  includeExamples: z.string().optional().describe("Whether to include example improvements in the review ('true' | 'false'). Defaults to 'false'.")
+});
+var codeReviewPrompt = {
+  name: PROMPT_NAME,
+  description: PROMPT_DESCRIPTION,
+  argumentsSchema: ArgumentsSchema,
+  generate: (args) => {
+    const focus = args.focus || "general";
+    const includeExamples = args.includeExamples === "true";
+    const focusGuidance = {
+      security: `- Security vulnerabilities and potential exploits
+- Input validation and sanitization
+- Authentication and authorization issues
+- Data exposure risks`,
+      performance: `- Algorithmic complexity and bottlenecks
+- Memory usage and leaks
+- Database query optimization
+- Caching opportunities`,
+      style: `- Code readability and clarity
+- Naming conventions
+- Code organization and structure
+- Documentation completeness`,
+      general: `- Overall code quality
+- Security considerations
+- Performance implications
+- Maintainability and readability`
+    };
+    const examplesSection = includeExamples ? `
+
+For each significant finding, provide a concrete example of how to improve the code.` : "";
+    return [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `You are an expert code reviewer${args.language ? ` specializing in ${args.language}` : ""}. Please conduct a thorough code review with a focus on ${focus}.
+
+Review the code for:
+${focusGuidance[focus] || focusGuidance["general"]}
+
+Structure your review as follows:
+1. **Summary**: 2-3 sentence overview of the code's quality
+2. **Key Findings**: Bullet-point list of important observations
+3. **Critical Issues**: Any must-fix problems (if found)
+4. **Recommendations**: Suggested improvements prioritized by impact${examplesSection}
+
+Be constructive, specific, and actionable in your feedback.`
+        }
+      }
+    ];
+  }
+};
+
+// src/mcp-server/prompts/definitions/index.ts
+var allPromptDefinitions = [codeReviewPrompt];
+
+// src/mcp-server/prompts/prompt-registration.ts
+class PromptRegistry {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  registerAll(server) {
+    const context = requestContextService.createRequestContext({
+      operation: "PromptRegistry.registerAll"
+    });
+    this.logger.debug(`Registering ${allPromptDefinitions.length} prompts...`, context);
+    for (const promptDef of allPromptDefinitions) {
+      this.logger.debug(`Registering prompt: ${promptDef.name}`, context);
+      server.registerPrompt(promptDef.name, {
+        description: promptDef.description,
+        ...promptDef.argumentsSchema && {
+          argsSchema: promptDef.argumentsSchema.shape
+        }
+      }, async (args) => {
+        const messages = await promptDef.generate(args);
+        return { messages };
+      });
+      this.logger.info(`Registered prompt: ${promptDef.name}`, context);
+    }
+    this.logger.info(`Successfully registered ${allPromptDefinitions.length} prompts`, context);
+  }
+}
+PromptRegistry = __legacyDecorateClassTS([
+  import_tsyringe8.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe8.inject(Logger2)),
+  __legacyMetadataTS("design:paramtypes", [
+    Object
+  ])
+], PromptRegistry);
+
+// src/mcp-server/roots/roots-registration.ts
 var import_tsyringe9 = __toESM(require_cjs3(), 1);
+class RootsRegistry {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  registerAll(_server) {
+    const context = requestContextService.createRequestContext({
+      operation: "RootsRegistry.registerAll"
+    });
+    this.logger.debug("Roots capability enabled (client-provided roots)", context);
+    this.logger.info("Roots capability registered successfully", context);
+  }
+}
+RootsRegistry = __legacyDecorateClassTS([
+  import_tsyringe9.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe9.inject(Logger2)),
+  __legacyMetadataTS("design:paramtypes", [
+    Object
+  ])
+], RootsRegistry);
 
 // src/mcp-server/tools/tool-registration.ts
-var import_tsyringe8 = __toESM(require_cjs3(), 1);
+var import_tsyringe10 = __toESM(require_cjs3(), 1);
 
 // src/mcp-server/tools/definitions/template-cat-fact.tool.ts
 var TOOL_NAME = "template_cat_fact";
@@ -129254,11 +129781,136 @@ var catFactTool = {
   responseFormatter
 };
 
-// src/mcp-server/tools/definitions/template-echo-message.tool.ts
-var TOOL_NAME2 = "template_echo_message";
-var TOOL_TITLE2 = "Template Echo Message";
-var TOOL_DESCRIPTION2 = "Echoes a message back with optional formatting and repetition.";
+// src/mcp-server/tools/definitions/template-code-review-sampling.tool.ts
+var TOOL_NAME2 = "template_code_review_sampling";
+var TOOL_TITLE2 = "Code Review with Sampling";
+var TOOL_DESCRIPTION2 = "Demonstrates MCP sampling by requesting an LLM to review code snippets. The tool uses the client's LLM to generate a code review summary.";
 var TOOL_ANNOTATIONS2 = {
+  readOnlyHint: true,
+  idempotentHint: false,
+  openWorldHint: true
+};
+var InputSchema2 = z.object({
+  code: z.string().min(1, "Code snippet cannot be empty.").max(1e4, "Code snippet too large (max 10000 characters).").describe("The code snippet to review."),
+  language: z.string().optional().describe('Programming language of the code (e.g., "typescript", "python").'),
+  focus: z.enum(["security", "performance", "style", "general"]).default("general").describe("The focus area for the code review."),
+  maxTokens: z.number().int().min(100).max(2000).default(500).describe("Maximum tokens for the LLM response.")
+}).describe("Request an LLM-powered code review via sampling.");
+var OutputSchema3 = z.object({
+  code: z.string().describe("The original code snippet."),
+  language: z.string().optional().describe("The programming language."),
+  focus: z.string().describe("The review focus area."),
+  review: z.string().describe("The LLM-generated code review summary."),
+  tokenUsage: z.object({
+    requested: z.number().describe("Requested max tokens."),
+    actual: z.number().optional().describe("Actual tokens used (if available).")
+  }).optional().describe("Token usage information.")
+}).describe("Code review tool response payload.");
+function hasSamplingCapability(ctx) {
+  return typeof ctx?.createMessage === "function";
+}
+async function codeReviewToolLogic(input, appContext, sdkContext) {
+  logger.debug("Processing code review with sampling.", {
+    ...appContext,
+    toolInput: { ...input, code: `${input.code.substring(0, 100)}...` }
+  });
+  if (!hasSamplingCapability(sdkContext)) {
+    throw new McpError(-32600 /* InvalidRequest */, "Sampling capability is not available. The client does not support MCP sampling.", { requestId: appContext.requestId, operation: "codeReview.sample" });
+  }
+  const focusInstructions = {
+    security: "Focus on security vulnerabilities, input validation, and potential exploits.",
+    performance: "Focus on performance bottlenecks, algorithmic complexity, and optimization opportunities.",
+    style: "Focus on code style, readability, naming conventions, and best practices.",
+    general: "Provide a comprehensive review covering security, performance, and code quality."
+  };
+  const prompt = `You are an expert code reviewer. Please review the following ${input.language || "code"} snippet.
+
+${focusInstructions[input.focus]}
+
+Provide a concise, structured review with:
+1. Summary (2-3 sentences)
+2. Key findings (bullet points)
+3. Recommendations (if applicable)
+
+Code to review:
+\`\`\`${input.language || ""}
+${input.code}
+\`\`\`
+
+Your review:`;
+  logger.debug("Requesting LLM completion via sampling...", {
+    ...appContext,
+    maxTokens: input.maxTokens,
+    focus: input.focus
+  });
+  try {
+    const samplingResult = await sdkContext.createMessage({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: prompt
+          }
+        }
+      ],
+      maxTokens: input.maxTokens,
+      temperature: 0.3,
+      modelPreferences: {
+        hints: [{ name: "claude-3-5-sonnet-20241022" }],
+        intelligencePriority: 0.8,
+        speedPriority: 0.2
+      }
+    });
+    logger.info("Sampling completed successfully.", {
+      ...appContext,
+      model: samplingResult.model,
+      stopReason: samplingResult.stopReason
+    });
+    const response = {
+      code: input.code,
+      language: input.language,
+      focus: input.focus,
+      review: samplingResult.content.text,
+      tokenUsage: {
+        requested: input.maxTokens
+      }
+    };
+    return response;
+  } catch (error2) {
+    logger.error("Sampling request failed.", {
+      ...appContext,
+      error: error2 instanceof Error ? error2.message : String(error2)
+    });
+    throw new McpError(-32603 /* InternalError */, `Failed to complete sampling request: ${error2 instanceof Error ? error2.message : "Unknown error"}`, { requestId: appContext.requestId, operation: "codeReview.sample" });
+  }
+}
+function responseFormatter2(result) {
+  return [
+    {
+      type: "text",
+      text: `# Code Review (${result.focus})
+
+${result.review}`
+    }
+  ];
+}
+var codeReviewSamplingTool = {
+  name: TOOL_NAME2,
+  title: TOOL_TITLE2,
+  description: TOOL_DESCRIPTION2,
+  inputSchema: InputSchema2,
+  outputSchema: OutputSchema3,
+  annotations: TOOL_ANNOTATIONS2,
+  logic: withToolAuth(["tool:code-review:use"], codeReviewToolLogic),
+  responseFormatter: responseFormatter2
+};
+
+// src/mcp-server/tools/definitions/template-echo-message.tool.ts
+var TOOL_NAME3 = "template_echo_message";
+var TOOL_TITLE3 = "Template Echo Message";
+var TOOL_DESCRIPTION3 = "Echoes a message back with optional formatting and repetition.";
+var TOOL_ANNOTATIONS3 = {
   readOnlyHint: true,
   idempotentHint: true,
   openWorldHint: false
@@ -129268,13 +129920,13 @@ var DEFAULT_MODE = "standard";
 var DEFAULT_REPEAT = 1;
 var DEFAULT_INCLUDE_TIMESTAMP = false;
 var TEST_ERROR_TRIGGER_MESSAGE = "TRIGGER_ERROR";
-var InputSchema2 = z.object({
+var InputSchema3 = z.object({
   message: z.string().min(1, "Message cannot be empty.").max(1000, "Message cannot exceed 1000 characters.").describe(`The message to echo back. To trigger a test error, provide '${TEST_ERROR_TRIGGER_MESSAGE}'.`),
   mode: z.enum(ECHO_MODES).default(DEFAULT_MODE).describe("How to format the message ('standard' | 'uppercase' | 'lowercase')."),
   repeat: z.number().int().min(1).max(5).default(DEFAULT_REPEAT).describe("Number of times to repeat the formatted message."),
   includeTimestamp: z.boolean().default(DEFAULT_INCLUDE_TIMESTAMP).describe("Whether to include an ISO 8601 timestamp in the response.")
 }).describe("Echo a message with optional formatting and repetition.");
-var OutputSchema3 = z.object({
+var OutputSchema4 = z.object({
   originalMessage: z.string().describe("The original message provided in the input."),
   formattedMessage: z.string().describe("The message after applying the specified formatting."),
   repeatedMessage: z.string().describe("The final message repeated the requested number of times."),
@@ -129308,7 +129960,7 @@ async function echoToolLogic(input, appContext, _sdkContext) {
   };
   return Promise.resolve(response);
 }
-function responseFormatter2(result) {
+function responseFormatter3(result) {
   const preview = result.repeatedMessage.length > 200 ? `${result.repeatedMessage.slice(0, 197)}…` : result.repeatedMessage;
   const lines = [
     `Echo (mode=${result.mode}, repeat=${result.repeatCount})`,
@@ -129324,14 +129976,14 @@ function responseFormatter2(result) {
   ];
 }
 var echoTool = {
-  name: TOOL_NAME2,
-  title: TOOL_TITLE2,
-  description: TOOL_DESCRIPTION2,
-  inputSchema: InputSchema2,
-  outputSchema: OutputSchema3,
-  annotations: TOOL_ANNOTATIONS2,
+  name: TOOL_NAME3,
+  title: TOOL_TITLE3,
+  description: TOOL_DESCRIPTION3,
+  inputSchema: InputSchema3,
+  outputSchema: OutputSchema4,
+  annotations: TOOL_ANNOTATIONS3,
   logic: withToolAuth(["tool:echo:read"], echoToolLogic),
-  responseFormatter: responseFormatter2
+  responseFormatter: responseFormatter3
 };
 
 // src/utils/internal/encoding.ts
@@ -129350,19 +130002,19 @@ function arrayBufferToBase64(buffer) {
 }
 
 // src/mcp-server/tools/definitions/template-image-test.tool.ts
-var TOOL_NAME3 = "template_image_test";
-var TOOL_TITLE3 = "Template Image Test";
-var TOOL_DESCRIPTION3 = "Fetches a random cat image and returns it base64-encoded with the MIME type. Useful for testing image handling.";
-var TOOL_ANNOTATIONS3 = {
+var TOOL_NAME4 = "template_image_test";
+var TOOL_TITLE4 = "Template Image Test";
+var TOOL_DESCRIPTION4 = "Fetches a random cat image and returns it base64-encoded with the MIME type. Useful for testing image handling.";
+var TOOL_ANNOTATIONS4 = {
   readOnlyHint: true,
   openWorldHint: true
 };
 var CAT_API_URL = "https://cataas.com/cat";
 var API_TIMEOUT_MS = 5000;
-var InputSchema3 = z.object({
+var InputSchema4 = z.object({
   trigger: z.boolean().optional().default(true).describe("A trigger to invoke the tool and fetch a new cat image.")
 }).describe("Parameters for fetching a random image.");
-var OutputSchema4 = z.object({
+var OutputSchema5 = z.object({
   data: z.string().describe("Base64 encoded image data."),
   mimeType: z.string().describe("The MIME type of the image (e.g., 'image/jpeg').")
 }).describe("Image tool response payload.");
@@ -129398,7 +130050,7 @@ async function imageTestToolLogic(input, appContext, _sdkContext) {
   });
   return result;
 }
-function responseFormatter3(result) {
+function responseFormatter4(result) {
   return [
     {
       type: "image",
@@ -129408,31 +130060,31 @@ function responseFormatter3(result) {
   ];
 }
 var imageTestTool = {
-  name: TOOL_NAME3,
-  title: TOOL_TITLE3,
-  description: TOOL_DESCRIPTION3,
-  inputSchema: InputSchema3,
-  outputSchema: OutputSchema4,
-  annotations: TOOL_ANNOTATIONS3,
+  name: TOOL_NAME4,
+  title: TOOL_TITLE4,
+  description: TOOL_DESCRIPTION4,
+  inputSchema: InputSchema4,
+  outputSchema: OutputSchema5,
+  annotations: TOOL_ANNOTATIONS4,
   logic: withToolAuth(["tool:image_test:read"], imageTestToolLogic),
-  responseFormatter: responseFormatter3
+  responseFormatter: responseFormatter4
 };
 
 // src/mcp-server/tools/definitions/template-madlibs-elicitation.tool.ts
-var TOOL_NAME4 = "template_madlibs_elicitation";
-var TOOL_TITLE4 = "Mad Libs Elicitation Game";
-var TOOL_DESCRIPTION4 = "Plays a game of Mad Libs. If any parts of speech (noun, verb, adjective) are missing, it will use elicitation to ask the user for them.";
-var TOOL_ANNOTATIONS4 = {
+var TOOL_NAME5 = "template_madlibs_elicitation";
+var TOOL_TITLE5 = "Mad Libs Elicitation Game";
+var TOOL_DESCRIPTION5 = "Plays a game of Mad Libs. If any parts of speech (noun, verb, adjective) are missing, it will use elicitation to ask the user for them.";
+var TOOL_ANNOTATIONS5 = {
   readOnlyHint: true,
   idempotentHint: false,
   openWorldHint: false
 };
-var InputSchema4 = z.object({
+var InputSchema5 = z.object({
   noun: z.string().optional().describe("A noun for the story."),
   verb: z.string().optional().describe("A verb (past tense) for the story."),
   adjective: z.string().optional().describe("An adjective for the story.")
 }).describe("Inputs for the Mad Libs game. Any missing fields will be elicited.");
-var OutputSchema5 = z.object({
+var OutputSchema6 = z.object({
   story: z.string().describe("The final, generated Mad Libs story."),
   noun: z.string().describe("The noun used in the story."),
   verb: z.string().describe("The verb used in the story."),
@@ -129472,7 +130124,7 @@ async function madlibsToolLogic(input, appContext, sdkContext) {
   };
   return Promise.resolve(response);
 }
-function responseFormatter4(result) {
+function responseFormatter5(result) {
   return [
     {
       type: "text",
@@ -129489,19 +130141,20 @@ function responseFormatter4(result) {
   ];
 }
 var madlibsElicitationTool = {
-  name: TOOL_NAME4,
-  title: TOOL_TITLE4,
-  description: TOOL_DESCRIPTION4,
-  inputSchema: InputSchema4,
-  outputSchema: OutputSchema5,
-  annotations: TOOL_ANNOTATIONS4,
+  name: TOOL_NAME5,
+  title: TOOL_TITLE5,
+  description: TOOL_DESCRIPTION5,
+  inputSchema: InputSchema5,
+  outputSchema: OutputSchema6,
+  annotations: TOOL_ANNOTATIONS5,
   logic: withToolAuth(["tool:madlibs:play"], madlibsToolLogic),
-  responseFormatter: responseFormatter4
+  responseFormatter: responseFormatter5
 };
 
 // src/mcp-server/tools/definitions/index.ts
 var allToolDefinitions = [
   catFactTool,
+  codeReviewSamplingTool,
   echoTool,
   imageTestTool,
   madlibsElicitationTool
@@ -129514,7 +130167,7 @@ var defaultResponseFormatter2 = (result) => [
 function createMcpToolHandler({
   toolName,
   logic,
-  responseFormatter: responseFormatter5 = defaultResponseFormatter2
+  responseFormatter: responseFormatter6 = defaultResponseFormatter2
 }) {
   return async (input, callContext) => {
     const sdkContext = callContext;
@@ -129531,7 +130184,7 @@ function createMcpToolHandler({
       const result = await measureToolExecution(() => logic(input, appContext, sdkContext), { ...appContext, toolName }, input);
       return {
         structuredContent: result,
-        content: responseFormatter5(result)
+        content: responseFormatter6(result)
       };
     } catch (error2) {
       const mcpError = ErrorHandler.handleError(error2, {
@@ -129602,8 +130255,8 @@ class ToolRegistry {
   }
 }
 ToolRegistry = __legacyDecorateClassTS([
-  import_tsyringe8.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe8.injectAll(ToolDefinitions)),
+  import_tsyringe10.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe10.injectAll(ToolDefinitions)),
   __legacyMetadataTS("design:paramtypes", [
     Array
   ])
@@ -129634,18 +130287,25 @@ async function createMcpServerInstance() {
       logging: {},
       resources: { listChanged: true },
       tools: { listChanged: true },
-      elicitation: {}
+      elicitation: {},
+      sampling: {},
+      prompts: { listChanged: true },
+      roots: { listChanged: true }
     }
   });
   try {
-    logger.debug("Registering resources and tools via registries...", context);
-    const toolRegistry = import_tsyringe9.container.resolve(ToolRegistry);
+    logger.debug("Registering all MCP capabilities via registries...", context);
+    const toolRegistry = import_tsyringe11.container.resolve(ToolRegistry);
     await toolRegistry.registerAll(server);
-    const resourceRegistry = import_tsyringe9.container.resolve(ResourceRegistry);
+    const resourceRegistry = import_tsyringe11.container.resolve(ResourceRegistry);
     await resourceRegistry.registerAll(server);
-    logger.info("Resources and tools registered successfully", context);
+    const promptRegistry = import_tsyringe11.container.resolve(PromptRegistry);
+    promptRegistry.registerAll(server);
+    const rootsRegistry = import_tsyringe11.container.resolve(RootsRegistry);
+    rootsRegistry.registerAll(server);
+    logger.info("All MCP capabilities registered successfully", context);
   } catch (err) {
-    logger.error("Failed to register resources/tools", {
+    logger.error("Failed to register MCP capabilities", {
       ...context,
       error: err instanceof Error ? err.message : String(err),
       stack: err instanceof Error ? err.stack : undefined
@@ -129656,7 +130316,7 @@ async function createMcpServerInstance() {
 }
 
 // src/mcp-server/transports/manager.ts
-var import_tsyringe13 = __toESM(require_cjs3(), 1);
+var import_tsyringe15 = __toESM(require_cjs3(), 1);
 
 // node_modules/hono/dist/http-exception.js
 var HTTPException = class extends Error {
@@ -132324,7 +132984,7 @@ var cors = (options) => {
 import http from "http";
 import { randomUUID } from "node:crypto";
 // src/mcp-server/transports/auth/authFactory.ts
-var import_tsyringe12 = __toESM(require_cjs3(), 1);
+var import_tsyringe14 = __toESM(require_cjs3(), 1);
 
 // node_modules/jose/dist/webapi/lib/buffer_utils.js
 var encoder = new TextEncoder;
@@ -133842,7 +134502,7 @@ function createRemoteJWKSet(url, options) {
   return remoteJWKSet;
 }
 // src/mcp-server/transports/auth/strategies/jwtStrategy.ts
-var import_tsyringe10 = __toESM(require_cjs3(), 1);
+var import_tsyringe12 = __toESM(require_cjs3(), 1);
 class JwtStrategy {
   config;
   logger;
@@ -133945,9 +134605,9 @@ class JwtStrategy {
   }
 }
 JwtStrategy = __legacyDecorateClassTS([
-  import_tsyringe10.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe10.inject(AppConfig)),
-  __legacyDecorateParamTS(1, import_tsyringe10.inject(Logger2)),
+  import_tsyringe12.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe12.inject(AppConfig)),
+  __legacyDecorateParamTS(1, import_tsyringe12.inject(Logger2)),
   __legacyMetadataTS("design:paramtypes", [
     Object,
     Object
@@ -133955,7 +134615,7 @@ JwtStrategy = __legacyDecorateClassTS([
 ], JwtStrategy);
 
 // src/mcp-server/transports/auth/strategies/oauthStrategy.ts
-var import_tsyringe11 = __toESM(require_cjs3(), 1);
+var import_tsyringe13 = __toESM(require_cjs3(), 1);
 class OauthStrategy {
   config;
   logger;
@@ -134006,6 +134666,26 @@ class OauthStrategy {
         ...context,
         claims: payload
       });
+      if (this.config.mcpServerResourceIdentifier) {
+        const resourceClaim = payload.resource || payload.aud;
+        const expectedResource = this.config.mcpServerResourceIdentifier;
+        const isResourceValid = Array.isArray(resourceClaim) && resourceClaim.includes(expectedResource) || resourceClaim === expectedResource;
+        if (!isResourceValid) {
+          this.logger.warning("Token resource indicator mismatch. Token was not issued for this MCP server.", {
+            ...context,
+            expected: expectedResource,
+            received: resourceClaim
+          });
+          throw new McpError(-32005 /* Forbidden */, "Token was not issued for this MCP server. Resource indicator mismatch.", {
+            expected: expectedResource,
+            received: resourceClaim
+          });
+        }
+        this.logger.debug("RFC 8707 resource indicator validated successfully.", {
+          ...context,
+          resource: expectedResource
+        });
+      }
       const scopes = typeof payload.scope === "string" ? payload.scope.split(" ") : [];
       if (scopes.length === 0) {
         this.logger.warning("Invalid token: missing or empty 'scope' claim.", context);
@@ -134052,9 +134732,9 @@ class OauthStrategy {
   }
 }
 OauthStrategy = __legacyDecorateClassTS([
-  import_tsyringe11.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe11.inject(AppConfig)),
-  __legacyDecorateParamTS(1, import_tsyringe11.inject(Logger2)),
+  import_tsyringe13.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe13.inject(AppConfig)),
+  __legacyDecorateParamTS(1, import_tsyringe13.inject(Logger2)),
   __legacyMetadataTS("design:paramtypes", [
     Object,
     Object
@@ -134062,8 +134742,8 @@ OauthStrategy = __legacyDecorateClassTS([
 ], OauthStrategy);
 
 // src/mcp-server/transports/auth/authFactory.ts
-import_tsyringe12.container.register(JwtStrategy, { useClass: JwtStrategy });
-import_tsyringe12.container.register(OauthStrategy, { useClass: OauthStrategy });
+import_tsyringe14.container.register(JwtStrategy, { useClass: JwtStrategy });
+import_tsyringe14.container.register(OauthStrategy, { useClass: OauthStrategy });
 function createAuthStrategy() {
   const context = requestContextService.createRequestContext({
     operation: "createAuthStrategy",
@@ -134073,10 +134753,10 @@ function createAuthStrategy() {
   switch (config.mcpAuthMode) {
     case "jwt":
       logger.debug("Resolving JWT strategy from container.", context);
-      return import_tsyringe12.container.resolve(JwtStrategy);
+      return import_tsyringe14.container.resolve(JwtStrategy);
     case "oauth":
       logger.debug("Resolving OAuth strategy from container.", context);
-      return import_tsyringe12.container.resolve(OauthStrategy);
+      return import_tsyringe14.container.resolve(OauthStrategy);
     case "none":
       logger.info("Authentication is disabled ('none' mode).", context);
       return null;
@@ -134245,6 +134925,18 @@ function createHttpApp(mcpServer, parentContext) {
   }));
   app.onError(httpErrorHandler);
   app.get("/healthz", (c) => c.json({ status: "ok" }));
+  app.get("/.well-known/oauth-protected-resource", (c) => {
+    if (!config.oauthIssuerUrl) {
+      return c.json({ error: "OAuth not configured on this server" }, { status: 404 });
+    }
+    return c.json({
+      resource: config.mcpServerResourceIdentifier || config.oauthAudience,
+      authorization_servers: [config.oauthIssuerUrl],
+      bearer_methods_supported: ["header"],
+      resource_signing_alg_values_supported: ["RS256", "ES256", "PS256"],
+      ...config.oauthJwksUri && { jwks_uri: config.oauthJwksUri }
+    });
+  });
   app.get(config.mcpHttpEndpointPath, (c) => {
     return c.json({
       status: "ok",
@@ -134267,11 +134959,21 @@ function createHttpApp(mcpServer, parentContext) {
     logger.info("Authentication is disabled; MCP endpoint is unprotected.", transportContext);
   }
   app.all(config.mcpHttpEndpointPath, async (c) => {
+    const protocolVersion = c.req.header("mcp-protocol-version") ?? "2025-03-26";
     logger.debug("Handling MCP request.", {
       ...transportContext,
       path: c.req.path,
-      method: c.req.method
+      method: c.req.method,
+      protocolVersion
     });
+    const supportedVersions = ["2025-03-26", "2025-06-18"];
+    if (!supportedVersions.includes(protocolVersion)) {
+      logger.warning("Unsupported MCP protocol version requested.", {
+        ...transportContext,
+        protocolVersion,
+        supportedVersions
+      });
+    }
     const sessionId = c.req.header("mcp-session-id") ?? randomUUID();
     const transport = new McpSessionTransport(sessionId);
     const handleRpc = async () => {
@@ -134289,7 +134991,13 @@ function createHttpApp(mcpServer, parentContext) {
       }
       return await handleRpc();
     } catch (err) {
-      await transport.close?.();
+      await transport.close?.().catch((closeErr) => {
+        logger.warning("Failed to close transport after error", {
+          ...transportContext,
+          sessionId,
+          error: closeErr instanceof Error ? closeErr.message : String(closeErr)
+        });
+      });
       throw err instanceof Error ? err : new Error(String(err));
     }
   });
@@ -134488,7 +135196,7 @@ async function startStdioTransport(server, parentContext) {
     logger.info("MCP Server connected and listening via stdio transport.", operationContext);
     logStartupBanner(`
 \uD83D\uDE80 MCP Server running in STDIO mode.
-   (MCP Spec: 2025-03-26 Stdio Transport)
+   (MCP Spec: 2025-06-18 Stdio Transport)
 `);
     return server;
   } catch (err) {
@@ -134562,10 +135270,10 @@ class TransportManager {
   }
 }
 TransportManager = __legacyDecorateClassTS([
-  import_tsyringe13.injectable(),
-  __legacyDecorateParamTS(0, import_tsyringe13.inject(AppConfig)),
-  __legacyDecorateParamTS(1, import_tsyringe13.inject(Logger2)),
-  __legacyDecorateParamTS(2, import_tsyringe13.inject(CreateMcpServerInstance)),
+  import_tsyringe15.injectable(),
+  __legacyDecorateParamTS(0, import_tsyringe15.inject(AppConfig)),
+  __legacyDecorateParamTS(1, import_tsyringe15.inject(Logger2)),
+  __legacyDecorateParamTS(2, import_tsyringe15.inject(CreateMcpServerInstance)),
   __legacyMetadataTS("design:paramtypes", [
     typeof AppConfigType === "undefined" ? Object : AppConfigType,
     Object,
@@ -134575,14 +135283,14 @@ TransportManager = __legacyDecorateClassTS([
 
 // src/container/registrations/mcp.ts
 var registerMcpServices = () => {
-  import_tsyringe14.container.registerSingleton(ToolRegistry);
-  import_tsyringe14.container.registerSingleton(ResourceRegistry);
-  registerTools(import_tsyringe14.container);
-  registerResources(import_tsyringe14.container);
-  import_tsyringe14.container.register(CreateMcpServerInstance, {
+  import_tsyringe16.container.registerSingleton(ToolRegistry);
+  import_tsyringe16.container.registerSingleton(ResourceRegistry);
+  registerTools(import_tsyringe16.container);
+  registerResources(import_tsyringe16.container);
+  import_tsyringe16.container.register(CreateMcpServerInstance, {
     useValue: createMcpServerInstance
   });
-  import_tsyringe14.container.registerSingleton(TransportManagerToken, TransportManager);
+  import_tsyringe16.container.registerSingleton(TransportManagerToken, TransportManager);
   logger.info("MCP services and factories registered with the DI container.");
 };
 
@@ -134596,7 +135304,7 @@ function composeContainer() {
   registerMcpServices();
   isContainerComposed = true;
 }
-var container_default = import_tsyringe15.container;
+var container_default = import_tsyringe17.container;
 
 // src/index.ts
 var config2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-ts-template",
-  "version": "2.2.3",
+  "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",