@casys/mcp-erpnext 0.1.8 → 0.1.9

package/mcp-erpnext.mjs

@@ -1,4 +1,5 @@
-import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+#!/usr/bin/env node
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -6808,13 +6809,13 @@ var require_dist = __commonJS({
 var require_identity = __commonJS({
   "node_modules/yaml/dist/nodes/identity.js"(exports) {
     "use strict";
-    var ALIAS = /* @__PURE__ */ Symbol.for("yaml.alias");
-    var DOC = /* @__PURE__ */ Symbol.for("yaml.document");
-    var MAP = /* @__PURE__ */ Symbol.for("yaml.map");
-    var PAIR = /* @__PURE__ */ Symbol.for("yaml.pair");
-    var SCALAR = /* @__PURE__ */ Symbol.for("yaml.scalar");
-    var SEQ = /* @__PURE__ */ Symbol.for("yaml.seq");
-    var NODE_TYPE = /* @__PURE__ */ Symbol.for("yaml.node.type");
+    var ALIAS = Symbol.for("yaml.alias");
+    var DOC = Symbol.for("yaml.document");
+    var MAP = Symbol.for("yaml.map");
+    var PAIR = Symbol.for("yaml.pair");
+    var SCALAR = Symbol.for("yaml.scalar");
+    var SEQ = Symbol.for("yaml.seq");
+    var NODE_TYPE = Symbol.for("yaml.node.type");
     var isAlias = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === ALIAS;
     var isDocument = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === DOC;
     var isMap = (node) => !!node && typeof node === "object" && node[NODE_TYPE] === MAP;
@@ -6866,9 +6867,9 @@ var require_visit = __commonJS({
   "node_modules/yaml/dist/visit.js"(exports) {
     "use strict";
     var identity = require_identity();
-    var BREAK = /* @__PURE__ */ Symbol("break visit");
-    var SKIP = /* @__PURE__ */ Symbol("skip children");
-    var REMOVE = /* @__PURE__ */ Symbol("remove node");
+    var BREAK = Symbol("break visit");
+    var SKIP = Symbol("skip children");
+    var REMOVE = Symbol("remove node");
     function visit(node, visitor) {
       const visitor_ = initVisitor(visitor);
       if (identity.isDocument(node)) {
@@ -11412,12 +11413,12 @@ var require_resolve_flow_scalar = __commonJS({
           };
       }
       const valueEnd = offset + source.length;
-      const re = resolveEnd.resolveEnd(end, valueEnd, strict, onError);
+      const re2 = resolveEnd.resolveEnd(end, valueEnd, strict, onError);
       return {
         value,
         type: _type,
-        comment: re.comment,
-        range: [offset, valueEnd, re.offset]
+        comment: re2.comment,
+        range: [offset, valueEnd, re2.offset]
       };
     }
     function plainValue(source, onError) {
@@ -11797,10 +11798,10 @@ var require_compose_node = __commonJS({
       if (alias.source.endsWith(":"))
         onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
       const valueEnd = offset + source.length;
-      const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError);
-      alias.range = [offset, valueEnd, re.offset];
-      if (re.comment)
-        alias.comment = re.comment;
+      const re2 = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError);
+      alias.range = [offset, valueEnd, re2.offset];
+      if (re2.comment)
+        alias.comment = re2.comment;
       return alias;
     }
     exports.composeEmptyNode = composeEmptyNode;
@@ -11841,10 +11842,10 @@ var require_compose_doc = __commonJS({
       }
       doc.contents = value ? composeNode.composeNode(ctx, value, props, onError) : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError);
       const contentEnd = doc.contents.range[2];
-      const re = resolveEnd.resolveEnd(end, contentEnd, false, onError);
-      if (re.comment)
-        doc.comment = re.comment;
-      doc.range = [offset, contentEnd, re.offset];
+      const re2 = resolveEnd.resolveEnd(end, contentEnd, false, onError);
+      if (re2.comment)
+        doc.comment = re2.comment;
+      doc.range = [offset, contentEnd, re2.offset];
       return doc;
     }
     exports.composeDoc = composeDoc;
@@ -12307,9 +12308,9 @@ var require_cst_stringify = __commonJS({
 var require_cst_visit = __commonJS({
   "node_modules/yaml/dist/parse/cst-visit.js"(exports) {
     "use strict";
-    var BREAK = /* @__PURE__ */ Symbol("break visit");
-    var SKIP = /* @__PURE__ */ Symbol("skip children");
-    var REMOVE = /* @__PURE__ */ Symbol("remove item");
+    var BREAK = Symbol("break visit");
+    var SKIP = Symbol("skip children");
+    var REMOVE = Symbol("remove item");
     function visit(cst, visitor) {
       if ("type" in cst && cst.type === "document")
         cst = { start: cst.start, value: cst.value };
@@ -17801,6 +17802,7 @@ ZodNaN.create = (params) => {
     ...processCreateParams(params)
   });
 };
+var BRAND = Symbol("zod_brand");
 var ZodBranded = class extends ZodType {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
@@ -18025,6 +18027,7 @@ function $constructor(name, initializer3, params) {
   Object.defineProperty(_, "name", { value: name });
   return _;
 }
+var $brand = Symbol("zod_brand");
 var $ZodAsyncError = class extends Error {
   constructor() {
     super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
@@ -18171,7 +18174,7 @@ function floatSafeRemainder2(val, step) {
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
-var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
+var EVALUATING = Symbol("evaluating");
 function defineLazy(object3, key, getter) {
   let value = void 0;
   Object.defineProperty(object3, key, {
@@ -21698,6 +21701,8 @@ function en_default2() {
 
 // node_modules/zod/v4/core/registries.js
 var _a;
+var $output = Symbol("ZodOutput");
+var $input = Symbol("ZodInput");
 var $ZodRegistry = class {
   constructor() {
     this._map = /* @__PURE__ */ new WeakMap();
@@ -26555,7 +26560,7 @@ function isTerminal(status) {
 }
 
 // node_modules/zod-to-json-schema/dist/esm/Options.js
-var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
+var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
 var defaultOptions = {
   name: void 0,
   $refStrategy: "root",
@@ -29525,7 +29530,7 @@ var Server = class extends Protocol {
 };
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
-var COMPLETABLE_SYMBOL = /* @__PURE__ */ Symbol.for("mcp.completable");
+var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
 function isCompletable(schema) {
   return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
 }
@@ -32203,7 +32208,7 @@ var RegExpRouter = class {
     }
     const paramCount = (path.match(/\/:/g) || []).length;
     if (/\*$/.test(path)) {
-      const re = buildWildcardRegExp(path);
+      const re2 = buildWildcardRegExp(path);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
           middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
@@ -32214,14 +32219,14 @@ var RegExpRouter = class {
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
           Object.keys(middleware[m]).forEach((p) => {
-            re.test(p) && middleware[m][p].push([handler, paramCount]);
+            re2.test(p) && middleware[m][p].push([handler, paramCount]);
           });
         }
       });
       Object.keys(routes).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
           Object.keys(routes[m]).forEach(
-            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
+            (p) => re2.test(p) && routes[m][p].push([handler, paramCount])
           );
         }
       });
@@ -33319,11 +33324,758 @@ function collectBody(req, maxBytes) {
   });
 }
 
+// node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
+var _globalThis = typeof globalThis === "object" ? globalThis : global;
+
+// node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION = "1.9.0";
+
+// node_modules/@opentelemetry/api/build/esm/internal/semver.js
+var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function _makeCompatibilityCheck(ownVersion) {
+  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  var rejectedVersions = /* @__PURE__ */ new Set();
+  var myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return function() {
+      return false;
+    };
+  }
+  var ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    };
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  return function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    var globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    var globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  };
+}
+var isCompatible = _makeCompatibilityCheck(VERSION);
+
+// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+var major = VERSION.split(".")[0];
+var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+var _global = _globalThis;
+function registerGlobal(type, instance, diag, allowOverride) {
+  var _a2;
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a2 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a2 !== void 0 ? _a2 : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+    diag.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  return true;
+}
+function getGlobal(type) {
+  var _a2, _b;
+  var globalVersion = (_a2 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a2 === void 0 ? void 0 : _a2.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag) {
+  diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+
+// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+var __read = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error2) {
+    e = { error: error2 };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var DiagComponentLogger = (
+  /** @class */
+  (function() {
+    function DiagComponentLogger2(props) {
+      this._namespace = props.namespace || "DiagComponentLogger";
+    }
+    DiagComponentLogger2.prototype.debug = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("debug", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.error = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("error", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.info = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("info", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.warn = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("warn", this._namespace, args);
+    };
+    DiagComponentLogger2.prototype.verbose = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return logProxy("verbose", this._namespace, args);
+    };
+    return DiagComponentLogger2;
+  })()
+);
+function logProxy(funcName, namespace, args) {
+  var logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  args.unshift(namespace);
+  return logger[funcName].apply(logger, __spreadArray([], __read(args), false));
+}
+
+// node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+(function(DiagLogLevel2) {
+  DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+  DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+  DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+  DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+  DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+  DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+  DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+
+// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    var theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+
+// node_modules/@opentelemetry/api/build/esm/api/diag.js
+var __read2 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error2) {
+    e = { error: error2 };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray2 = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var API_NAME = "diag";
+var DiagAPI = (
+  /** @class */
+  (function() {
+    function DiagAPI2() {
+      function _logProxy(funcName) {
+        return function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var logger = getGlobal("diag");
+          if (!logger)
+            return;
+          return logger[funcName].apply(logger, __spreadArray2([], __read2(args), false));
+        };
+      }
+      var self = this;
+      var setLogger = function(logger, optionsOrLogLevel) {
+        var _a2, _b, _c;
+        if (optionsOrLogLevel === void 0) {
+          optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+        }
+        if (logger === self) {
+          var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+          self.error((_a2 = err.stack) !== null && _a2 !== void 0 ? _a2 : err.message);
+          return false;
+        }
+        if (typeof optionsOrLogLevel === "number") {
+          optionsOrLogLevel = {
+            logLevel: optionsOrLogLevel
+          };
+        }
+        var oldLogger = getGlobal("diag");
+        var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+        if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+          var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+          oldLogger.warn("Current logger will be overwritten from " + stack);
+          newLogger.warn("Current logger will overwrite one already registered from " + stack);
+        }
+        return registerGlobal("diag", newLogger, self, true);
+      };
+      self.setLogger = setLogger;
+      self.disable = function() {
+        unregisterGlobal(API_NAME, self);
+      };
+      self.createComponentLogger = function(options) {
+        return new DiagComponentLogger(options);
+      };
+      self.verbose = _logProxy("verbose");
+      self.debug = _logProxy("debug");
+      self.info = _logProxy("info");
+      self.warn = _logProxy("warn");
+      self.error = _logProxy("error");
+    }
+    DiagAPI2.instance = function() {
+      if (!this._instance) {
+        this._instance = new DiagAPI2();
+      }
+      return this._instance;
+    };
+    return DiagAPI2;
+  })()
+);
+
+// node_modules/@opentelemetry/api/build/esm/context/context.js
+function createContextKey(description) {
+  return Symbol.for(description);
+}
+var BaseContext = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function BaseContext2(parentContext) {
+      var self = this;
+      self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+      self.getValue = function(key) {
+        return self._currentContext.get(key);
+      };
+      self.setValue = function(key, value) {
+        var context = new BaseContext2(self._currentContext);
+        context._currentContext.set(key, value);
+        return context;
+      };
+      self.deleteValue = function(key) {
+        var context = new BaseContext2(self._currentContext);
+        context._currentContext.delete(key);
+        return context;
+      };
+    }
+    return BaseContext2;
+  })()
+);
+var ROOT_CONTEXT = new BaseContext();
+
+// node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var __read3 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error2) {
+    e = { error: error2 };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray3 = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var NoopContextManager = (
+  /** @class */
+  (function() {
+    function NoopContextManager2() {
+    }
+    NoopContextManager2.prototype.active = function() {
+      return ROOT_CONTEXT;
+    };
+    NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
+      var args = [];
+      for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+      }
+      return fn.call.apply(fn, __spreadArray3([thisArg], __read3(args), false));
+    };
+    NoopContextManager2.prototype.bind = function(_context, target) {
+      return target;
+    };
+    NoopContextManager2.prototype.enable = function() {
+      return this;
+    };
+    NoopContextManager2.prototype.disable = function() {
+      return this;
+    };
+    return NoopContextManager2;
+  })()
+);
+
+// node_modules/@opentelemetry/api/build/esm/api/context.js
+var __read4 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error2) {
+    e = { error: error2 };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray4 = function(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+var API_NAME2 = "context";
+var NOOP_CONTEXT_MANAGER = new NoopContextManager();
+var ContextAPI = (
+  /** @class */
+  (function() {
+    function ContextAPI2() {
+    }
+    ContextAPI2.getInstance = function() {
+      if (!this._instance) {
+        this._instance = new ContextAPI2();
+      }
+      return this._instance;
+    };
+    ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
+      return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+    };
+    ContextAPI2.prototype.active = function() {
+      return this._getContextManager().active();
+    };
+    ContextAPI2.prototype.with = function(context, fn, thisArg) {
+      var _a2;
+      var args = [];
+      for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+      }
+      return (_a2 = this._getContextManager()).with.apply(_a2, __spreadArray4([context, fn, thisArg], __read4(args), false));
+    };
+    ContextAPI2.prototype.bind = function(context, target) {
+      return this._getContextManager().bind(context, target);
+    };
+    ContextAPI2.prototype._getContextManager = function() {
+      return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+    };
+    ContextAPI2.prototype.disable = function() {
+      this._getContextManager().disable();
+      unregisterGlobal(API_NAME2, DiagAPI.instance());
+    };
+    return ContextAPI2;
+  })()
+);
+
+// node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+var TraceFlags;
+(function(TraceFlags2) {
+  TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+  TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+})(TraceFlags || (TraceFlags = {}));
+
+// node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+var INVALID_SPANID = "0000000000000000";
+var INVALID_TRACEID = "00000000000000000000000000000000";
+var INVALID_SPAN_CONTEXT = {
+  traceId: INVALID_TRACEID,
+  spanId: INVALID_SPANID,
+  traceFlags: TraceFlags.NONE
+};
+
+// node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+var NonRecordingSpan = (
+  /** @class */
+  (function() {
+    function NonRecordingSpan2(_spanContext) {
+      if (_spanContext === void 0) {
+        _spanContext = INVALID_SPAN_CONTEXT;
+      }
+      this._spanContext = _spanContext;
+    }
+    NonRecordingSpan2.prototype.spanContext = function() {
+      return this._spanContext;
+    };
+    NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addLink = function(_link) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.addLinks = function(_links) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.setStatus = function(_status) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.updateName = function(_name) {
+      return this;
+    };
+    NonRecordingSpan2.prototype.end = function(_endTime) {
+    };
+    NonRecordingSpan2.prototype.isRecording = function() {
+      return false;
+    };
+    NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
+    };
+    return NonRecordingSpan2;
+  })()
+);
+
+// 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 getActiveSpan() {
+  return getSpan(ContextAPI.getInstance().active());
+}
+function setSpan(context, span) {
+  return context.setValue(SPAN_KEY, span);
+}
+function deleteSpan(context) {
+  return context.deleteValue(SPAN_KEY);
+}
+function setSpanContext(context, spanContext) {
+  return setSpan(context, new NonRecordingSpan(spanContext));
+}
+function getSpanContext(context) {
+  var _a2;
+  return (_a2 = getSpan(context)) === null || _a2 === void 0 ? void 0 : _a2.spanContext();
+}
+
+// node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
+var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
+function isValidTraceId(traceId) {
+  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
+}
+function isValidSpanId(spanId) {
+  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
+}
+function isSpanContextValid(spanContext) {
+  return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+function wrapSpanContext(spanContext) {
+  return new NonRecordingSpan(spanContext);
+}
+
+// node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+var contextApi = ContextAPI.getInstance();
+var NoopTracer = (
+  /** @class */
+  (function() {
+    function NoopTracer2() {
+    }
+    NoopTracer2.prototype.startSpan = function(name, options, context) {
+      if (context === void 0) {
+        context = contextApi.active();
+      }
+      var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+      if (root) {
+        return new NonRecordingSpan();
+      }
+      var parentFromContext = context && getSpanContext(context);
+      if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+        return new NonRecordingSpan(parentFromContext);
+      } else {
+        return new NonRecordingSpan();
+      }
+    };
+    NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
+      var opts;
+      var ctx;
+      var fn;
+      if (arguments.length < 2) {
+        return;
+      } else if (arguments.length === 2) {
+        fn = arg2;
+      } else if (arguments.length === 3) {
+        opts = arg2;
+        fn = arg3;
+      } else {
+        opts = arg2;
+        ctx = arg3;
+        fn = arg4;
+      }
+      var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+      var span = this.startSpan(name, opts, parentContext);
+      var contextWithSpanSet = setSpan(parentContext, span);
+      return contextApi.with(contextWithSpanSet, fn, void 0, span);
+    };
+    return NoopTracer2;
+  })()
+);
+function isSpanContext(spanContext) {
+  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
+}
+
+// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+var NOOP_TRACER = new NoopTracer();
+var ProxyTracer = (
+  /** @class */
+  (function() {
+    function ProxyTracer2(_provider, name, version2, options) {
+      this._provider = _provider;
+      this.name = name;
+      this.version = version2;
+      this.options = options;
+    }
+    ProxyTracer2.prototype.startSpan = function(name, options, context) {
+      return this._getTracer().startSpan(name, options, context);
+    };
+    ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
+      var tracer = this._getTracer();
+      return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+    };
+    ProxyTracer2.prototype._getTracer = function() {
+      if (this._delegate) {
+        return this._delegate;
+      }
+      var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+      if (!tracer) {
+        return NOOP_TRACER;
+      }
+      this._delegate = tracer;
+      return this._delegate;
+    };
+    return ProxyTracer2;
+  })()
+);
+
+// node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+var NoopTracerProvider = (
+  /** @class */
+  (function() {
+    function NoopTracerProvider2() {
+    }
+    NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
+      return new NoopTracer();
+    };
+    return NoopTracerProvider2;
+  })()
+);
+
+// node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+var ProxyTracerProvider = (
+  /** @class */
+  (function() {
+    function ProxyTracerProvider2() {
+    }
+    ProxyTracerProvider2.prototype.getTracer = function(name, version2, options) {
+      var _a2;
+      return (_a2 = this.getDelegateTracer(name, version2, options)) !== null && _a2 !== void 0 ? _a2 : new ProxyTracer(this, name, version2, options);
+    };
+    ProxyTracerProvider2.prototype.getDelegate = function() {
+      var _a2;
+      return (_a2 = this._delegate) !== null && _a2 !== void 0 ? _a2 : NOOP_TRACER_PROVIDER;
+    };
+    ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
+      this._delegate = delegate;
+    };
+    ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version2, options) {
+      var _a2;
+      return (_a2 = this._delegate) === null || _a2 === void 0 ? void 0 : _a2.getTracer(name, version2, options);
+    };
+    return ProxyTracerProvider2;
+  })()
+);
+
+// node_modules/@opentelemetry/api/build/esm/trace/status.js
+var SpanStatusCode;
+(function(SpanStatusCode2) {
+  SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+  SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+  SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+
+// node_modules/@opentelemetry/api/build/esm/api/trace.js
+var API_NAME3 = "trace";
+var TraceAPI = (
+  /** @class */
+  (function() {
+    function TraceAPI2() {
+      this._proxyTracerProvider = new ProxyTracerProvider();
+      this.wrapSpanContext = wrapSpanContext;
+      this.isSpanContextValid = isSpanContextValid;
+      this.deleteSpan = deleteSpan;
+      this.getSpan = getSpan;
+      this.getActiveSpan = getActiveSpan;
+      this.getSpanContext = getSpanContext;
+      this.setSpan = setSpan;
+      this.setSpanContext = setSpanContext;
+    }
+    TraceAPI2.getInstance = function() {
+      if (!this._instance) {
+        this._instance = new TraceAPI2();
+      }
+      return this._instance;
+    };
+    TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
+      var success2 = registerGlobal(API_NAME3, this._proxyTracerProvider, DiagAPI.instance());
+      if (success2) {
+        this._proxyTracerProvider.setDelegate(provider);
+      }
+      return success2;
+    };
+    TraceAPI2.prototype.getTracerProvider = function() {
+      return getGlobal(API_NAME3) || this._proxyTracerProvider;
+    };
+    TraceAPI2.prototype.getTracer = function(name, version2) {
+      return this.getTracerProvider().getTracer(name, version2);
+    };
+    TraceAPI2.prototype.disable = function() {
+      unregisterGlobal(API_NAME3, DiagAPI.instance());
+      this._proxyTracerProvider = new ProxyTracerProvider();
+    };
+    return TraceAPI2;
+  })()
+);
+
+// node_modules/@opentelemetry/api/build/esm/trace-api.js
+var trace = TraceAPI.getInstance();
+
 // node_modules/@casys/mcp-server/src/observability/otel.ts
-import {
-  SpanStatusCode,
-  trace
-} from "@opentelemetry/api";
 var serverTracer = null;
 function getServerTracer() {
   if (!serverTracer) {
@@ -33549,98 +34301,17 @@ function decode3(input) {
   }
 }
 
-// node_modules/jose/dist/webapi/util/errors.js
-var JOSEError = class extends Error {
-  static code = "ERR_JOSE_GENERIC";
-  code = "ERR_JOSE_GENERIC";
-  constructor(message2, options) {
-    super(message2, options);
-    this.name = this.constructor.name;
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-};
-var JWTClaimValidationFailed = class extends JOSEError {
-  static code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
-  code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
-  claim;
-  reason;
-  payload;
-  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
-    super(message2, { cause: { claim, reason, payload } });
-    this.claim = claim;
-    this.reason = reason;
-    this.payload = payload;
-  }
-};
-var JWTExpired = class extends JOSEError {
-  static code = "ERR_JWT_EXPIRED";
-  code = "ERR_JWT_EXPIRED";
-  claim;
-  reason;
-  payload;
-  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
-    super(message2, { cause: { claim, reason, payload } });
-    this.claim = claim;
-    this.reason = reason;
-    this.payload = payload;
-  }
-};
-var JOSEAlgNotAllowed = class extends JOSEError {
-  static code = "ERR_JOSE_ALG_NOT_ALLOWED";
-  code = "ERR_JOSE_ALG_NOT_ALLOWED";
-};
-var JOSENotSupported = class extends JOSEError {
-  static code = "ERR_JOSE_NOT_SUPPORTED";
-  code = "ERR_JOSE_NOT_SUPPORTED";
-};
-var JWSInvalid = class extends JOSEError {
-  static code = "ERR_JWS_INVALID";
-  code = "ERR_JWS_INVALID";
-};
-var JWTInvalid = class extends JOSEError {
-  static code = "ERR_JWT_INVALID";
-  code = "ERR_JWT_INVALID";
-};
-var JWKSInvalid = class extends JOSEError {
-  static code = "ERR_JWKS_INVALID";
-  code = "ERR_JWKS_INVALID";
-};
-var JWKSNoMatchingKey = class extends JOSEError {
-  static code = "ERR_JWKS_NO_MATCHING_KEY";
-  code = "ERR_JWKS_NO_MATCHING_KEY";
-  constructor(message2 = "no applicable key found in the JSON Web Key Set", options) {
-    super(message2, options);
-  }
-};
-var JWKSMultipleMatchingKeys = class extends JOSEError {
-  [Symbol.asyncIterator];
-  static code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
-  code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
-  constructor(message2 = "multiple matching keys found in the JSON Web Key Set", options) {
-    super(message2, options);
-  }
-};
-var JWKSTimeout = class extends JOSEError {
-  static code = "ERR_JWKS_TIMEOUT";
-  code = "ERR_JWKS_TIMEOUT";
-  constructor(message2 = "request timed out", options) {
-    super(message2, options);
-  }
-};
-var JWSSignatureVerificationFailed = class extends JOSEError {
-  static code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
-  code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
-  constructor(message2 = "signature verification failed", options) {
-    super(message2, options);
-  }
-};
-
 // node_modules/jose/dist/webapi/lib/crypto_key.js
 var unusable = (name, prop = "algorithm.name") => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
 var isAlgorithm = (algorithm, name) => algorithm.name === name;
 function getHashLength(hash2) {
   return parseInt(hash2.name.slice(4), 10);
 }
+function checkHashLength(algorithm, expected) {
+  const actual = getHashLength(algorithm.hash);
+  if (actual !== expected)
+    throw unusable(`SHA-${expected}`, "algorithm.hash");
+}
 function getNamedCurve(alg) {
   switch (alg) {
     case "ES256":
@@ -33665,10 +34336,7 @@ function checkSigCryptoKey(key, alg, usage) {
     case "HS512": {
       if (!isAlgorithm(key.algorithm, "HMAC"))
         throw unusable("HMAC");
-      const expected = parseInt(alg.slice(2), 10);
-      const actual = getHashLength(key.algorithm.hash);
-      if (actual !== expected)
-        throw unusable(`SHA-${expected}`, "algorithm.hash");
+      checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
       break;
     }
     case "RS256":
@@ -33676,10 +34344,7 @@ function checkSigCryptoKey(key, alg, usage) {
     case "RS512": {
       if (!isAlgorithm(key.algorithm, "RSASSA-PKCS1-v1_5"))
         throw unusable("RSASSA-PKCS1-v1_5");
-      const expected = parseInt(alg.slice(2), 10);
-      const actual = getHashLength(key.algorithm.hash);
-      if (actual !== expected)
-        throw unusable(`SHA-${expected}`, "algorithm.hash");
+      checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
       break;
     }
     case "PS256":
@@ -33687,10 +34352,7 @@ function checkSigCryptoKey(key, alg, usage) {
     case "PS512": {
       if (!isAlgorithm(key.algorithm, "RSA-PSS"))
         throw unusable("RSA-PSS");
-      const expected = parseInt(alg.slice(2), 10);
-      const actual = getHashLength(key.algorithm.hash);
-      if (actual !== expected)
-        throw unusable(`SHA-${expected}`, "algorithm.hash");
+      checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
       break;
     }
     case "Ed25519":
@@ -33748,6 +34410,92 @@ function message(msg, actual, ...types) {
 var invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types);
 var withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);
 
+// node_modules/jose/dist/webapi/util/errors.js
+var JOSEError = class extends Error {
+  static code = "ERR_JOSE_GENERIC";
+  code = "ERR_JOSE_GENERIC";
+  constructor(message2, options) {
+    super(message2, options);
+    this.name = this.constructor.name;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var JWTClaimValidationFailed = class extends JOSEError {
+  static code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
+  code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
+  claim;
+  reason;
+  payload;
+  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
+    super(message2, { cause: { claim, reason, payload } });
+    this.claim = claim;
+    this.reason = reason;
+    this.payload = payload;
+  }
+};
+var JWTExpired = class extends JOSEError {
+  static code = "ERR_JWT_EXPIRED";
+  code = "ERR_JWT_EXPIRED";
+  claim;
+  reason;
+  payload;
+  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
+    super(message2, { cause: { claim, reason, payload } });
+    this.claim = claim;
+    this.reason = reason;
+    this.payload = payload;
+  }
+};
+var JOSEAlgNotAllowed = class extends JOSEError {
+  static code = "ERR_JOSE_ALG_NOT_ALLOWED";
+  code = "ERR_JOSE_ALG_NOT_ALLOWED";
+};
+var JOSENotSupported = class extends JOSEError {
+  static code = "ERR_JOSE_NOT_SUPPORTED";
+  code = "ERR_JOSE_NOT_SUPPORTED";
+};
+var JWSInvalid = class extends JOSEError {
+  static code = "ERR_JWS_INVALID";
+  code = "ERR_JWS_INVALID";
+};
+var JWTInvalid = class extends JOSEError {
+  static code = "ERR_JWT_INVALID";
+  code = "ERR_JWT_INVALID";
+};
+var JWKSInvalid = class extends JOSEError {
+  static code = "ERR_JWKS_INVALID";
+  code = "ERR_JWKS_INVALID";
+};
+var JWKSNoMatchingKey = class extends JOSEError {
+  static code = "ERR_JWKS_NO_MATCHING_KEY";
+  code = "ERR_JWKS_NO_MATCHING_KEY";
+  constructor(message2 = "no applicable key found in the JSON Web Key Set", options) {
+    super(message2, options);
+  }
+};
+var JWKSMultipleMatchingKeys = class extends JOSEError {
+  [Symbol.asyncIterator];
+  static code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
+  code = "ERR_JWKS_MULTIPLE_MATCHING_KEYS";
+  constructor(message2 = "multiple matching keys found in the JSON Web Key Set", options) {
+    super(message2, options);
+  }
+};
+var JWKSTimeout = class extends JOSEError {
+  static code = "ERR_JWKS_TIMEOUT";
+  code = "ERR_JWKS_TIMEOUT";
+  constructor(message2 = "request timed out", options) {
+    super(message2, options);
+  }
+};
+var JWSSignatureVerificationFailed = class extends JOSEError {
+  static code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
+  code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
+  constructor(message2 = "signature verification failed", options) {
+    super(message2, options);
+  }
+};
+
 // node_modules/jose/dist/webapi/lib/is_key_like.js
 var isCryptoKey = (key) => {
   if (key?.[Symbol.toStringTag] === "CryptoKey")
@@ -33761,7 +34509,31 @@ var isCryptoKey = (key) => {
 var isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject";
 var isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
 
-// node_modules/jose/dist/webapi/lib/is_disjoint.js
+// node_modules/jose/dist/webapi/lib/helpers.js
+var unprotected = Symbol();
+function decodeBase64url(value, label, ErrorClass) {
+  try {
+    return decode3(value);
+  } catch {
+    throw new ErrorClass(`Failed to base64url decode the ${label}`);
+  }
+}
+
+// node_modules/jose/dist/webapi/lib/type_checks.js
+var isObjectLike = (value) => typeof value === "object" && value !== null;
+function isObject2(input) {
+  if (!isObjectLike(input) || Object.prototype.toString.call(input) !== "[object Object]") {
+    return false;
+  }
+  if (Object.getPrototypeOf(input) === null) {
+    return true;
+  }
+  let proto = input;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(input) === proto;
+}
 function isDisjoint(...headers) {
   const sources = headers.filter(Boolean);
   if (sources.length === 0 || sources.length === 1) {
@@ -33783,24 +34555,12 @@ function isDisjoint(...headers) {
   }
   return true;
 }
+var isJWK = (key) => isObject2(key) && typeof key.kty === "string";
+var isPrivateJWK = (key) => key.kty !== "oct" && (key.kty === "AKP" && typeof key.priv === "string" || typeof key.d === "string");
+var isPublicJWK = (key) => key.kty !== "oct" && key.d === void 0 && key.priv === void 0;
+var isSecretJWK = (key) => key.kty === "oct" && typeof key.k === "string";
 
-// node_modules/jose/dist/webapi/lib/is_object.js
-var isObjectLike = (value) => typeof value === "object" && value !== null;
-function isObject2(input) {
-  if (!isObjectLike(input) || Object.prototype.toString.call(input) !== "[object Object]") {
-    return false;
-  }
-  if (Object.getPrototypeOf(input) === null) {
-    return true;
-  }
-  let proto = input;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
-  }
-  return Object.getPrototypeOf(input) === proto;
-}
-
-// node_modules/jose/dist/webapi/lib/check_key_length.js
+// node_modules/jose/dist/webapi/lib/signing.js
 function checkKeyLength(alg, key) {
   if (alg.startsWith("RS") || alg.startsWith("PS")) {
     const { modulusLength } = key.algorithm;
@@ -33809,8 +34569,59 @@ function checkKeyLength(alg, key) {
     }
   }
 }
+function subtleAlgorithm(alg, algorithm) {
+  const hash2 = `SHA-${alg.slice(-3)}`;
+  switch (alg) {
+    case "HS256":
+    case "HS384":
+    case "HS512":
+      return { hash: hash2, name: "HMAC" };
+    case "PS256":
+    case "PS384":
+    case "PS512":
+      return { hash: hash2, name: "RSA-PSS", saltLength: parseInt(alg.slice(-3), 10) >> 3 };
+    case "RS256":
+    case "RS384":
+    case "RS512":
+      return { hash: hash2, name: "RSASSA-PKCS1-v1_5" };
+    case "ES256":
+    case "ES384":
+    case "ES512":
+      return { hash: hash2, name: "ECDSA", namedCurve: algorithm.namedCurve };
+    case "Ed25519":
+    case "EdDSA":
+      return { name: "Ed25519" };
+    case "ML-DSA-44":
+    case "ML-DSA-65":
+    case "ML-DSA-87":
+      return { name: alg };
+    default:
+      throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
+  }
+}
+async function getSigKey(alg, key, usage) {
+  if (key instanceof Uint8Array) {
+    if (!alg.startsWith("HS")) {
+      throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
+    }
+    return crypto.subtle.importKey("raw", key, { hash: `SHA-${alg.slice(-3)}`, name: "HMAC" }, false, [usage]);
+  }
+  checkSigCryptoKey(key, alg, usage);
+  return key;
+}
+async function verify(alg, key, signature, data) {
+  const cryptoKey = await getSigKey(alg, key, "verify");
+  checkKeyLength(alg, cryptoKey);
+  const algorithm = subtleAlgorithm(alg, cryptoKey.algorithm);
+  try {
+    return await crypto.subtle.verify(algorithm, cryptoKey, signature, data);
+  } catch {
+    return false;
+  }
+}
 
 // node_modules/jose/dist/webapi/lib/jwk_to_key.js
+var unsupportedAlg = 'Invalid or unsupported JWK "alg" (Algorithm) Parameter value';
 function subtleMapping(jwk) {
   let algorithm;
   let keyUsages;
@@ -33824,7 +34635,7 @@ function subtleMapping(jwk) {
           keyUsages = jwk.priv ? ["sign"] : ["verify"];
           break;
         default:
-          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+          throw new JOSENotSupported(unsupportedAlg);
       }
       break;
     }
@@ -33853,22 +34664,19 @@ function subtleMapping(jwk) {
           keyUsages = jwk.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
           break;
         default:
-          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+          throw new JOSENotSupported(unsupportedAlg);
       }
       break;
     }
     case "EC": {
       switch (jwk.alg) {
         case "ES256":
-          algorithm = { name: "ECDSA", namedCurve: "P-256" };
-          keyUsages = jwk.d ? ["sign"] : ["verify"];
-          break;
         case "ES384":
-          algorithm = { name: "ECDSA", namedCurve: "P-384" };
-          keyUsages = jwk.d ? ["sign"] : ["verify"];
-          break;
         case "ES512":
-          algorithm = { name: "ECDSA", namedCurve: "P-521" };
+          algorithm = {
+            name: "ECDSA",
+            namedCurve: { ES256: "P-256", ES384: "P-384", ES512: "P-521" }[jwk.alg]
+          };
           keyUsages = jwk.d ? ["sign"] : ["verify"];
           break;
         case "ECDH-ES":
@@ -33879,7 +34687,7 @@ function subtleMapping(jwk) {
           keyUsages = jwk.d ? ["deriveBits"] : [];
           break;
         default:
-          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+          throw new JOSENotSupported(unsupportedAlg);
       }
       break;
     }
@@ -33898,7 +34706,7 @@ function subtleMapping(jwk) {
           keyUsages = jwk.d ? ["deriveBits"] : [];
           break;
         default:
-          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+          throw new JOSENotSupported(unsupportedAlg);
       }
       break;
     }
@@ -33920,91 +34728,8 @@ async function jwkToKey(jwk) {
   return crypto.subtle.importKey("jwk", keyData, algorithm, jwk.ext ?? (jwk.d || jwk.priv ? false : true), jwk.key_ops ?? keyUsages);
 }
 
-// node_modules/jose/dist/webapi/key/import.js
-async function importJWK(jwk, alg, options) {
-  if (!isObject2(jwk)) {
-    throw new TypeError("JWK must be an object");
-  }
-  let ext;
-  alg ??= jwk.alg;
-  ext ??= options?.extractable ?? jwk.ext;
-  switch (jwk.kty) {
-    case "oct":
-      if (typeof jwk.k !== "string" || !jwk.k) {
-        throw new TypeError('missing "k" (Key Value) Parameter value');
-      }
-      return decode3(jwk.k);
-    case "RSA":
-      if ("oth" in jwk && jwk.oth !== void 0) {
-        throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
-      }
-      return jwkToKey({ ...jwk, alg, ext });
-    case "AKP": {
-      if (typeof jwk.alg !== "string" || !jwk.alg) {
-        throw new TypeError('missing "alg" (Algorithm) Parameter value');
-      }
-      if (alg !== void 0 && alg !== jwk.alg) {
-        throw new TypeError("JWK alg and alg option value mismatch");
-      }
-      return jwkToKey({ ...jwk, ext });
-    }
-    case "EC":
-    case "OKP":
-      return jwkToKey({ ...jwk, alg, ext });
-    default:
-      throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
-  }
-}
-
-// node_modules/jose/dist/webapi/lib/validate_crit.js
-function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
-  if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0) {
-    throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
-  }
-  if (!protectedHeader || protectedHeader.crit === void 0) {
-    return /* @__PURE__ */ new Set();
-  }
-  if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input !== "string" || input.length === 0)) {
-    throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-  }
-  let recognized;
-  if (recognizedOption !== void 0) {
-    recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
-  } else {
-    recognized = recognizedDefault;
-  }
-  for (const parameter of protectedHeader.crit) {
-    if (!recognized.has(parameter)) {
-      throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-    }
-    if (joseHeader[parameter] === void 0) {
-      throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-    }
-    if (recognized.get(parameter) && protectedHeader[parameter] === void 0) {
-      throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
-    }
-  }
-  return new Set(protectedHeader.crit);
-}
-
-// node_modules/jose/dist/webapi/lib/validate_algorithms.js
-function validateAlgorithms(option, algorithms) {
-  if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== "string"))) {
-    throw new TypeError(`"${option}" option must be an array of strings`);
-  }
-  if (!algorithms) {
-    return void 0;
-  }
-  return new Set(algorithms);
-}
-
-// node_modules/jose/dist/webapi/lib/is_jwk.js
-var isJWK = (key) => isObject2(key) && typeof key.kty === "string";
-var isPrivateJWK = (key) => key.kty !== "oct" && (key.kty === "AKP" && typeof key.priv === "string" || typeof key.d === "string");
-var isPublicJWK = (key) => key.kty !== "oct" && key.d === void 0 && key.priv === void 0;
-var isSecretJWK = (key) => key.kty === "oct" && typeof key.k === "string";
-
 // node_modules/jose/dist/webapi/lib/normalize_key.js
+var unusableForAlg = "given KeyObject instance cannot be used for this algorithm";
 var cache;
 var handleJWK = async (key, jwk, alg, freeze = false) => {
   cache ||= /* @__PURE__ */ new WeakMap();
@@ -34039,13 +34764,13 @@ var handleKeyObject = (keyObject, alg) => {
       case "ECDH-ES+A256KW":
         break;
       default:
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+        throw new TypeError(unusableForAlg);
     }
     cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, isPublic ? [] : ["deriveBits"]);
   }
   if (keyObject.asymmetricKeyType === "ed25519") {
     if (alg !== "EdDSA" && alg !== "Ed25519") {
-      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+      throw new TypeError(unusableForAlg);
     }
     cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [
       isPublic ? "verify" : "sign"
@@ -34056,7 +34781,7 @@ var handleKeyObject = (keyObject, alg) => {
     case "ml-dsa-65":
     case "ml-dsa-87": {
       if (alg !== keyObject.asymmetricKeyType.toUpperCase()) {
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+        throw new TypeError(unusableForAlg);
       }
       cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [
         isPublic ? "verify" : "sign"
@@ -34085,7 +34810,7 @@ var handleKeyObject = (keyObject, alg) => {
         hash2 = "SHA-512";
         break;
       default:
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+        throw new TypeError(unusableForAlg);
     }
     if (alg.startsWith("RSA-OAEP")) {
       return keyObject.toCryptoKey({
@@ -34106,21 +34831,10 @@ var handleKeyObject = (keyObject, alg) => {
     ]);
     const namedCurve = nist.get(keyObject.asymmetricKeyDetails?.namedCurve);
     if (!namedCurve) {
-      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+      throw new TypeError(unusableForAlg);
     }
-    if (alg === "ES256" && namedCurve === "P-256") {
-      cryptoKey = keyObject.toCryptoKey({
-        name: "ECDSA",
-        namedCurve
-      }, extractable, [isPublic ? "verify" : "sign"]);
-    }
-    if (alg === "ES384" && namedCurve === "P-384") {
-      cryptoKey = keyObject.toCryptoKey({
-        name: "ECDSA",
-        namedCurve
-      }, extractable, [isPublic ? "verify" : "sign"]);
-    }
-    if (alg === "ES512" && namedCurve === "P-521") {
+    const expectedCurve = { ES256: "P-256", ES384: "P-384", ES512: "P-521" };
+    if (expectedCurve[alg] && namedCurve === expectedCurve[alg]) {
       cryptoKey = keyObject.toCryptoKey({
         name: "ECDSA",
         namedCurve
@@ -34134,7 +34848,7 @@ var handleKeyObject = (keyObject, alg) => {
     }
   }
   if (!cryptoKey) {
-    throw new TypeError("given KeyObject instance cannot be used for this algorithm");
+    throw new TypeError(unusableForAlg);
   }
   if (!cached2) {
     cache.set(keyObject, { [alg]: cryptoKey });
@@ -34175,6 +34889,84 @@ async function normalizeKey(key, alg) {
   throw new Error("unreachable");
 }
 
+// node_modules/jose/dist/webapi/key/import.js
+async function importJWK(jwk, alg, options) {
+  if (!isObject2(jwk)) {
+    throw new TypeError("JWK must be an object");
+  }
+  let ext;
+  alg ??= jwk.alg;
+  ext ??= options?.extractable ?? jwk.ext;
+  switch (jwk.kty) {
+    case "oct":
+      if (typeof jwk.k !== "string" || !jwk.k) {
+        throw new TypeError('missing "k" (Key Value) Parameter value');
+      }
+      return decode3(jwk.k);
+    case "RSA":
+      if ("oth" in jwk && jwk.oth !== void 0) {
+        throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
+      }
+      return jwkToKey({ ...jwk, alg, ext });
+    case "AKP": {
+      if (typeof jwk.alg !== "string" || !jwk.alg) {
+        throw new TypeError('missing "alg" (Algorithm) Parameter value');
+      }
+      if (alg !== void 0 && alg !== jwk.alg) {
+        throw new TypeError("JWK alg and alg option value mismatch");
+      }
+      return jwkToKey({ ...jwk, ext });
+    }
+    case "EC":
+    case "OKP":
+      return jwkToKey({ ...jwk, alg, ext });
+    default:
+      throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
+  }
+}
+
+// node_modules/jose/dist/webapi/lib/validate_crit.js
+function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
+  if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0) {
+    throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
+  }
+  if (!protectedHeader || protectedHeader.crit === void 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input !== "string" || input.length === 0)) {
+    throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
+  }
+  let recognized;
+  if (recognizedOption !== void 0) {
+    recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
+  } else {
+    recognized = recognizedDefault;
+  }
+  for (const parameter of protectedHeader.crit) {
+    if (!recognized.has(parameter)) {
+      throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
+    }
+    if (joseHeader[parameter] === void 0) {
+      throw new Err(`Extension Header Parameter "${parameter}" is missing`);
+    }
+    if (recognized.get(parameter) && protectedHeader[parameter] === void 0) {
+      throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
+    }
+  }
+  return new Set(protectedHeader.crit);
+}
+
+// node_modules/jose/dist/webapi/lib/validate_algorithms.js
+function validateAlgorithms(option, algorithms) {
+  if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== "string"))) {
+    throw new TypeError(`"${option}" option must be an array of strings`);
+  }
+  if (!algorithms) {
+    return void 0;
+  }
+  return new Set(algorithms);
+}
+
 // node_modules/jose/dist/webapi/lib/check_key_type.js
 var tag = (key) => key?.[Symbol.toStringTag];
 var jwkMatchesOp = (alg, key, usage) => {
@@ -34295,62 +35087,6 @@ function checkKeyType(alg, key, usage) {
   }
 }
 
-// node_modules/jose/dist/webapi/lib/subtle_dsa.js
-function subtleAlgorithm(alg, algorithm) {
-  const hash2 = `SHA-${alg.slice(-3)}`;
-  switch (alg) {
-    case "HS256":
-    case "HS384":
-    case "HS512":
-      return { hash: hash2, name: "HMAC" };
-    case "PS256":
-    case "PS384":
-    case "PS512":
-      return { hash: hash2, name: "RSA-PSS", saltLength: parseInt(alg.slice(-3), 10) >> 3 };
-    case "RS256":
-    case "RS384":
-    case "RS512":
-      return { hash: hash2, name: "RSASSA-PKCS1-v1_5" };
-    case "ES256":
-    case "ES384":
-    case "ES512":
-      return { hash: hash2, name: "ECDSA", namedCurve: algorithm.namedCurve };
-    case "Ed25519":
-    case "EdDSA":
-      return { name: "Ed25519" };
-    case "ML-DSA-44":
-    case "ML-DSA-65":
-    case "ML-DSA-87":
-      return { name: alg };
-    default:
-      throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-  }
-}
-
-// node_modules/jose/dist/webapi/lib/get_sign_verify_key.js
-async function getSigKey(alg, key, usage) {
-  if (key instanceof Uint8Array) {
-    if (!alg.startsWith("HS")) {
-      throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
-    }
-    return crypto.subtle.importKey("raw", key, { hash: `SHA-${alg.slice(-3)}`, name: "HMAC" }, false, [usage]);
-  }
-  checkSigCryptoKey(key, alg, usage);
-  return key;
-}
-
-// node_modules/jose/dist/webapi/lib/verify.js
-async function verify(alg, key, signature, data) {
-  const cryptoKey = await getSigKey(alg, key, "verify");
-  checkKeyLength(alg, cryptoKey);
-  const algorithm = subtleAlgorithm(alg, cryptoKey.algorithm);
-  try {
-    return await crypto.subtle.verify(algorithm, cryptoKey, signature, data);
-  } catch {
-    return false;
-  }
-}
-
 // node_modules/jose/dist/webapi/jws/flattened/verify.js
 async function flattenedVerify(jws, key, options) {
   if (!isObject2(jws)) {
@@ -34417,12 +35153,7 @@ async function flattenedVerify(jws, key, options) {
   }
   checkKeyType(alg, key, "verify");
   const data = concat(jws.protected !== void 0 ? encode3(jws.protected) : new Uint8Array(), encode3("."), typeof jws.payload === "string" ? b64 ? encode3(jws.payload) : encoder.encode(jws.payload) : jws.payload);
-  let signature;
-  try {
-    signature = decode3(jws.signature);
-  } catch {
-    throw new JWSInvalid("Failed to base64url decode the signature");
-  }
+  const signature = decodeBase64url(jws.signature, "signature", JWSInvalid);
   const k = await normalizeKey(key, alg);
   const verified = await verify(alg, k, signature, data);
   if (!verified) {
@@ -34430,11 +35161,7 @@ async function flattenedVerify(jws, key, options) {
   }
   let payload;
   if (b64) {
-    try {
-      payload = decode3(jws.payload);
-    } catch {
-      throw new JWSInvalid("Failed to base64url decode the payload");
-    }
+    payload = decodeBase64url(jws.payload, "payload", JWSInvalid);
   } else if (typeof jws.payload === "string") {
     payload = encoder.encode(jws.payload);
   } else {
@@ -34766,10 +35493,10 @@ function isCloudflareWorkers() {
 var USER_AGENT;
 if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) {
   const NAME = "jose";
-  const VERSION = "v6.1.3";
-  USER_AGENT = `${NAME}/${VERSION}`;
+  const VERSION2 = "v6.2.1";
+  USER_AGENT = `${NAME}/${VERSION2}`;
 }
-var customFetch = /* @__PURE__ */ Symbol();
+var customFetch = Symbol();
 async function fetchJwks(url2, headers, signal, fetchImpl = fetch) {
   const response = await fetchImpl(url2, {
     method: "GET",
@@ -34791,7 +35518,7 @@ async function fetchJwks(url2, headers, signal, fetchImpl = fetch) {
     throw new JOSEError("Failed to parse the JSON Web Key Set HTTP response as JSON");
   }
 }
-var jwksCache = /* @__PURE__ */ Symbol();
+var jwksCache = Symbol();
 function isFreshJwksCache(input, cacheMaxAge) {
   if (typeof input !== "object" || input === null) {
     return false;
@@ -36585,22 +37312,6 @@ var ConcurrentMCPServer = class _ConcurrentMCPServer {
             });
           }
         }
-        if (method === "ping") {
-          return c.json({ jsonrpc: "2.0", id, result: {} });
-        }
-        if (method === "prompts/list") {
-          return c.json({ jsonrpc: "2.0", id, result: { prompts: [] } });
-        }
-        if (method === "logging/setLevel") {
-          return c.json({ jsonrpc: "2.0", id, result: {} });
-        }
-        if (method === "completion/complete") {
-          return c.json({
-            jsonrpc: "2.0",
-            id,
-            result: { completion: { values: [] } }
-          });
-        }
         if (method && !id) {
           return new Response(null, { status: 202 });
         }
@@ -40967,89 +41678,8 @@ var setupTools = [
 // src/tools/analytics.ts
 var CHART_UI = { ui: { resourceUri: "ui://mcp-erpnext/chart-viewer" } };
 var KPI_UI = { ui: { resourceUri: "ui://mcp-erpnext/kpi-viewer" } };
-var PIPELINE_UI = { ui: { resourceUri: "ui://mcp-erpnext/order-pipeline-viewer" } };
 var FUNNEL_UI = { ui: { resourceUri: "ui://mcp-erpnext/funnel-viewer" } };
 var analyticsTools = [
-  // ── Order Pipeline ────────────────────────────────────────────────────────
-  {
-    name: "erpnext_order_pipeline",
-    _meta: PIPELINE_UI,
-    description: "Get sales orders grouped by workflow status as a kanban pipeline. Returns columns (Draft, Open, To Deliver, To Bill, Completed, Cancelled) with order count, total value, and individual order cards. Ideal for seeing the current state of your sales pipeline at a glance.",
-    category: "analytics",
-    inputSchema: {
-      type: "object",
-      properties: {
-        limit: { type: "number", description: "Max total orders to fetch (default 200)" },
-        customer: { type: "string", description: "Filter by customer name" },
-        exclude_cancelled: {
-          type: "boolean",
-          description: "Exclude cancelled orders from results (default false)"
-        }
-      }
-    },
-    handler: async (input, ctx) => {
-      const limit = input.limit ?? 200;
-      const filters = [];
-      if (input.customer) {
-        filters.push(["customer", "=", input.customer]);
-      }
-      if (input.exclude_cancelled) {
-        filters.push(["status", "!=", "Cancelled"]);
-      }
-      const orders = await ctx.client.list("Sales Order", {
-        fields: [
-          "name",
-          "customer",
-          "customer_name",
-          "status",
-          "grand_total",
-          "transaction_date",
-          "delivery_date"
-        ],
-        filters,
-        limit,
-        order_by: "modified desc"
-      });
-      const STATUS_MAP = {
-        "Draft": { label: "Draft", color: "#78716c" },
-        "Open": { label: "Open", color: "#fbbf24" },
-        "To Deliver and Bill": { label: "To Deliver", color: "#60a5fa" },
-        "To Bill": { label: "To Bill", color: "#c084fc" },
-        "Completed": { label: "Completed", color: "#4ade80" },
-        "Cancelled": { label: "Cancelled", color: "#f87171" }
-      };
-      const grouped = {};
-      for (const order of orders) {
-        const status = order.status ?? "Draft";
-        if (!grouped[status]) grouped[status] = [];
-        grouped[status].push(order);
-      }
-      const columns = Object.entries(STATUS_MAP).filter(([status]) => grouped[status]?.length > 0).map(([status, { label, color }]) => {
-        const statusOrders = grouped[status] ?? [];
-        return {
-          status,
-          label,
-          color,
-          count: statusOrders.length,
-          total: statusOrders.reduce((sum, o) => sum + (Number(o.grand_total) || 0), 0),
-          orders: statusOrders.map((o) => ({
-            name: o.name,
-            customer: o.customer_name ?? o.customer,
-            amount: Number(o.grand_total) || 0,
-            date: o.transaction_date,
-            delivery_date: o.delivery_date
-          }))
-        };
-      });
-      return {
-        title: "Sales Order Pipeline",
-        currency: "EUR",
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        columns,
-        _meta: PIPELINE_UI
-      };
-    }
-  },
   // ── Stock Chart ───────────────────────────────────────────────────────────
   {
     name: "erpnext_stock_chart",
@@ -42232,79 +42862,625 @@ var analyticsTools = [
         _meta: CHART_UI
       };
     }
+  }
+];
+
+// src/kanban/definitions.ts
+var KANBAN_BOARD_DEFINITIONS = [
+  {
+    doctype: "Task",
+    title: "Task Board",
+    adapterKey: "task",
+    moveToolName: "erpnext_kanban_move_card"
   },
-  // ── Purchase Pipeline ─────────────────────────────────────────────────────
   {
-    name: "erpnext_purchase_pipeline",
-    _meta: PIPELINE_UI,
-    description: "Purchase Orders grouped by status as a kanban pipeline. Shows columns (Draft, To Receive, To Bill, Completed, Cancelled) with order count, total value, and individual order cards.",
-    category: "analytics",
+    doctype: "Opportunity",
+    title: "Opportunity Board",
+    adapterKey: "opportunity",
+    moveToolName: "erpnext_kanban_move_card"
+  },
+  {
+    doctype: "Issue",
+    title: "Issue Board",
+    adapterKey: "issue",
+    moveToolName: "erpnext_kanban_move_card"
+  }
+];
+function getKanbanBoardDefinition(doctype) {
+  return KANBAN_BOARD_DEFINITIONS.find((definition) => definition.doctype === doctype);
+}
+
+// src/kanban/adapters/task.ts
+var TASK_COLUMNS = [
+  { id: "open", label: "Open", color: "#60a5fa", status: "Open" },
+  { id: "working", label: "Working", color: "#f59e0b", status: "Working" },
+  { id: "pending-review", label: "Pending Review", color: "#a78bfa", status: "Pending Review" },
+  { id: "overdue", label: "Overdue", color: "#ef4444", status: "Overdue" },
+  { id: "completed", label: "Completed", color: "#22c55e", status: "Completed" },
+  { id: "cancelled", label: "Cancelled", color: "#78716c", status: "Cancelled" }
+];
+var STATUS_BY_COLUMN = new Map(TASK_COLUMNS.map((column) => [column.id, column.status]));
+var COLUMN_BY_STATUS = new Map(TASK_COLUMNS.map((column) => [column.status, column.id]));
+var TASK_LIST_FIELDS = [
+  "name",
+  "subject",
+  "project",
+  "status",
+  "priority",
+  "progress"
+];
+var TASK_ALLOWED_TRANSITIONS = [
+  { fromColumn: "open", toColumn: "working", allowed: true, label: "Start work" },
+  { fromColumn: "open", toColumn: "pending-review", allowed: true },
+  { fromColumn: "open", toColumn: "completed", allowed: true },
+  { fromColumn: "open", toColumn: "cancelled", allowed: true },
+  { fromColumn: "working", toColumn: "open", allowed: true },
+  { fromColumn: "working", toColumn: "pending-review", allowed: true, label: "Request review" },
+  { fromColumn: "working", toColumn: "completed", allowed: true },
+  { fromColumn: "working", toColumn: "cancelled", allowed: true },
+  { fromColumn: "pending-review", toColumn: "working", allowed: true, label: "Resume work" },
+  { fromColumn: "pending-review", toColumn: "completed", allowed: true, label: "Approve" },
+  { fromColumn: "pending-review", toColumn: "open", allowed: true },
+  { fromColumn: "pending-review", toColumn: "cancelled", allowed: true },
+  { fromColumn: "completed", toColumn: "working", allowed: true, label: "Reopen" },
+  { fromColumn: "completed", toColumn: "open", allowed: true },
+  { fromColumn: "cancelled", toColumn: "open", allowed: true, label: "Reopen" }
+];
+function buildTaskCard(row) {
+  const status = String(row.status ?? "Open");
+  const columnId = columnIdForTaskStatus(status);
+  const priority = typeof row.priority === "string" ? row.priority : void 0;
+  const progress = typeof row.progress === "number" ? row.progress : Number.isFinite(Number(row.progress)) ? Number(row.progress) : void 0;
+  return {
+    id: String(row.name ?? ""),
+    title: String(row.subject ?? row.name ?? "Untitled task"),
+    subtitle: typeof row.project === "string" ? row.project : void 0,
+    columnId,
+    accent: TASK_COLUMNS.find((column) => column.id === columnId)?.color,
+    badges: priority ? [{ label: priority, tone: priorityTone(priority) }] : [],
+    metrics: progress === void 0 ? [] : [{ label: "Progress", value: `${progress}%` }]
+  };
+}
+function priorityTone(priority) {
+  if (priority === "Urgent") return "error";
+  if (priority === "High") return "warning";
+  return "neutral";
+}
+function columnIdForTaskStatus(status) {
+  return COLUMN_BY_STATUS.get(String(status ?? "Open")) ?? "open";
+}
+var taskKanbanAdapter = {
+  doctype: "Task",
+  getColumns() {
+    return TASK_COLUMNS.map((column) => ({
+      id: column.id,
+      label: column.label,
+      color: column.color,
+      count: 0
+    }));
+  },
+  getAllowedTransitions() {
+    return TASK_ALLOWED_TRANSITIONS;
+  },
+  getListFields() {
+    return TASK_LIST_FIELDS;
+  },
+  buildListFilters(input) {
+    const filters = [];
+    if (typeof input.project === "string" && input.project.length > 0) {
+      filters.push(["project", "=", input.project]);
+    }
+    if (typeof input.priority === "string" && input.priority.length > 0) {
+      filters.push(["priority", "=", input.priority]);
+    }
+    return filters;
+  },
+  buildCards(rows) {
+    return rows.map(buildTaskCard);
+  },
+  validateTransition(move) {
+    if (move.toColumn === "overdue") {
+      return { allowed: false, reason: "Overdue is system-managed" };
+    }
+    const match2 = TASK_ALLOWED_TRANSITIONS.find(
+      (transition) => transition.fromColumn === move.fromColumn && transition.toColumn === move.toColumn && transition.allowed
+    );
+    if (!match2) {
+      return { allowed: false, reason: "Task transition is not allowed" };
+    }
+    return { allowed: true };
+  },
+  async executeMove(move, ctx) {
+    const currentTask = await ctx.client.get("Task", move.cardId);
+    const serverColumn = columnIdForTaskStatus(currentTask.status);
+    if (serverColumn !== move.fromColumn) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: serverColumn,
+        toColumn: move.toColumn,
+        errorMessage: `Task moved on the server from ${move.fromColumn} to ${serverColumn}. Refresh the board and try again.`
+      };
+    }
+    const validation = this.validateTransition(move);
+    if (!validation.allowed) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: move.fromColumn,
+        toColumn: move.toColumn,
+        errorMessage: validation.reason
+      };
+    }
+    const status = STATUS_BY_COLUMN.get(move.toColumn);
+    if (!status) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: move.fromColumn,
+        toColumn: move.toColumn,
+        errorMessage: "Unknown Task column"
+      };
+    }
+    const serverTask = await ctx.client.update("Task", move.cardId, { status });
+    return {
+      ok: true,
+      cardId: move.cardId,
+      fromColumn: serverColumn,
+      toColumn: move.toColumn,
+      serverCard: buildTaskCard(serverTask)
+    };
+  }
+};
+
+// src/kanban/adapters/opportunity.ts
+var OPPORTUNITY_COLUMNS = [
+  { id: "open", label: "Open", color: "#60a5fa", status: "Open" },
+  { id: "replied", label: "Replied", color: "#f59e0b", status: "Replied" },
+  { id: "quotation", label: "Quotation", color: "#a78bfa", status: "Quotation" },
+  { id: "converted", label: "Converted", color: "#22c55e", status: "Converted" },
+  { id: "closed", label: "Closed", color: "#64748b", status: "Closed" },
+  { id: "lost", label: "Lost", color: "#ef4444", status: "Lost" }
+];
+var STATUS_BY_COLUMN2 = new Map(OPPORTUNITY_COLUMNS.map((column) => [column.id, column.status]));
+var COLUMN_BY_STATUS2 = new Map(OPPORTUNITY_COLUMNS.map((column) => [column.status, column.id]));
+var OPPORTUNITY_LIST_FIELDS = [
+  "name",
+  "title",
+  "opportunity_from",
+  "party_name",
+  "status",
+  "opportunity_amount",
+  "currency",
+  "probability",
+  "opportunity_owner"
+];
+var OPPORTUNITY_ALLOWED_TRANSITIONS = [
+  { fromColumn: "open", toColumn: "replied", allowed: true, label: "Reply" },
+  { fromColumn: "open", toColumn: "quotation", allowed: true, label: "Send quotation" },
+  { fromColumn: "open", toColumn: "converted", allowed: true, label: "Convert" },
+  { fromColumn: "open", toColumn: "closed", allowed: true, label: "Close" },
+  { fromColumn: "open", toColumn: "lost", allowed: true, label: "Mark lost" },
+  { fromColumn: "replied", toColumn: "open", allowed: true, label: "Reopen" },
+  { fromColumn: "replied", toColumn: "quotation", allowed: true, label: "Send quotation" },
+  { fromColumn: "replied", toColumn: "converted", allowed: true, label: "Convert" },
+  { fromColumn: "replied", toColumn: "closed", allowed: true, label: "Close" },
+  { fromColumn: "replied", toColumn: "lost", allowed: true, label: "Mark lost" },
+  { fromColumn: "quotation", toColumn: "open", allowed: true, label: "Reopen" },
+  { fromColumn: "quotation", toColumn: "replied", allowed: true, label: "Resume conversation" },
+  { fromColumn: "quotation", toColumn: "converted", allowed: true, label: "Convert" },
+  { fromColumn: "quotation", toColumn: "closed", allowed: true, label: "Close" },
+  { fromColumn: "quotation", toColumn: "lost", allowed: true, label: "Mark lost" },
+  { fromColumn: "converted", toColumn: "open", allowed: true, label: "Reopen" },
+  { fromColumn: "converted", toColumn: "closed", allowed: true, label: "Close" },
+  { fromColumn: "closed", toColumn: "open", allowed: true, label: "Reopen" },
+  { fromColumn: "closed", toColumn: "replied", allowed: true, label: "Resume" },
+  { fromColumn: "lost", toColumn: "open", allowed: true, label: "Reopen" },
+  { fromColumn: "lost", toColumn: "replied", allowed: true, label: "Resume" }
+];
+function columnIdForOpportunityStatus(status) {
+  return COLUMN_BY_STATUS2.get(String(status ?? "Open")) ?? "open";
+}
+function formatOpportunityAmount(amount, currency) {
+  const numeric = Number(amount);
+  if (!Number.isFinite(numeric)) return null;
+  const currencyCode = typeof currency === "string" && currency.length > 0 ? currency : "Amount";
+  return `${currencyCode} ${numeric}`;
+}
+function buildOpportunityCard(row) {
+  const status = String(row.status ?? "Open");
+  const columnId = columnIdForOpportunityStatus(status);
+  const amountValue = formatOpportunityAmount(row.opportunity_amount, row.currency);
+  const probability = Number(row.probability);
+  const probabilityValue = Number.isFinite(probability) ? `${probability}%` : null;
+  const title = typeof row.title === "string" && row.title.length > 0 ? row.title : typeof row.party_name === "string" && row.party_name.length > 0 ? row.party_name : String(row.name ?? "Untitled opportunity");
+  return {
+    id: String(row.name ?? ""),
+    title,
+    subtitle: typeof row.party_name === "string" ? row.party_name : void 0,
+    columnId,
+    accent: OPPORTUNITY_COLUMNS.find((column) => column.id === columnId)?.color,
+    badges: typeof row.opportunity_from === "string" && row.opportunity_from.length > 0 ? [{ label: row.opportunity_from, tone: "neutral" }] : [],
+    metrics: [
+      ...amountValue ? [{ label: "Amount", value: amountValue }] : [],
+      ...probabilityValue ? [{ label: "Probability", value: probabilityValue }] : []
+    ]
+  };
+}
+var opportunityKanbanAdapter = {
+  doctype: "Opportunity",
+  getColumns() {
+    return OPPORTUNITY_COLUMNS.map((column) => ({
+      id: column.id,
+      label: column.label,
+      color: column.color,
+      count: 0
+    }));
+  },
+  getAllowedTransitions() {
+    return OPPORTUNITY_ALLOWED_TRANSITIONS;
+  },
+  getListFields() {
+    return OPPORTUNITY_LIST_FIELDS;
+  },
+  buildListFilters(input) {
+    const filters = [];
+    if (typeof input.status === "string" && input.status.length > 0) {
+      filters.push(["status", "=", input.status]);
+    }
+    if (typeof input.opportunity_owner === "string" && input.opportunity_owner.length > 0) {
+      filters.push(["opportunity_owner", "=", input.opportunity_owner]);
+    }
+    if (typeof input.party_name === "string" && input.party_name.length > 0) {
+      filters.push(["party_name", "=", input.party_name]);
+    }
+    return filters;
+  },
+  buildCards(rows) {
+    return rows.map(buildOpportunityCard);
+  },
+  validateTransition(move) {
+    const match2 = OPPORTUNITY_ALLOWED_TRANSITIONS.find(
+      (transition) => transition.fromColumn === move.fromColumn && transition.toColumn === move.toColumn && transition.allowed
+    );
+    if (!match2) {
+      return { allowed: false, reason: "Opportunity transition is not allowed" };
+    }
+    return { allowed: true };
+  },
+  async executeMove(move, ctx) {
+    const currentOpportunity = await ctx.client.get("Opportunity", move.cardId);
+    const serverColumn = columnIdForOpportunityStatus(currentOpportunity.status);
+    if (serverColumn !== move.fromColumn) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: serverColumn,
+        toColumn: move.toColumn,
+        errorMessage: `Opportunity moved on the server from ${move.fromColumn} to ${serverColumn}. Refresh the board and try again.`
+      };
+    }
+    const validation = this.validateTransition(move);
+    if (!validation.allowed) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: move.fromColumn,
+        toColumn: move.toColumn,
+        errorMessage: validation.reason
+      };
+    }
+    const status = STATUS_BY_COLUMN2.get(move.toColumn);
+    if (!status) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: move.fromColumn,
+        toColumn: move.toColumn,
+        errorMessage: "Unknown Opportunity column"
+      };
+    }
+    const serverOpportunity = await ctx.client.update("Opportunity", move.cardId, {
+      status
+    });
+    return {
+      ok: true,
+      cardId: move.cardId,
+      fromColumn: serverColumn,
+      toColumn: move.toColumn,
+      serverCard: buildOpportunityCard(serverOpportunity)
+    };
+  }
+};
+
+// src/kanban/adapters/issue.ts
+var ISSUE_COLUMNS = [
+  { id: "open", label: "Open", color: "#60a5fa", status: "Open" },
+  { id: "replied", label: "Replied", color: "#f59e0b", status: "Replied" },
+  { id: "on-hold", label: "On Hold", color: "#a78bfa", status: "On Hold" },
+  { id: "resolved", label: "Resolved", color: "#22c55e", status: "Resolved" },
+  { id: "closed", label: "Closed", color: "#64748b", status: "Closed" }
+];
+var STATUS_BY_COLUMN3 = new Map(ISSUE_COLUMNS.map((column) => [column.id, column.status]));
+var COLUMN_BY_STATUS3 = new Map(ISSUE_COLUMNS.map((column) => [column.status, column.id]));
+var ISSUE_LIST_FIELDS = [
+  "name",
+  "subject",
+  "status",
+  "priority",
+  "customer",
+  "raised_by"
+];
+var ISSUE_ALLOWED_TRANSITIONS = [
+  { fromColumn: "open", toColumn: "replied", allowed: true, label: "Reply" },
+  { fromColumn: "open", toColumn: "on-hold", allowed: true, label: "Put on hold" },
+  { fromColumn: "open", toColumn: "resolved", allowed: true, label: "Resolve" },
+  { fromColumn: "open", toColumn: "closed", allowed: true, label: "Close" },
+  { fromColumn: "replied", toColumn: "open", allowed: true, label: "Reopen" },
+  { fromColumn: "replied", toColumn: "on-hold", allowed: true, label: "Put on hold" },
+  { fromColumn: "replied", toColumn: "resolved", allowed: true, label: "Resolve" },
+  { fromColumn: "replied", toColumn: "closed", allowed: true, label: "Close" },
+  { fromColumn: "on-hold", toColumn: "open", allowed: true, label: "Resume" },
+  { fromColumn: "on-hold", toColumn: "replied", allowed: true, label: "Reply" },
+  { fromColumn: "on-hold", toColumn: "resolved", allowed: true, label: "Resolve" },
+  { fromColumn: "on-hold", toColumn: "closed", allowed: true, label: "Close" },
+  { fromColumn: "resolved", toColumn: "open", allowed: true, label: "Reopen" },
+  { fromColumn: "resolved", toColumn: "replied", allowed: true, label: "Reply" },
+  { fromColumn: "resolved", toColumn: "closed", allowed: true, label: "Close" },
+  { fromColumn: "closed", toColumn: "open", allowed: true, label: "Reopen" },
+  { fromColumn: "closed", toColumn: "replied", allowed: true, label: "Reply" }
+];
+function columnIdForIssueStatus(status) {
+  return COLUMN_BY_STATUS3.get(String(status ?? "Open")) ?? "open";
+}
+function priorityTone2(priority) {
+  if (priority === "Urgent") return "error";
+  if (priority === "High") return "warning";
+  return "neutral";
+}
+function buildIssueCard(row) {
+  const status = String(row.status ?? "Open");
+  const columnId = columnIdForIssueStatus(status);
+  const priority = typeof row.priority === "string" ? row.priority : void 0;
+  const subtitle = typeof row.customer === "string" && row.customer.length > 0 ? row.customer : typeof row.raised_by === "string" && row.raised_by.length > 0 ? row.raised_by : void 0;
+  return {
+    id: String(row.name ?? ""),
+    title: String(row.subject ?? row.name ?? "Untitled issue"),
+    subtitle,
+    columnId,
+    accent: ISSUE_COLUMNS.find((column) => column.id === columnId)?.color,
+    badges: priority ? [{ label: priority, tone: priorityTone2(priority) }] : [],
+    metrics: typeof row.raised_by === "string" && row.raised_by.length > 0 ? [{ label: "Raised By", value: row.raised_by }] : []
+  };
+}
+var issueKanbanAdapter = {
+  doctype: "Issue",
+  getColumns() {
+    return ISSUE_COLUMNS.map((column) => ({
+      id: column.id,
+      label: column.label,
+      color: column.color,
+      count: 0
+    }));
+  },
+  getAllowedTransitions() {
+    return ISSUE_ALLOWED_TRANSITIONS;
+  },
+  getListFields() {
+    return ISSUE_LIST_FIELDS;
+  },
+  buildListFilters(input) {
+    const filters = [];
+    if (typeof input.status === "string" && input.status.length > 0) {
+      filters.push(["status", "=", input.status]);
+    }
+    if (typeof input.priority === "string" && input.priority.length > 0) {
+      filters.push(["priority", "=", input.priority]);
+    }
+    if (typeof input.customer === "string" && input.customer.length > 0) {
+      filters.push(["customer", "=", input.customer]);
+    }
+    if (typeof input.raised_by === "string" && input.raised_by.length > 0) {
+      filters.push(["raised_by", "=", input.raised_by]);
+    }
+    return filters;
+  },
+  buildCards(rows) {
+    return rows.map(buildIssueCard);
+  },
+  validateTransition(move) {
+    const match2 = ISSUE_ALLOWED_TRANSITIONS.find(
+      (transition) => transition.fromColumn === move.fromColumn && transition.toColumn === move.toColumn && transition.allowed
+    );
+    if (!match2) {
+      return { allowed: false, reason: "Issue transition is not allowed" };
+    }
+    return { allowed: true };
+  },
+  async executeMove(move, ctx) {
+    const currentIssue = await ctx.client.get("Issue", move.cardId);
+    const serverColumn = columnIdForIssueStatus(currentIssue.status);
+    if (serverColumn !== move.fromColumn) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: serverColumn,
+        toColumn: move.toColumn,
+        errorMessage: `Issue moved on the server from ${move.fromColumn} to ${serverColumn}. Refresh the board and try again.`
+      };
+    }
+    const validation = this.validateTransition(move);
+    if (!validation.allowed) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: move.fromColumn,
+        toColumn: move.toColumn,
+        errorMessage: validation.reason
+      };
+    }
+    const status = STATUS_BY_COLUMN3.get(move.toColumn);
+    if (!status) {
+      return {
+        ok: false,
+        cardId: move.cardId,
+        fromColumn: move.fromColumn,
+        toColumn: move.toColumn,
+        errorMessage: "Unknown Issue column"
+      };
+    }
+    const serverIssue = await ctx.client.update("Issue", move.cardId, { status });
+    return {
+      ok: true,
+      cardId: move.cardId,
+      fromColumn: serverColumn,
+      toColumn: move.toColumn,
+      serverCard: buildIssueCard(serverIssue)
+    };
+  }
+};
+
+// src/tools/kanban.ts
+var KANBAN_UI = { ui: { resourceUri: "ui://mcp-erpnext/kanban-viewer" } };
+var ADAPTERS = {
+  task: taskKanbanAdapter,
+  opportunity: opportunityKanbanAdapter,
+  issue: issueKanbanAdapter
+};
+function getAdapter(doctype) {
+  const definition = getKanbanBoardDefinition(doctype);
+  if (!definition) {
+    throw new Error(`[erpnext_kanban] Unsupported kanban doctype: ${doctype}`);
+  }
+  const adapter = ADAPTERS[definition.adapterKey];
+  if (!adapter) {
+    throw new Error(`[erpnext_kanban] No adapter registered for ${doctype}`);
+  }
+  return { definition, adapter };
+}
+function withColumnCounts(columns, cards) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const card of cards) {
+    counts.set(card.columnId, (counts.get(card.columnId) ?? 0) + 1);
+  }
+  return columns.map((column) => ({
+    ...column,
+    count: counts.get(column.id) ?? 0
+  }));
+}
+var kanbanTools = [
+  {
+    name: "erpnext_kanban_get_board",
+    category: "kanban",
+    _meta: KANBAN_UI,
+    description: "Get a normalized kanban board for a supported ERPNext DocType. Supports Task, Opportunity, and Issue, with pagination and MCP App metadata.",
     inputSchema: {
       type: "object",
       properties: {
-        limit: { type: "number", description: "Max POs (default 200)" },
-        supplier: { type: "string", description: "Filter by supplier name" }
-      }
+        doctype: {
+          type: "string",
+          description: "Kanban-enabled ERPNext DocType",
+          enum: ["Task", "Opportunity", "Issue"]
+        },
+        limit: { type: "number", description: "Page size (default 50)" },
+        offset: { type: "number", description: "Pagination offset (default 0)" },
+        project: { type: "string", description: "Optional Task project filter" },
+        priority: {
+          type: "string",
+          description: "Optional Task priority filter",
+          enum: ["Low", "Medium", "High", "Urgent"]
+        },
+        status: {
+          type: "string",
+          description: "Optional Opportunity status filter",
+          enum: ["Open", "Replied", "Quotation", "Converted", "Closed", "Lost"]
+        },
+        opportunity_owner: {
+          type: "string",
+          description: "Optional Opportunity owner filter"
+        },
+        party_name: {
+          type: "string",
+          description: "Optional Opportunity party filter"
+        },
+        customer: {
+          type: "string",
+          description: "Optional Issue customer filter"
+        },
+        raised_by: {
+          type: "string",
+          description: "Optional Issue reporter email filter"
+        }
+      },
+      required: ["doctype"]
     },
     handler: async (input, ctx) => {
-      const limit = input.limit ?? 200;
-      const filters = [];
-      if (input.supplier) {
-        filters.push(["supplier_name", "=", input.supplier]);
-      }
-      const orders = await ctx.client.list("Purchase Order", {
-        fields: [
-          "name",
-          "supplier",
-          "supplier_name",
-          "status",
-          "grand_total",
-          "transaction_date",
-          "schedule_date"
-        ],
-        filters,
-        limit,
+      const doctype = String(input.doctype ?? "");
+      const { definition, adapter } = getAdapter(doctype);
+      const limit = Math.max(1, Number(input.limit ?? 50));
+      const offset = Math.max(0, Number(input.offset ?? 0));
+      const rows = await ctx.client.list(doctype, {
+        fields: adapter.getListFields(),
+        filters: adapter.buildListFilters(input),
+        limit: limit + 1,
+        limit_start: offset,
         order_by: "modified desc"
       });
-      const STATUS_MAP = {
-        "Draft": { label: "Draft", color: "#78716c" },
-        "To Receive and Bill": { label: "To Receive", color: "#60a5fa" },
-        "To Receive": { label: "To Receive Only", color: "#fbbf24" },
-        "To Bill": { label: "To Bill", color: "#c084fc" },
-        "Completed": { label: "Completed", color: "#4ade80" },
-        "Cancelled": { label: "Cancelled", color: "#f87171" }
+      const hasMore = rows.length > limit;
+      const visibleRows = rows.slice(0, limit);
+      const cards = adapter.buildCards(visibleRows);
+      const board = {
+        boardId: `${doctype.toLowerCase()}-board`,
+        title: definition.title,
+        doctype,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        moveToolName: definition.moveToolName,
+        refreshArguments: { ...input, doctype, limit, offset },
+        columns: withColumnCounts(adapter.getColumns(), cards),
+        cards,
+        allowedTransitions: adapter.getAllowedTransitions(),
+        capabilities: { canMoveCards: true },
+        pagination: {
+          limit,
+          offset,
+          loadedCount: offset + visibleRows.length,
+          hasMore
+        }
       };
-      const grouped = {};
-      for (const order of orders) {
-        const status = order.status ?? "Draft";
-        if (!grouped[status]) grouped[status] = [];
-        grouped[status].push(order);
-      }
-      const columns = Object.entries(STATUS_MAP).filter(([status]) => grouped[status]?.length > 0).map(([status, { label, color }]) => {
-        const statusOrders = grouped[status] ?? [];
-        return {
-          status,
-          label,
-          color,
-          count: statusOrders.length,
-          total: statusOrders.reduce((sum, o) => sum + (Number(o.grand_total) || 0), 0),
-          orders: statusOrders.map((o) => ({
-            name: o.name,
-            customer: o.supplier_name ?? o.supplier,
-            amount: Number(o.grand_total) || 0,
-            date: o.transaction_date,
-            delivery_date: o.schedule_date
-          }))
-        };
-      });
       return {
-        title: "Purchase Order Pipeline",
-        currency: "EUR",
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        columns,
-        _meta: PIPELINE_UI
+        ...board,
+        _meta: KANBAN_UI
       };
     }
+  },
+  {
+    name: "erpnext_kanban_move_card",
+    category: "kanban",
+    description: "Move a kanban card for a supported ERPNext DocType. Returns structured success or business error details for MCP App reconciliation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        doctype: {
+          type: "string",
+          description: "Kanban-enabled ERPNext DocType",
+          enum: ["Task", "Opportunity", "Issue"]
+        },
+        card_id: { type: "string", description: "Card/document identifier" },
+        from_column: { type: "string", description: "Source column identifier" },
+        to_column: { type: "string", description: "Destination column identifier" }
+      },
+      required: ["doctype", "card_id", "from_column", "to_column"]
+    },
+    handler: async (input, ctx) => {
+      const doctype = String(input.doctype ?? "");
+      const { adapter } = getAdapter(doctype);
+      return await adapter.executeMove({
+        doctype,
+        cardId: String(input.card_id ?? ""),
+        fromColumn: String(input.from_column ?? ""),
+        toColumn: String(input.to_column ?? "")
+      }, ctx);
+    }
   }
 ];
 
@@ -42322,7 +43498,8 @@ var toolsByCategory = {
   assets: assetsTools,
   operations: operationsTools,
   setup: setupTools,
-  analytics: analyticsTools
+  analytics: analyticsTools,
+  kanban: kanbanTools
 };
 var allTools = [
   ...salesTools,
@@ -42337,7 +43514,8 @@ var allTools = [
   ...assetsTools,
   ...operationsTools,
   ...setupTools,
-  ...analyticsTools
+  ...analyticsTools,
+  ...kanbanTools
 ];
 function getToolsByCategory(category) {
   return toolsByCategory[category] ?? [];
@@ -42584,6 +43762,34 @@ function getFrappeClient() {
   return _client;
 }
 
+// src/tools/ui-refresh.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasUiResource(result) {
+  const meta3 = result._meta;
+  if (!isRecord(meta3)) return false;
+  const ui = meta3.ui;
+  if (!isRecord(ui)) return false;
+  return typeof ui.resourceUri === "string" && ui.resourceUri.length > 0;
+}
+function withUiRefreshRequest(result, toolName, args) {
+  if (!isRecord(result) || !hasUiResource(result)) {
+    return result;
+  }
+  const refreshable = result;
+  if (refreshable.refreshRequest) {
+    return result;
+  }
+  return {
+    ...refreshable,
+    refreshRequest: {
+      toolName,
+      arguments: { ...args }
+    }
+  };
+}
+
 // src/client.ts
 var ErpNextToolsClient = class {
   tools;
@@ -42617,9 +43823,10 @@ var ErpNextToolsClient = class {
   buildHandlersMap() {
     const handlers = /* @__PURE__ */ new Map();
     for (const tool of this.tools) {
-      handlers.set(tool.name, (args) => {
+      handlers.set(tool.name, async (args) => {
         const client = getFrappeClient();
-        return tool.handler(args, { client });
+        const result = await tool.handler(args, { client });
+        return withUiRefreshRequest(result, tool.name, args);
       });
     }
     return handlers;
@@ -42633,7 +43840,8 @@ var ErpNextToolsClient = class {
       );
     }
     const client = getFrappeClient();
-    return await tool.handler(args, { client });
+    const result = await tool.handler(args, { client });
+    return withUiRefreshRequest(result, tool.name, args);
   }
   /** Get tool count */
   get count() {
@@ -42642,17 +43850,43 @@ var ErpNextToolsClient = class {
 };
 var defaultClient = new ErpNextToolsClient();
 
-// server.ts
-var DEFAULT_HTTP_PORT = 3012;
+// src/ui/viewers.ts
 var UI_VIEWERS = [
   "invoice-viewer",
   "stock-viewer",
   "doclist-viewer",
-  "order-pipeline-viewer",
   "chart-viewer",
   "kpi-viewer",
-  "funnel-viewer"
+  "funnel-viewer",
+  "kanban-viewer"
 ];
+
+// src/ui/viewer-resource-paths.ts
+function fileUrlToPath(url2) {
+  const decodedPath = decodeURIComponent(url2.pathname);
+  if (/^\/[A-Za-z]:\//.test(decodedPath)) {
+    return decodedPath.slice(1);
+  }
+  if (url2.host.length > 0) {
+    return `//${url2.host}${decodedPath}`;
+  }
+  return decodedPath;
+}
+function resolveViewerDistPath(moduleUrl, viewerName, exists) {
+  const candidates = [
+    fileUrlToPath(new URL(`./src/ui/dist/${viewerName}/index.html`, moduleUrl)),
+    fileUrlToPath(new URL(`./ui-dist/${viewerName}/index.html`, moduleUrl))
+  ];
+  for (const candidate of candidates) {
+    if (exists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+// server.ts
+var DEFAULT_HTTP_PORT = 3012;
 async function main() {
   const args = getArgs();
   const categoriesArg = args.find((arg) => arg.startsWith("--categories="));
@@ -42667,7 +43901,7 @@ async function main() {
   );
   const server = new ConcurrentMCPServer({
     name: "mcp-erpnext",
-    version: "0.1.0",
+    version: "0.1.9",
     maxConcurrent: 10,
     backpressureStrategy: "queue",
     validateSchema: true,
@@ -42677,13 +43911,10 @@ async function main() {
   const handlers = toolsClient.buildHandlersMap();
   server.registerTools(mcpTools, handlers);
   for (const viewerName of UI_VIEWERS) {
-    const distPath = new URL(
-      `./src/ui/dist/${viewerName}/index.html`,
-      import.meta.url
-    ).pathname;
+    const distPath = resolveViewerDistPath(import.meta.url, viewerName, statSync);
     const resourceUri = `ui://mcp-erpnext/${viewerName}`;
     const humanName = viewerName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-    if (statSync(distPath)) {
+    if (distPath) {
       server.registerResource(
         {
           uri: resourceUri,
@@ -42699,7 +43930,7 @@ async function main() {
       console.error(`[mcp-erpnext] Registered UI resource: ${resourceUri}`);
     } else {
       console.error(
-        `[mcp-erpnext] Warning: UI not built for ${resourceUri}. Run 'cd lib/erpnext/src/ui && node build-all.mjs' first.`
+        `[mcp-erpnext] Warning: UI not built for ${resourceUri}. Run 'cd lib/erpnext/src/ui && node build-all.mjs' first or package ui-dist with the npm bundle.`
       );
     }
   }