@decaf-ts/decorator-validation 1.7.17 → 1.7.18

package/lib/mcp/ModelContextProtocol.cjs

@@ -3,6 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelContextProtocol = void 0;
 const fastmcp_1 = require("fastmcp");
 const logging_1 = require("@decaf-ts/logging");
+/**
+ * @description Validates and normalizes a semantic version string.
+ * @summary Ensures the provided version follows semantic versioning (major.minor.patch) and returns a tuple-like template string typed as `${number}.${number}.${number}`.
+ * @template
+ * @param {string} version The version string to validate, expected in the form MAJOR.MINOR.PATCH.
+ * @return {string} The normalized version string if valid.
+ * @function validateVersion
+ * @memberOf module:decorator-validation
+ */
 function validateVersion(version) {
     const regexp = /(\d+)\.(\d+)\.(\d+)/g;
     const match = regexp.exec(version);
@@ -10,21 +19,69 @@ function validateVersion(version) {
         throw new Error(`Invalid version string. should obey semantic versioning: ${version}`);
     return `${match[1]}.${match[2]}.${match[3]}`;
 }
+/**
+ * @description Fluent builder for creating a configured ModelContextProtocol instance.
+ * @summary Collects MCP configuration including a semantic version, a name, and a registry of tools, offering chainable methods and a final build step to produce a ready-to-use ModelContextProtocol.
+ * @param {string} [name] The name of the MCP instance to build.
+ * @param {string} [version] The semantic version of the MCP instance.
+ * @param {Record<string, Tool<any, any>>} [tools] A map of tool configurations indexed by tool name.
+ * @class
+ * @example
+ * // Build a new MCP with a single tool
+ * const mcp = ModelContextProtocol.builder
+ *   .setName("Example")
+ *   .setVersion("1.0.0")
+ *   .addTool({ name: "do", description: "", parameters: z.any(), execute: async () => "ok" })
+ *   .build();
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev as Developer
+ *   participant B as Builder
+ *   participant MCP as ModelContextProtocol
+ *   Dev->>B: setName("Example")
+ *   B-->>Dev: Builder
+ *   Dev->>B: setVersion("1.0.0")
+ *   B-->>Dev: Builder
+ *   Dev->>B: addTool(tool)
+ *   B-->>Dev: Builder
+ *   Dev->>B: build()
+ *   B->>MCP: new ModelContextProtocol(FastMCP)
+ *   B-->>Dev: ModelContextProtocol
+ */
 class Builder {
     constructor() {
         this.tools = {};
         this.log = logging_1.Logging.for("MCP Builder");
     }
+    /**
+     * @description Sets the MCP instance name.
+     * @summary Assigns a human-readable identifier to the builder configuration and enables method chaining.
+     * @param {string} value The name to assign to the MCP instance.
+     * @return {this} The current builder instance for chaining.
+     */
     setName(value) {
         this.name = value;
         this.log.debug(`name set to ${value}`);
         return this;
     }
+    /**
+     * @description Sets and validates the semantic version for the MCP instance.
+     * @summary Parses the provided value against semantic versioning and stores the normalized version; enables method chaining.
+     * @param {string} value The semantic version string (e.g., "1.2.3").
+     * @return {this} The current builder instance for chaining.
+     */
     setVersion(value) {
         this.version = validateVersion(value);
         this.log.debug(`version set to ${value}`);
         return this;
     }
+    /**
+     * @description Registers a new tool in the builder.
+     * @summary Adds a tool configuration by its unique name to the internal registry, throwing if a tool with the same name already exists.
+     * @template Auth extends FastMCPSessionAuth
+     * @param {Tool<Auth, any>} config The tool configuration object, including a unique name and an execute handler.
+     * @return {this} The current builder instance for chaining.
+     */
     addTool(config) {
         const { name } = config;
         if (name in this.tools)
@@ -33,6 +90,12 @@ class Builder {
         this.log.debug(`tool ${name} added`);
         return this;
     }
+    /**
+     * @description Finalizes the configuration and produces a ModelContextProtocol instance.
+     * @summary Validates required fields (name and version), constructs a FastMCP instance, registers all configured tools, and returns a ModelContextProtocol wrapping the MCP.
+     * @template Auth extends FastMCPSessionAuth
+     * @return {ModelContextProtocol<Auth>} A fully initialized ModelContextProtocol instance.
+     */
     build() {
         if (!this.name)
             throw new Error("name is required");
@@ -55,20 +118,66 @@ class Builder {
         return new ModelContextProtocol(mcp);
     }
 }
+/**
+ * @description A thin wrapper around FastMCP providing a typed interface for model-centric protocols.
+ * @summary Encapsulates a configured FastMCP instance and exposes factory utilities via a static Builder for constructing MCPs with tools, versioning, and naming semantics.
+ * @template Auth extends FastMCPSessionAuth Authentication payload type stored in the MCP session, or undefined for no auth.
+ * @param {FastMCP<Auth>} mcp The underlying FastMCP instance used to register and run tools.
+ * @class
+ * @example
+ * // Using the builder
+ * const protocol = ModelContextProtocol.builder
+ *   .setName("Validator")
+ *   .setVersion("1.2.3")
+ *   .addTool({ name: "ping", description: "", parameters: z.any(), execute: async () => "pong" })
+ *   .build();
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev as Developer
+ *   participant B as ModelContextProtocol.Builder
+ *   participant MCP as FastMCP
+ *   participant Proto as ModelContextProtocol
+ *   Dev->>B: setName()/setVersion()/addTool()
+ *   Dev->>B: build()
+ *   B->>MCP: new FastMCP({ name, version })
+ *   B->>MCP: addTool(tool...)
+ *   B->>Proto: new ModelContextProtocol(MCP)
+ *   B-->>Dev: ModelContextProtocol
+ */
 class ModelContextProtocol {
+    /**
+     * @description Lazily obtains a logger instance for this protocol wrapper.
+     * @summary Uses the Logging facility to create a context-aware Logger bound to this instance.
+     * @return {Logger} A logger instance for this class.
+     */
     get log() {
         return logging_1.Logging.for(this);
     }
     constructor(mcp) {
         this.mcp = mcp;
     }
+    /**
+     * @description Alias to the inner Builder class for external access.
+     * @summary Exposes the builder type to consumers to enable typed construction of ModelContextProtocol instances.
+     */
     static { this.Builder = Builder; }
+    /**
+     * @description Factory accessor for a new Builder instance.
+     * @summary Creates a new builder to fluently configure and construct a ModelContextProtocol.
+     * @return {Builder} A new builder instance.
+     */
     static get builder() {
         return new ModelContextProtocol.Builder();
     }
+    /**
+     * @description Validates a semantic version string.
+     * @summary Utility wrapper around the module-level validateVersion to keep a typed validator close to the class API.
+     * @param {string} version The version string to validate.
+     * @return {string} The normalized semantic version string.
+     */
     static validateVersion(version) {
         return validateVersion(version);
     }
 }
 exports.ModelContextProtocol = ModelContextProtocol;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ModelContextProtocol.js","sourceRoot":"","sources":["../../src/mcp/ModelContextProtocol.ts"],"names":[],"mappings":";;;AAAA,qCAAwC;AACxC,+CAAoD;AAGpD;;;;;;;;GAQG;AACH,SAAS,eAAe,CAAC,OAAe;IACtC,MAAM,MAAM,GAAG,sBAAsB,CAAC;IACtC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,CAAC,KAAK;QACR,MAAM,IAAI,KAAK,CACb,4DAA4D,OAAO,EAAE,CACtE,CAAC;IACJ,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,EAAqC,CAAC;AAClF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO;IAOX;QAJA,UAAK,GAAmC,EAAE,CAAC;QAE3C,QAAG,GAAG,iBAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IAElB,CAAC;IAEhB;;;;;OAKG;IACH,OAAO,CAAC,KAAa;QACnB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,eAAe,KAAK,EAAE,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,KAAa;QACtB,IAAI,CAAC,OAAO,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,kBAAkB,KAAK,EAAE,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CACL,MAAuB;QAEvB,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC;QACxB,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,qBAAqB,CAAC,CAAC;QAC3E,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,IAAI,QAAQ,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,KAAK;QAGH,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAC1D,MAAM,GAAG,GAAG,IAAI,iBAAO,CAAO;YAC5B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACzC,IAAI,CAAC;gBACH,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;YAAC,OAAO,CAAU,EAAE,CAAC;gBACpB,MAAM,IAAI,KAAK,CAAC,sBAAsB,IAAI,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,YAAY,CAAC,CAAC;QACxC,IAAI,CAAC,GAAG,CAAC,KAAK,CACZ,GAAG,IAAI,CAAC,IAAI,2BAA2B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC5E,CAAC;QACF,OAAO,IAAI,oBAAoB,CAAC,GAAG,CAAC,CAAC;IACvC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAa,oBAAoB;IAC/B;;;;OAIG;IACH,IAAc,GAAG;QACf,OAAO,iBAAO,CAAC,GAAG,CAAC,IAAW,CAAC,CAAC;IAClC,CAAC;IAED,YAA+B,GAAkB;QAAlB,QAAG,GAAH,GAAG,CAAe;IAAG,CAAC;IAErD;;;OAGG;aACa,YAAO,GAAG,OAAO,CAAC;IAElC;;;;OAIG;IACH,MAAM,KAAK,OAAO;QAChB,OAAO,IAAI,oBAAoB,CAAC,OAAO,EAAE,CAAC;IAC5C,CAAC;IAED;;;;;OAKG;IACK,MAAM,CAAC,eAAe,CAC5B,OAAe;QAEf,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;;AArCH,oDAsCC","sourcesContent":["import { FastMCP, Tool } from \"fastmcp\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { FastMCPSessionAuth } from \"./types\";\n\n/**\n * @description Validates and normalizes a semantic version string.\n * @summary Ensures the provided version follows semantic versioning (major.minor.patch) and returns a tuple-like template string typed as `${number}.${number}.${number}`.\n * @template\n * @param {string} version The version string to validate, expected in the form MAJOR.MINOR.PATCH.\n * @return {string} The normalized version string if valid.\n * @function validateVersion\n * @memberOf module:decorator-validation\n */\nfunction validateVersion(version: string): `${number}.${number}.${number}` {\n  const regexp = /(\\d+)\\.(\\d+)\\.(\\d+)/g;\n  const match = regexp.exec(version);\n  if (!match)\n    throw new Error(\n      `Invalid version string. should obey semantic versioning: ${version}`\n    );\n  return `${match[1]}.${match[2]}.${match[3]}` as `${number}.${number}.${number}`;\n}\n\n/**\n * @description Fluent builder for creating a configured ModelContextProtocol instance.\n * @summary Collects MCP configuration including a semantic version, a name, and a registry of tools, offering chainable methods and a final build step to produce a ready-to-use ModelContextProtocol.\n * @param {string} [name] The name of the MCP instance to build.\n * @param {string} [version] The semantic version of the MCP instance.\n * @param {Record<string, Tool<any, any>>} [tools] A map of tool configurations indexed by tool name.\n * @class\n * @example\n * // Build a new MCP with a single tool\n * const mcp = ModelContextProtocol.builder\n *   .setName(\"Example\")\n *   .setVersion(\"1.0.0\")\n *   .addTool({ name: \"do\", description: \"\", parameters: z.any(), execute: async () => \"ok\" })\n *   .build();\n * @mermaid\n * sequenceDiagram\n *   participant Dev as Developer\n *   participant B as Builder\n *   participant MCP as ModelContextProtocol\n *   Dev->>B: setName(\"Example\")\n *   B-->>Dev: Builder\n *   Dev->>B: setVersion(\"1.0.0\")\n *   B-->>Dev: Builder\n *   Dev->>B: addTool(tool)\n *   B-->>Dev: Builder\n *   Dev->>B: build()\n *   B->>MCP: new ModelContextProtocol(FastMCP)\n *   B-->>Dev: ModelContextProtocol\n */\nclass Builder {\n  name!: string;\n  version!: `${number}.${number}.${number}`;\n  tools: Record<string, Tool<any, any>> = {};\n\n  log = Logging.for(\"MCP Builder\");\n\n  constructor() {}\n\n  /**\n   * @description Sets the MCP instance name.\n   * @summary Assigns a human-readable identifier to the builder configuration and enables method chaining.\n   * @param {string} value The name to assign to the MCP instance.\n   * @return {this} The current builder instance for chaining.\n   */\n  setName(value: string) {\n    this.name = value;\n    this.log.debug(`name set to ${value}`);\n    return this;\n  }\n\n  /**\n   * @description Sets and validates the semantic version for the MCP instance.\n   * @summary Parses the provided value against semantic versioning and stores the normalized version; enables method chaining.\n   * @param {string} value The semantic version string (e.g., \"1.2.3\").\n   * @return {this} The current builder instance for chaining.\n   */\n  setVersion(value: string) {\n    this.version = validateVersion(value);\n    this.log.debug(`version set to ${value}`);\n    return this;\n  }\n\n  /**\n   * @description Registers a new tool in the builder.\n   * @summary Adds a tool configuration by its unique name to the internal registry, throwing if a tool with the same name already exists.\n   * @template Auth extends FastMCPSessionAuth\n   * @param {Tool<Auth, any>} config The tool configuration object, including a unique name and an execute handler.\n   * @return {this} The current builder instance for chaining.\n   */\n  addTool<Auth extends FastMCPSessionAuth = undefined>(\n    config: Tool<Auth, any>\n  ) {\n    const { name } = config;\n    if (name in this.tools) throw new Error(`tool ${name} already registered`);\n    this.tools[name] = config;\n    this.log.debug(`tool ${name} added`);\n    return this;\n  }\n\n  /**\n   * @description Finalizes the configuration and produces a ModelContextProtocol instance.\n   * @summary Validates required fields (name and version), constructs a FastMCP instance, registers all configured tools, and returns a ModelContextProtocol wrapping the MCP.\n   * @template Auth extends FastMCPSessionAuth\n   * @return {ModelContextProtocol<Auth>} A fully initialized ModelContextProtocol instance.\n   */\n  build<\n    Auth extends FastMCPSessionAuth = undefined,\n  >(): ModelContextProtocol<Auth> {\n    if (!this.name) throw new Error(\"name is required\");\n    if (!this.version) throw new Error(\"version is required\");\n    const mcp = new FastMCP<Auth>({\n      name: this.name,\n      version: this.version,\n    });\n    Object.values(this.tools).forEach((tool) => {\n      try {\n        mcp.addTool(tool);\n      } catch (e: unknown) {\n        throw new Error(`Failed to add tool ${tool.name}: ${e}`);\n      }\n    });\n    this.log.info(`${this.name} MCP built`);\n    this.log.debug(\n      `${this.name} MCP - available tools: ${Object.keys(this.tools).join(\", \")}`\n    );\n    return new ModelContextProtocol(mcp);\n  }\n}\n\n/**\n * @description A thin wrapper around FastMCP providing a typed interface for model-centric protocols.\n * @summary Encapsulates a configured FastMCP instance and exposes factory utilities via a static Builder for constructing MCPs with tools, versioning, and naming semantics.\n * @template Auth extends FastMCPSessionAuth Authentication payload type stored in the MCP session, or undefined for no auth.\n * @param {FastMCP<Auth>} mcp The underlying FastMCP instance used to register and run tools.\n * @class\n * @example\n * // Using the builder\n * const protocol = ModelContextProtocol.builder\n *   .setName(\"Validator\")\n *   .setVersion(\"1.2.3\")\n *   .addTool({ name: \"ping\", description: \"\", parameters: z.any(), execute: async () => \"pong\" })\n *   .build();\n * @mermaid\n * sequenceDiagram\n *   participant Dev as Developer\n *   participant B as ModelContextProtocol.Builder\n *   participant MCP as FastMCP\n *   participant Proto as ModelContextProtocol\n *   Dev->>B: setName()/setVersion()/addTool()\n *   Dev->>B: build()\n *   B->>MCP: new FastMCP({ name, version })\n *   B->>MCP: addTool(tool...)\n *   B->>Proto: new ModelContextProtocol(MCP)\n *   B-->>Dev: ModelContextProtocol\n */\nexport class ModelContextProtocol<Auth extends FastMCPSessionAuth = undefined> {\n  /**\n   * @description Lazily obtains a logger instance for this protocol wrapper.\n   * @summary Uses the Logging facility to create a context-aware Logger bound to this instance.\n   * @return {Logger} A logger instance for this class.\n   */\n  protected get log(): Logger {\n    return Logging.for(this as any);\n  }\n\n  constructor(protected readonly mcp: FastMCP<Auth>) {}\n\n  /**\n   * @description Alias to the inner Builder class for external access.\n   * @summary Exposes the builder type to consumers to enable typed construction of ModelContextProtocol instances.\n   */\n  static readonly Builder = Builder;\n\n  /**\n   * @description Factory accessor for a new Builder instance.\n   * @summary Creates a new builder to fluently configure and construct a ModelContextProtocol.\n   * @return {Builder} A new builder instance.\n   */\n  static get builder() {\n    return new ModelContextProtocol.Builder();\n  }\n\n  /**\n   * @description Validates a semantic version string.\n   * @summary Utility wrapper around the module-level validateVersion to keep a typed validator close to the class API.\n   * @param {string} version The version string to validate.\n   * @return {string} The normalized semantic version string.\n   */\n  private static validateVersion(\n    version: string\n  ): `${number}.${number}.${number}` {\n    return validateVersion(version);\n  }\n}\n"]}

package/lib/mcp/ModelContextProtocol.d.ts

@@ -1,23 +1,123 @@
 import { FastMCP, Tool } from "fastmcp";
 import { Logger } from "@decaf-ts/logging";
 import { FastMCPSessionAuth } from "./types";
+/**
+ * @description Fluent builder for creating a configured ModelContextProtocol instance.
+ * @summary Collects MCP configuration including a semantic version, a name, and a registry of tools, offering chainable methods and a final build step to produce a ready-to-use ModelContextProtocol.
+ * @param {string} [name] The name of the MCP instance to build.
+ * @param {string} [version] The semantic version of the MCP instance.
+ * @param {Record<string, Tool<any, any>>} [tools] A map of tool configurations indexed by tool name.
+ * @class
+ * @example
+ * // Build a new MCP with a single tool
+ * const mcp = ModelContextProtocol.builder
+ *   .setName("Example")
+ *   .setVersion("1.0.0")
+ *   .addTool({ name: "do", description: "", parameters: z.any(), execute: async () => "ok" })
+ *   .build();
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev as Developer
+ *   participant B as Builder
+ *   participant MCP as ModelContextProtocol
+ *   Dev->>B: setName("Example")
+ *   B-->>Dev: Builder
+ *   Dev->>B: setVersion("1.0.0")
+ *   B-->>Dev: Builder
+ *   Dev->>B: addTool(tool)
+ *   B-->>Dev: Builder
+ *   Dev->>B: build()
+ *   B->>MCP: new ModelContextProtocol(FastMCP)
+ *   B-->>Dev: ModelContextProtocol
+ */
 declare class Builder {
     name: string;
     version: `${number}.${number}.${number}`;
     tools: Record<string, Tool<any, any>>;
     log: Logger;
     constructor();
+    /**
+     * @description Sets the MCP instance name.
+     * @summary Assigns a human-readable identifier to the builder configuration and enables method chaining.
+     * @param {string} value The name to assign to the MCP instance.
+     * @return {this} The current builder instance for chaining.
+     */
     setName(value: string): this;
+    /**
+     * @description Sets and validates the semantic version for the MCP instance.
+     * @summary Parses the provided value against semantic versioning and stores the normalized version; enables method chaining.
+     * @param {string} value The semantic version string (e.g., "1.2.3").
+     * @return {this} The current builder instance for chaining.
+     */
     setVersion(value: string): this;
+    /**
+     * @description Registers a new tool in the builder.
+     * @summary Adds a tool configuration by its unique name to the internal registry, throwing if a tool with the same name already exists.
+     * @template Auth extends FastMCPSessionAuth
+     * @param {Tool<Auth, any>} config The tool configuration object, including a unique name and an execute handler.
+     * @return {this} The current builder instance for chaining.
+     */
     addTool<Auth extends FastMCPSessionAuth = undefined>(config: Tool<Auth, any>): this;
+    /**
+     * @description Finalizes the configuration and produces a ModelContextProtocol instance.
+     * @summary Validates required fields (name and version), constructs a FastMCP instance, registers all configured tools, and returns a ModelContextProtocol wrapping the MCP.
+     * @template Auth extends FastMCPSessionAuth
+     * @return {ModelContextProtocol<Auth>} A fully initialized ModelContextProtocol instance.
+     */
     build<Auth extends FastMCPSessionAuth = undefined>(): ModelContextProtocol<Auth>;
 }
+/**
+ * @description A thin wrapper around FastMCP providing a typed interface for model-centric protocols.
+ * @summary Encapsulates a configured FastMCP instance and exposes factory utilities via a static Builder for constructing MCPs with tools, versioning, and naming semantics.
+ * @template Auth extends FastMCPSessionAuth Authentication payload type stored in the MCP session, or undefined for no auth.
+ * @param {FastMCP<Auth>} mcp The underlying FastMCP instance used to register and run tools.
+ * @class
+ * @example
+ * // Using the builder
+ * const protocol = ModelContextProtocol.builder
+ *   .setName("Validator")
+ *   .setVersion("1.2.3")
+ *   .addTool({ name: "ping", description: "", parameters: z.any(), execute: async () => "pong" })
+ *   .build();
+ * @mermaid
+ * sequenceDiagram
+ *   participant Dev as Developer
+ *   participant B as ModelContextProtocol.Builder
+ *   participant MCP as FastMCP
+ *   participant Proto as ModelContextProtocol
+ *   Dev->>B: setName()/setVersion()/addTool()
+ *   Dev->>B: build()
+ *   B->>MCP: new FastMCP({ name, version })
+ *   B->>MCP: addTool(tool...)
+ *   B->>Proto: new ModelContextProtocol(MCP)
+ *   B-->>Dev: ModelContextProtocol
+ */
 export declare class ModelContextProtocol<Auth extends FastMCPSessionAuth = undefined> {
     protected readonly mcp: FastMCP<Auth>;
+    /**
+     * @description Lazily obtains a logger instance for this protocol wrapper.
+     * @summary Uses the Logging facility to create a context-aware Logger bound to this instance.
+     * @return {Logger} A logger instance for this class.
+     */
     protected get log(): Logger;
     constructor(mcp: FastMCP<Auth>);
+    /**
+     * @description Alias to the inner Builder class for external access.
+     * @summary Exposes the builder type to consumers to enable typed construction of ModelContextProtocol instances.
+     */
     static readonly Builder: typeof Builder;
+    /**
+     * @description Factory accessor for a new Builder instance.
+     * @summary Creates a new builder to fluently configure and construct a ModelContextProtocol.
+     * @return {Builder} A new builder instance.
+     */
     static get builder(): Builder;
+    /**
+     * @description Validates a semantic version string.
+     * @summary Utility wrapper around the module-level validateVersion to keep a typed validator close to the class API.
+     * @param {string} version The version string to validate.
+     * @return {string} The normalized semantic version string.
+     */
     private static validateVersion;
 }
 export {};

package/lib/model/constants.cjs

@@ -2,60 +2,69 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.jsTypes = exports.ReservedModels = exports.Primitives = void 0;
 /**
- * @summary References the relevant JS primitives
- *
+ * @description Enumeration of JavaScript primitive type identifiers used by the model system.
+ * @summary References the relevant JS primitives and standardizes their string representations across the library.
  * @property {string} STRING references the string primitive
  * @property {string} NUMBER references the number primitive
  * @property {string} BOOLEAN references the boolean primitive
  * @property {string} BIGINT references the bigint primitive
- *
- * @constant Primitives
+ * @enum Primitives
+ * @readonly
  * @memberOf module:decorator-validation
  */
 var Primitives;
 (function (Primitives) {
+    /** references the string primitive */
     Primitives["STRING"] = "string";
+    /** references the number primitive */
     Primitives["NUMBER"] = "number";
+    /** references the boolean primitive */
     Primitives["BOOLEAN"] = "boolean";
+    /** references the bigint primitive */
     Primitives["BIGINT"] = "bigint";
 })(Primitives || (exports.Primitives = Primitives = {}));
 /**
- * @summary References the Reserved model names to ignore during Model rebuilding
- *
+ * @description Reserved model names which are excluded from model rebuilding.
+ * @summary References the Reserved model names to ignore during Model rebuilding to avoid interfering with native types and special cases.
  * @property {string} STRING
  * @property {string} OBJECT
  * @property {string} NUMBER
  * @property {string} BOOLEAN
  * @property {string} BIGINT
  * @property {string} DATE
- *
- * @constant ReservedModels
+ * @enum ReservedModels
+ * @readonly
  * @memberOf module:decorator-validation
  */
 var ReservedModels;
 (function (ReservedModels) {
+    /** reserved name for string */
     ReservedModels["STRING"] = "string";
+    /** reserved name for object */
     ReservedModels["OBJECT"] = "object";
+    /** reserved name for number */
     ReservedModels["NUMBER"] = "number";
+    /** reserved name for boolean */
     ReservedModels["BOOLEAN"] = "boolean";
+    /** reserved name for bigint */
     ReservedModels["BIGINT"] = "bigint";
+    /** reserved name for Date */
     ReservedModels["DATE"] = "date";
 })(ReservedModels || (exports.ReservedModels = ReservedModels = {}));
 /**
- * @summary References the basic supported js types
- *
- * @property {string} string
- * @property {string} array
- * @property {string} number
- * @property {string} boolean
- * @property {string} symbol
- * @property {string} function
- * @property {string} object
- * @property {string} undefined
- * @property {string} null
- * @property {string} BIGINT
- *
- * @constant jsTypes
+ * @description Basic supported JavaScript types used by the validation system.
+ * @summary References the basic supported JS types as strings that can be used for type checking and metadata.
+ * @typedef {Object} JsTypes
+ * @property {"string"} string String primitive identifier
+ * @property {"array"} array Array type identifier
+ * @property {"number"} number Number primitive identifier
+ * @property {"boolean"} boolean Boolean primitive identifier
+ * @property {"symbol"} symbol Symbol primitive identifier
+ * @property {"function"} function Function type identifier
+ * @property {"object"} object Object type identifier
+ * @property {"undefined"} undefined Undefined type identifier
+ * @property {"null"} null Null value identifier
+ * @property {"bigint"} BIGINT BigInt primitive identifier
  * @memberOf module:decorator-validation
  */
 exports.jsTypes = [
@@ -70,4 +79,4 @@ exports.jsTypes = [
     "null",
     "bigint",
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/constants.d.ts

@@ -1,56 +1,65 @@
 /**
- * @summary References the relevant JS primitives
- *
+ * @description Enumeration of JavaScript primitive type identifiers used by the model system.
+ * @summary References the relevant JS primitives and standardizes their string representations across the library.
  * @property {string} STRING references the string primitive
  * @property {string} NUMBER references the number primitive
  * @property {string} BOOLEAN references the boolean primitive
  * @property {string} BIGINT references the bigint primitive
- *
- * @constant Primitives
+ * @enum Primitives
+ * @readonly
  * @memberOf module:decorator-validation
  */
 export declare enum Primitives {
+    /** references the string primitive */
     STRING = "string",
+    /** references the number primitive */
     NUMBER = "number",
+    /** references the boolean primitive */
     BOOLEAN = "boolean",
+    /** references the bigint primitive */
     BIGINT = "bigint"
 }
 /**
- * @summary References the Reserved model names to ignore during Model rebuilding
- *
+ * @description Reserved model names which are excluded from model rebuilding.
+ * @summary References the Reserved model names to ignore during Model rebuilding to avoid interfering with native types and special cases.
  * @property {string} STRING
  * @property {string} OBJECT
  * @property {string} NUMBER
  * @property {string} BOOLEAN
  * @property {string} BIGINT
  * @property {string} DATE
- *
- * @constant ReservedModels
+ * @enum ReservedModels
+ * @readonly
  * @memberOf module:decorator-validation
  */
 export declare enum ReservedModels {
+    /** reserved name for string */
     STRING = "string",
+    /** reserved name for object */
     OBJECT = "object",
+    /** reserved name for number */
     NUMBER = "number",
+    /** reserved name for boolean */
     BOOLEAN = "boolean",
+    /** reserved name for bigint */
     BIGINT = "bigint",
+    /** reserved name for Date */
     DATE = "date"
 }
 /**
- * @summary References the basic supported js types
- *
- * @property {string} string
- * @property {string} array
- * @property {string} number
- * @property {string} boolean
- * @property {string} symbol
- * @property {string} function
- * @property {string} object
- * @property {string} undefined
- * @property {string} null
- * @property {string} BIGINT
- *
- * @constant jsTypes
+ * @description Basic supported JavaScript types used by the validation system.
+ * @summary References the basic supported JS types as strings that can be used for type checking and metadata.
+ * @typedef {Object} JsTypes
+ * @property {"string"} string String primitive identifier
+ * @property {"array"} array Array type identifier
+ * @property {"number"} number Number primitive identifier
+ * @property {"boolean"} boolean Boolean primitive identifier
+ * @property {"symbol"} symbol Symbol primitive identifier
+ * @property {"function"} function Function type identifier
+ * @property {"object"} object Object type identifier
+ * @property {"undefined"} undefined Undefined type identifier
+ * @property {"null"} null Null value identifier
+ * @property {"bigint"} BIGINT BigInt primitive identifier
  * @memberOf module:decorator-validation
  */
 export declare const jsTypes: string[];

package/lib/model/construction.cjs

@@ -5,14 +5,12 @@ exports.findLastProtoBeforeObject = findLastProtoBeforeObject;
 exports.bindModelPrototype = bindModelPrototype;
 const Model_1 = require("./Model.cjs");
 /**
- * @summary Helper Function to override constructors
- *
+ * @description Helper function to create an instance by invoking a constructor with dynamic arguments.
+ * @summary Overrides standard construction patterns by wrapping the given constructor to allow spread argument invocation while preserving the prototype chain.
  * @template M the model instance type
- *
- * @param {Function} constructor
- * @param {any[]} [args]
- * @return {M} the new instance
- *
+ * @param {any} constructor The constructor function to invoke.
+ * @param {...any[]} args Optional arguments to pass to the constructor.
+ * @return {M} The newly constructed instance.
  * @function construct
  * @memberOf module:decorator-validation
  */
@@ -22,9 +20,10 @@ function construct(constructor, ...args) {
     return _constr(...args);
 }
 /**
- * @summary Recursively finds the last prototype before Object
- * @param {object} obj
- *
+ * @description Recursively finds the last prototype in the chain before reaching Object.prototype.
+ * @summary Walks up the prototype chain to locate the most derived prototype that still precedes the base Object prototype.
+ * @param {object} obj The object whose prototype chain will be inspected.
+ * @return {object} The last prototype before Object.prototype, or the input object if its prototype is Object.prototype.
  * @function findLastProtoBeforeObject
  * @memberOf module:decorator-validation
  */
@@ -42,11 +41,27 @@ function findLastProtoBeforeObject(obj) {
     throw new Error("Could not find proper prototype");
 }
 /**
- * @sumary binds the {@link Model} class as a root prototype of the provided instance
- *
- * @param {unknown} obj
- *
+ * @description Binds the Model class as the root prototype of the provided instance when not already a Model.
+ * @summary Ensures objects created outside of the Model inheritance chain gain Model as their ultimate prototype to access model utilities.
+ * @param {unknown} obj The object to bind to the Model prototype chain.
+ * @return {void}
  * @function bindModelPrototype
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant Fn as bindModelPrototype
+ *   participant M as Model.prototype
+ *   Caller->>Fn: obj
+ *   alt obj instanceof Model
+ *     Fn-->>Caller: return
+ *   else obj chain ends at Object.prototype
+ *     Fn->>Fn: setPrototypeOf(obj, M)
+ *     Fn-->>Caller: return
+ *   else deep prototype chain
+ *     Fn->>Fn: walk prototypes
+ *     Fn->>Fn: setPrototypeOf(last, M)
+ *     Fn-->>Caller: return
+ *   end
  * @memberOf module:decorator-validation
  */
 function bindModelPrototype(obj) {
@@ -68,4 +83,4 @@ function bindModelPrototype(obj) {
     }
     throw new Error("Could not find proper prototype to bind");
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RydWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZGVsL2NvbnN0cnVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQWNBLDhCQU9DO0FBU0QsOERBU0M7QUFVRCxnREFxQkM7QUF0RUQsdUNBQWdDO0FBRWhDOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsU0FBZ0IsU0FBUyxDQUN2QixXQUFnQixFQUNoQixHQUFHLElBQVc7SUFFZCxNQUFNLE9BQU8sR0FBRyxDQUFDLEdBQUcsSUFBVyxFQUFFLEVBQUUsQ0FBQyxJQUFJLFdBQVcsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDO0lBQzdELE9BQU8sQ0FBQyxTQUFTLEdBQUcsV0FBVyxDQUFDLFNBQVMsQ0FBQztJQUMxQyxPQUFPLE9BQU8sQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDO0FBQzFCLENBQUM7QUFFRDs7Ozs7O0dBTUc7QUFDSCxTQUFnQix5QkFBeUIsQ0FBQyxHQUFXO0lBQ25ELElBQUksU0FBUyxHQUFRLE1BQU0sQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDaEQsSUFBSSxTQUFTLEtBQUssTUFBTSxDQUFDLFNBQVM7UUFBRSxPQUFPLEdBQUcsQ0FBQztJQUMvQyxPQUFPLFNBQVMsS0FBSyxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDdEMsU0FBUyxHQUFHLE1BQU0sQ0FBQyxjQUFjLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDN0MsSUFBSSxTQUFTLEtBQUssTUFBTSxDQUFDLFNBQVM7WUFBRSxPQUFPLFNBQVMsQ0FBQztRQUNyRCxJQUFJLE1BQU0sQ0FBQyxjQUFjLENBQUMsU0FBUyxDQUFDLEtBQUssTUFBTSxDQUFDLFNBQVM7WUFBRSxPQUFPLFNBQVMsQ0FBQztJQUM5RSxDQUFDO0lBQ0QsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO0FBQ3JELENBQUM7QUFFRDs7Ozs7OztHQU9HO0FBQ0gsU0FBZ0Isa0JBQWtCLENBQUMsR0FBWTtJQUM3QyxJQUFJLEdBQUcsWUFBWSxhQUFLO1FBQUUsT0FBTztJQUVqQyxTQUFTLGFBQWEsQ0FBQyxhQUFzQixFQUFFLFNBQWlCO1FBQzlELE1BQU0sQ0FBQyxjQUFjLENBQUMsYUFBYSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFRCxNQUFNLFNBQVMsR0FBUSxNQUFNLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2xELElBQUksU0FBUyxLQUFLLE1BQU0sQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUNuQyxPQUFPLGFBQWEsQ0FBQyxHQUFHLEVBQUUsYUFBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQzdDLENBQUM7SUFDRCxPQUFPLFNBQVMsS0FBSyxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDdEMsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUM5QyxJQUNFLElBQUksS0FBSyxNQUFNLENBQUMsU0FBUztZQUN6QixNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxLQUFLLE1BQU0sQ0FBQyxTQUFTLEVBQ2hELENBQUM7WUFDRCxPQUFPLGFBQWEsQ0FBQyxTQUFTLEVBQUUsYUFBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ25ELENBQUM7SUFDSCxDQUFDO0lBQ0QsTUFBTSxJQUFJLEtBQUssQ0FBQyx5Q0FBeUMsQ0FBQyxDQUFDO0FBQzdELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb2RlbCB9IGZyb20gXCIuL01vZGVsXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgSGVscGVyIEZ1bmN0aW9uIHRvIG92ZXJyaWRlIGNvbnN0cnVjdG9yc1xuICpcbiAqIEB0ZW1wbGF0ZSBNIHRoZSBtb2RlbCBpbnN0YW5jZSB0eXBlXG4gKlxuICogQHBhcmFtIHtGdW5jdGlvbn0gY29uc3RydWN0b3JcbiAqIEBwYXJhbSB7YW55W119IFthcmdzXVxuICogQHJldHVybiB7TX0gdGhlIG5ldyBpbnN0YW5jZVxuICpcbiAqIEBmdW5jdGlvbiBjb25zdHJ1Y3RcbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGVjb3JhdG9yLXZhbGlkYXRpb25cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNvbnN0cnVjdDxNIGV4dGVuZHMgTW9kZWw+KFxuICBjb25zdHJ1Y3RvcjogYW55LFxuICAuLi5hcmdzOiBhbnlbXVxuKTogTSB7XG4gIGNvbnN0IF9jb25zdHIgPSAoLi4uYXJnejogYW55W10pID0+IG5ldyBjb25zdHJ1Y3RvciguLi5hcmd6KTtcbiAgX2NvbnN0ci5wcm90b3R5cGUgPSBjb25zdHJ1Y3Rvci5wcm90b3R5cGU7XG4gIHJldHVybiBfY29uc3RyKC4uLmFyZ3MpO1xufVxuXG4vKipcbiAqIEBzdW1tYXJ5IFJlY3Vyc2l2ZWx5IGZpbmRzIHRoZSBsYXN0IHByb3RvdHlwZSBiZWZvcmUgT2JqZWN0XG4gKiBAcGFyYW0ge29iamVjdH0gb2JqXG4gKlxuICogQGZ1bmN0aW9uIGZpbmRMYXN0UHJvdG9CZWZvcmVPYmplY3RcbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGVjb3JhdG9yLXZhbGlkYXRpb25cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZpbmRMYXN0UHJvdG9CZWZvcmVPYmplY3Qob2JqOiBvYmplY3QpOiBvYmplY3Qge1xuICBsZXQgcHJvdG90eXBlOiBhbnkgPSBPYmplY3QuZ2V0UHJvdG90eXBlT2Yob2JqKTtcbiAgaWYgKHByb3RvdHlwZSA9PT0gT2JqZWN0LnByb3RvdHlwZSkgcmV0dXJuIG9iajtcbiAgd2hpbGUgKHByb3RvdHlwZSAhPT0gT2JqZWN0LnByb3RvdHlwZSkge1xuICAgIHByb3RvdHlwZSA9IE9iamVjdC5nZXRQcm90b3R5cGVPZihwcm90b3R5cGUpO1xuICAgIGlmIChwcm90b3R5cGUgPT09IE9iamVjdC5wcm90b3R5cGUpIHJldHVybiBwcm90b3R5cGU7XG4gICAgaWYgKE9iamVjdC5nZXRQcm90b3R5cGVPZihwcm90b3R5cGUpID09PSBPYmplY3QucHJvdG90eXBlKSByZXR1cm4gcHJvdG90eXBlO1xuICB9XG4gIHRocm93IG5ldyBFcnJvcihcIkNvdWxkIG5vdCBmaW5kIHByb3BlciBwcm90b3R5cGVcIik7XG59XG5cbi8qKlxuICogQHN1bWFyeSBiaW5kcyB0aGUge0BsaW5rIE1vZGVsfSBjbGFzcyBhcyBhIHJvb3QgcHJvdG90eXBlIG9mIHRoZSBwcm92aWRlZCBpbnN0YW5jZVxuICpcbiAqIEBwYXJhbSB7dW5rbm93bn0gb2JqXG4gKlxuICogQGZ1bmN0aW9uIGJpbmRNb2RlbFByb3RvdHlwZVxuICogQG1lbWJlck9mIG1vZHVsZTpkZWNvcmF0b3ItdmFsaWRhdGlvblxuICovXG5leHBvcnQgZnVuY3Rpb24gYmluZE1vZGVsUHJvdG90eXBlKG9iajogdW5rbm93bikge1xuICBpZiAob2JqIGluc3RhbmNlb2YgTW9kZWwpIHJldHVybjtcblxuICBmdW5jdGlvbiBiaW5kUHJvdG90eXBlKG9ialRvT3ZlcnJpZGU6IHVua25vd24sIHByb3RvdHlwZTogb2JqZWN0KSB7XG4gICAgT2JqZWN0LnNldFByb3RvdHlwZU9mKG9ialRvT3ZlcnJpZGUsIHByb3RvdHlwZSk7XG4gIH1cblxuICBjb25zdCBwcm90b3R5cGU6IGFueSA9IE9iamVjdC5nZXRQcm90b3R5cGVPZihvYmopO1xuICBpZiAocHJvdG90eXBlID09PSBPYmplY3QucHJvdG90eXBlKSB7XG4gICAgcmV0dXJuIGJpbmRQcm90b3R5cGUob2JqLCBNb2RlbC5wcm90b3R5cGUpO1xuICB9XG4gIHdoaWxlIChwcm90b3R5cGUgIT09IE9iamVjdC5wcm90b3R5cGUpIHtcbiAgICBjb25zdCBwcm90ID0gT2JqZWN0LmdldFByb3RvdHlwZU9mKHByb3RvdHlwZSk7XG4gICAgaWYgKFxuICAgICAgcHJvdCA9PT0gT2JqZWN0LnByb3RvdHlwZSB8fFxuICAgICAgT2JqZWN0LmdldFByb3RvdHlwZU9mKHByb3QpID09PSBPYmplY3QucHJvdG90eXBlXG4gICAgKSB7XG4gICAgICByZXR1cm4gYmluZFByb3RvdHlwZShwcm90b3R5cGUsIE1vZGVsLnByb3RvdHlwZSk7XG4gICAgfVxuICB9XG4gIHRocm93IG5ldyBFcnJvcihcIkNvdWxkIG5vdCBmaW5kIHByb3BlciBwcm90b3R5cGUgdG8gYmluZFwiKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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