@frontmcp/adapters 0.12.2 → 1.0.0-beta.10

package/openapi/index.js

@@ -29,6 +29,8 @@ var __decorateClass = (decorators, target, key, kind) => {
 var openapi_exports = {};
 __export(openapi_exports, {
   FRONTMCP_EXTENSION_KEY: () => FRONTMCP_EXTENSION_KEY,
+  OpenAPIFetchError: () => OpenAPIFetchError,
+  OpenApiSpecPoller: () => OpenApiSpecPoller,
   default: () => OpenapiAdapter,
   forceJwtSecurity: () => forceJwtSecurity,
   removeSecurityFromOperations: () => removeSecurityFromOperations
@@ -36,16 +38,17 @@ __export(openapi_exports, {
 module.exports = __toCommonJS(openapi_exports);
 
 // libs/adapters/src/openapi/openapi.adapter.ts
-var import_sdk2 = require("@frontmcp/sdk");
+var import_sdk4 = require("@frontmcp/sdk");
 var import_mcp_from_openapi2 = require("mcp-from-openapi");
 
 // libs/adapters/src/openapi/openapi.tool.ts
 var import_zod2 = require("zod");
-var import_sdk = require("@frontmcp/sdk");
+var import_sdk2 = require("@frontmcp/sdk");
 var import_zod_from_json_schema = require("zod-from-json-schema");
 
 // libs/adapters/src/openapi/openapi.utils.ts
 var import_utils = require("@frontmcp/utils");
+var import_sdk = require("@frontmcp/sdk");
 function coerceToString(value, paramName, location) {
   if (value === null || value === void 0) {
     return "";
@@ -102,8 +105,10 @@ function buildRequest(tool2, input, security, baseUrl) {
       case "header": {
         const headerValue = coerceToString(value, mapper.key, "header");
         if (/[\r\n\x00\f\v]/.test(headerValue)) {
-          throw new Error(
-            `Invalid header value for '${mapper.key}': contains control characters (possible header injection attack)`
+          throw new import_sdk.PublicMcpError(
+            `Invalid header value for '${mapper.key}': contains control characters (possible header injection attack)`,
+            "INVALID_HEADER_VALUE",
+            400
           );
         }
         headers.set(mapper.key, headerValue);
@@ -683,7 +688,7 @@ function createOpenApiTool(openapiTool, options, logger) {
   if (toolTransform.ui) {
     toolMetadata["ui"] = toolTransform.ui;
   }
-  return (0, import_sdk.tool)(toolMetadata)(async (input, toolCtx) => {
+  return (0, import_sdk2.tool)(toolMetadata)(async (input, toolCtx) => {
     const ctx = toolCtx.context;
     const transformContext = {
       ctx,
@@ -886,6 +891,174 @@ function getZodSchemaFromJsonSchema(jsonSchema, toolName, logger) {
   }
 }
 
+// libs/adapters/src/openapi/openapi-spec-poller.ts
+var import_utils2 = require("@frontmcp/utils");
+
+// libs/adapters/src/openapi/openapi.errors.ts
+var import_sdk3 = require("@frontmcp/sdk");
+var OpenAPIFetchError = class extends import_sdk3.InternalMcpError {
+  constructor(url, status, statusText) {
+    super(`OpenAPI spec fetch failed from "${url}": ${status} ${statusText}`, "OPENAPI_FETCH_FAILED");
+  }
+};
+
+// libs/adapters/src/openapi/openapi-spec-poller.ts
+var DEFAULT_RETRY = {
+  maxRetries: 3,
+  initialDelayMs: 1e3,
+  maxDelayMs: 1e4,
+  backoffMultiplier: 2
+};
+var OpenApiSpecPoller = class {
+  url;
+  intervalMs;
+  fetchTimeoutMs;
+  changeDetection;
+  retry;
+  unhealthyThreshold;
+  headers;
+  callbacks;
+  intervalTimer = null;
+  lastHash = null;
+  lastEtag = null;
+  lastModified = null;
+  consecutiveFailures = 0;
+  isPolling = false;
+  wasUnhealthy = false;
+  health = "unknown";
+  constructor(url, options = {}, callbacks = {}) {
+    this.url = url;
+    this.intervalMs = options.intervalMs ?? 6e4;
+    this.fetchTimeoutMs = options.fetchTimeoutMs ?? 1e4;
+    this.changeDetection = options.changeDetection ?? "auto";
+    this.retry = { ...DEFAULT_RETRY, ...options.retry };
+    this.unhealthyThreshold = options.unhealthyThreshold ?? 3;
+    this.headers = options.headers ?? {};
+    this.callbacks = callbacks;
+  }
+  /**
+   * Start polling for changes.
+   */
+  start() {
+    if (this.intervalTimer) return;
+    this.poll().catch(() => {
+    });
+    this.intervalTimer = setInterval(() => {
+      this.poll().catch(() => {
+      });
+    }, this.intervalMs);
+  }
+  /**
+   * Stop polling.
+   */
+  stop() {
+    if (this.intervalTimer) {
+      clearInterval(this.intervalTimer);
+      this.intervalTimer = null;
+    }
+  }
+  /**
+   * Get current stats.
+   */
+  getStats() {
+    return {
+      hash: this.lastHash,
+      consecutiveFailures: this.consecutiveFailures,
+      health: this.health,
+      isRunning: this.intervalTimer !== null
+    };
+  }
+  /**
+   * Perform a single poll cycle.
+   */
+  async poll() {
+    if (this.isPolling) return;
+    this.isPolling = true;
+    try {
+      await this.fetchWithRetry();
+    } finally {
+      this.isPolling = false;
+    }
+  }
+  async fetchWithRetry() {
+    const { maxRetries, initialDelayMs, maxDelayMs, backoffMultiplier } = this.retry;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        await this.doFetch();
+        if (this.consecutiveFailures > 0) {
+          this.consecutiveFailures = 0;
+          if (this.wasUnhealthy) {
+            this.wasUnhealthy = false;
+            this.health = "healthy";
+            this.callbacks.onRecovered?.();
+          }
+        }
+        this.health = "healthy";
+        return;
+      } catch (error) {
+        if (attempt === maxRetries) {
+          this.consecutiveFailures++;
+          this.callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+          if (this.consecutiveFailures >= this.unhealthyThreshold && !this.wasUnhealthy) {
+            this.wasUnhealthy = true;
+            this.health = "unhealthy";
+            this.callbacks.onUnhealthy?.(this.consecutiveFailures);
+          }
+          return;
+        }
+        const delay = Math.min(initialDelayMs * Math.pow(backoffMultiplier, attempt), maxDelayMs);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+  }
+  async doFetch() {
+    const headers = { ...this.headers };
+    if (this.changeDetection !== "content-hash") {
+      if (this.lastEtag) {
+        headers["If-None-Match"] = this.lastEtag;
+      }
+      if (this.lastModified) {
+        headers["If-Modified-Since"] = this.lastModified;
+      }
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.fetchTimeoutMs);
+    try {
+      const response = await fetch(this.url, {
+        headers,
+        signal: controller.signal
+      });
+      if (response.status === 304) {
+        this.callbacks.onUnchanged?.();
+        return;
+      }
+      if (!response.ok) {
+        throw new OpenAPIFetchError(this.url, response.status, response.statusText);
+      }
+      const etag = response.headers.get("etag");
+      const lastModified = response.headers.get("last-modified");
+      if (etag) this.lastEtag = etag;
+      if (lastModified) this.lastModified = lastModified;
+      const body = await response.text();
+      const hash = (0, import_utils2.sha256Hex)(body);
+      if (this.lastHash && this.lastHash === hash) {
+        this.callbacks.onUnchanged?.();
+        return;
+      }
+      this.lastHash = hash;
+      this.callbacks.onChanged?.(body, hash);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  /**
+   * Dispose the poller and release resources.
+   */
+  dispose() {
+    this.stop();
+  }
+};
+
 // libs/adapters/src/openapi/openapi.adapter.ts
 var RESERVED_KEYS2 = ["__proto__", "constructor", "prototype"];
 function createConsoleLogger(prefix) {
@@ -899,14 +1072,22 @@ function createConsoleLogger(prefix) {
     child: (childPrefix) => createConsoleLogger(`${prefix}:${childPrefix}`)
   };
 }
-var OpenapiAdapter = class extends import_sdk2.DynamicAdapter {
+var OpenapiAdapter = class extends import_sdk4.DynamicAdapter {
   generator;
   logger;
   options;
+  poller = null;
+  updateCallbacks = /* @__PURE__ */ new Set();
+  rebuildChain = Promise.resolve();
   constructor(options) {
     super();
     this.options = options;
     this.logger = options.logger ?? createConsoleLogger(`openapi:${options.name}`);
+    if (options.polling?.enabled && !("url" in options)) {
+      throw new Error(
+        `[OpenAPI Adapter: ${options.name}] Polling requires URL-based options (use 'url' instead of 'spec').`
+      );
+    }
   }
   /**
    * Receive the SDK logger. Called by the SDK before fetch().
@@ -982,13 +1163,31 @@ Add one of the following to your adapter configuration:
     if (this.options.toolTransforms) {
       transformedTools = transformedTools.map((tool2) => this.applyToolTransforms(tool2));
     }
+    const nameMap = /* @__PURE__ */ new Map();
+    for (const tool2 of transformedTools) {
+      const meta = tool2.metadata;
+      const source = `${meta["method"]?.toUpperCase() ?? "?"} ${meta["path"] ?? "?"}`;
+      const existing = nameMap.get(tool2.name);
+      if (existing) {
+        existing.push(source);
+      } else {
+        nameMap.set(tool2.name, [source]);
+      }
+    }
+    for (const [name, sources] of nameMap) {
+      if (sources.length > 1) {
+        throw new Error(
+          `Tool name collision: "${name}" produced by ${sources.length} operations: ${sources.join(", ")}. Rename conflicting operations in your OpenAPI spec or use toolTransforms.perTool to assign unique names.`
+        );
+      }
+    }
     if (this.options.inputTransforms) {
       transformedTools = transformedTools.map((tool2) => this.applyInputTransforms(tool2));
     }
     if (this.options.schemaTransforms) {
       transformedTools = transformedTools.map((tool2) => this.applySchemaTransforms(tool2));
     }
-    const dataTransforms = this.options.dataTransforms || this.options.outputTransforms;
+    const dataTransforms = this.options.dataTransforms;
     if (this.options.outputSchema || dataTransforms) {
       transformedTools = await Promise.all(
         transformedTools.map((tool2) => this.applyOutputSchemaOptions(tool2, dataTransforms))
@@ -1064,6 +1263,15 @@ ${opDescription}`;
       description
     };
   }
+  /**
+   * Look up a value in a perTool map by tool name, using own-property check.
+   * @private
+   */
+  resolvePerTool(perTool, tool2) {
+    if (!perTool) return void 0;
+    if (Object.prototype.hasOwnProperty.call(perTool, tool2.name)) return perTool[tool2.name];
+    return void 0;
+  }
   /**
    * Collect tool transforms for a specific tool
    * @private
@@ -1084,8 +1292,9 @@ ${opDescription}`;
         result.examples = [...opts.global.examples];
       }
     }
-    if (opts.perTool?.[tool2.name]) {
-      const perTool = opts.perTool[tool2.name];
+    const perToolMatch = this.resolvePerTool(opts.perTool, tool2);
+    if (perToolMatch) {
+      const perTool = perToolMatch;
       if (perTool.name) result.name = perTool.name;
       if (perTool.description) result.description = perTool.description;
       if (perTool.hideFromDiscovery !== void 0) result.hideFromDiscovery = perTool.hideFromDiscovery;
@@ -1162,8 +1371,9 @@ ${opDescription}`;
     if (opts.global) {
       transforms.push(...opts.global);
     }
-    if (opts.perTool?.[tool2.name]) {
-      transforms.push(...opts.perTool[tool2.name]);
+    const perToolInputTransforms = this.resolvePerTool(opts.perTool, tool2);
+    if (perToolInputTransforms) {
+      transforms.push(...perToolInputTransforms);
     }
     if (opts.generator) {
       transforms.push(...opts.generator(tool2));
@@ -1310,8 +1520,9 @@ ${opDescription}`;
       const generated = opts.generator(tool2);
       if (generated) return generated;
     }
-    if (opts.perTool?.[tool2.name]) {
-      return opts.perTool[tool2.name];
+    const perToolInputSchema = this.resolvePerTool(opts.perTool, tool2);
+    if (perToolInputSchema) {
+      return perToolInputSchema;
     }
     return opts.global;
   }
@@ -1326,8 +1537,9 @@ ${opDescription}`;
       const generated = opts.generator(tool2);
       if (generated) return generated;
     }
-    if (opts.perTool?.[tool2.name]) {
-      return opts.perTool[tool2.name];
+    const perToolOutputSchema = this.resolvePerTool(opts.perTool, tool2);
+    if (perToolOutputSchema) {
+      return perToolOutputSchema;
     }
     return opts.global;
   }
@@ -1429,8 +1641,9 @@ ${this.formatSchemaAsSummary(schema)}`;
     if (opts.global) {
       result = { ...opts.global };
     }
-    if (opts.perTool?.[tool2.name]) {
-      result = { ...result, ...opts.perTool[tool2.name] };
+    const perToolPre = this.resolvePerTool(opts.perTool, tool2);
+    if (perToolPre) {
+      result = { ...result, ...perToolPre };
     }
     if (opts.generator) {
       const generated = opts.generator(tool2);
@@ -1451,12 +1664,12 @@ ${this.formatSchemaAsSummary(schema)}`;
     if (opts.global) {
       result = { ...opts.global };
     }
-    if (opts.perTool?.[tool2.name]) {
-      const perTool = opts.perTool[tool2.name];
+    const perToolPost = this.resolvePerTool(opts.perTool, tool2);
+    if (perToolPost) {
       result = result ? {
-        transform: perTool.transform,
-        filter: perTool.filter ?? result.filter
-      } : perTool;
+        transform: perToolPost.transform,
+        filter: perToolPost.filter ?? result.filter
+      } : perToolPost;
     }
     if (opts.generator) {
       const generated = opts.generator(tool2);
@@ -1508,9 +1721,69 @@ ${this.formatSchemaAsSummary(schema)}`;
     }
     return schema.type || "any";
   }
+  // ============================================================================
+  // Polling Lifecycle
+  // ============================================================================
+  /**
+   * Register a callback for when the adapter's tools are updated via polling.
+   * Returns an unsubscribe function.
+   */
+  onUpdate(callback) {
+    this.updateCallbacks.add(callback);
+    return () => {
+      this.updateCallbacks.delete(callback);
+    };
+  }
+  /**
+   * Start polling for spec changes.
+   * Creates the poller and on spec change, re-runs fetch() and calls the update callback.
+   * Rebuilds are serialized via a Promise chain to prevent races.
+   */
+  startPolling() {
+    if (this.poller) return;
+    const polling = this.options.polling;
+    if (!polling?.enabled || !("url" in this.options)) return;
+    this.poller = new OpenApiSpecPoller(this.options.url, polling, {
+      onChanged: (_spec, _hash) => {
+        this.rebuildChain = this.rebuildChain.then(async () => {
+          const previousGenerator = this.generator;
+          try {
+            this.generator = void 0;
+            const response = await this.fetch();
+            this.updateCallbacks.forEach((cb) => cb(response));
+            this.logger.info("OpenAPI spec updated, tools rebuilt");
+          } catch (error) {
+            this.generator = previousGenerator;
+            this.logger.error(`Failed to rebuild tools after spec change: ${error.message}`);
+          }
+        });
+      },
+      onError: (error) => {
+        this.logger.warn(`OpenAPI spec poll error: ${error.message}`);
+      },
+      onUnhealthy: (failures) => {
+        this.logger.error(`OpenAPI spec poller unhealthy after ${failures} consecutive failures`);
+      },
+      onRecovered: () => {
+        this.logger.info("OpenAPI spec poller recovered");
+      }
+    });
+    this.poller.start();
+    this.logger.info(`Started polling OpenAPI spec at ${this.options.polling?.intervalMs ?? 6e4}ms intervals`);
+  }
+  /**
+   * Stop polling for spec changes.
+   */
+  stopPolling() {
+    if (this.poller) {
+      this.poller.dispose();
+      this.poller = null;
+      this.logger.info("Stopped polling OpenAPI spec");
+    }
+  }
 };
 OpenapiAdapter = __decorateClass([
-  (0, import_sdk2.Adapter)({
+  (0, import_sdk4.Adapter)({
     name: "openapi",
     description: "OpenAPI adapter for FrontMCP - Automatically generates MCP tools from OpenAPI specifications"
   })
@@ -1622,6 +1895,8 @@ function removeSecurityFromOperations(spec, operations) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FRONTMCP_EXTENSION_KEY,
+  OpenAPIFetchError,
+  OpenApiSpecPoller,
   forceJwtSecurity,
   removeSecurityFromOperations
 });

package/openapi/openapi-spec-poller.d.ts

@@ -0,0 +1,56 @@
+/**
+ * OpenAPI Spec Poller
+ *
+ * Polls an OpenAPI specification URL for changes using content-hash detection.
+ * Uses @frontmcp/utils for crypto operations (sha256Hex) and follows the
+ * HealthChecker pattern from libs/sdk/src/remote-mcp/resilience/health-check.ts.
+ *
+ * @packageDocumentation
+ */
+import type { SpecPollerOptions, SpecPollerCallbacks, SpecPollerStats } from './openapi-spec-poller.types';
+/**
+ * Polls an OpenAPI spec URL for changes using content-hash and ETag detection.
+ * Follows the callback-based emitter pattern (like ToolEmitter).
+ */
+export declare class OpenApiSpecPoller {
+    private readonly url;
+    private readonly intervalMs;
+    private readonly fetchTimeoutMs;
+    private readonly changeDetection;
+    private readonly retry;
+    private readonly unhealthyThreshold;
+    private readonly headers;
+    private readonly callbacks;
+    private intervalTimer;
+    private lastHash;
+    private lastEtag;
+    private lastModified;
+    private consecutiveFailures;
+    private isPolling;
+    private wasUnhealthy;
+    private health;
+    constructor(url: string, options?: SpecPollerOptions, callbacks?: SpecPollerCallbacks);
+    /**
+     * Start polling for changes.
+     */
+    start(): void;
+    /**
+     * Stop polling.
+     */
+    stop(): void;
+    /**
+     * Get current stats.
+     */
+    getStats(): SpecPollerStats;
+    /**
+     * Perform a single poll cycle.
+     */
+    poll(): Promise<void>;
+    private fetchWithRetry;
+    private doFetch;
+    /**
+     * Dispose the poller and release resources.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=openapi-spec-poller.d.ts.map

package/openapi/openapi-spec-poller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-spec-poller.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi-spec-poller.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EAGhB,MAAM,6BAA6B,CAAC;AAUrC;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAmC;IACnE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IACxD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAEhD,OAAO,CAAC,aAAa,CAA+C;IACpE,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAiC;gBAEnC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,EAAE,SAAS,GAAE,mBAAwB;IAW7F;;OAEG;IACH,KAAK,IAAI,IAAI;IAWb;;OAEG;IACH,IAAI,IAAI,IAAI;IAOZ;;OAEG;IACH,QAAQ,IAAI,eAAe;IAS3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAWb,cAAc;YAoCd,OAAO;IAqDrB;;OAEG;IACH,OAAO,IAAI,IAAI;CAGhB"}

package/openapi/openapi-spec-poller.types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * OpenAPI Spec Poller Types
+ *
+ * Type definitions for the OpenAPI specification polling system.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Change detection strategy.
+ */
+export type SpecChangeDetection = 'content-hash' | 'etag' | 'auto';
+/**
+ * Retry configuration for failed polls.
+ */
+export interface SpecPollerRetryConfig {
+    /** Maximum number of retries per poll cycle @default 3 */
+    maxRetries?: number;
+    /** Initial delay before first retry in ms @default 1000 */
+    initialDelayMs?: number;
+    /** Maximum delay between retries in ms @default 10000 */
+    maxDelayMs?: number;
+    /** Backoff multiplier @default 2 */
+    backoffMultiplier?: number;
+}
+/**
+ * Health status of the poller.
+ */
+export type PollerHealthStatus = 'healthy' | 'unhealthy' | 'unknown';
+/**
+ * Configuration for the OpenAPI spec poller.
+ */
+export interface SpecPollerOptions {
+    /** Poll interval in milliseconds @default 60000 */
+    intervalMs?: number;
+    /** Fetch timeout in milliseconds @default 10000 */
+    fetchTimeoutMs?: number;
+    /** Change detection strategy @default 'auto' */
+    changeDetection?: SpecChangeDetection;
+    /** Retry configuration */
+    retry?: SpecPollerRetryConfig;
+    /** Number of consecutive failures before marking unhealthy @default 3 */
+    unhealthyThreshold?: number;
+    /** Additional headers for fetch requests */
+    headers?: Record<string, string>;
+}
+/**
+ * Callback types for spec poller events.
+ */
+export interface SpecPollerCallbacks {
+    /** Called when the spec content has changed */
+    onChanged?: (spec: string, hash: string) => void;
+    /** Called when the spec hasn't changed */
+    onUnchanged?: () => void;
+    /** Called on poll error */
+    onError?: (error: Error) => void;
+    /** Called when poller becomes unhealthy */
+    onUnhealthy?: (consecutiveFailures: number) => void;
+    /** Called when poller recovers from unhealthy state */
+    onRecovered?: () => void;
+}
+/**
+ * Spec poller stats for monitoring.
+ */
+export interface SpecPollerStats {
+    /** Current content hash */
+    hash: string | null;
+    /** Number of consecutive failures */
+    consecutiveFailures: number;
+    /** Health status */
+    health: PollerHealthStatus;
+    /** Whether the poller is currently running */
+    isRunning: boolean;
+}
+//# sourceMappingURL=openapi-spec-poller.types.d.ts.map

package/openapi/openapi-spec-poller.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-spec-poller.types.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi-spec-poller.types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC,0BAA0B;IAC1B,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,yEAAyE;IACzE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,+CAA+C;IAC/C,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,0CAA0C;IAC1C,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,2CAA2C;IAC3C,WAAW,CAAC,EAAE,CAAC,mBAAmB,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,2BAA2B;IAC3B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,qCAAqC;IACrC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB;IACpB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,8CAA8C;IAC9C,SAAS,EAAE,OAAO,CAAC;CACpB"}

package/openapi/openapi.adapter.d.ts

@@ -4,6 +4,9 @@ export default class OpenapiAdapter extends DynamicAdapter<OpenApiAdapterOptions
     private generator?;
     private logger;
     options: OpenApiAdapterOptions;
+    private poller;
+    private updateCallbacks;
+    private rebuildChain;
     constructor(options: OpenApiAdapterOptions);
     /**
      * Receive the SDK logger. Called by the SDK before fetch().
@@ -20,6 +23,11 @@ export default class OpenapiAdapter extends DynamicAdapter<OpenApiAdapterOptions
      * @private
      */
     private applyDescriptionMode;
+    /**
+     * Look up a value in a perTool map by tool name, using own-property check.
+     * @private
+     */
+    private resolvePerTool;
     /**
      * Collect tool transforms for a specific tool
      * @private
@@ -95,5 +103,20 @@ export default class OpenapiAdapter extends DynamicAdapter<OpenApiAdapterOptions
      * @private
      */
     private getSchemaTypeString;
+    /**
+     * Register a callback for when the adapter's tools are updated via polling.
+     * Returns an unsubscribe function.
+     */
+    onUpdate(callback: (response: FrontMcpAdapterResponse) => void): () => void;
+    /**
+     * Start polling for spec changes.
+     * Creates the poller and on spec change, re-runs fetch() and calls the update callback.
+     * Rebuilds are serialized via a Promise chain to prevent races.
+     */
+    startPolling(): void;
+    /**
+     * Stop polling for spec changes.
+     */
+    stopPolling(): void;
 }
 //# sourceMappingURL=openapi.adapter.d.ts.map

package/openapi/openapi.adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openapi.adapter.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,cAAc,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACjG,OAAO,EACL,qBAAqB,EAWtB,MAAM,iBAAiB,CAAC;AA2BzB,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,cAAc,CAAC,qBAAqB,CAAC;IAC/E,OAAO,CAAC,SAAS,CAAC,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAiB;IACxB,OAAO,EAAE,qBAAqB,CAAC;gBAE1B,OAAO,EAAE,qBAAqB;IAO1C;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIjC,KAAK,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAgH/C;;;OAGG;YACW,mBAAmB;IAqBjC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA0C5B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IA4D7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAsC3B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAuBhC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAoD5B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA2D7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA0C7B;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAiBnC;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAmBpC;;;;OAIG;YACW,wBAAwB;IAiFtC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;;OAGG;IACH,OAAO,CAAC,0CAA0C;IA8BlD;;;OAGG;IACH,OAAO,CAAC,2CAA2C;IAyCnD;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;CAY5B"}
+{"version":3,"file":"openapi.adapter.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,cAAc,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACjG,OAAO,EACL,qBAAqB,EAWtB,MAAM,iBAAiB,CAAC;AA4BzB,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,cAAc,CAAC,qBAAqB,CAAC;IAC/E,OAAO,CAAC,SAAS,CAAC,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAiB;IACxB,OAAO,EAAE,qBAAqB,CAAC;IACtC,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,eAAe,CAA0D;IACjF,OAAO,CAAC,YAAY,CAAoC;gBAE5C,OAAO,EAAE,qBAAqB;IAc1C;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAIjC,KAAK,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAqI/C;;;OAGG;YACW,mBAAmB;IAqBjC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IA0C5B;;;OAGG;IACH,OAAO,CAAC,cAAc;IAMtB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IA6D7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAsC3B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAoD5B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA2D7B;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IA0C7B;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAkBnC;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAoBpC;;;;OAIG;YACW,wBAAwB;IAiFtC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;;OAGG;IACH,OAAO,CAAC,0CAA0C;IA+BlD;;;OAGG;IACH,OAAO,CAAC,2CAA2C;IAyCnD;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,GAAG,MAAM,IAAI;IAO3E;;;;OAIG;IACH,YAAY,IAAI,IAAI;IAsCpB;;OAEG;IACH,WAAW,IAAI,IAAI;CAOpB"}

package/openapi/openapi.errors.d.ts

@@ -0,0 +1,8 @@
+import { InternalMcpError } from '@frontmcp/sdk';
+/**
+ * Thrown when fetching the OpenAPI spec from a remote URL fails with a non-ok HTTP status.
+ */
+export declare class OpenAPIFetchError extends InternalMcpError {
+    constructor(url: string, status: number, statusText: string);
+}
+//# sourceMappingURL=openapi.errors.d.ts.map

package/openapi/openapi.errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi.errors.d.ts","sourceRoot":"","sources":["../../src/openapi/openapi.errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,gBAAgB;gBACzC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAG5D"}