@hvgllc/hvgerp-mcp 3.0.0 → 3.0.1

package/hvgerp-mcp.mjs

@@ -1769,7 +1769,7 @@ var require_code2 = __commonJS({
       return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
     }
     exports.schemaProperties = schemaProperties;
-    function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
+    function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context2, passSchema) {
       const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
       const valCxt = [
         [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
@@ -1780,7 +1780,7 @@ var require_code2 = __commonJS({
       if (it.opts.dynamicRef)
         valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
       const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
-      return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
+      return context2 !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context2}, ${args})` : (0, codegen_1._)`${func}(${args})`;
     }
     exports.callValidateCode = callValidateCode;
     var newRegExp = (0, codegen_1._)`new RegExp`;
@@ -6921,6 +6921,830 @@ var require_dist = __commonJS({
   }
 });
 
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js
+var require_dynamicAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dynamicAnchor = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var compile_1 = require_compile();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicAnchor",
+      schemaType: "string",
+      code: (cxt) => dynamicAnchor(cxt, cxt.schema)
+    };
+    function dynamicAnchor(cxt, anchor) {
+      const { gen, it } = cxt;
+      it.schemaEnv.root.dynamicAnchors[anchor] = true;
+      const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
+      const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
+      gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
+    }
+    exports.dynamicAnchor = dynamicAnchor;
+    function _getValidate(cxt) {
+      const { schemaEnv, schema, self: self2 } = cxt.it;
+      const { root, baseId, localRefs, meta: meta2 } = schemaEnv.root;
+      const { schemaId } = self2.opts;
+      const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta: meta2 });
+      compile_1.compileSchema.call(self2, sch);
+      return (0, ref_1.getValidate)(cxt, sch);
+    }
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
+var require_dynamicRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dynamicRef = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicRef",
+      schemaType: "string",
+      code: (cxt) => dynamicRef(cxt, cxt.schema)
+    };
+    function dynamicRef(cxt, ref) {
+      const { gen, keyword, it } = cxt;
+      if (ref[0] !== "#")
+        throw new Error(`"${keyword}" only supports hash fragment reference`);
+      const anchor = ref.slice(1);
+      if (it.allErrors) {
+        _dynamicRef();
+      } else {
+        const valid = gen.let("valid", false);
+        _dynamicRef(valid);
+        cxt.ok(valid);
+      }
+      function _dynamicRef(valid) {
+        if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+          const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
+          gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
+        } else {
+          _callRef(it.validateName, valid)();
+        }
+      }
+      function _callRef(validate, valid) {
+        return valid ? () => gen.block(() => {
+          (0, ref_1.callRef)(cxt, validate);
+          gen.let(valid, true);
+        }) : () => (0, ref_1.callRef)(cxt, validate);
+      }
+    }
+    exports.dynamicRef = dynamicRef;
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
+var require_recursiveAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var util_1 = require_util();
+    var def = {
+      keyword: "$recursiveAnchor",
+      schemaType: "boolean",
+      code(cxt) {
+        if (cxt.schema)
+          (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
+        else
+          (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
+var require_recursiveRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicRef_1 = require_dynamicRef();
+    var def = {
+      keyword: "$recursiveRef",
+      schemaType: "string",
+      code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/index.js
+var require_dynamic = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var dynamicRef_1 = require_dynamicRef();
+    var recursiveAnchor_1 = require_recursiveAnchor();
+    var recursiveRef_1 = require_recursiveRef();
+    var dynamic = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default];
+    exports.default = dynamic;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/dependentRequired.js
+var require_dependentRequired = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/dependentRequired.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentRequired",
+      type: "object",
+      schemaType: "object",
+      error: dependencies_1.error,
+      code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
+var require_dependentSchemas = __commonJS({
+  "node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentSchemas",
+      type: "object",
+      schemaType: "object",
+      code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/limitContains.js
+var require_limitContains = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/limitContains.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var util_1 = require_util();
+    var def = {
+      keyword: ["maxContains", "minContains"],
+      type: "array",
+      schemaType: "number",
+      code({ keyword, parentSchema, it }) {
+        if (parentSchema.contains === void 0) {
+          (0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/next.js
+var require_next = __commonJS({
+  "node_modules/ajv/dist/vocabularies/next.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependentRequired_1 = require_dependentRequired();
+    var dependentSchemas_1 = require_dependentSchemas();
+    var limitContains_1 = require_limitContains();
+    var next = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
+    exports.default = next;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
+var require_unevaluatedProperties = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var names_1 = require_names();
+    var error2 = {
+      message: "must NOT have unevaluated properties",
+      params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
+    };
+    var def = {
+      keyword: "unevaluatedProperties",
+      type: "object",
+      schemaType: ["boolean", "object"],
+      trackErrors: true,
+      error: error2,
+      code(cxt) {
+        const { gen, schema, data, errsCount, it } = cxt;
+        if (!errsCount)
+          throw new Error("ajv implementation error");
+        const { allErrors, props } = it;
+        if (props instanceof codegen_1.Name) {
+          gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
+        } else if (props !== true) {
+          gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
+        }
+        it.props = true;
+        cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+        function unevaluatedPropCode(key) {
+          if (schema === false) {
+            cxt.setParams({ unevaluatedProperty: key });
+            cxt.error();
+            if (!allErrors)
+              gen.break();
+            return;
+          }
+          if (!(0, util_1.alwaysValidSchema)(it, schema)) {
+            const valid = gen.name("valid");
+            cxt.subschema({
+              keyword: "unevaluatedProperties",
+              dataProp: key,
+              dataPropType: util_1.Type.Str
+            }, valid);
+            if (!allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          }
+        }
+        function unevaluatedDynamic(evaluatedProps, key) {
+          return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
+        }
+        function unevaluatedStatic(evaluatedProps, key) {
+          const ps = [];
+          for (const p in evaluatedProps) {
+            if (evaluatedProps[p] === true)
+              ps.push((0, codegen_1._)`${key} !== ${p}`);
+          }
+          return (0, codegen_1.and)(...ps);
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js
+var require_unevaluatedItems = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var error2 = {
+      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
+      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
+    };
+    var def = {
+      keyword: "unevaluatedItems",
+      type: "array",
+      schemaType: ["boolean", "object"],
+      error: error2,
+      code(cxt) {
+        const { gen, schema, data, it } = cxt;
+        const items = it.items || 0;
+        if (items === true)
+          return;
+        const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+        if (schema === false) {
+          cxt.setParams({ len: items });
+          cxt.fail((0, codegen_1._)`${len} > ${items}`);
+        } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+          const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
+          gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
+          cxt.ok(valid);
+        }
+        it.items = true;
+        function validateItems(valid, from) {
+          gen.forRange("i", from, len, (i) => {
+            cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
+            if (!it.allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          });
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/index.js
+var require_unevaluated = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var unevaluatedProperties_1 = require_unevaluatedProperties();
+    var unevaluatedItems_1 = require_unevaluatedItems();
+    var unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
+    exports.default = unevaluated;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/draft2020.js
+var require_draft2020 = __commonJS({
+  "node_modules/ajv/dist/vocabularies/draft2020.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var core_1 = require_core2();
+    var validation_1 = require_validation();
+    var applicator_1 = require_applicator();
+    var dynamic_1 = require_dynamic();
+    var next_1 = require_next();
+    var unevaluated_1 = require_unevaluated();
+    var format_1 = require_format2();
+    var metadata_1 = require_metadata();
+    var draft2020Vocabularies = [
+      dynamic_1.default,
+      core_1.default,
+      validation_1.default,
+      (0, applicator_1.default)(true),
+      format_1.default,
+      metadata_1.metadataVocabulary,
+      metadata_1.contentVocabulary,
+      next_1.default,
+      unevaluated_1.default
+    ];
+    exports.default = draft2020Vocabularies;
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/schema.json
+var require_schema = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/schema.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/schema",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core and Validation specifications meta-schema",
+      allOf: [
+        { $ref: "meta/core" },
+        { $ref: "meta/applicator" },
+        { $ref: "meta/unevaluated" },
+        { $ref: "meta/validation" },
+        { $ref: "meta/meta-data" },
+        { $ref: "meta/format-annotation" },
+        { $ref: "meta/content" }
+      ],
+      type: ["object", "boolean"],
+      $comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+      properties: {
+        definitions: {
+          $comment: '"definitions" has been replaced by "$defs".',
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          deprecated: true,
+          default: {}
+        },
+        dependencies: {
+          $comment: '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.',
+          type: "object",
+          additionalProperties: {
+            anyOf: [{ $dynamicRef: "#meta" }, { $ref: "meta/validation#/$defs/stringArray" }]
+          },
+          deprecated: true,
+          default: {}
+        },
+        $recursiveAnchor: {
+          $comment: '"$recursiveAnchor" has been replaced by "$dynamicAnchor".',
+          $ref: "meta/core#/$defs/anchorString",
+          deprecated: true
+        },
+        $recursiveRef: {
+          $comment: '"$recursiveRef" has been replaced by "$dynamicRef".',
+          $ref: "meta/core#/$defs/uriReferenceString",
+          deprecated: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json
+var require_applicator2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/applicator",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        prefixItems: { $ref: "#/$defs/schemaArray" },
+        items: { $dynamicRef: "#meta" },
+        contains: { $dynamicRef: "#meta" },
+        additionalProperties: { $dynamicRef: "#meta" },
+        properties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        patternProperties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          propertyNames: { format: "regex" },
+          default: {}
+        },
+        dependentSchemas: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        propertyNames: { $dynamicRef: "#meta" },
+        if: { $dynamicRef: "#meta" },
+        then: { $dynamicRef: "#meta" },
+        else: { $dynamicRef: "#meta" },
+        allOf: { $ref: "#/$defs/schemaArray" },
+        anyOf: { $ref: "#/$defs/schemaArray" },
+        oneOf: { $ref: "#/$defs/schemaArray" },
+        not: { $dynamicRef: "#meta" }
+      },
+      $defs: {
+        schemaArray: {
+          type: "array",
+          minItems: 1,
+          items: { $dynamicRef: "#meta" }
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
+var require_unevaluated2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Unevaluated applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        unevaluatedItems: { $dynamicRef: "#meta" },
+        unevaluatedProperties: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
+var require_content = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/content",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Content vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        contentEncoding: { type: "string" },
+        contentMediaType: { type: "string" },
+        contentSchema: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
+var require_core3 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/core",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        $id: {
+          $ref: "#/$defs/uriReferenceString",
+          $comment: "Non-empty fragments not allowed.",
+          pattern: "^[^#]*#?$"
+        },
+        $schema: { $ref: "#/$defs/uriString" },
+        $ref: { $ref: "#/$defs/uriReferenceString" },
+        $anchor: { $ref: "#/$defs/anchorString" },
+        $dynamicRef: { $ref: "#/$defs/uriReferenceString" },
+        $dynamicAnchor: { $ref: "#/$defs/anchorString" },
+        $vocabulary: {
+          type: "object",
+          propertyNames: { $ref: "#/$defs/uriString" },
+          additionalProperties: {
+            type: "boolean"
+          }
+        },
+        $comment: {
+          type: "string"
+        },
+        $defs: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" }
+        }
+      },
+      $defs: {
+        anchorString: {
+          type: "string",
+          pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        uriString: {
+          type: "string",
+          format: "uri"
+        },
+        uriReferenceString: {
+          type: "string",
+          format: "uri-reference"
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
+var require_format_annotation = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Format vocabulary meta-schema for annotation results",
+      type: ["object", "boolean"],
+      properties: {
+        format: { type: "string" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
+var require_meta_data = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Meta-data vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        title: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        default: true,
+        deprecated: {
+          type: "boolean",
+          default: false
+        },
+        readOnly: {
+          type: "boolean",
+          default: false
+        },
+        writeOnly: {
+          type: "boolean",
+          default: false
+        },
+        examples: {
+          type: "array",
+          items: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+var require_validation2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/validation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/validation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Validation vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        type: {
+          anyOf: [
+            { $ref: "#/$defs/simpleTypes" },
+            {
+              type: "array",
+              items: { $ref: "#/$defs/simpleTypes" },
+              minItems: 1,
+              uniqueItems: true
+            }
+          ]
+        },
+        const: true,
+        enum: {
+          type: "array",
+          items: true
+        },
+        multipleOf: {
+          type: "number",
+          exclusiveMinimum: 0
+        },
+        maximum: {
+          type: "number"
+        },
+        exclusiveMaximum: {
+          type: "number"
+        },
+        minimum: {
+          type: "number"
+        },
+        exclusiveMinimum: {
+          type: "number"
+        },
+        maxLength: { $ref: "#/$defs/nonNegativeInteger" },
+        minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        pattern: {
+          type: "string",
+          format: "regex"
+        },
+        maxItems: { $ref: "#/$defs/nonNegativeInteger" },
+        minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        uniqueItems: {
+          type: "boolean",
+          default: false
+        },
+        maxContains: { $ref: "#/$defs/nonNegativeInteger" },
+        minContains: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 1
+        },
+        maxProperties: { $ref: "#/$defs/nonNegativeInteger" },
+        minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        required: { $ref: "#/$defs/stringArray" },
+        dependentRequired: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/stringArray"
+          }
+        }
+      },
+      $defs: {
+        nonNegativeInteger: {
+          type: "integer",
+          minimum: 0
+        },
+        nonNegativeIntegerDefault0: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 0
+        },
+        simpleTypes: {
+          enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+        },
+        stringArray: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true,
+          default: []
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/index.js
+var require_json_schema_2020_12 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var metaSchema = require_schema();
+    var applicator = require_applicator2();
+    var unevaluated = require_unevaluated2();
+    var content = require_content();
+    var core = require_core3();
+    var format = require_format_annotation();
+    var metadata = require_meta_data();
+    var validation = require_validation2();
+    var META_SUPPORT_DATA = ["/properties"];
+    function addMetaSchema2020($data) {
+      ;
+      [
+        metaSchema,
+        applicator,
+        unevaluated,
+        content,
+        core,
+        with$data(this, format),
+        metadata,
+        with$data(this, validation)
+      ].forEach((sch) => this.addMetaSchema(sch, void 0, false));
+      return this;
+      function with$data(ajv, sch) {
+        return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
+      }
+    }
+    exports.default = addMetaSchema2020;
+  }
+});
+
+// node_modules/ajv/dist/2020.js
+var require__ = __commonJS({
+  "node_modules/ajv/dist/2020.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
+    var core_1 = require_core();
+    var draft2020_1 = require_draft2020();
+    var discriminator_1 = require_discriminator();
+    var json_schema_2020_12_1 = require_json_schema_2020_12();
+    var META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+    var Ajv2020 = class extends core_1.default {
+      constructor(opts = {}) {
+        super({
+          ...opts,
+          dynamicRef: true,
+          next: true,
+          unevaluated: true
+        });
+      }
+      _addVocabularies() {
+        super._addVocabularies();
+        draft2020_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+          this.addKeyword(discriminator_1.default);
+      }
+      _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        const { $data, meta: meta2 } = this.opts;
+        if (!meta2)
+          return;
+        json_schema_2020_12_1.default.call(this, $data);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+      }
+      defaultMeta() {
+        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+      }
+    };
+    exports.Ajv2020 = Ajv2020;
+    module.exports = exports = Ajv2020;
+    module.exports.Ajv2020 = Ajv2020;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.default = Ajv2020;
+    var validate_1 = require_validate();
+    Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
+      return validate_1.KeywordCxt;
+    } });
+    var codegen_1 = require_codegen();
+    Object.defineProperty(exports, "_", { enumerable: true, get: function() {
+      return codegen_1._;
+    } });
+    Object.defineProperty(exports, "str", { enumerable: true, get: function() {
+      return codegen_1.str;
+    } });
+    Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
+      return codegen_1.stringify;
+    } });
+    Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
+      return codegen_1.nil;
+    } });
+    Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
+      return codegen_1.Name;
+    } });
+    Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
+      return codegen_1.CodeGen;
+    } });
+    var validation_error_1 = require_validation_error();
+    Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
+      return validation_error_1.default;
+    } });
+    var ref_error_1 = require_ref_error();
+    Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
+      return ref_error_1.default;
+    } });
+  }
+});
+
 // node_modules/@casys/mcp-server/src/runtime/runtime.deno.ts
 var runtime_deno_exports = {};
 __export(runtime_deno_exports, {
@@ -9692,7 +10516,7 @@ var require_int = __commonJS({
 });
 
 // node_modules/yaml/dist/schema/core/schema.js
-var require_schema = __commonJS({
+var require_schema2 = __commonJS({
   "node_modules/yaml/dist/schema/core/schema.js"(exports) {
     "use strict";
     var map = require_map();
@@ -9720,7 +10544,7 @@ var require_schema = __commonJS({
 });
 
 // node_modules/yaml/dist/schema/json/schema.js
-var require_schema2 = __commonJS({
+var require_schema3 = __commonJS({
   "node_modules/yaml/dist/schema/json/schema.js"(exports) {
     "use strict";
     var Scalar = require_Scalar();
@@ -10346,7 +11170,7 @@ var require_timestamp = __commonJS({
 });
 
 // node_modules/yaml/dist/schema/yaml-1.1/schema.js
-var require_schema3 = __commonJS({
+var require_schema4 = __commonJS({
   "node_modules/yaml/dist/schema/yaml-1.1/schema.js"(exports) {
     "use strict";
     var map = require_map();
@@ -10400,13 +11224,13 @@ var require_tags = __commonJS({
     var bool = require_bool();
     var float = require_float();
     var int2 = require_int();
-    var schema = require_schema();
-    var schema$1 = require_schema2();
+    var schema = require_schema2();
+    var schema$1 = require_schema3();
     var binary = require_binary();
     var merge2 = require_merge();
     var omap = require_omap();
     var pairs = require_pairs();
-    var schema$2 = require_schema3();
+    var schema$2 = require_schema4();
     var set = require_set();
     var timestamp = require_timestamp();
     var schemas = /* @__PURE__ */ new Map([
@@ -12539,15 +13363,15 @@ var require_cst_scalar = __commonJS({
       }
       return null;
     }
-    function createScalarToken(value, context) {
-      const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context;
+    function createScalarToken(value, context2) {
+      const { implicitKey = false, indent, inFlow = false, offset = -1, type = "PLAIN" } = context2;
       const source = stringifyString.stringifyString({ type, value }, {
         implicitKey,
         indent: indent > 0 ? " ".repeat(indent) : "",
         inFlow,
         options: { blockQuote: true, lineWidth: -1 }
       });
-      const end = context.end ?? [
+      const end = context2.end ?? [
         { type: "newline", offset: -1, indent, source: "\n" }
       ];
       switch (source[0]) {
@@ -12571,8 +13395,8 @@ var require_cst_scalar = __commonJS({
           return { type: "scalar", offset, indent, source, end };
       }
     }
-    function setScalarValue(token, value, context = {}) {
-      let { afterKey = false, implicitKey = false, inFlow = false, type } = context;
+    function setScalarValue(token, value, context2 = {}) {
+      let { afterKey = false, implicitKey = false, inFlow = false, type } = context2;
       let indent = "indent" in token ? token.indent : null;
       if (afterKey && typeof indent === "number")
         indent += 2;
@@ -29659,7 +30483,7 @@ var StdioServerTransport = class {
 
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
-  return (context, next) => {
+  return (context2, next) => {
     let index = -1;
     return dispatch(0);
     async function dispatch(i) {
@@ -29672,31 +30496,31 @@ var compose = (middleware, onError, onNotFound) => {
       let handler;
       if (middleware[i]) {
         handler = middleware[i][0][0];
-        context.req.routeIndex = i;
+        context2.req.routeIndex = i;
       } else {
         handler = i === middleware.length && next || void 0;
       }
       if (handler) {
         try {
-          res = await handler(context, () => dispatch(i + 1));
+          res = await handler(context2, () => dispatch(i + 1));
         } catch (err) {
           if (err instanceof Error && onError) {
-            context.error = err;
-            res = await onError(err, context);
+            context2.error = err;
+            res = await onError(err, context2);
             isError = true;
           } else {
             throw err;
           }
         }
       } else {
-        if (context.finalized === false && onNotFound) {
-          res = await onNotFound(context);
+        if (context2.finalized === false && onNotFound) {
+          res = await onNotFound(context2);
         }
       }
-      if (res && (context.finalized === false || isError)) {
-        context.res = res;
+      if (res && (context2.finalized === false || isError)) {
+        context2.res = res;
       }
-      return context;
+      return context2;
     }
   };
 };
@@ -29907,13 +30731,13 @@ var checkOptionalParameter = (path) => {
     if (segment !== "" && !/\:/.test(segment)) {
       basePath += "/" + segment;
     } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
+      if (segment.charCodeAt(segment.length - 1) === 63) {
         if (results.length === 0 && basePath === "") {
           results.push("/");
         } else {
           results.push(basePath);
         }
-        const optionalSegment = segment.replace("?", "");
+        const optionalSegment = segment.slice(0, -1);
         basePath += "/" + optionalSegment;
         results.push(basePath);
       } else {
@@ -30296,7 +31120,7 @@ var raw = (value, callbacks) => {
   escapedString.callbacks = callbacks;
   return escapedString;
 };
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) => {
   if (typeof str === "object" && !(str instanceof String)) {
     if (!(str instanceof Promise)) {
       str = str.toString();
@@ -30314,9 +31138,9 @@ var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) =>
   } else {
     buffer = [str];
   }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context: context2 }))).then(
     (res) => Promise.all(
-      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context2, buffer))
     ).then(() => buffer[0])
   );
   if (preserveCallbacks) {
@@ -31060,13 +31884,13 @@ var Hono = class _Hono {
     const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
-        const context = await composed(c);
-        if (!context.finalized) {
+        const context2 = await composed(c);
+        if (!context2.finalized) {
           throw new Error(
             "Context is not finalized. Did you forget to return a Response object or `await next()`?"
           );
         }
-        return context.res;
+        return context2.res;
       } catch (err) {
         return this.#handleError(err, c);
       }
@@ -31187,7 +32011,7 @@ var Node = class _Node {
   #index;
   #varIndex;
   #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context, isStatic) {
+  insert(tokens, index, paramMap, context2, isStatic) {
     let node = this;
     for (let i = 0, len = tokens.length; i < len; i++) {
       const token = tokens[i];
@@ -31223,7 +32047,7 @@ var Node = class _Node {
           nextNode = node.#children[regexpStr] = new _Node();
         }
         if (name !== "") {
-          nextNode.#varIndex ??= context.varIndex++;
+          nextNode.#varIndex ??= context2.varIndex++;
           paramMap.push([name, nextNode.#varIndex]);
         }
       } else {
@@ -31771,6 +32595,8 @@ var cors = (options) => {
     exposeHeaders: [],
     ...options
   };
+  const exposeHeadersStr = opts.exposeHeaders?.length ? opts.exposeHeaders.join(",") : void 0;
+  const allowHeadersStr = opts.allowHeaders?.length ? opts.allowHeaders.join(",") : void 0;
   const findAllowOrigin = ((optsOrigin) => {
     if (typeof optsOrigin === "string") {
       if (optsOrigin === "*") {
@@ -31786,11 +32612,12 @@ var cors = (options) => {
   })(opts.origin);
   const findAllowMethods = ((optsAllowMethods) => {
     if (typeof optsAllowMethods === "function") {
-      return optsAllowMethods;
+      return async (origin, c) => (await optsAllowMethods(origin, c)).join(",");
     } else if (Array.isArray(optsAllowMethods)) {
-      return () => optsAllowMethods;
+      const methodsStr = optsAllowMethods.join(",");
+      return () => methodsStr;
     } else {
-      return () => [];
+      return () => "";
     }
   })(opts.allowMethods);
   return async function cors2(c, next) {
@@ -31804,8 +32631,8 @@ var cors = (options) => {
     if (opts.credentials) {
       set("Access-Control-Allow-Credentials", "true");
     }
-    if (opts.exposeHeaders?.length) {
-      set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
+    if (exposeHeadersStr) {
+      set("Access-Control-Expose-Headers", exposeHeadersStr);
     }
     if (c.req.method === "OPTIONS") {
       if (opts.origin !== "*") {
@@ -31815,18 +32642,18 @@ var cors = (options) => {
         set("Access-Control-Max-Age", opts.maxAge.toString());
       }
       const allowMethods = await findAllowMethods(c.req.header("origin") || "", c);
-      if (allowMethods.length) {
-        set("Access-Control-Allow-Methods", allowMethods.join(","));
+      if (allowMethods) {
+        set("Access-Control-Allow-Methods", allowMethods);
       }
-      let headers = opts.allowHeaders;
-      if (!headers?.length) {
+      let headersStr = allowHeadersStr;
+      if (!headersStr) {
         const requestHeaders = c.req.header("Access-Control-Request-Headers");
         if (requestHeaders) {
-          headers = requestHeaders.split(",").map((h) => h.trim());
+          headersStr = requestHeaders.split(",").map((h) => h.trim()).join(",");
         }
       }
-      if (headers?.length) {
-        set("Access-Control-Allow-Headers", headers.join(","));
+      if (headersStr) {
+        set("Access-Control-Allow-Headers", headersStr);
         c.res.headers.append("Vary", "Access-Control-Request-Headers");
       }
       c.res.headers.delete("Content-Length");
@@ -32064,8 +32891,8 @@ var RateLimiter = class _RateLimiter {
 };
 
 // node_modules/@casys/mcp-server/src/validation/schema-validator.ts
-var import_ajv2 = __toESM(require_ajv(), 1);
-var Ajv2 = import_ajv2.default.default ?? import_ajv2.default;
+var import__ = __toESM(require__(), 1);
+var Ajv2 = import__.default.default ?? import__.default;
 function plural(n, singular, plural2 = `${singular}s`) {
   return `${n} ${n === 1 ? singular : plural2}`;
 }
@@ -32550,19 +33377,19 @@ var BaseContext = class _BaseContext {
    *
    * @param parentContext a context from which to inherit values
    */
-  constructor(parentContext) {
+  constructor(parentContext2) {
     const self2 = this;
-    self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+    self2._currentContext = parentContext2 ? new Map(parentContext2) : /* @__PURE__ */ new Map();
     self2.getValue = (key) => self2._currentContext.get(key);
     self2.setValue = (key, value) => {
-      const context = new _BaseContext(self2._currentContext);
-      context._currentContext.set(key, value);
-      return context;
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.set(key, value);
+      return context2;
     };
     self2.deleteValue = (key) => {
-      const context = new _BaseContext(self2._currentContext);
-      context._currentContext.delete(key);
-      return context;
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.delete(key);
+      return context2;
     };
   }
 };
@@ -32623,8 +33450,8 @@ var ContextAPI = class _ContextAPI {
    * @param thisArg optional receiver to be used for calling fn
    * @param args optional arguments forwarded to fn
    */
-  with(context, fn, thisArg, ...args) {
-    return this._getContextManager().with(context, fn, thisArg, ...args);
+  with(context2, fn, thisArg, ...args) {
+    return this._getContextManager().with(context2, fn, thisArg, ...args);
   }
   /**
    * Bind a context to a target function or event emitter
@@ -32632,8 +33459,8 @@ var ContextAPI = class _ContextAPI {
    * @param context context to bind to the event emitter or function. Defaults to the currently active context
    * @param target function or event emitter to bind
    */
-  bind(context, target) {
-    return this._getContextManager().bind(context, target);
+  bind(context2, target) {
+    return this._getContextManager().bind(context2, target);
   }
   _getContextManager() {
     return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
@@ -32710,24 +33537,24 @@ var NonRecordingSpan = class {
 
 // node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
 var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
-function getSpan(context) {
-  return context.getValue(SPAN_KEY) || void 0;
+function getSpan(context2) {
+  return context2.getValue(SPAN_KEY) || void 0;
 }
 function getActiveSpan() {
   return getSpan(ContextAPI.getInstance().active());
 }
-function setSpan(context, span) {
-  return context.setValue(SPAN_KEY, span);
+function setSpan(context2, span) {
+  return context2.setValue(SPAN_KEY, span);
 }
-function deleteSpan(context) {
-  return context.deleteValue(SPAN_KEY);
+function deleteSpan(context2) {
+  return context2.deleteValue(SPAN_KEY);
 }
-function setSpanContext(context, spanContext) {
-  return setSpan(context, new NonRecordingSpan(spanContext));
+function setSpanContext(context2, spanContext) {
+  return setSpan(context2, new NonRecordingSpan(spanContext));
 }
-function getSpanContext(context) {
+function getSpanContext(context2) {
   var _a3;
-  return (_a3 = getSpan(context)) === null || _a3 === void 0 ? void 0 : _a3.spanContext();
+  return (_a3 = getSpan(context2)) === null || _a3 === void 0 ? void 0 : _a3.spanContext();
 }
 
 // node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
@@ -32862,12 +33689,12 @@ function wrapSpanContext(spanContext) {
 var contextApi = ContextAPI.getInstance();
 var NoopTracer = class {
   // startSpan starts a noop span.
-  startSpan(name, options, context = contextApi.active()) {
+  startSpan(name, options, context2 = contextApi.active()) {
     const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
     if (root) {
       return new NonRecordingSpan();
     }
-    const parentFromContext = context && getSpanContext(context);
+    const parentFromContext = context2 && getSpanContext(context2);
     if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
       return new NonRecordingSpan(parentFromContext);
     } else {
@@ -32890,9 +33717,9 @@ var NoopTracer = class {
       ctx = arg3;
       fn = arg4;
     }
-    const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-    const span = this.startSpan(name, opts, parentContext);
-    const contextWithSpanSet = setSpan(parentContext, span);
+    const parentContext2 = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+    const span = this.startSpan(name, opts, parentContext2);
+    const contextWithSpanSet = setSpan(parentContext2, span);
     return contextApi.with(contextWithSpanSet, fn, void 0, span);
   }
 };
@@ -32909,8 +33736,8 @@ var ProxyTracer = class {
     this.version = version2;
     this.options = options;
   }
-  startSpan(name, options, context) {
-    return this._getTracer().startSpan(name, options, context);
+  startSpan(name, options, context2) {
+    return this._getTracer().startSpan(name, options, context2);
   }
   startActiveSpan(_name, _options, _context, _fn) {
     const tracer = this._getTracer();
@@ -32974,6 +33801,9 @@ var SpanStatusCode;
   SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
 })(SpanStatusCode || (SpanStatusCode = {}));
 
+// node_modules/@opentelemetry/api/build/esm/context-api.js
+var context = ContextAPI.getInstance();
+
 // node_modules/@opentelemetry/api/build/esm/api/trace.js
 var API_NAME3 = "trace";
 var TraceAPI = class _TraceAPI {
@@ -33032,15 +33862,101 @@ var trace = TraceAPI.getInstance();
 
 // node_modules/@casys/mcp-server/src/observability/otel.ts
 var serverTracer = null;
+var TRACEPARENT = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})/;
+var TRACEPARENT_PREFIX_LENGTH = 55;
+var INVALID_TRACE_ID = "0".repeat(32);
+var INVALID_SPAN_ID = "0".repeat(16);
+var TRACESTATE_MAX_MEMBERS = 32;
+var TRACESTATE_KEY = /^(?:[a-z][a-z0-9_\-*/]{0,255}|[a-z0-9][a-z0-9_\-*/]{0,240}@[a-z][a-z0-9_\-*/]{0,13})$/;
+var TRACESTATE_VALUE = /^[\x20-\x2B\x2D-\x3C\x3E-\x7E]{0,255}[\x21-\x2B\x2D-\x3C\x3E-\x7E]$/;
+function trimOws(member) {
+  return member.replace(/^[ \t]+/, "").replace(/[ \t]+$/, "");
+}
+var ListTraceState = class _ListTraceState {
+  #entries;
+  constructor(entries) {
+    this.#entries = entries;
+  }
+  static #isValid(key, value) {
+    return TRACESTATE_KEY.test(key) && TRACESTATE_VALUE.test(value);
+  }
+  static parse(raw2) {
+    const seen = /* @__PURE__ */ new Set();
+    const entries = [];
+    for (const member of raw2.split(",")) {
+      const trimmed = trimOws(member);
+      if (trimmed.length === 0) continue;
+      const at = trimmed.indexOf("=");
+      if (at <= 0) continue;
+      const key = trimmed.slice(0, at);
+      const value = trimmed.slice(at + 1);
+      if (seen.has(key)) continue;
+      if (!_ListTraceState.#isValid(key, value)) continue;
+      seen.add(key);
+      entries.push([key, value]);
+      if (entries.length === TRACESTATE_MAX_MEMBERS) break;
+    }
+    return entries.length > 0 ? new _ListTraceState(entries) : void 0;
+  }
+  get(key) {
+    return this.#entries.find(([k]) => k === key)?.[1];
+  }
+  set(key, value) {
+    if (!_ListTraceState.#isValid(key, value)) return this;
+    return new _ListTraceState([
+      [key, value],
+      ...this.#entries.filter(([k]) => k !== key)
+    ].slice(0, TRACESTATE_MAX_MEMBERS));
+  }
+  unset(key) {
+    return new _ListTraceState(this.#entries.filter(([k]) => k !== key));
+  }
+  serialize() {
+    return this.#entries.map(([k, v]) => `${k}=${v}`).join(",");
+  }
+};
+function parseTraceParent(traceparent, tracestate) {
+  if (typeof traceparent !== "string") return void 0;
+  if (traceparent.length < TRACEPARENT_PREFIX_LENGTH) return void 0;
+  const match2 = TRACEPARENT.exec(traceparent);
+  if (!match2) return void 0;
+  const [, version2, traceId, spanId, flags] = match2;
+  if (version2 === "ff") return void 0;
+  if (version2 === "00") {
+    if (traceparent.length !== TRACEPARENT_PREFIX_LENGTH) return void 0;
+  } else if (traceparent.length > TRACEPARENT_PREFIX_LENGTH && traceparent[TRACEPARENT_PREFIX_LENGTH] !== "-") {
+    return void 0;
+  }
+  if (traceId === INVALID_TRACE_ID || spanId === INVALID_SPAN_ID) {
+    return void 0;
+  }
+  const traceState = typeof tracestate === "string" ? ListTraceState.parse(tracestate) : void 0;
+  return {
+    traceId,
+    spanId,
+    // Only the sampled bit is defined; the rest of the byte is reserved.
+    traceFlags: parseInt(flags, 16) & TraceFlags.SAMPLED,
+    isRemote: true,
+    ...traceState ? { traceState } : {}
+  };
+}
+function parentContext(remote) {
+  const active = context.active();
+  return remote ? trace.setSpanContext(active, remote) : active;
+}
 function getServerTracer() {
   if (!serverTracer) {
     serverTracer = trace.getTracer("mcp.server", "0.8.0");
   }
   return serverTracer;
 }
-function startToolCallSpan(toolName, attributes) {
+function startToolCallSpan(toolName, attributes, remoteParent) {
   const tracer = getServerTracer();
-  return tracer.startSpan(`mcp.tool.call ${toolName}`, { attributes });
+  return tracer.startSpan(
+    `mcp.tool.call ${toolName}`,
+    { attributes },
+    parentContext(remoteParent)
+  );
 }
 function endToolCallSpan(span, success, durationMs, error2) {
   span.setAttribute("mcp.tool.duration_ms", durationMs);
@@ -34096,7 +35012,7 @@ function isCloudflareWorkers() {
 var USER_AGENT;
 if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) {
   const NAME = "jose";
-  const VERSION2 = "v6.2.8";
+  const VERSION2 = "v6.2.9";
   USER_AGENT = `${NAME}/${VERSION2}`;
 }
 var customFetch = Symbol();
@@ -36564,6 +37480,8 @@ var STATELESS_SUPPORTED_VERSIONS = [
 ];
 var STATELESS_SERVER_INFO_KEY = "io.modelcontextprotocol/serverInfo";
 var STATELESS_LOG_LEVEL_KEY = "io.modelcontextprotocol/logLevel";
+var TRACEPARENT_KEY = "traceparent";
+var TRACESTATE_KEY2 = "tracestate";
 var SPEC_2026_07_28 = "2026-07-28";
 var TASKS_EXTENSION_ID = "io.modelcontextprotocol/tasks";
 var STATELESS_FALLBACK_VERSION = "2026-07-28";
@@ -36571,6 +37489,13 @@ var JSONRPC_INVALID_PARAMS = ErrorCode.InvalidParams;
 var MCP_HEADER_MISMATCH = -32020;
 var MCP_MISSING_REQUIRED_CLIENT_CAPABILITY = -32021;
 var MCP_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+function readTraceContext(meta2) {
+  const traceContext = parseTraceParent(
+    meta2[TRACEPARENT_KEY],
+    meta2[TRACESTATE_KEY2]
+  );
+  return traceContext ? { traceContext } : {};
+}
 var MCP_LOG_LEVELS = [
   "debug",
   "info",
@@ -36865,15 +37790,63 @@ var McpApp = class {
       async (request) => {
         const toolName = request.params.name;
         const args = request.params.arguments || {};
+        const meta2 = request.params._meta;
+        const clientMeta = isRecord5(meta2) ? {
+          ...readTraceContext(meta2),
+          ...readLogLevel(meta2) !== void 0 ? { logLevel: readLogLevel(meta2) } : {}
+        } : void 0;
         let result;
         try {
-          result = await this.executeToolCall(toolName, args);
+          result = await this.executeToolCall(
+            toolName,
+            args,
+            void 0,
+            void 0,
+            void 0,
+            clientMeta
+          );
         } catch (error2) {
           return this.handleToolError(error2, toolName);
         }
         return this.buildToolCallResult(toolName, result);
       }
     );
+    server.fallbackRequestHandler = (request) => {
+      if (request.method !== "server/discover") {
+        throw new McpError(ErrorCode.MethodNotFound, "Method not found");
+      }
+      return Promise.resolve(this.buildDiscoverResult());
+    };
+  }
+  /**
+   * The `server/discover` result (spec 2026-07-28, SEP-2575).
+   *
+   * Single source of truth for both transports. They used to be one inline
+   * object on the HTTP path; a stdio copy would have been the second place to
+   * forget `instructions` or a new capability.
+   *
+   * Always stamped as 2026-07-28 regardless of what the transport negotiated.
+   * That is deliberate but not free: nothing gates the method, so a peer that
+   * negotiated `2025-11-25` over stdio can call it and receive an envelope it
+   * never agreed to. The alternative is worse — stamping the negotiated version
+   * would make the probe answer "2025" to the client asking whether this server
+   * speaks 2026, which is the one question it exists to answer. Treat
+   * `server/discover` as a cross-version exception: its result describes what
+   * the server supports, not what the current transport negotiated.
+   */
+  buildDiscoverResult() {
+    return this.stampResult(
+      this.withCacheHints({
+        supportedVersions: [...STATELESS_SUPPORTED_VERSIONS],
+        capabilities: this.buildServerCapabilities(),
+        serverInfo: {
+          name: this.options.name,
+          version: this.options.version
+        },
+        ...this.options.instructions ? { instructions: this.options.instructions } : {}
+      }, SPEC_2026_07_28),
+      SPEC_2026_07_28
+    );
   }
   /**
    * Register tools with their handlers
@@ -37129,12 +38102,16 @@ var McpApp = class {
       ...mrtr?.inputResponses !== void 0 ? { inputResponses: mrtr.inputResponses } : {},
       ...mrtr?.retryVerified !== void 0 ? { retryVerified: mrtr.retryVerified } : {}
     };
-    const span = startToolCallSpan(toolName, {
-      "mcp.tool.name": toolName,
-      "mcp.server.name": this.options.name,
-      "mcp.transport": request ? "http" : "stdio",
-      "mcp.session.id": sessionId
-    });
+    const span = startToolCallSpan(
+      toolName,
+      {
+        "mcp.tool.name": toolName,
+        "mcp.server.name": this.options.name,
+        "mcp.transport": request ? "http" : "stdio",
+        "mcp.session.id": sessionId
+      },
+      clientMeta?.traceContext
+    );
     const queueMetrics = this.requestQueue.getMetrics();
     this.serverMetrics.setGauges({
       activeRequests: queueMetrics.inFlight,
@@ -37582,14 +38559,14 @@ var McpApp = class {
         return { allowed: true, retryAfterMs: 0 };
       }
       const ip = getClientIpFromHeaders(request.headers);
-      const context = {
+      const context2 = {
         ip,
         method: request.method,
         path: new URL(request.url).pathname,
         headers: overrideHeaders ?? request.headers,
         sessionId
       };
-      const key = httpRateLimit.keyExtractor?.(context) ?? ip;
+      const key = httpRateLimit.keyExtractor?.(context2) ?? ip;
       const behavior = httpRateLimit.onLimitExceeded ?? "reject";
       if (behavior === "wait") {
         try {
@@ -37787,18 +38764,7 @@ var McpApp = class {
           return c.json({
             jsonrpc: "2.0",
             id,
-            result: this.stampResult(
-              this.withCacheHints({
-                supportedVersions: [...STATELESS_SUPPORTED_VERSIONS],
-                capabilities: this.buildServerCapabilities(),
-                serverInfo: {
-                  name: this.options.name,
-                  version: this.options.version
-                },
-                ...this.options.instructions ? { instructions: this.options.instructions } : {}
-              }, statelessVersion),
-              statelessVersion
-            )
+            result: this.buildDiscoverResult()
           });
         }
         if (method === "initialize") {
@@ -37836,7 +38802,8 @@ var McpApp = class {
           const statelessClientMeta = isRecord5(params) && isRecord5(params["_meta"]) ? {
             clientInfo: params["_meta"][STATELESS_CLIENT_INFO_KEY],
             clientCapabilities: params["_meta"][STATELESS_CLIENT_CAPABILITIES_KEY],
-            logLevel: readLogLevel(params["_meta"])
+            logLevel: readLogLevel(params["_meta"]),
+            ...readTraceContext(params["_meta"])
           } : void 0;
           const mrtrEnabled = true;
           const ingressDigest = mrtrEnabled ? await paramsDigest({ arguments: args, name: toolName }) : "";
@@ -38977,7 +39944,7 @@ var McpApp = class {
    * A violation is the server author's bug, so it surfaces as `-32603` rather
    * than being emitted as an invalid MRTR result for the client to puzzle over.
    */
-  async buildInputRequiredResult(signal, context) {
+  async buildInputRequiredResult(signal, context2) {
     const requests = signal.inputRequests;
     if (requests !== void 0 && !isRecord5(requests)) {
       return {
@@ -38998,7 +39965,7 @@ var McpApp = class {
     if (hasRequests) {
       const check = checkInputRequestCapabilities(
         requests,
-        context.clientCapabilities
+        context2.clientCapabilities
       );
       if (!check.ok) {
         if (check.kind === "malformed") {
@@ -39044,9 +40011,9 @@ var McpApp = class {
     if (key !== null) {
       const ttl = this.options.mrtr?.defaultTtlSecs ?? 300;
       requestState = await sealRequestState({
-        sub: context.principal,
-        method: context.method,
-        paramsDigest: context.paramsDigest,
+        sub: context2.principal,
+        method: context2.method,
+        paramsDigest: context2.paramsDigest,
         exp: Math.floor(Date.now() / 1e3) + ttl,
         nonce: bytesToHexLocal(crypto.getRandomValues(new Uint8Array(16)))
       }, key);
@@ -48072,8 +49039,8 @@ function getToolByName(name) {
 function linkDisambiguationRequestKey(inputPath) {
   return `link-disambiguation:${inputPath}`;
 }
-function supportsElicitation(context) {
-  return context?.clientCapabilities?.elicitation !== void 0;
+function supportsElicitation(context2) {
+  return context2?.clientCapabilities?.elicitation !== void 0;
 }
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -48107,16 +49074,16 @@ function buildInputRequiredSignal(ambiguity, inputPath) {
     }
   };
 }
-function selectedRecordId(ambiguity, inputPath, context) {
-  const hasRetryContext = context?.inputResponses !== void 0 || context?.retryVerified !== void 0;
+function selectedRecordId(ambiguity, inputPath, context2) {
+  const hasRetryContext = context2?.inputResponses !== void 0 || context2?.retryVerified !== void 0;
   if (!hasRetryContext) return void 0;
-  if (context?.retryVerified !== true) {
+  if (context2?.retryVerified !== true) {
     throw new Error(
       "[link-disambiguation] Refusing to use an unverified MRTR response."
     );
   }
   const key = linkDisambiguationRequestKey(inputPath);
-  const response = context.inputResponses?.[key];
+  const response = context2.inputResponses?.[key];
   if (!isRecord6(response)) {
     throw new Error(
       `[link-disambiguation] Missing or invalid response for "${key}".`