toolception 0.2.5 → 0.4.0

package/dist/index.js

@@ -1,10 +1,16 @@
-import { z as f } from "zod";
-import p from "fastify";
-import A from "@fastify/cors";
-import { randomUUID as m } from "node:crypto";
-import { StreamableHTTPServerTransport as w } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { isInitializeRequest as b } from "@modelcontextprotocol/sdk/types.js";
-const g = {
+var A = (r) => {
+  throw TypeError(r);
+};
+var W = (r, e, s) => e.has(r) || A("Cannot " + s);
+var y = (r, e, s) => e.has(r) ? A("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, s);
+var u = (r, e, s) => (W(r, e, "access private method"), s);
+import { z as w } from "zod";
+import M from "fastify";
+import x from "@fastify/cors";
+import { randomUUID as v } from "node:crypto";
+import { StreamableHTTPServerTransport as E } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest as I } from "@modelcontextprotocol/sdk/types.js";
+const S = {
   dynamic: [
     "dynamic-tool-discovery",
     "dynamicToolDiscovery",
@@ -12,11 +18,11 @@ const g = {
   ],
   toolsets: ["tool-sets", "toolSets", "FMP_TOOL_SETS"]
 };
-class S {
+class q {
   constructor(e = {}) {
     this.keys = {
-      dynamic: e.keys?.dynamic ?? g.dynamic,
-      toolsets: e.keys?.toolsets ?? g.toolsets
+      dynamic: e.keys?.dynamic ?? S.dynamic,
+      toolsets: e.keys?.toolsets ?? S.toolsets
     };
   }
   resolveMode(e, s) {
@@ -24,20 +30,20 @@ class S {
   }
   parseCommaSeparatedToolSets(e, s) {
     if (!e || typeof e != "string") return [];
-    const t = e.split(",").map((i) => i.trim()).filter((i) => i.length > 0), o = new Set(Object.keys(s)), r = [];
-    for (const i of t)
-      o.has(i) ? r.push(i) : console.warn(
-        `Invalid toolset '${i}' ignored. Available: ${Array.from(
+    const t = e.split(",").map((n) => n.trim()).filter((n) => n.length > 0), o = new Set(Object.keys(s)), i = [];
+    for (const n of t)
+      o.has(n) ? i.push(n) : console.warn(
+        `Invalid toolset '${n}' ignored. Available: ${Array.from(
           o
         ).join(", ")}`
       );
-    return r;
+    return i;
   }
   getModulesForToolSets(e, s) {
     const t = /* @__PURE__ */ new Set();
     for (const o of e) {
-      const r = s[o];
-      r && (r.modules || []).forEach((i) => t.add(i));
+      const i = s[o];
+      i && (i.modules || []).forEach((n) => t.add(n));
     }
     return Array.from(t);
   }
@@ -62,13 +68,22 @@ class S {
       ).join(", ")}`
     };
   }
+  /**
+   * Validates and retrieves modules for a set of toolsets.
+   * Note: A toolset with only direct tools (no modules) is valid and returns an empty modules array.
+   * @param toolsetNames - Array of toolset names to validate
+   * @param catalog - The toolset catalog to validate against
+   * @returns Validation result with modules array if valid
+   */
   validateToolsetModules(e, s) {
     try {
-      const t = this.getModulesForToolSets(e, s);
-      return !t || t.length === 0 ? {
-        isValid: !1,
-        error: `No modules found for toolsets: ${e.join(", ")}`
-      } : { isValid: !0, modules: t };
+      for (const o of e)
+        if (!s[o])
+          return {
+            isValid: !1,
+            error: `Toolset '${o}' not found in catalog`
+          };
+      return { isValid: !0, modules: this.getModulesForToolSets(e, s) };
     } catch (t) {
       return {
         isValid: !1,
@@ -94,7 +109,7 @@ class S {
       }
   }
 }
-class x {
+class J {
   constructor(e) {
     this.catalog = e.catalog, this.moduleLoaders = e.moduleLoaders ?? {};
   }
@@ -128,18 +143,18 @@ class x {
   async resolveToolsForToolsets(e, s) {
     const t = [];
     for (const o of e) {
-      const r = this.catalog[o];
-      if (r && (Array.isArray(r.tools) && r.tools.length > 0 && t.push(...r.tools), Array.isArray(r.modules) && r.modules.length > 0))
-        for (const i of r.modules) {
-          const l = this.moduleLoaders[i];
+      const i = this.catalog[o];
+      if (i && (Array.isArray(i.tools) && i.tools.length > 0 && t.push(...i.tools), Array.isArray(i.modules) && i.modules.length > 0))
+        for (const n of i.modules) {
+          const l = this.moduleLoaders[n];
           if (l)
             try {
-              const n = await l(s);
-              Array.isArray(n) && n.length > 0 && t.push(...n);
-            } catch (n) {
+              const a = await l(s);
+              Array.isArray(a) && a.length > 0 && t.push(...a);
+            } catch (a) {
               console.warn(
-                `Module loader '${i}' failed for toolset '${o}':`,
-                n
+                `Module loader '${n}' failed for toolset '${o}':`,
+                a
               );
             }
         }
@@ -147,12 +162,12 @@ class x {
     return t;
   }
 }
-class T extends Error {
+class C extends Error {
   constructor(e, s, t, o) {
     super(e), this.name = "ToolingError", this.code = s, this.details = t;
   }
 }
-class v {
+class P {
   constructor(e = {}) {
     this.names = /* @__PURE__ */ new Set(), this.toolsetToNames = /* @__PURE__ */ new Map(), this.options = {
       namespaceWithToolset: e.namespaceWithToolset ?? !0
@@ -166,7 +181,7 @@ class v {
   }
   add(e) {
     if (this.names.has(e))
-      throw new T(
+      throw new C(
         `Tool name collision: '${e}' already registered`,
         "E_TOOL_NAME_CONFLICT"
       );
@@ -181,7 +196,7 @@ class v {
     return s.map((t) => {
       const o = this.getSafeName(e, t.name);
       if (this.has(o))
-        throw new T(
+        throw new C(
           `Tool name collision for '${o}'`,
           "E_TOOL_NAME_CONFLICT"
         );
@@ -198,9 +213,23 @@ class v {
     return e;
   }
 }
-class C {
+class G {
   constructor(e) {
-    this.activeToolsets = /* @__PURE__ */ new Set(), this.server = e.server, this.resolver = e.resolver, this.context = e.context, this.onToolsListChanged = e.onToolsListChanged, this.exposurePolicy = e.exposurePolicy, this.toolRegistry = e.toolRegistry ?? new v({ namespaceWithToolset: !0 });
+    this.activeToolsets = /* @__PURE__ */ new Set(), this.server = e.server, this.resolver = e.resolver, this.context = e.context, this.onToolsListChanged = e.onToolsListChanged, this.exposurePolicy = e.exposurePolicy, this.toolRegistry = e.toolRegistry ?? new P({ namespaceWithToolset: !0 });
+  }
+  /**
+   * Sends a tool list change notification if configured.
+   * Logs warnings on failure instead of throwing.
+   * @returns Promise that resolves when notification is sent (or skipped)
+   * @private
+   */
+  async notifyToolsChanged() {
+    if (this.onToolsListChanged)
+      try {
+        await this.onToolsListChanged();
+      } catch (e) {
+        console.warn("Failed to send tool list change notification:", e);
+      }
   }
   getAvailableToolsets() {
     return this.resolver.getAvailableToolsets();
@@ -214,66 +243,97 @@ class C {
   isActive(e) {
     return this.activeToolsets.has(e);
   }
-  async enableToolset(e) {
-    const s = this.resolver.validateToolsetName(e);
-    if (!s.isValid || !s.sanitized)
+  /**
+   * Enables a single toolset by name.
+   * Validates the toolset, checks exposure policies, resolves tools, and registers them.
+   * @param toolsetName - The name of the toolset to enable
+   * @param skipNotification - If true, skips the tool list change notification (for batch operations)
+   * @returns Result object with success status and message
+   */
+  async enableToolset(e, s = !1) {
+    const t = this.resolver.validateToolsetName(e);
+    if (!t.isValid || !t.sanitized)
       return {
         success: !1,
-        message: s.error || "Unknown validation error"
+        message: t.error || "Unknown validation error"
       };
-    const t = s.sanitized;
-    if (this.activeToolsets.has(t))
+    const o = t.sanitized;
+    if (this.activeToolsets.has(o))
       return {
         success: !1,
-        message: `Toolset '${t}' is already enabled.`
+        message: `Toolset '${o}' is already enabled.`
       };
+    const i = this.checkExposurePolicy(o);
+    if (!i.allowed)
+      return { success: !1, message: i.message };
+    const n = [];
     try {
-      const o = await this.resolver.resolveToolsForToolsets(
-        [t],
+      const l = await this.resolver.resolveToolsForToolsets(
+        [o],
         this.context
       );
-      if (this.exposurePolicy?.allowlist && !this.exposurePolicy.allowlist.includes(t))
-        return {
-          success: !1,
-          message: `Toolset '${t}' is not allowed by policy.`
-        };
-      if (this.exposurePolicy?.denylist && this.exposurePolicy.denylist.includes(t))
-        return {
-          success: !1,
-          message: `Toolset '${t}' is denied by policy.`
-        };
-      if (this.exposurePolicy?.maxActiveToolsets !== void 0 && this.activeToolsets.size + 1 > this.exposurePolicy.maxActiveToolsets)
-        return this.exposurePolicy.onLimitExceeded?.(
-          [t],
-          Array.from(this.activeToolsets)
-        ), {
-          success: !1,
-          message: `Activation exceeds maxActiveToolsets (${this.exposurePolicy.maxActiveToolsets}).`
-        };
-      if (o && o.length > 0) {
-        const r = this.toolRegistry.mapAndValidate(
-          t,
-          o
+      if (l && l.length > 0) {
+        const a = this.toolRegistry.mapAndValidate(
+          o,
+          l
         );
-        this.registerDirectTools(r, t);
-      }
-      this.activeToolsets.add(t);
-      try {
-        await this.onToolsListChanged?.();
-      } catch (r) {
-        console.warn("Failed to send tool list change notification:", r);
+        for (const c of a)
+          this.registerSingleTool(c, o), n.push(c.name);
       }
-      return {
+      return this.activeToolsets.add(o), s || await this.notifyToolsChanged(), {
         success: !0,
-        message: `Toolset '${t}' enabled successfully. Registered ${o?.length ?? 0} tools.`
+        message: `Toolset '${o}' enabled successfully. Registered ${l?.length ?? 0} tools.`
       };
-    } catch (o) {
-      return this.activeToolsets.delete(t), {
+    } catch (l) {
+      return n.length > 0 && console.warn(
+        `Partial failure enabling toolset '${o}'. ${n.length} tools were registered but toolset activation failed. Tools remain registered due to MCP limitations: ${n.join(", ")}`
+      ), {
         success: !1,
-        message: `Failed to enable toolset '${t}': ${o instanceof Error ? o.message : "Unknown error"}`
+        message: `Failed to enable toolset '${o}': ${l instanceof Error ? l.message : "Unknown error"}`
       };
     }
   }
+  /**
+   * Checks if a toolset is allowed by the exposure policy.
+   * @param toolsetName - The sanitized toolset name to check
+   * @returns Object indicating if allowed and reason message if not
+   * @private
+   */
+  checkExposurePolicy(e) {
+    return this.exposurePolicy?.allowlist && !this.exposurePolicy.allowlist.includes(e) ? {
+      allowed: !1,
+      message: `Toolset '${e}' is not allowed by policy.`
+    } : this.exposurePolicy?.denylist && this.exposurePolicy.denylist.includes(e) ? {
+      allowed: !1,
+      message: `Toolset '${e}' is denied by policy.`
+    } : this.exposurePolicy?.maxActiveToolsets !== void 0 && this.activeToolsets.size + 1 > this.exposurePolicy.maxActiveToolsets ? (this.exposurePolicy.onLimitExceeded?.(
+      [e],
+      Array.from(this.activeToolsets)
+    ), {
+      allowed: !1,
+      message: `Activation exceeds maxActiveToolsets (${this.exposurePolicy.maxActiveToolsets}).`
+    }) : { allowed: !0, message: "" };
+  }
+  /**
+   * Registers a single tool with the MCP server.
+   * @param tool - The tool definition to register
+   * @param toolsetKey - The toolset key for tracking
+   * @private
+   */
+  registerSingleTool(e, s) {
+    this.server.tool(
+      e.name,
+      e.description,
+      e.inputSchema,
+      async (t) => await e.handler(t)
+    ), this.toolRegistry.addForToolset(s, e.name);
+  }
+  /**
+   * Disables a toolset by name.
+   * Note: Due to MCP limitations, tools remain registered but the toolset is marked inactive.
+   * @param toolsetName - The name of the toolset to disable
+   * @returns Result object with success status and message
+   */
   async disableToolset(e) {
     const s = this.resolver.validateToolsetName(e);
     if (!s.isValid || !s.sanitized) {
@@ -284,20 +344,12 @@ class C {
       };
     }
     const t = s.sanitized;
-    if (!this.activeToolsets.has(t))
-      return {
-        success: !1,
-        message: `Toolset '${t}' is not currently active. Active toolsets: ${Array.from(this.activeToolsets).join(", ") || "none"}`
-      };
-    this.activeToolsets.delete(t);
-    try {
-      await this.onToolsListChanged?.();
-    } catch (o) {
-      console.warn("Failed to send tool list change notification:", o);
-    }
-    return {
+    return this.activeToolsets.has(t) ? (this.activeToolsets.delete(t), await this.notifyToolsChanged(), {
       success: !0,
       message: `Toolset '${t}' disabled successfully. Individual tools remain registered due to MCP limitations.`
+    }) : {
+      success: !1,
+      message: `Toolset '${t}' is not currently active. Active toolsets: ${Array.from(this.activeToolsets).join(", ") || "none"}`
     };
   }
   getStatus() {
@@ -311,159 +363,181 @@ class C {
       toolsetToTools: this.toolRegistry.listByToolset()
     };
   }
+  /**
+   * Enables multiple toolsets in a batch operation.
+   * Sends a single notification after all toolsets are processed.
+   * @param toolsetNames - Array of toolset names to enable
+   * @returns Result object with overall success status and individual results
+   */
   async enableToolsets(e) {
     const s = [];
-    for (const r of e)
+    for (const n of e)
       try {
-        const i = await this.enableToolset(r);
-        s.push({ name: r, ...i });
-      } catch (i) {
+        const l = await this.enableToolset(n, !0);
+        s.push({ name: n, ...l });
+      } catch (l) {
         s.push({
-          name: r,
+          name: n,
           success: !1,
-          message: i instanceof Error ? i.message : "Unknown error",
+          message: l instanceof Error ? l.message : "Unknown error",
           code: "E_INTERNAL"
         });
       }
-    const t = s.every((r) => r.success), o = t ? "All toolsets enabled" : "Some toolsets failed to enable";
-    if (s.length > 0)
-      try {
-        await this.onToolsListChanged?.();
-      } catch {
-      }
-    return { success: t, results: s, message: o };
-  }
-  registerDirectTools(e, s) {
-    for (const t of e)
-      try {
-        this.server.tool(
-          t.name,
-          t.description,
-          t.inputSchema,
-          async (o) => await t.handler(o)
-        ), s ? this.toolRegistry.addForToolset(s, t.name) : this.toolRegistry.add(t.name);
-      } catch (o) {
-        throw console.error(`Failed to register direct tool '${t.name}':`, o), o;
-      }
+    const t = s.every((n) => n.success), o = s.some((n) => n.success), i = t ? "All toolsets enabled" : o ? "Some toolsets failed to enable" : "All toolsets failed to enable";
+    return o && await this.notifyToolsChanged(), { success: t, results: s, message: i };
   }
+  /**
+   * Enables all available toolsets in a batch operation.
+   * @returns Result object with overall success status and individual results
+   */
   async enableAllToolsets() {
     const e = this.getAvailableToolsets();
     return this.enableToolsets(e);
   }
 }
-function I(a, e, s) {
-  const t = s?.mode ?? "DYNAMIC";
-  a.tool(
+function K(r, e, s) {
+  (s?.mode ?? "DYNAMIC") === "DYNAMIC" && (r.tool(
     "enable_toolset",
     "Enable a toolset by name",
-    { name: f.string().describe("Toolset name") },
+    { name: w.string().describe("Toolset name") },
     async (o) => {
-      const { name: r } = o, i = await e.enableToolset(r);
+      const i = await e.enableToolset(o.name);
       return {
         content: [{ type: "text", text: JSON.stringify(i) }]
       };
     }
-  ), a.tool(
+  ), r.tool(
     "disable_toolset",
     "Disable a toolset by name (state only)",
-    { name: f.string().describe("Toolset name") },
+    { name: w.string().describe("Toolset name") },
     async (o) => {
-      const { name: r } = o, i = await e.disableToolset(r);
+      const i = await e.disableToolset(o.name);
       return {
         content: [{ type: "text", text: JSON.stringify(i) }]
       };
     }
-  ), t === "DYNAMIC" && (a.tool(
+  ), r.tool(
     "list_toolsets",
     "List available toolsets with active status and definitions",
     {},
     async () => {
-      const o = e.getAvailableToolsets(), r = e.getStatus().toolsetToTools, i = o.map((l) => {
-        const n = e.getToolsetDefinition(l);
+      const o = e.getAvailableToolsets(), i = e.getStatus().toolsetToTools, n = o.map((l) => {
+        const a = e.getToolsetDefinition(l);
         return {
           key: l,
           active: e.isActive(l),
-          definition: n ? {
-            name: n.name,
-            description: n.description,
-            modules: n.modules ?? [],
-            decisionCriteria: n.decisionCriteria ?? void 0
+          definition: a ? {
+            name: a.name,
+            description: a.description,
+            modules: a.modules ?? [],
+            decisionCriteria: a.decisionCriteria ?? void 0
           } : null,
-          tools: r[l] ?? []
+          tools: i[l] ?? []
         };
       });
       return {
         content: [
-          { type: "text", text: JSON.stringify({ toolsets: i }) }
+          { type: "text", text: JSON.stringify({ toolsets: n }) }
         ]
       };
     }
-  ), a.tool(
+  ), r.tool(
     "describe_toolset",
     "Describe a toolset with definition, active status and tools",
-    { name: f.string().describe("Toolset name") },
+    { name: w.string().describe("Toolset name") },
     async (o) => {
-      const { name: r } = o, i = e.getToolsetDefinition(r), l = e.getStatus().toolsetToTools;
+      const i = e.getToolsetDefinition(o.name), n = e.getStatus().toolsetToTools;
       if (!i)
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify({ error: `Unknown toolset '${r}'` })
+              text: JSON.stringify({ error: `Unknown toolset '${o.name}'` })
             }
           ]
         };
-      const n = {
-        key: r,
-        active: e.isActive(r),
+      const l = {
+        key: o.name,
+        active: e.isActive(o.name),
         definition: {
           name: i.name,
           description: i.description,
           modules: i.modules ?? [],
           decisionCriteria: i.decisionCriteria ?? void 0
         },
-        tools: l[r] ?? []
+        tools: n[o.name] ?? []
       };
       return {
-        content: [{ type: "text", text: JSON.stringify(n) }]
+        content: [{ type: "text", text: JSON.stringify(l) }]
       };
     }
-  )), a.tool(
+  )), r.tool(
     "list_tools",
     "List currently registered tool names (best effort)",
     {},
     async () => {
-      const o = e.getStatus(), r = {
+      const o = e.getStatus(), i = {
         tools: o.tools,
         toolsetToTools: o.toolsetToTools
       };
       return {
-        content: [{ type: "text", text: JSON.stringify(r) }]
+        content: [{ type: "text", text: JSON.stringify(i) }]
       };
     }
   );
 }
-class y {
+class T {
   constructor(e) {
-    this.toolsetValidator = new S();
+    this.initError = null, this.toolsetValidator = new q();
     const s = e.startup ?? {}, t = this.resolveStartupConfig(s, e.catalog);
-    this.mode = t.mode, this.resolver = new x({
+    this.mode = t.mode, this.resolver = new J({
       catalog: e.catalog,
       moduleLoaders: e.moduleLoaders
     });
-    const o = new v({
+    const o = new P({
       namespaceWithToolset: e.exposurePolicy?.namespaceToolsWithSetKey ?? !0
     });
-    this.manager = new C({
+    this.manager = new G({
       server: e.server,
       resolver: this.resolver,
       context: e.context,
       onToolsListChanged: e.notifyToolsListChanged,
       exposurePolicy: e.exposurePolicy,
       toolRegistry: o
-    }), e.registerMetaTools !== !1 && I(e.server, this.manager, { mode: this.mode });
-    const r = t.toolsets;
-    r === "ALL" ? this.manager.enableToolsets(this.resolver.getAvailableToolsets()) : Array.isArray(r) && r.length > 0 && this.manager.enableToolsets(r);
+    }), e.registerMetaTools !== !1 && K(e.server, this.manager, { mode: this.mode });
+    const i = t.toolsets;
+    this.initPromise = this.initializeToolsets(i);
+  }
+  /**
+   * Initializes toolsets asynchronously during construction.
+   * Stores any errors for later retrieval via ensureReady().
+   * @param initial - The toolsets to initialize or "ALL"
+   * @returns Promise that resolves when initialization is complete
+   * @private
+   */
+  async initializeToolsets(e) {
+    try {
+      e === "ALL" ? await this.manager.enableToolsets(this.resolver.getAvailableToolsets()) : Array.isArray(e) && e.length > 0 && await this.manager.enableToolsets(e);
+    } catch (s) {
+      this.initError = s instanceof Error ? s : new Error(String(s)), console.error("Failed to initialize toolsets:", this.initError);
+    }
+  }
+  /**
+   * Waits for the orchestrator to be fully initialized.
+   * Call this before using the orchestrator to ensure all toolsets are loaded.
+   * @throws {Error} If initialization failed
+   */
+  async ensureReady() {
+    if (await this.initPromise, this.initError)
+      throw this.initError;
+  }
+  /**
+   * Checks if the orchestrator has finished initialization.
+   * Does not throw on error - use ensureReady() for that.
+   * @returns Promise that resolves to true if ready, false if initialization failed
+   */
+  async isReady() {
+    return await this.initPromise, this.initError === null;
   }
   resolveStartupConfig(e, s) {
     if (e.mode) {
@@ -473,9 +547,9 @@ class y {
         if (e.toolsets === "ALL")
           return { mode: "STATIC", toolsets: "ALL" };
         const t = Array.isArray(e.toolsets) ? e.toolsets : [], o = [];
-        for (const r of t) {
-          const { isValid: i, sanitized: l, error: n } = this.toolsetValidator.validateToolsetName(r, s);
-          i && l ? o.push(l) : n && console.warn(n);
+        for (const i of t) {
+          const { isValid: n, sanitized: l, error: a } = this.toolsetValidator.validateToolsetName(i, s);
+          n && l ? o.push(l) : a && console.warn(a);
         }
         if (t.length > 0 && o.length === 0)
           throw new Error(
@@ -489,8 +563,8 @@ class y {
     if (Array.isArray(e.toolsets) && e.toolsets.length > 0) {
       const t = [];
       for (const o of e.toolsets) {
-        const { isValid: r, sanitized: i, error: l } = this.toolsetValidator.validateToolsetName(o, s);
-        r && i ? t.push(i) : l && console.warn(l);
+        const { isValid: i, sanitized: n, error: l } = this.toolsetValidator.validateToolsetName(o, s);
+        i && n ? t.push(n) : l && console.warn(l);
       }
       if (t.length === 0)
         throw new Error(
@@ -507,9 +581,11 @@ class y {
     return this.manager;
   }
 }
-class M {
+var p, b;
+class $ {
   constructor(e = {}) {
-    this.storage = /* @__PURE__ */ new Map(), this.maxSize = e.maxSize ?? 1e3, this.ttlMs = e.ttlMs ?? 1e3 * 60 * 60;
+    y(this, p);
+    this.storage = /* @__PURE__ */ new Map(), this.maxSize = e.maxSize ?? 1e3, this.ttlMs = e.ttlMs ?? 1e3 * 60 * 60, this.onEvict = e.onEvict;
     const s = e.pruneIntervalMs ?? 1e3 * 60 * 10;
     this.pruneInterval = setInterval(() => this.pruneExpired(), s);
   }
@@ -531,25 +607,76 @@ class M {
     const t = { resource: s, lastAccessed: Date.now() };
     this.storage.set(e, t);
   }
+  /**
+   * Removes an entry from the cache.
+   * Calls the onEvict callback if configured.
+   * @param key - The key to remove
+   */
   delete(e) {
-    this.storage.delete(e);
+    const s = this.storage.get(e);
+    s && (this.storage.delete(e), u(this, p, b).call(this, e, s.resource));
   }
-  stop() {
-    this.pruneInterval && (clearInterval(this.pruneInterval), this.pruneInterval = void 0);
+  /**
+   * Stops the background pruning interval and optionally clears all entries.
+   * @param clearEntries - If true, also removes all entries and calls onEvict for each
+   */
+  stop(e = !1) {
+    this.pruneInterval && (clearInterval(this.pruneInterval), this.pruneInterval = void 0), e && this.clear();
   }
+  /**
+   * Clears all entries from the cache.
+   * Calls onEvict for each entry being removed.
+   */
+  clear() {
+    const e = Array.from(this.storage.entries());
+    this.storage.clear();
+    for (const [s, t] of e)
+      u(this, p, b).call(this, s, t.resource);
+  }
+  /**
+   * Evicts the least recently used entry from the cache.
+   * @private
+   */
   evictLeastRecentlyUsed() {
     const e = this.storage.keys().next().value;
     e && this.delete(e);
   }
+  /**
+   * Removes all expired entries from the cache.
+   * @private
+   */
   pruneExpired() {
-    const e = Date.now();
-    for (const [s, t] of this.storage.entries())
-      e - t.lastAccessed > this.ttlMs && this.delete(s);
+    const e = Date.now(), s = [];
+    for (const [t, o] of this.storage.entries())
+      e - o.lastAccessed > this.ttlMs && s.push(t);
+    for (const t of s)
+      this.delete(t);
   }
 }
-class L {
+p = new WeakSet(), /**
+ * Safely calls the evict callback, catching and logging any errors.
+ * @param key - The key being evicted
+ * @param resource - The resource being evicted
+ * @private
+ */
+b = function(e, s) {
+  if (this.onEvict)
+    try {
+      const t = this.onEvict(e, s);
+      t instanceof Promise && t.catch((o) => {
+        console.warn(`Error in cache eviction callback for key '${e}':`, o);
+      });
+    } catch (t) {
+      console.warn(`Error in cache eviction callback for key '${e}':`, t);
+    }
+};
+class Q {
   constructor(e, s, t = {}, o) {
-    this.app = null, this.clientCache = new M(), this.defaultManager = e, this.createBundle = s, this.options = {
+    this.app = null, this.clientCache = new $({
+      onEvict: (i, n) => {
+        this.cleanupBundle(n);
+      }
+    }), this.defaultManager = e, this.createBundle = s, this.options = {
       host: t.host ?? "0.0.0.0",
       port: t.port ?? 3e3,
       basePath: t.basePath ?? "/",
@@ -560,8 +687,8 @@ class L {
   }
   async start() {
     if (this.app) return;
-    const e = this.options.app ?? p({ logger: this.options.logger });
-    this.options.cors && await e.register(A, { origin: !0 });
+    const e = this.options.app ?? M({ logger: this.options.logger });
+    this.options.cors && await e.register(x, { origin: !0 });
     const s = this.options.basePath.endsWith("/") ? this.options.basePath.slice(0, -1) : this.options.basePath;
     e.get(`${s}/healthz`, async () => ({ ok: !0 })), e.get(`${s}/tools`, async () => this.defaultManager.getStatus()), e.get(`${s}/.well-known/mcp-config`, async (t, o) => (o.header("Content-Type", "application/schema+json; charset=utf-8"), this.configSchema ?? {
       $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -575,30 +702,30 @@ class L {
     })), e.post(
       `${s}/mcp`,
       async (t, o) => {
-        const r = t.headers["mcp-client-id"]?.trim(), i = r && r.length > 0 ? r : `anon-${m()}`, l = !i.startsWith("anon-");
-        let n = l ? this.clientCache.get(i) : null;
-        if (!n) {
-          const h = this.createBundle(), u = h.sessions;
-          n = {
-            server: h.server,
-            orchestrator: h.orchestrator,
-            sessions: u instanceof Map ? u : /* @__PURE__ */ new Map()
-          }, l && this.clientCache.set(i, n);
+        const i = t.headers["mcp-client-id"]?.trim(), n = i && i.length > 0 ? i : `anon-${v()}`, l = !n.startsWith("anon-");
+        let a = l ? this.clientCache.get(n) : null;
+        if (!a) {
+          const m = this.createBundle(), g = m.sessions;
+          a = {
+            server: m.server,
+            orchestrator: m.orchestrator,
+            sessions: g instanceof Map ? g : /* @__PURE__ */ new Map()
+          }, l && this.clientCache.set(n, a);
         }
         const c = t.headers["mcp-session-id"];
         let d;
-        if (c && n.sessions.get(c))
-          d = n.sessions.get(c);
-        else if (!c && b(t.body)) {
-          const h = m();
-          d = new w({
-            sessionIdGenerator: () => h,
-            onsessioninitialized: (u) => {
-              n.sessions.set(u, d);
+        if (c && a.sessions.get(c))
+          d = a.sessions.get(c);
+        else if (!c && I(t.body)) {
+          const m = v();
+          d = new E({
+            sessionIdGenerator: () => m,
+            onsessioninitialized: (g) => {
+              a.sessions.set(g, d);
             }
           });
           try {
-            await n.server.connect(d);
+            await a.server.connect(d);
           } catch {
             return o.code(500), {
               jsonrpc: "2.0",
@@ -607,7 +734,7 @@ class L {
             };
           }
           d.onclose = () => {
-            d?.sessionId && n.sessions.delete(d.sessionId);
+            d?.sessionId && a.sessions.delete(d.sessionId);
           };
         } else
           return o.code(400), {
@@ -622,22 +749,22 @@ class L {
         ), o;
       }
     ), e.get(`${s}/mcp`, async (t, o) => {
-      const r = t.headers["mcp-client-id"]?.trim(), i = r && r.length > 0 ? r : "";
-      if (!i)
+      const i = t.headers["mcp-client-id"]?.trim(), n = i && i.length > 0 ? i : "";
+      if (!n)
         return o.code(400), "Missing mcp-client-id";
-      const l = this.clientCache.get(i);
+      const l = this.clientCache.get(n);
       if (!l)
         return o.code(400), "Invalid or expired client";
-      const n = t.headers["mcp-session-id"];
-      if (!n)
+      const a = t.headers["mcp-session-id"];
+      if (!a)
         return o.code(400), "Missing mcp-session-id";
-      const c = l.sessions.get(n);
+      const c = l.sessions.get(a);
       return c ? (await c.handleRequest(t.raw, o.raw), o) : (o.code(400), "Invalid or expired session ID");
     }), e.delete(
       `${s}/mcp`,
       async (t, o) => {
-        const r = t.headers["mcp-client-id"]?.trim(), i = r && r.length > 0 ? r : "", l = t.headers["mcp-session-id"];
-        if (!i || !l)
+        const i = t.headers["mcp-client-id"]?.trim(), n = i && i.length > 0 ? i : "", l = t.headers["mcp-session-id"];
+        if (!n || !l)
           return o.code(400), {
             jsonrpc: "2.0",
             error: {
@@ -646,8 +773,8 @@ class L {
             },
             id: null
           };
-        const n = this.clientCache.get(i), c = n?.sessions.get(l);
-        if (!n || !c)
+        const a = this.clientCache.get(n), c = a?.sessions.get(l);
+        if (!a || !c)
           return o.code(404), {
             jsonrpc: "2.0",
             error: { code: -32e3, message: "Session not found or expired" },
@@ -660,59 +787,81 @@ class L {
             } catch {
             }
         } finally {
-          c?.sessionId ? n.sessions.delete(c.sessionId) : n.sessions.delete(l);
+          c?.sessionId ? a.sessions.delete(c.sessionId) : a.sessions.delete(l);
         }
         return o.code(204).send(), o;
       }
     ), this.options.app || await e.listen({ host: this.options.host, port: this.options.port }), this.app = e;
   }
+  /**
+   * Stops the Fastify server and cleans up all resources.
+   * Closes all client sessions and clears the cache.
+   */
   async stop() {
-    this.app && (this.options.app || await this.app.close(), this.app = null);
+    this.app && (this.clientCache.stop(!0), this.options.app || await this.app.close(), this.app = null);
+  }
+  /**
+   * Cleans up resources associated with a client bundle.
+   * Closes all sessions within the bundle.
+   * @param bundle - The client bundle to clean up
+   * @private
+   */
+  cleanupBundle(e) {
+    for (const [s, t] of e.sessions.entries())
+      try {
+        typeof t.close == "function" && t.close().catch((o) => {
+          console.warn(`Error closing session ${s}:`, o);
+        });
+      } catch (o) {
+        console.warn(`Error closing session ${s}:`, o);
+      }
+    e.sessions.clear();
   }
 }
-async function O(a) {
-  const e = a.startup?.mode ?? "DYNAMIC";
-  if (typeof a.createServer != "function")
+async function ge(r) {
+  const e = r.startup?.mode ?? "DYNAMIC";
+  if (typeof r.createServer != "function")
     throw new Error("createMcpServer: `createServer` (factory) is required");
-  const s = a.createServer(), t = (n) => typeof n?.server?.notification == "function", o = (n) => typeof n?.notifyToolsListChanged == "function", r = async (n) => {
+  const s = r.createServer(), t = (a) => typeof a?.server?.notification == "function", o = (a) => typeof a?.notifyToolsListChanged == "function", i = async (a) => {
     try {
-      if (t(n)) {
-        await n.server.notification({
+      if (t(a)) {
+        await a.server.notification({
           method: "notifications/tools/list_changed"
         });
         return;
       }
-      o(n) && await n.notifyToolsListChanged();
-    } catch {
+      o(a) && await a.notifyToolsListChanged();
+    } catch (c) {
+      console.warn("Failed to send tools list changed notification:", c);
     }
-  }, i = new y({
+  }, n = new T({
     server: s,
-    catalog: a.catalog,
-    moduleLoaders: a.moduleLoaders,
-    exposurePolicy: a.exposurePolicy,
-    context: a.context,
-    notifyToolsListChanged: async () => r(s),
-    startup: a.startup,
-    registerMetaTools: a.registerMetaTools !== void 0 ? a.registerMetaTools : e === "DYNAMIC"
-  }), l = new L(
-    i.getManager(),
+    catalog: r.catalog,
+    moduleLoaders: r.moduleLoaders,
+    exposurePolicy: r.exposurePolicy,
+    context: r.context,
+    notifyToolsListChanged: async () => i(s),
+    startup: r.startup,
+    registerMetaTools: r.registerMetaTools !== void 0 ? r.registerMetaTools : e === "DYNAMIC"
+  }), l = new Q(
+    n.getManager(),
     () => {
       if (e === "STATIC")
-        return { server: s, orchestrator: i };
-      const n = a.createServer(), c = new y({
-        server: n,
-        catalog: a.catalog,
-        moduleLoaders: a.moduleLoaders,
-        exposurePolicy: a.exposurePolicy,
-        context: a.context,
-        notifyToolsListChanged: async () => r(n),
-        startup: a.startup,
-        registerMetaTools: a.registerMetaTools !== void 0 ? a.registerMetaTools : e === "DYNAMIC"
+        return { server: s, orchestrator: n };
+      const a = r.createServer(), c = new T({
+        server: a,
+        catalog: r.catalog,
+        moduleLoaders: r.moduleLoaders,
+        exposurePolicy: r.exposurePolicy,
+        context: r.context,
+        notifyToolsListChanged: async () => i(a),
+        startup: r.startup,
+        registerMetaTools: r.registerMetaTools !== void 0 ? r.registerMetaTools : e === "DYNAMIC"
       });
-      return { server: n, orchestrator: c };
+      return { server: a, orchestrator: c };
     },
-    a.http,
-    a.configSchema
+    r.http,
+    r.configSchema
   );
   return {
     server: s,
@@ -724,7 +873,561 @@ async function O(a) {
     }
   };
 }
+function X(r) {
+  Z(r), ee(r), se(r), te(r);
+}
+function Z(r) {
+  if (!r || typeof r != "object")
+    throw new Error(
+      "Permission configuration is required for createPermissionBasedMcpServer"
+    );
+}
+function ee(r) {
+  if (!r.source)
+    throw new Error('Permission source must be either "headers" or "config"');
+  if (r.source !== "headers" && r.source !== "config")
+    throw new Error(
+      `Invalid permission source: "${r.source}". Must be either "headers" or "config"`
+    );
+}
+function se(r) {
+  if (r.source === "config" && !r.staticMap && !r.resolver)
+    throw new Error(
+      "Config-based permissions require at least one of: staticMap or resolver function"
+    );
+}
+function te(r) {
+  if (r.staticMap !== void 0) {
+    if (typeof r.staticMap != "object" || r.staticMap === null)
+      throw new Error(
+        "staticMap must be an object mapping client IDs to toolset arrays"
+      );
+    oe(r.staticMap);
+  }
+  if (r.resolver !== void 0 && typeof r.resolver != "function")
+    throw new Error(
+      "resolver must be a synchronous function: (clientId: string) => string[]"
+    );
+  if (r.defaultPermissions !== void 0 && !Array.isArray(r.defaultPermissions))
+    throw new Error("defaultPermissions must be an array of toolset names");
+  if (r.headerName !== void 0 && (typeof r.headerName != "string" || r.headerName.length === 0))
+    throw new Error("headerName must be a non-empty string");
+}
+function oe(r) {
+  for (const [e, s] of Object.entries(r))
+    if (!Array.isArray(s))
+      throw new Error(
+        `staticMap value for client "${e}" must be an array of toolset names`
+      );
+}
+var f, L, j, N, k, D;
+class re {
+  /**
+   * Creates a new PermissionResolver instance.
+   * @param config - The permission configuration defining how permissions are resolved
+   */
+  constructor(e) {
+    y(this, f);
+    this.config = e, this.cache = /* @__PURE__ */ new Map(), this.normalizedHeaderName = (e.headerName || "mcp-toolset-permissions").toLowerCase();
+  }
+  /**
+   * Resolves permissions for a client based on the configured source.
+   * Results are cached to improve performance for subsequent requests from the same client.
+   * Handles all errors gracefully by returning empty permissions on failure.
+   * 
+   * Note on caching: For header-based permissions, permissions are cached by clientId.
+   * This means subsequent requests from the same client will use cached permissions,
+   * even if headers change. Use invalidateCache(clientId) to force re-resolution.
+   * 
+   * @param clientId - The unique identifier for the client
+   * @param headers - Optional request headers (required for header-based permissions)
+   * @returns Array of toolset names the client is allowed to access
+   */
+  resolvePermissions(e, s) {
+    if (this.cache.has(e))
+      return this.cache.get(e);
+    let t;
+    try {
+      this.config.source === "headers" ? t = u(this, f, L).call(this, s) : t = u(this, f, N).call(this, e), Array.isArray(t) || (console.warn(
+        `Permission resolution returned non-array for client ${e}, using empty permissions`
+      ), t = []), t = t.filter(
+        (o) => typeof o == "string" && o.trim().length > 0
+      );
+    } catch (o) {
+      console.error(
+        `Unexpected error resolving permissions for client ${e}:`,
+        o
+      ), t = [];
+    }
+    return this.cache.set(e, t), t;
+  }
+  /**
+   * Invalidates cached permissions for a specific client.
+   * Call this when you know a client's permissions have changed.
+   * @param clientId - The client ID to invalidate
+   */
+  invalidateCache(e) {
+    this.cache.delete(e);
+  }
+  /**
+   * Clears the permission cache.
+   * Useful for cleanup during server shutdown or when permissions need to be refreshed.
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+}
+f = new WeakSet(), /**
+ * Parses permissions from request headers.
+ * Extracts comma-separated toolset names from the configured header.
+ * Handles malformed headers gracefully by returning empty permissions.
+ * Uses case-insensitive header lookup per RFC 7230.
+ * @param headers - Request headers containing permission data
+ * @returns Array of toolset names from headers, or empty array if header is missing/malformed
+ * @private
+ */
+L = function(e) {
+  if (!e)
+    return [];
+  const s = u(this, f, j).call(this, e, this.normalizedHeaderName);
+  if (!s)
+    return [];
+  try {
+    return s.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  } catch (t) {
+    return console.warn(
+      `Failed to parse permission header '${this.normalizedHeaderName}':`,
+      t
+    ), [];
+  }
+}, /**
+ * Finds a header value using case-insensitive key matching.
+ * HTTP headers are case-insensitive per RFC 7230.
+ * @param headers - The headers object to search
+ * @param normalizedKey - The lowercase key to search for
+ * @returns The header value if found, undefined otherwise
+ * @private
+ */
+j = function(e, s) {
+  if (e[s] !== void 0)
+    return e[s];
+  for (const [t, o] of Object.entries(e))
+    if (t.toLowerCase() === s)
+      return o;
+}, /**
+ * Resolves permissions from server-side configuration.
+ * Tries resolver function first (if provided), then falls back to static map,
+ * and finally to default permissions. Handles errors gracefully.
+ * @param clientId - The unique identifier for the client
+ * @returns Array of toolset names from configuration
+ * @private
+ */
+N = function(e) {
+  if (this.config.resolver) {
+    const s = u(this, f, k).call(this, e);
+    if (s !== null)
+      return s;
+  }
+  if (this.config.staticMap) {
+    const s = u(this, f, D).call(this, e);
+    if (s !== null)
+      return s;
+  }
+  return this.config.defaultPermissions || [];
+}, /**
+ * Attempts to resolve permissions using the configured resolver function.
+ * Handles errors gracefully and returns null on failure to allow fallback.
+ * @param clientId - The unique identifier for the client
+ * @returns Array of toolset names if successful, null if resolver fails or returns invalid data
+ * @private
+ */
+k = function(e) {
+  try {
+    const s = this.config.resolver(e);
+    return Array.isArray(s) ? s : (console.warn(
+      `Permission resolver returned non-array for client ${e}, using fallback`
+    ), null);
+  } catch (s) {
+    const t = s instanceof Error ? s.message : String(s);
+    return console.warn(
+      `Permission resolver declined client ${e} (${t}), trying fallback`
+    ), null;
+  }
+}, /**
+ * Looks up permissions in the static map configuration.
+ * Returns null if client is not found to allow fallback to defaults.
+ * @param clientId - The unique identifier for the client
+ * @returns Array of toolset names if found, null if client not in map
+ * @private
+ */
+D = function(e) {
+  const s = this.config.staticMap[e];
+  return s !== void 0 ? Array.isArray(s) ? s : [] : null;
+};
+function ie(r, e) {
+  return async (s) => {
+    const t = e.resolvePermissions(
+      s.clientId,
+      s.headers
+    ), o = r(t), i = o.orchestrator.getManager(), n = [], l = [];
+    if (t.length > 0) {
+      const a = await i.enableToolsets(t);
+      for (const c of a.results)
+        c.success ? n.push(c.name) : (l.push(c.name), console.warn(
+          `Failed to enable toolset '${c.name}' for client '${s.clientId}': ${c.message}`
+        ));
+      if (n.length === 0 && l.length > 0)
+        throw new Error(
+          `All requested toolsets failed to enable for client '${s.clientId}'. Requested: [${t.join(", ")}]. Check that toolset names in permissions match the catalog.`
+        );
+    }
+    return {
+      server: o.server,
+      orchestrator: o.orchestrator,
+      allowedToolsets: n,
+      failedToolsets: l
+    };
+  };
+}
+var h, z, R, O, F, V, _, B, Y, H, U;
+class ne {
+  /**
+   * Creates a new PermissionAwareFastifyTransport instance.
+   * @param defaultManager - Default tool manager for status endpoints
+   * @param createPermissionAwareBundle - Function to create permission-aware bundles
+   * @param options - Transport configuration options
+   * @param configSchema - Optional JSON schema for configuration discovery
+   */
+  constructor(e, s, t = {}, o) {
+    y(this, h);
+    this.app = null, this.clientCache = new $({
+      onEvict: (i, n) => {
+        u(this, h, z).call(this, n);
+      }
+    }), this.defaultManager = e, this.createPermissionAwareBundle = s, this.options = {
+      host: t.host ?? "0.0.0.0",
+      port: t.port ?? 3e3,
+      basePath: t.basePath ?? "/",
+      cors: t.cors ?? !0,
+      logger: t.logger ?? !1,
+      app: t.app
+    }, this.configSchema = o;
+  }
+  /**
+   * Starts the Fastify server and registers all MCP endpoints.
+   * Sets up routes for health checks, tool status, and MCP protocol handling.
+   */
+  async start() {
+    if (this.app) return;
+    const e = this.options.app ?? M({ logger: this.options.logger });
+    this.options.cors && await e.register(x, { origin: !0 });
+    const s = u(this, h, R).call(this, this.options.basePath);
+    u(this, h, O).call(this, e, s), u(this, h, F).call(this, e, s), u(this, h, V).call(this, e, s), u(this, h, _).call(this, e, s), u(this, h, B).call(this, e, s), u(this, h, Y).call(this, e, s), this.options.app || await e.listen({ host: this.options.host, port: this.options.port }), this.app = e;
+  }
+  /**
+   * Stops the Fastify server and cleans up all resources.
+   * Closes all client sessions and clears the cache.
+   */
+  async stop() {
+    this.app && (this.clientCache.stop(!0), this.options.app || await this.app.close(), this.app = null);
+  }
+}
+h = new WeakSet(), /**
+ * Cleans up resources associated with a client bundle.
+ * Closes all sessions within the bundle.
+ * @param bundle - The client bundle to clean up
+ * @private
+ */
+z = function(e) {
+  for (const [s, t] of e.sessions.entries())
+    try {
+      typeof t.close == "function" && t.close().catch((o) => {
+        console.warn(`Error closing session ${s}:`, o);
+      });
+    } catch (o) {
+      console.warn(`Error closing session ${s}:`, o);
+    }
+  e.sessions.clear();
+}, /**
+ * Normalizes the base path by removing trailing slashes.
+ * @param basePath - The base path to normalize
+ * @returns Normalized base path without trailing slash
+ * @private
+ */
+R = function(e) {
+  return e.endsWith("/") ? e.slice(0, -1) : e;
+}, /**
+ * Registers the health check endpoint.
+ * @param app - Fastify instance
+ * @param base - Base path for routes
+ * @private
+ */
+O = function(e, s) {
+  e.get(`${s}/healthz`, async () => ({ ok: !0 }));
+}, /**
+ * Registers the tools status endpoint.
+ * @param app - Fastify instance
+ * @param base - Base path for routes
+ * @private
+ */
+F = function(e, s) {
+  e.get(`${s}/tools`, async () => this.defaultManager.getStatus());
+}, /**
+ * Registers the MCP configuration discovery endpoint.
+ * @param app - Fastify instance
+ * @param base - Base path for routes
+ * @private
+ */
+V = function(e, s) {
+  e.get(`${s}/.well-known/mcp-config`, async (t, o) => (o.header("Content-Type", "application/schema+json; charset=utf-8"), this.configSchema ?? {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    title: "MCP Session Configuration",
+    description: "Schema for the /mcp endpoint configuration",
+    type: "object",
+    properties: {},
+    required: [],
+    "x-mcp-version": "1.0",
+    "x-query-style": "dot+bracket"
+  }));
+}, /**
+ * Registers the POST /mcp endpoint for JSON-RPC requests.
+ * Extracts client context, resolves permissions, and handles MCP protocol.
+ * @param app - Fastify instance
+ * @param base - Base path for routes
+ * @private
+ */
+_ = function(e, s) {
+  e.post(
+    `${s}/mcp`,
+    async (t, o) => {
+      const i = u(this, h, H).call(this, t), n = !i.clientId.startsWith("anon-");
+      let l = n ? this.clientCache.get(i.clientId) : null;
+      if (!l)
+        try {
+          const d = await this.createPermissionAwareBundle(i);
+          d.failedToolsets.length > 0 && console.warn(
+            `Client ${i.clientId} had ${d.failedToolsets.length} toolsets fail to enable: [${d.failedToolsets.join(", ")}]. Successfully enabled: [${d.allowedToolsets.join(", ")}]`
+          );
+          const m = d.sessions;
+          l = {
+            server: d.server,
+            orchestrator: d.orchestrator,
+            allowedToolsets: d.allowedToolsets,
+            failedToolsets: d.failedToolsets,
+            sessions: m instanceof Map ? m : /* @__PURE__ */ new Map()
+          }, n && this.clientCache.set(i.clientId, l);
+        } catch (d) {
+          return console.error(
+            `Failed to create permission-aware bundle for client ${i.clientId}:`,
+            d
+          ), o.code(403), u(this, h, U).call(this, "Access denied");
+        }
+      const a = t.headers["mcp-session-id"];
+      let c;
+      if (a && l.sessions.get(a))
+        c = l.sessions.get(a);
+      else if (!a && I(t.body)) {
+        const d = v();
+        c = new E({
+          sessionIdGenerator: () => d,
+          onsessioninitialized: (m) => {
+            l.sessions.set(m, c);
+          }
+        });
+        try {
+          await l.server.connect(c);
+        } catch {
+          return o.code(500), {
+            jsonrpc: "2.0",
+            error: { code: -32603, message: "Error initializing server." },
+            id: null
+          };
+        }
+        c.onclose = () => {
+          c?.sessionId && l.sessions.delete(c.sessionId);
+        };
+      } else
+        return o.code(400), {
+          jsonrpc: "2.0",
+          error: { code: -32e3, message: "Session not found or expired" },
+          id: null
+        };
+      return await c.handleRequest(
+        t.raw,
+        o.raw,
+        t.body
+      ), o;
+    }
+  );
+}, /**
+ * Registers the GET /mcp endpoint for SSE notifications.
+ * @param app - Fastify instance
+ * @param base - Base path for routes
+ * @private
+ */
+B = function(e, s) {
+  e.get(`${s}/mcp`, async (t, o) => {
+    const i = t.headers["mcp-client-id"]?.trim(), n = i && i.length > 0 ? i : "";
+    if (!n)
+      return o.code(400), "Missing mcp-client-id";
+    const l = this.clientCache.get(n);
+    if (!l)
+      return o.code(400), "Invalid or expired client";
+    const a = t.headers["mcp-session-id"];
+    if (!a)
+      return o.code(400), "Missing mcp-session-id";
+    const c = l.sessions.get(a);
+    return c ? (await c.handleRequest(t.raw, o.raw), o) : (o.code(400), "Invalid or expired session ID");
+  });
+}, /**
+ * Registers the DELETE /mcp endpoint for session termination.
+ * @param app - Fastify instance
+ * @param base - Base path for routes
+ * @private
+ */
+Y = function(e, s) {
+  e.delete(
+    `${s}/mcp`,
+    async (t, o) => {
+      const i = t.headers["mcp-client-id"]?.trim(), n = i && i.length > 0 ? i : "", l = t.headers["mcp-session-id"];
+      if (!n || !l)
+        return o.code(400), {
+          jsonrpc: "2.0",
+          error: {
+            code: -32600,
+            message: "Missing mcp-client-id or mcp-session-id header"
+          },
+          id: null
+        };
+      const a = this.clientCache.get(n), c = a?.sessions.get(l);
+      if (!a || !c)
+        return o.code(404), {
+          jsonrpc: "2.0",
+          error: { code: -32e3, message: "Session not found or expired" },
+          id: null
+        };
+      try {
+        if (typeof c.close == "function")
+          try {
+            await c.close();
+          } catch {
+          }
+      } finally {
+        c?.sessionId ? a.sessions.delete(c.sessionId) : a.sessions.delete(l);
+      }
+      return o.code(204).send(), o;
+    }
+  );
+}, /**
+ * Extracts client context from the request.
+ * Generates anonymous client ID if not provided in headers.
+ * @param req - Fastify request object
+ * @returns Client request context with ID and headers
+ * @private
+ */
+H = function(e) {
+  const s = e.headers["mcp-client-id"]?.trim(), t = s && s.length > 0 ? s : `anon-${v()}`, o = {};
+  for (const [i, n] of Object.entries(e.headers))
+    typeof n == "string" && (o[i] = n);
+  return { clientId: t, headers: o };
+}, /**
+ * Creates a safe error response that doesn't expose unauthorized toolset information.
+ * Used for permission-related errors to prevent information leakage.
+ * @param message - Generic error message to return to client
+ * @param code - JSON-RPC error code (default: -32000 for server error)
+ * @returns JSON-RPC error response object
+ * @private
+ */
+U = function(e = "Access denied", s = -32e3) {
+  return {
+    jsonrpc: "2.0",
+    error: {
+      code: s,
+      message: e
+    },
+    id: null
+  };
+};
+function ae(r) {
+  if (!r) return;
+  const e = {
+    namespaceToolsWithSetKey: r.namespaceToolsWithSetKey
+  };
+  return r.allowlist !== void 0 && console.warn(
+    "Permission-based servers: exposurePolicy.allowlist is ignored. Allowed toolsets are determined by client permissions."
+  ), r.denylist !== void 0 && console.warn(
+    "Permission-based servers: exposurePolicy.denylist is ignored. Use permission configuration to control toolset access."
+  ), r.maxActiveToolsets !== void 0 && console.warn(
+    "Permission-based servers: exposurePolicy.maxActiveToolsets is ignored. Toolset count is determined by client permissions."
+  ), r.onLimitExceeded !== void 0 && console.warn(
+    "Permission-based servers: exposurePolicy.onLimitExceeded is ignored. No toolset limits are enforced."
+  ), e;
+}
+async function pe(r) {
+  if (!r.permissions)
+    throw new Error(
+      "Permission configuration is required for createPermissionBasedMcpServer. Please provide a 'permissions' field in the options."
+    );
+  if (X(r.permissions), r.startup)
+    throw new Error(
+      "Permission-based servers determine toolsets from client permissions. The 'startup' option is not allowed. Remove it from your configuration."
+    );
+  if (typeof r.createServer != "function")
+    throw new Error(
+      "createPermissionBasedMcpServer: `createServer` (factory) is required"
+    );
+  const e = ae(
+    r.exposurePolicy
+  ), s = new re(r.permissions), t = r.createServer(), o = new T({
+    server: t,
+    catalog: r.catalog,
+    moduleLoaders: r.moduleLoaders,
+    exposurePolicy: e,
+    context: r.context,
+    notifyToolsListChanged: void 0,
+    // No notifications in STATIC mode
+    startup: { mode: "STATIC", toolsets: [] },
+    registerMetaTools: !1
+  }), i = ie(
+    (l) => {
+      const a = r.createServer(), c = new T({
+        server: a,
+        catalog: r.catalog,
+        moduleLoaders: r.moduleLoaders,
+        exposurePolicy: e,
+        context: r.context,
+        notifyToolsListChanged: void 0,
+        // No notifications in STATIC mode
+        startup: { mode: "STATIC", toolsets: [] },
+        // Empty - we'll enable manually
+        registerMetaTools: !1
+        // No meta-tools - toolsets are fixed per client
+      });
+      return { server: a, orchestrator: c };
+    },
+    s
+  ), n = new ne(
+    o.getManager(),
+    i,
+    r.http,
+    r.configSchema
+  );
+  return {
+    server: t,
+    start: async () => {
+      await n.start();
+    },
+    close: async () => {
+      try {
+        await n.stop();
+      } finally {
+        s.clearCache();
+      }
+    }
+  };
+}
 export {
-  O as createMcpServer
+  ge as createMcpServer,
+  pe as createPermissionBasedMcpServer
 };
 //# sourceMappingURL=index.js.map