@frontmcp/plugin-skilled-openapi 0.0.1

package/index.js

@@ -0,0 +1,1524 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key2, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key2) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key2, result);
+  return result;
+};
+
+// plugins/plugin-skilled-openapi/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SkilledOpenApiConfig: () => SkilledOpenApiConfig,
+  SkilledOpenApiCredentialResolver: () => SkilledOpenApiCredentialResolver,
+  SkilledOpenApiPlugin: () => SkilledOpenApiPlugin,
+  default: () => index_default,
+  skilledOpenApiPluginOptionsSchema: () => skilledOpenApiPluginOptionsSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// plugins/plugin-skilled-openapi/src/skilled-openapi.plugin.ts
+var import_skills5 = require("@frontmcp/adapters/skills");
+var import_sdk5 = require("@frontmcp/sdk");
+
+// plugins/plugin-skilled-openapi/src/executor/credential-resolver.ts
+var MemoryCredentialResolver = class {
+  defaults;
+  perBundle = /* @__PURE__ */ new Map();
+  constructor(defaults = {}) {
+    this.defaults = new Map(Object.entries(defaults).map(([k, v]) => [k, normalizeSecret(v)]));
+  }
+  /**
+   * Override (or add) a credential for a specific bundle. Per-bundle entries
+   * take precedence over the tenant-wide defaults supplied to the constructor.
+   */
+  setForBundle(bundleId, ref, value) {
+    let bundle = this.perBundle.get(bundleId);
+    if (!bundle) {
+      bundle = /* @__PURE__ */ new Map();
+      this.perBundle.set(bundleId, bundle);
+    }
+    bundle.set(ref, normalizeSecret(value));
+  }
+  async resolve(ref, opts) {
+    const scoped = this.perBundle.get(opts.bundleId)?.get(ref);
+    if (typeof scoped === "string") return scoped;
+    const fallback = this.defaults.get(ref);
+    return typeof fallback === "string" ? fallback : void 0;
+  }
+};
+function normalizeSecret(value) {
+  return value.replace(/\r?\n$/, "");
+}
+
+// plugins/plugin-skilled-openapi/src/registry/hidden-op.registry.ts
+var key = (skillId, actionId) => `${skillId}\0${actionId}`;
+var HiddenOpRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  /** Number of entries currently registered. Used for `/healthz`. */
+  get size() {
+    return this.entries.size;
+  }
+  /**
+   * Look up the operation registered for `(skillId, actionId)`. Returns
+   * undefined if the skill or action is unknown — the meta-tool surfaces this
+   * as a structured error to the caller.
+   */
+  get(skillId, actionId) {
+    return this.entries.get(key(skillId, actionId));
+  }
+  /** Set or replace the entry for `(skillId, actionId)`. */
+  set(entry) {
+    this.entries.set(key(entry.skillId, entry.op.operationId), entry);
+  }
+  /** Remove the entry for `(skillId, actionId)`. Returns true if anything was removed. */
+  delete(skillId, actionId) {
+    return this.entries.delete(key(skillId, actionId));
+  }
+  /**
+   * Remove every entry belonging to `skillId`. Used when a skill is removed
+   * by a bundle swap. Returns the number of entries removed.
+   */
+  deleteSkill(skillId) {
+    const prefix = `${skillId}\0`;
+    let removed = 0;
+    for (const k of [...this.entries.keys()]) {
+      if (k.startsWith(prefix)) {
+        this.entries.delete(k);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  /** Iterate all entries. Used by `/healthz` and audit log. */
+  values() {
+    return this.entries.values();
+  }
+  /** Reset to empty state (used by tests and panic-button). */
+  clear() {
+    this.entries.clear();
+  }
+};
+
+// plugins/plugin-skilled-openapi/src/security/authority-guard.ts
+var import_auth = require("@frontmcp/auth");
+var AuthorityGuard = class {
+  engine;
+  contextBuilder;
+  logger;
+  constructor(opts = {}) {
+    const profiles = opts.profiles ?? new import_auth.AuthoritiesProfileRegistry();
+    const evaluators = opts.evaluators ?? new import_auth.AuthoritiesEvaluatorRegistry();
+    this.engine = new import_auth.AuthoritiesEngine(profiles, evaluators);
+    this.contextBuilder = new import_auth.AuthoritiesContextBuilder();
+    this.logger = opts.logger;
+  }
+  async check(args) {
+    const { policy, authInfo, input, env } = args;
+    if (policy === void 0) {
+      return { granted: true, evaluatedPolicies: [] };
+    }
+    try {
+      const ctx = this.contextBuilder.build(authInfo, input, env);
+      return await this.engine.evaluate(policy, ctx);
+    } catch (e) {
+      const message = normalizeCaughtMessage(e);
+      this.logger?.error(`[skilled-openapi:authority] evaluation failed: ${message}`);
+      return {
+        granted: false,
+        deniedBy: "authority_evaluation_failed",
+        message,
+        evaluatedPolicies: []
+      };
+    }
+  }
+};
+function normalizeCaughtMessage(e) {
+  if (e instanceof Error) return e.message || "authority evaluation threw";
+  if (typeof e === "string") return e;
+  if (e !== null && typeof e === "object" && typeof e.message === "string") {
+    return e.message;
+  }
+  return String(e ?? "authority evaluation threw");
+}
+
+// plugins/plugin-skilled-openapi/src/skilled-openapi.symbols.ts
+var SkilledOpenApiConfig = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get outbound() {
+    return this.options.outbound;
+  }
+};
+var SkilledOpenApiCredentialResolver = class {
+};
+
+// plugins/plugin-skilled-openapi/src/skilled-openapi.types.ts
+var import_skills = require("@frontmcp/adapters/skills");
+var import_lazy_zod = require("@frontmcp/lazy-zod");
+var import_skills2 = require("@frontmcp/adapters/skills");
+var outboundOptionsSchema = import_lazy_zod.z.object({
+  /**
+   * Allow outbound connections to private/loopback/link-local IPs.
+   * MUST stay false in production. Set true only for self-hosted scenarios
+   * where the customer's REST API legitimately lives on a private network.
+   */
+  allowPrivateNetworks: import_lazy_zod.z.boolean().default(false),
+  /** Optional egress proxy URL (honors HTTPS_PROXY env if not set). */
+  egressProxy: import_lazy_zod.z.string().url().optional(),
+  /** Per-host concurrent request cap. */
+  maxConcurrencyPerHost: import_lazy_zod.z.number().int().positive().default(10),
+  /** Default per-op HTTP timeout in milliseconds. */
+  defaultTimeoutMs: import_lazy_zod.z.number().int().positive().default(3e4),
+  /** Default response size cap in bytes. Per-op overrides apply. */
+  defaultMaxResponseBytes: import_lazy_zod.z.number().int().positive().default(256 * 1024),
+  /**
+   * Permit `http:` URLs in addition to `https:`. Off by default; only enable
+   * for local dev where the mock REST server doesn't have a TLS cert.
+   */
+  allowHttp: import_lazy_zod.z.boolean().default(false)
+}).default({
+  allowPrivateNetworks: false,
+  maxConcurrencyPerHost: 10,
+  defaultTimeoutMs: 3e4,
+  defaultMaxResponseBytes: 256 * 1024,
+  allowHttp: false
+});
+var skilledOpenApiPluginOptionsObjectSchema = import_lazy_zod.z.object({
+  /** Bundle source — static, npm, or saas. */
+  source: import_skills.bundleSourceSchema,
+  /**
+   * Require a valid bundle signature. Defaults to true. Setting `dev: true`
+   * disables the requirement and emits a startup warning. Never set false
+   * (unsigned mode) silently in production.
+   */
+  requireSignature: import_lazy_zod.z.boolean().default(true),
+  /**
+   * Trusted public keys for bundle signature verification. At least one must
+   * match the bundle's signed `kid` for the bundle to load.
+   */
+  trustedKeys: import_lazy_zod.z.array(import_skills.signatureKeySchema).default([]),
+  /**
+   * Development mode: bypass signature verification and relax some defaults
+   * (e.g. allow http:). Loud startup warning. Never true in production.
+   */
+  dev: import_lazy_zod.z.boolean().default(false),
+  /** Outbound HTTP / SSRF defenses for the executor. */
+  outbound: outboundOptionsSchema,
+  /**
+   * Source-conflict policy when more than one source registers a skill with
+   * the same id. Default: locally-pinned static beats npm beats saas.
+   */
+  sourceConflictPolicy: import_lazy_zod.z.enum(["static-wins", "last-wins", "reject"]).default("static-wins"),
+  /**
+   * Cache directory for the last successfully loaded SaaS bundle, used as a
+   * fallback if a fresh pull fails at boot. Defaults to `.frontmcp/skilled-openapi/`.
+   * Only applies to source.type === 'saas'.
+   */
+  bundleCacheDir: import_lazy_zod.z.string().optional(),
+  /**
+   * Static credential map seeded into the in-memory `CredentialResolver` for
+   * dev / demo / single-tenant deployments. Keys match `vaultRef` strings on
+   * the bundle's `authBindings`. Production deployments should override the
+   * `SkilledOpenApiCredentialResolver` provider with a libs/auth-vault-backed
+   * resolver instead of using this option.
+   */
+  credentials: import_lazy_zod.z.record(import_lazy_zod.z.string().min(1).max(256), import_lazy_zod.z.string().min(1)).optional(),
+  /**
+   * Register each bundle operation as an internal SDK tool (visibility:
+   * 'internal') so other tools, agents, CodeCall scripts, and jobs can
+   * compose with it via `this.callTool('<bundleId>.<operationId>', args)`.
+   *
+   * Internal tools are excluded from `tools/list` and rejected for external
+   * `tools/call` requests — only callable in-process via the SDK helper.
+   *
+   * Default: true. Disable for very large bundles where the additional tool
+   * registry pressure outweighs the composition convenience, or when the
+   * three meta-tools are sufficient.
+   */
+  exposeOperationsAsInternalTools: import_lazy_zod.z.boolean().default(true)
+});
+var DEFAULT_OUTBOUND_OPTIONS = {
+  allowPrivateNetworks: false,
+  maxConcurrencyPerHost: 10,
+  defaultTimeoutMs: 3e4,
+  defaultMaxResponseBytes: 256 * 1024,
+  allowHttp: false
+};
+var skilledOpenApiPluginOptionsSchema = skilledOpenApiPluginOptionsObjectSchema.transform((opts) => {
+  const outbound = {
+    ...DEFAULT_OUTBOUND_OPTIONS,
+    ...opts.outbound ?? {}
+  };
+  if (opts.dev) {
+    outbound.allowHttp = true;
+  }
+  return {
+    ...opts,
+    outbound,
+    bundleCacheDir: opts.bundleCacheDir ?? ".frontmcp/skilled-openapi/"
+  };
+});
+
+// plugins/plugin-skilled-openapi/src/sync/bundle-sync.service.ts
+var import_skills3 = require("@frontmcp/adapters/skills");
+var BundleSyncService = class {
+  constructor(skillRegistry, hiddenOps, bundleStore, options, logger, operationToolFactory) {
+    this.skillRegistry = skillRegistry;
+    this.hiddenOps = hiddenOps;
+    this.bundleStore = bundleStore;
+    this.options = options;
+    this.logger = logger;
+    this.operationToolFactory = operationToolFactory;
+  }
+  skillUnregisterByBundleId = /* @__PURE__ */ new Map();
+  /**
+   * Validate signature and apply the bundle. Returns a structured result;
+   * never throws on validation/registration failure (caller logs + ignores).
+   * Throws ONLY on programmer error (e.g. invalid argument).
+   */
+  async apply(bundle) {
+    if (!bundle) throw new Error("apply: bundle is required");
+    if (this.bundleStore.isPinned()) {
+      const pinned = this.bundleStore.pinned();
+      return {
+        applied: false,
+        reason: pinned === bundle.version ? `bundle store pinned to ${pinned}; ${bundle.version} already active` : `bundle store pinned to ${pinned}; ${bundle.version} not applied`,
+        bundleId: bundle.bundleId,
+        bundleVersion: bundle.version
+      };
+    }
+    if (this.options.requireSignature) {
+      const verifyResult = (0, import_skills3.verifyBundleSignature)(bundle, this.options.trustedKeys, this.options.telemetry);
+      if (!verifyResult.ok) {
+        this.logger.warn(`[bundle-sync] rejected bundle ${bundle.bundleId}@${bundle.version}: ${verifyResult.reason}`);
+        return {
+          applied: false,
+          reason: verifyResult.reason,
+          bundleId: bundle.bundleId,
+          bundleVersion: bundle.version
+        };
+      }
+    }
+    const previous = this.bundleStore.current();
+    const diff = (0, import_skills3.diffBundles)(previous, bundle);
+    const snapshotEntries = [...this.hiddenOps.values()];
+    const priorHandles = new Map(this.skillUnregisterByBundleId);
+    const priorContents = previous ? new Map(previous.skills.map((s) => [s.id, this.toSkillContent(s, previous)])) : /* @__PURE__ */ new Map();
+    const newHandles = [];
+    const successfullyRemovedIds = [];
+    try {
+      this.rebuildHiddenOps(bundle);
+      let orderedSkills;
+      try {
+        orderedSkills = (0, import_skills3.resolveSkillLoadOrder)(bundle.skills);
+      } catch (e) {
+        if (e instanceof import_skills3.SkillDependencyCycleError) {
+          throw new Error(
+            `[bundle-sync] dependency cycle in ${bundle.bundleId}@${bundle.version}: ${e.cycle.join(" -> ")}`
+          );
+        }
+        if (e instanceof import_skills3.SkillDependencyMissingError) {
+          throw new Error(
+            `[bundle-sync] missing dependency in ${bundle.bundleId}@${bundle.version}: skill "${e.skillId}" requires "${e.missingId}"`
+          );
+        }
+        throw e;
+      }
+      for (const skill of orderedSkills) {
+        const content = this.toSkillContent(skill, bundle);
+        const handle = await this.skillRegistry.registerSkillContent(content, {
+          source: `skilled-openapi:${bundle.bundleId}`
+        });
+        newHandles.push(handle);
+      }
+      for (const removedId of diff.removedSkillIds) {
+        const handle = priorHandles.get(removedId);
+        if (handle) {
+          await handle();
+          successfullyRemovedIds.push(removedId);
+        }
+      }
+      this.skillUnregisterByBundleId.clear();
+      for (const h of newHandles) {
+        this.skillUnregisterByBundleId.set(h.id, h.unregister);
+      }
+      if (this.options.exposeOperationsAsInternalTools && this.operationToolFactory) {
+        try {
+          this.operationToolFactory.unregisterAll();
+          for (const entry of this.hiddenOps.values()) {
+            try {
+              this.operationToolFactory.register(entry);
+            } catch (regErr) {
+              this.logger.warn(
+                `[bundle-sync] internal-tool register failed for ${entry.bundleId}.${entry.op.operationId}: ${regErr.message}`
+              );
+            }
+          }
+        } catch (factoryErr) {
+          this.logger.warn(
+            `[bundle-sync] internal-tool factory error: ${factoryErr.message}; continuing without internal tools`
+          );
+        }
+      }
+      this.bundleStore.swap(bundle);
+      this.logger.info(`[bundle-sync] applied ${bundle.bundleId}@${bundle.version} (${(0, import_skills3.formatDiffSummary)(diff)})`);
+      return { applied: true, bundleId: bundle.bundleId, bundleVersion: bundle.version, diff };
+    } catch (e) {
+      this.logger.error(
+        `[bundle-sync] apply failed for ${bundle.bundleId}@${bundle.version}: ${e.message}; rolling back`
+      );
+      this.hiddenOps.clear();
+      for (const entry of snapshotEntries) {
+        this.hiddenOps.set(entry);
+      }
+      if (this.options.exposeOperationsAsInternalTools && this.operationToolFactory) {
+        try {
+          this.operationToolFactory.unregisterAll();
+          for (const entry of snapshotEntries) {
+            try {
+              this.operationToolFactory.register(entry);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      for (const h of newHandles) {
+        try {
+          await h.unregister();
+        } catch {
+        }
+      }
+      const toRestore = /* @__PURE__ */ new Map();
+      for (const h of newHandles) {
+        const prev = priorContents.get(h.id);
+        if (prev) toRestore.set(h.id, prev);
+      }
+      for (const id of successfullyRemovedIds) {
+        const prev = priorContents.get(id);
+        if (prev) toRestore.set(id, prev);
+      }
+      this.skillUnregisterByBundleId = new Map(priorHandles);
+      for (const [id, content] of toRestore) {
+        try {
+          const handle = await this.skillRegistry.registerSkillContent(content, {
+            source: `skilled-openapi:${bundle.bundleId}:rollback`
+          });
+          this.skillUnregisterByBundleId.set(id, handle.unregister);
+        } catch (restoreErr) {
+          this.logger.error(
+            `[bundle-sync] failed to restore prior skill ${id} during rollback: ${restoreErr.message}`
+          );
+          this.skillUnregisterByBundleId.delete(id);
+        }
+      }
+      return {
+        applied: false,
+        reason: `rollback: ${e.message}`,
+        bundleId: bundle.bundleId,
+        bundleVersion: bundle.version
+      };
+    }
+  }
+  /**
+   * Project a single BundledSkill into a SkillContent the SDK SkillRegistry
+   * understands. The `actions[]` extension carries the per-op schemas the LLM
+   * needs to know about; `bundleVersion` lets polling clients detect changes.
+   */
+  toSkillContent(skill, bundle) {
+    const actions = (0, import_skills3.bundleSkillToActions)(skill, bundle.operations);
+    return {
+      id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      instructions: skill.instructions,
+      tools: [],
+      actions,
+      bundleVersion: bundle.version
+    };
+  }
+  rebuildHiddenOps(bundle) {
+    this.hiddenOps.clear();
+    const servicesById = new Map(bundle.services.map((s) => [s.id, s]));
+    for (const skill of bundle.skills) {
+      for (const opId of skill.operationIds) {
+        const op = bundle.operations[opId];
+        if (!op) {
+          throw new Error(
+            `[bundle-sync] malformed bundle ${bundle.bundleId}@${bundle.version}: skill "${skill.id}" references unknown operationId "${opId}"`
+          );
+        }
+        const service = servicesById.get(op.serviceId);
+        if (!service) {
+          throw new Error(
+            `[bundle-sync] malformed bundle ${bundle.bundleId}@${bundle.version}: operation "${opId}" references unknown serviceId "${op.serviceId}"`
+          );
+        }
+        const authBinding = bundle.authBindings[op.authBindingRef];
+        if (!authBinding) {
+          throw new Error(
+            `[bundle-sync] malformed bundle ${bundle.bundleId}@${bundle.version}: operation "${opId}" references unknown authBindingRef "${op.authBindingRef}"`
+          );
+        }
+        const entry = {
+          skillId: skill.id,
+          op,
+          service,
+          authBinding,
+          bundleId: bundle.bundleId,
+          bundleVersion: bundle.version
+        };
+        this.hiddenOps.set(entry);
+      }
+    }
+  }
+};
+
+// plugins/plugin-skilled-openapi/src/tools/execute-action.tool.ts
+var import_skills4 = require("@frontmcp/adapters/skills");
+var import_sdk = require("@frontmcp/sdk");
+
+// plugins/plugin-skilled-openapi/src/executor/openapi-runtime.ts
+var import_openapi = require("@frontmcp/adapters/openapi");
+
+// plugins/plugin-skilled-openapi/src/executor/ssrf-guard.ts
+var import_node_dns = require("node:dns");
+var PRIVATE_IPV4_BLOCKS = [
+  // RFC 1918
+  { net: ipv4ToInt("10.0.0.0"), mask: 4278190080 },
+  { net: ipv4ToInt("172.16.0.0"), mask: 4293918720 },
+  { net: ipv4ToInt("192.168.0.0"), mask: 4294901760 },
+  // Loopback
+  { net: ipv4ToInt("127.0.0.0"), mask: 4278190080 },
+  // Link-local incl. AWS/GCP/Azure metadata 169.254.169.254
+  { net: ipv4ToInt("169.254.0.0"), mask: 4294901760 },
+  // 0.0.0.0/8
+  { net: ipv4ToInt("0.0.0.0"), mask: 4278190080 }
+];
+function ipv4ToInt(ip) {
+  const parts = ip.split(".").map((n) => parseInt(n, 10));
+  if (parts.length !== 4 || parts.some((p) => Number.isNaN(p))) return 0;
+  const [a, b, c, d] = parts;
+  return a * 16777216 + (b << 16 >>> 0) + (c << 8 >>> 0) + d >>> 0;
+}
+function isPrivateIPv4(ip) {
+  if (!/^\d+\.\d+\.\d+\.\d+$/.test(ip)) return false;
+  const parts = ip.split(".").map((n) => parseInt(n, 10));
+  if (parts.some((p) => Number.isNaN(p) || p < 0 || p > 255)) return false;
+  const v = ipv4ToInt(ip);
+  return PRIVATE_IPV4_BLOCKS.some((b) => (v & b.mask) >>> 0 === b.net);
+}
+function isPrivateIPv6(ip) {
+  const lower = ip.toLowerCase();
+  if (lower === "::1" || lower === "::") return true;
+  if (lower.startsWith("fc") || lower.startsWith("fd")) return true;
+  if (lower.startsWith("fe80:")) return true;
+  if (lower.startsWith("::ffff:")) {
+    const v4 = lower.slice("::ffff:".length);
+    return isPrivateIPv4(v4);
+  }
+  return false;
+}
+var FORBIDDEN_METADATA_HOSTS = /* @__PURE__ */ new Set(["metadata.google.internal", "metadata.azure.com", "metadata.aws.com"]);
+async function checkOutboundUrl(target, allowedHosts, outbound) {
+  let url;
+  try {
+    url = new URL(target);
+  } catch {
+    return { ok: false, reason: `invalid URL: ${target}` };
+  }
+  if (url.protocol !== "https:" && !(outbound.allowHttp && url.protocol === "http:")) {
+    return { ok: false, reason: `forbidden scheme "${url.protocol}" (https: required)` };
+  }
+  const hostname = url.hostname.toLowerCase();
+  if (FORBIDDEN_METADATA_HOSTS.has(hostname)) {
+    return { ok: false, reason: `cloud metadata hostname "${hostname}" is blocked` };
+  }
+  if (!allowedHosts.has(hostname)) {
+    return { ok: false, reason: `hostname "${hostname}" is not in the bundle's declared services` };
+  }
+  if (outbound.allowPrivateNetworks) {
+    return { ok: true };
+  }
+  let addresses;
+  try {
+    addresses = await import_node_dns.promises.lookup(hostname, { all: true });
+  } catch (e) {
+    return { ok: false, reason: `DNS resolution failed for "${hostname}": ${e.message}` };
+  }
+  for (const a of addresses) {
+    if (a.family === 4 && isPrivateIPv4(a.address)) {
+      return { ok: false, reason: `host "${hostname}" resolved to private/loopback IPv4 ${a.address}` };
+    }
+    if (a.family === 6 && isPrivateIPv6(a.address)) {
+      return { ok: false, reason: `host "${hostname}" resolved to private IPv6 ${a.address}` };
+    }
+  }
+  return { ok: true };
+}
+
+// plugins/plugin-skilled-openapi/src/executor/openapi-runtime.ts
+async function buildSecurityContext(args) {
+  const { binding, bundleId, resolver, callerToken } = args;
+  const ctx = {};
+  switch (binding.kind) {
+    case "none":
+      return ctx;
+    case "bearer": {
+      let token;
+      if (binding.passthroughCallerToken) {
+        token = callerToken;
+        if (!token) throw new Error("passthrough caller token requested but not supplied");
+      } else {
+        token = await resolver.resolve(binding.vaultRef, { bundleId });
+        if (!token) throw new Error(`bearer vaultRef "${binding.vaultRef}" did not resolve`);
+      }
+      ctx.jwt = token;
+      return ctx;
+    }
+    case "apiKey": {
+      const value = await resolver.resolve(binding.vaultRef, { bundleId });
+      if (!value) throw new Error(`apiKey vaultRef "${binding.vaultRef}" did not resolve`);
+      ctx.apiKeys = { [binding.name]: value };
+      ctx.apiKey = value;
+      return ctx;
+    }
+    case "oauth2": {
+      const token = await resolver.resolve(binding.vaultRef, { bundleId });
+      if (!token) throw new Error(`oauth2 vaultRef "${binding.vaultRef}" did not resolve`);
+      ctx.oauth2Token = token;
+      return ctx;
+    }
+  }
+}
+function toMcpOpenAPITool(entry) {
+  const { op, service, authBinding } = entry;
+  const securityMapper = [];
+  if (authBinding.kind === "apiKey") {
+    securityMapper.push({
+      inputKey: `__sec_${authBinding.name}`,
+      type: authBinding.in,
+      key: authBinding.name,
+      required: false,
+      security: { scheme: authBinding.name, type: "apiKey", name: authBinding.name, in: authBinding.in }
+    });
+  } else if (authBinding.kind === "bearer") {
+    securityMapper.push({
+      inputKey: "__sec_bearer",
+      type: "header",
+      key: "Authorization",
+      required: false,
+      security: { scheme: "bearer", type: "http", httpScheme: "bearer" }
+    });
+  } else if (authBinding.kind === "oauth2") {
+    securityMapper.push({
+      inputKey: "__sec_oauth2",
+      type: "header",
+      key: "Authorization",
+      required: false,
+      security: { scheme: "oauth2", type: "oauth2" }
+    });
+  }
+  return {
+    name: op.operationId,
+    description: op.description ?? op.summary ?? `${op.httpMethod} ${op.pathTemplate}`,
+    inputSchema: op.inputSchema,
+    outputSchema: op.outputSchema,
+    mapper: [...op.mapper, ...securityMapper],
+    metadata: {
+      path: op.pathTemplate,
+      method: op.httpMethod,
+      operationId: op.operationId,
+      operationSummary: op.summary,
+      operationDescription: op.description,
+      servers: [{ url: service.baseUrl }]
+    }
+  };
+}
+async function resolveSecurity(tool, ctx) {
+  const { SecurityResolver } = require("mcp-from-openapi");
+  const resolver = new SecurityResolver();
+  return resolver.resolve(tool.mapper, ctx);
+}
+async function executeOperation(args) {
+  const { entry, bundleId, input, callerToken, deps } = args;
+  const { outbound, resolver, allowedHosts, logger } = deps;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  let mcpTool;
+  try {
+    mcpTool = toMcpOpenAPITool(entry);
+  } catch (e) {
+    return failure(0, `tool projection failed: ${e.message}`);
+  }
+  let securityContext;
+  try {
+    securityContext = await buildSecurityContext({
+      binding: entry.authBinding,
+      bundleId,
+      resolver,
+      callerToken
+    });
+  } catch (e) {
+    return failure(0, `auth resolution failed: ${e.message}`);
+  }
+  let security;
+  try {
+    security = await resolveSecurity(mcpTool, securityContext);
+  } catch (e) {
+    return failure(0, `security resolve failed: ${e.message}`);
+  }
+  let req;
+  try {
+    req = (0, import_openapi.buildRequest)(mcpTool, input, security, entry.service.baseUrl);
+  } catch (e) {
+    return failure(0, `request build failed: ${e.message}`);
+  }
+  const ssrf = await checkOutboundUrl(req.url, allowedHosts, outbound);
+  if (!ssrf.ok) {
+    return failure(0, `ssrf check rejected request: ${ssrf.reason}`);
+  }
+  const timeoutMs = entry.op.timeoutMs ?? outbound.defaultTimeoutMs;
+  const maxBytes = entry.op.maxResponseBytes ?? outbound.defaultMaxResponseBytes;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  timer.unref?.();
+  try {
+    const response = await fetchImpl(req.url, {
+      method: entry.op.httpMethod,
+      headers: req.headers,
+      body: req.body !== void 0 ? JSON.stringify(req.body) : void 0,
+      signal: ac.signal
+    });
+    const contentType = response.headers.get("content-type") ?? void 0;
+    const reader = response.body?.getReader();
+    let received = 0;
+    const chunks = [];
+    if (reader) {
+      for (; ; ) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        if (value) {
+          received += value.byteLength;
+          if (received > maxBytes) {
+            return failure(response.status, `response exceeded maxResponseBytes (${maxBytes})`);
+          }
+          chunks.push(value);
+        }
+      }
+    }
+    const buf = Buffer.concat(chunks.map((c) => Buffer.from(c)));
+    const synthetic = new Response(buf, {
+      status: response.status,
+      headers: response.headers
+    });
+    const parsed = await (0, import_openapi.parseResponse)(synthetic);
+    void logger;
+    return {
+      ok: response.ok,
+      status: response.status,
+      contentType,
+      data: parsed.data,
+      responseBytes: received
+    };
+  } catch (e) {
+    const err = e;
+    return failure(0, err.name === "AbortError" ? `timeout after ${timeoutMs}ms` : err.message);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function failure(status, error) {
+  return { ok: false, status, data: null, error, responseBytes: 0 };
+}
+
+// plugins/plugin-skilled-openapi/src/executor/schema-cache.ts
+var import_lazy_zod2 = require("@frontmcp/lazy-zod");
+var compiled = /* @__PURE__ */ new Map();
+var cacheKey = (bundleVersion, opId) => `${bundleVersion}\0${opId}`;
+function compileOne(jsonSchema) {
+  if (!jsonSchema || typeof jsonSchema !== "object") {
+    return { schema: import_lazy_zod2.z.looseObject({}), failed: true };
+  }
+  try {
+    const zodSchema = import_lazy_zod2.z.fromJSONSchema(
+      jsonSchema,
+      {
+        defaultTarget: "draft-2020-12"
+      }
+    );
+    if (typeof zodSchema?.parse !== "function") {
+      return { schema: import_lazy_zod2.z.looseObject({}), failed: true };
+    }
+    return { schema: zodSchema, failed: false };
+  } catch {
+    return { schema: import_lazy_zod2.z.looseObject({}), failed: true };
+  }
+}
+function getCompiledOpSchemas(args) {
+  const key2 = cacheKey(args.bundleVersion, args.operationId);
+  const hit = compiled.get(key2);
+  if (hit) return hit;
+  const input = compileOne(args.inputSchema);
+  const output = compileOne(args.outputSchema);
+  const value = {
+    input: input.schema,
+    output: output.schema,
+    inputConversionFailed: input.failed,
+    outputConversionFailed: output.failed
+  };
+  compiled.set(key2, value);
+  return value;
+}
+
+// plugins/plugin-skilled-openapi/src/tools/execute-action.schema.ts
+var import_lazy_zod3 = require("@frontmcp/lazy-zod");
+var executeActionDescription = `Execute one action of a previously loaded skill.
+
+Pipeline:
+  1. Resolve (skillId, actionId) \u2192 bundled OpenAPI operation
+  2. Authorize: caller's authInfo is checked against the action's required authorities (if any)
+  3. Validate: the input is validated against the action's inputJsonSchema by the underlying executor
+  4. Outbound: an HTTPS request is built and sent to the service the action belongs to,
+     with credentials injected from the configured vault (never echoed back to you)
+  5. Response: the response body is validated against outputJsonSchema and returned in
+     a structured envelope. Failures (auth, schema, network) are returned as ok:false
+     with a structured error string \u2014 they DO NOT throw.
+
+INPUT: { skillId, actionId, input }
+OUTPUT: { ok, status, data?, contentType?, error? }`;
+var executeActionInputSchema = {
+  skillId: import_lazy_zod3.z.string().min(1).max(256).describe("Skill that owns the action"),
+  actionId: import_lazy_zod3.z.string().min(1).max(256).describe("Action id (operationId) within the skill"),
+  input: import_lazy_zod3.z.record(import_lazy_zod3.z.string(), import_lazy_zod3.z.unknown()).optional().describe("Flat input object; keys correspond to the action inputJsonSchema properties")
+};
+var executeActionOutputSchema = {
+  ok: import_lazy_zod3.z.boolean(),
+  status: import_lazy_zod3.z.number().int(),
+  data: import_lazy_zod3.z.unknown().optional(),
+  contentType: import_lazy_zod3.z.string().optional(),
+  error: import_lazy_zod3.z.string().optional()
+};
+
+// plugins/plugin-skilled-openapi/src/tools/execute-action.tool.ts
+var ExecuteActionTool = class extends import_sdk.ToolContext {
+  async execute(input) {
+    this.get(BundleSyncService);
+    const config = this.get(SkilledOpenApiConfig);
+    const hiddenOps = this.get(HiddenOpRegistry);
+    const bundleStore = this.get(import_skills4.BundleStore);
+    const guard = this.get(AuthorityGuard);
+    const resolver = this.get(SkilledOpenApiCredentialResolver);
+    const auditWriter = this.tryGet(import_skills4.SkillAuditWriterToken);
+    const auditSubject = this.authInfo?.user?.sub ?? "anonymous";
+    const detachAudit = (op, phase) => {
+      op.catch((error) => {
+        this.logger.warn(
+          `[skill-audit] detached ${phase} write failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    };
+    const TOTAL_STEPS = 5;
+    const tick = (step, message) => this.progress(step, TOTAL_STEPS, message);
+    const TELEMETRY_ACCESSOR_TOKEN = /* @__PURE__ */ Symbol.for("frontmcp:observability:telemetry-accessor");
+    const tel = this.tryGet(TELEMETRY_ACCESSOR_TOKEN);
+    const phaseEvent = (phase, attrs) => {
+      tel?.addEvent("skill_action.phase", {
+        phase,
+        skillId: input.skillId,
+        actionId: input.actionId,
+        ...attrs ?? {}
+      });
+    };
+    await tick(1, "resolve-action");
+    phaseEvent("resolve-action");
+    const entry = hiddenOps.get(input.skillId, input.actionId);
+    if (!entry) {
+      return {
+        ok: false,
+        status: 0,
+        error: `unknown action "${input.skillId}/${input.actionId}" \u2014 search_skill / load_skill first`
+      };
+    }
+    const pinned = entry;
+    const bundleId = pinned.bundleId;
+    const bundle = bundleStore.current();
+    await tick(2, "authority-check");
+    phaseEvent("authority-check", { bundleVersion: pinned.bundleVersion });
+    const policy = pinned.op.requiredAuthorities;
+    const authResult = await guard.check({
+      policy,
+      authInfo: this.authInfo ?? {},
+      input: input.input ?? {}
+    });
+    if (!authResult.granted) {
+      if (auditWriter) {
+        detachAudit(
+          auditWriter.writeAuthorityFail(
+            {
+              subject: auditSubject,
+              skillId: input.skillId,
+              actionId: input.actionId,
+              bundleId,
+              bundleVersion: pinned.bundleVersion,
+              input: input.input ?? {}
+            },
+            { reason: authResult.deniedBy ?? "policy not satisfied" }
+          ),
+          "authority-check-fail"
+        );
+      }
+      return {
+        ok: false,
+        status: 0,
+        error: `authority denied: ${authResult.deniedBy ?? "policy not satisfied"}`
+      };
+    }
+    if (auditWriter) {
+      detachAudit(
+        auditWriter.writeAuthorityPass({
+          subject: auditSubject,
+          skillId: input.skillId,
+          actionId: input.actionId,
+          bundleId,
+          bundleVersion: pinned.bundleVersion,
+          input: input.input ?? {}
+        }),
+        "authority-check-pass"
+      );
+    }
+    const schemas = getCompiledOpSchemas({
+      bundleVersion: pinned.bundleVersion,
+      operationId: pinned.op.operationId,
+      inputSchema: pinned.op.inputSchema,
+      outputSchema: pinned.op.outputSchema
+    });
+    await tick(3, "input-validate");
+    phaseEvent("input-validate", { bundleVersion: pinned.bundleVersion });
+    const inputParse = schemas.input.safeParse(input.input ?? {});
+    if (!inputParse.success) {
+      return {
+        ok: false,
+        status: 0,
+        error: `input validation failed: ${formatZodIssues(inputParse.error.issues)}`
+      };
+    }
+    const allowedHosts = /* @__PURE__ */ new Set();
+    try {
+      allowedHosts.add(new URL(pinned.service.baseUrl).hostname.toLowerCase());
+    } catch {
+    }
+    if (bundle) {
+      for (const svc of bundle.services) {
+        try {
+          allowedHosts.add(new URL(svc.baseUrl).hostname.toLowerCase());
+        } catch {
+        }
+      }
+    }
+    const deps = {
+      outbound: config.outbound,
+      resolver: { resolve: (ref, opts) => resolver.resolve(ref, opts) },
+      allowedHosts,
+      logger: this.logger
+    };
+    await tick(4, "http-call");
+    phaseEvent("http-call", { bundleVersion: pinned.bundleVersion });
+    let result;
+    try {
+      result = await executeOperation({
+        entry: pinned,
+        bundleId,
+        input: inputParse.data,
+        deps
+      });
+    } catch (e) {
+      if (auditWriter) {
+        detachAudit(
+          auditWriter.writeHttpCallFailure(
+            {
+              subject: auditSubject,
+              skillId: input.skillId,
+              actionId: input.actionId,
+              bundleId,
+              bundleVersion: pinned.bundleVersion,
+              input: input.input ?? {}
+            },
+            { status: 0, error: e }
+          ),
+          "http-call-failure"
+        );
+      }
+      throw e;
+    }
+    if (auditWriter) {
+      const auditCtx = {
+        subject: auditSubject,
+        skillId: input.skillId,
+        actionId: input.actionId,
+        bundleId,
+        bundleVersion: pinned.bundleVersion,
+        input: input.input ?? {}
+      };
+      if (result.ok) {
+        detachAudit(
+          auditWriter.writeHttpCallSuccess(auditCtx, {
+            status: result.status,
+            output: result.data ?? null
+          }),
+          "http-call-success"
+        );
+      } else {
+        detachAudit(
+          auditWriter.writeHttpCallFailure(auditCtx, {
+            status: result.status,
+            error: result.error ?? `http call failed with status ${result.status}`
+          }),
+          "http-call-failure"
+        );
+      }
+    }
+    const isJsonResponse = (result.contentType ?? "").toLowerCase().includes("application/json");
+    if (result.ok && isJsonResponse && result.data !== void 0 && result.data !== null) {
+      const outputParse = schemas.output.safeParse(result.data);
+      if (!outputParse.success) {
+        return {
+          ok: false,
+          status: result.status,
+          ...result.contentType ? { contentType: result.contentType } : {},
+          error: `upstream response failed output schema: ${formatZodIssues(outputParse.error.issues)}`
+        };
+      }
+    }
+    await tick(5, "done");
+    phaseEvent("done", { bundleVersion: pinned.bundleVersion });
+    tel?.setAttributes({
+      "skill_action.status": result.status,
+      "skill_action.ok": result.ok,
+      "skill_action.skill_id": input.skillId,
+      "skill_action.action_id": input.actionId,
+      "skill_action.bundle_version": pinned.bundleVersion
+    });
+    return {
+      ok: result.ok,
+      status: result.status,
+      ...result.data !== void 0 && result.data !== null ? { data: result.data } : {},
+      ...result.contentType ? { contentType: result.contentType } : {},
+      ...result.error ? { error: result.error } : {}
+    };
+  }
+};
+ExecuteActionTool = __decorateClass([
+  (0, import_sdk.Tool)({
+    name: "execute_action",
+    description: executeActionDescription,
+    inputSchema: executeActionInputSchema,
+    outputSchema: executeActionOutputSchema,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      openWorldHint: true
+    }
+  })
+], ExecuteActionTool);
+function formatZodIssues(issues) {
+  if (!issues.length) return "unspecified validation error";
+  return issues.slice(0, 3).map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+}
+
+// plugins/plugin-skilled-openapi/src/tools/load-skill.tool.ts
+var import_sdk2 = require("@frontmcp/sdk");
+
+// plugins/plugin-skilled-openapi/src/tools/load-skill.schema.ts
+var import_lazy_zod4 = require("@frontmcp/lazy-zod");
+var loadSkillDescription = `Load the full instructions and executable actions for a specific skill.
+
+Use this AFTER \`search_skill\` once you've identified the right skill for the
+user's task. The returned object contains:
+  - \`instructions\`: markdown the LLM should read carefully before invoking
+  - \`actions\`: each action's input/output JSON Schema and required authorities
+  - \`bundleVersion\`: changes when the bundle is hot-swapped (use it to detect drift)
+
+INPUT: { skillId }
+OUTPUT: { skill: { id, name, description, instructions, actions[] }, isComplete }`;
+var loadSkillInputSchema = {
+  skillId: import_lazy_zod4.z.string().min(1).max(256).describe("Stable skill identifier (returned by search_skill)")
+};
+var loadSkillOutputSchema = {
+  skill: import_lazy_zod4.z.object({
+    id: import_lazy_zod4.z.string(),
+    name: import_lazy_zod4.z.string(),
+    description: import_lazy_zod4.z.string(),
+    instructions: import_lazy_zod4.z.string(),
+    bundleVersion: import_lazy_zod4.z.string().optional(),
+    actions: import_lazy_zod4.z.array(
+      import_lazy_zod4.z.object({
+        actionId: import_lazy_zod4.z.string(),
+        summary: import_lazy_zod4.z.string(),
+        description: import_lazy_zod4.z.string().optional(),
+        inputJsonSchema: import_lazy_zod4.z.record(import_lazy_zod4.z.string(), import_lazy_zod4.z.unknown()),
+        outputJsonSchema: import_lazy_zod4.z.record(import_lazy_zod4.z.string(), import_lazy_zod4.z.unknown()),
+        requiredAuthorities: import_lazy_zod4.z.record(import_lazy_zod4.z.string(), import_lazy_zod4.z.unknown()).optional()
+      })
+    ).optional()
+  }),
+  isComplete: import_lazy_zod4.z.boolean(),
+  warning: import_lazy_zod4.z.string().optional()
+};
+
+// plugins/plugin-skilled-openapi/src/tools/load-skill.tool.ts
+var LoadSkillTool = class extends import_sdk2.ToolContext {
+  async execute(input) {
+    this.get(BundleSyncService);
+    const scope = this.get(import_sdk2.ScopeEntry);
+    const skillRegistry = scope.skills;
+    if (!skillRegistry) {
+      throw new import_sdk2.InternalMcpError("SkillRegistry is not available on the active scope", "SKILL_REGISTRY_UNAVAILABLE");
+    }
+    const result = await skillRegistry.loadSkill(input.skillId);
+    if (!result) {
+      throw new import_sdk2.PublicMcpError(`Skill "${input.skillId}" not found`, "SKILL_NOT_FOUND", 404);
+    }
+    const skill = result.skill;
+    return {
+      skill: {
+        id: skill.id,
+        name: skill.name,
+        description: skill.description,
+        instructions: skill.instructions,
+        ...skill.bundleVersion !== void 0 && { bundleVersion: skill.bundleVersion },
+        ...skill.actions ? { actions: skill.actions } : {}
+      },
+      isComplete: result.isComplete,
+      ...result.warning !== void 0 && { warning: result.warning }
+    };
+  }
+};
+LoadSkillTool = __decorateClass([
+  (0, import_sdk2.Tool)({
+    name: "load_skill",
+    description: loadSkillDescription,
+    inputSchema: loadSkillInputSchema,
+    outputSchema: loadSkillOutputSchema,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    }
+  })
+], LoadSkillTool);
+
+// plugins/plugin-skilled-openapi/src/tools/operation-tool.factory.ts
+var import_sdk3 = require("@frontmcp/sdk");
+var OPERATION_TOOL_OWNER_TOKEN = /* @__PURE__ */ Symbol.for("skilled-openapi:operation-tool-owner");
+var OPERATION_TOOL_OWNER = {
+  kind: "plugin",
+  id: "skilled-openapi",
+  ref: OPERATION_TOOL_OWNER_TOKEN
+};
+function operationToolName(bundleId, operationId) {
+  const namespaced = `${bundleId}.${operationId}`;
+  if (namespaced.length <= 64) return namespaced;
+  return operationId.length <= 64 ? operationId : operationId.slice(0, 64);
+}
+function buildOperationMetadata(entry) {
+  const name = operationToolName(entry.bundleId, entry.op.operationId);
+  const summary = entry.op.summary ?? `${entry.op.httpMethod} ${entry.op.pathTemplate}`;
+  const description = entry.op.description ? `${summary}
+
+${entry.op.description}` : summary;
+  const meta = {
+    name,
+    description,
+    inputSchema: {},
+    outputSchema: void 0,
+    visibility: "internal",
+    annotations: {
+      readOnlyHint: entry.op.httpMethod === "GET" || entry.op.httpMethod === "HEAD",
+      destructiveHint: entry.op.httpMethod !== "GET" && entry.op.httpMethod !== "HEAD",
+      openWorldHint: true
+    }
+  };
+  meta.rawInputSchema = entry.op.inputSchema;
+  return meta;
+}
+var OperationToolFactory = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** Map (bundleId|opId) → the executor function that doubles as registry token. */
+  registered = /* @__PURE__ */ new Map();
+  /**
+   * Register one operation as an internal tool. Idempotent — calling twice
+   * with the same `(bundleId, operationId)` is a no-op (the existing
+   * registration is left in place).
+   */
+  register(entry) {
+    const key2 = `${entry.bundleId}|${entry.op.operationId}`;
+    if (this.registered.has(key2)) return;
+    const executor = this.makeExecutor(entry);
+    const metadata = buildOperationMetadata(entry);
+    const record = {
+      kind: import_sdk3.ToolKind.FUNCTION,
+      provide: executor,
+      metadata
+    };
+    const instance = new import_sdk3.ToolInstance(record, this.deps.providers, OPERATION_TOOL_OWNER);
+    this.deps.toolRegistry.registerToolInstance(instance);
+    this.registered.set(key2, executor);
+  }
+  /**
+   * Unregister every tool this factory has registered. Used on bundle swap
+   * before re-registering the new bundle's operations.
+   */
+  unregisterAll() {
+    for (const executor of this.registered.values()) {
+      try {
+        this.deps.toolRegistry.unregisterToolInstance(executor);
+      } catch (e) {
+        this.deps.logger.warn(`unregister failed: ${e.message}`);
+      }
+    }
+    this.registered.clear();
+  }
+  /** Number of currently-registered internal operation tools (test/audit hook). */
+  get size() {
+    return this.registered.size;
+  }
+  /**
+   * Build the actual function executor for one op. Mirrors `ExecuteActionTool.execute`:
+   * authority check + input validation + `executeOperation` — so callers
+   * reaching the op via `callTool` get the same security gates as callers
+   * going through `execute_action`.
+   */
+  makeExecutor(entry) {
+    return async (input, ctx) => {
+      const config = ctx.get(SkilledOpenApiConfig);
+      const guard = ctx.get(AuthorityGuard);
+      const resolver = ctx.get(SkilledOpenApiCredentialResolver);
+      const policy = entry.op.requiredAuthorities;
+      const authResult = await guard.check({
+        policy,
+        authInfo: ctx.authInfo ?? {},
+        input: input ?? {}
+      });
+      if (!authResult.granted) {
+        return {
+          ok: false,
+          status: 0,
+          error: `authority denied: ${authResult.deniedBy ?? "policy not satisfied"}`
+        };
+      }
+      const schemas = getCompiledOpSchemas({
+        bundleVersion: entry.bundleVersion,
+        operationId: entry.op.operationId,
+        inputSchema: entry.op.inputSchema,
+        outputSchema: entry.op.outputSchema
+      });
+      const inputParse = schemas.input.safeParse(input ?? {});
+      if (!inputParse.success) {
+        return {
+          ok: false,
+          status: 0,
+          error: `input validation failed: ${inputParse.error.issues.slice(0, 3).map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ")}`
+        };
+      }
+      const allowedHosts = /* @__PURE__ */ new Set();
+      try {
+        allowedHosts.add(new URL(entry.service.baseUrl).hostname.toLowerCase());
+      } catch {
+      }
+      const deps = {
+        outbound: config.outbound,
+        resolver: { resolve: (ref, opts) => resolver.resolve(ref, opts) },
+        allowedHosts,
+        logger: ctx.logger
+      };
+      const result = await executeOperation({
+        entry,
+        bundleId: entry.bundleId,
+        input: inputParse.data,
+        deps
+      });
+      return {
+        ok: result.ok,
+        status: result.status,
+        ...result.data !== void 0 && result.data !== null ? { data: result.data } : {},
+        ...result.contentType ? { contentType: result.contentType } : {},
+        ...result.error ? { error: result.error } : {}
+      };
+    };
+  }
+};
+
+// plugins/plugin-skilled-openapi/src/tools/search-skill.tool.ts
+var import_sdk4 = require("@frontmcp/sdk");
+
+// plugins/plugin-skilled-openapi/src/tools/search-skill.schema.ts
+var import_lazy_zod5 = require("@frontmcp/lazy-zod");
+var searchSkillDescription = `Search the available skills by free-form query.
+
+A "skill" is a curated bundle of REST operations exposed to you behind a single
+named capability \u2014 instead of seeing each individual API endpoint, you see one
+skill that knows how to do something useful (e.g. "billing", "customers"). Use
+this tool first to discover what skills exist for the user's request, then call
+\`load_skill\` to read its instructions + the actions it offers, and \`execute_action\`
+to actually invoke one.
+
+INPUT:
+- query: short natural-language description of what you want to do
+- limit?: max results (default 20, max 50)
+- tags?: filter to skills carrying these tags
+
+OUTPUT: { skills: Array<{ skillId, name, description, score }> }`;
+var searchSkillInputSchema = {
+  query: import_lazy_zod5.z.string().min(1).max(2048).describe("Natural-language search query"),
+  limit: import_lazy_zod5.z.number().int().positive().max(50).optional().describe("Max results (default 20)"),
+  tags: import_lazy_zod5.z.array(import_lazy_zod5.z.string().min(1).max(64)).max(16).optional().describe("Filter by tags")
+};
+var searchSkillOutputSchema = {
+  skills: import_lazy_zod5.z.array(
+    import_lazy_zod5.z.object({
+      skillId: import_lazy_zod5.z.string(),
+      name: import_lazy_zod5.z.string(),
+      description: import_lazy_zod5.z.string(),
+      score: import_lazy_zod5.z.number(),
+      bundleVersion: import_lazy_zod5.z.string().optional()
+    })
+  )
+};
+
+// plugins/plugin-skilled-openapi/src/tools/search-skill.tool.ts
+var SearchSkillTool = class extends import_sdk4.ToolContext {
+  async execute(input) {
+    this.get(BundleSyncService);
+    const scope = this.get(import_sdk4.ScopeEntry);
+    const skillRegistry = scope.skills;
+    if (!skillRegistry || !skillRegistry.hasAny()) {
+      return { skills: [] };
+    }
+    const limit = input.limit ?? 20;
+    const tags = input.tags;
+    const results = await skillRegistry.search(input.query, {
+      topK: limit,
+      ...tags ? { tags } : {}
+    });
+    return {
+      skills: results.map((r) => ({
+        skillId: r.metadata.id ?? r.metadata.name,
+        name: r.metadata.name,
+        description: r.metadata.description ?? "",
+        score: r.score,
+        ...r.metadata.bundleVersion ? { bundleVersion: r.metadata.bundleVersion } : {}
+      }))
+    };
+  }
+};
+SearchSkillTool = __decorateClass([
+  (0, import_sdk4.Tool)({
+    name: "search_skill",
+    description: searchSkillDescription,
+    inputSchema: searchSkillInputSchema,
+    outputSchema: searchSkillOutputSchema,
+    annotations: {
+      readOnlyHint: true,
+      openWorldHint: false
+    }
+  })
+], SearchSkillTool);
+
+// plugins/plugin-skilled-openapi/src/skilled-openapi.plugin.ts
+var TELEMETRY_FACTORY_TOKEN = /* @__PURE__ */ Symbol.for("frontmcp:observability:telemetry-factory");
+function resolveBundleTelemetry(scope) {
+  const providers = scope?.providers;
+  if (!providers || typeof providers.get !== "function") return void 0;
+  let factory;
+  try {
+    factory = providers.get(TELEMETRY_FACTORY_TOKEN);
+  } catch {
+    return void 0;
+  }
+  if (!factory || typeof factory.createCounter !== "function") return void 0;
+  return {
+    createCounter: (name, description) => factory.createCounter(name, description),
+    startSpan: (name, attributes) => factory.startSpan(name, attributes)
+  };
+}
+var SkilledOpenApiPlugin = class extends import_sdk5.DynamicPlugin {
+  options;
+  cachedLogger;
+  constructor(options) {
+    super();
+    this.options = skilledOpenApiPluginOptionsSchema.parse(options);
+    this.warnIfInsecureConfig();
+  }
+  getLogger() {
+    if (!this.cachedLogger) {
+      this.cachedLogger = this.get(import_sdk5.FrontMcpLogger).child("skilled-openapi");
+    }
+    return this.cachedLogger;
+  }
+  warnIfInsecureConfig() {
+    if (this.options.dev) {
+      console.warn(
+        "[skilled-openapi] dev=true: signature verification BYPASSED and http:// URLs allowed. NEVER use this in production."
+      );
+    }
+    if (!this.options.requireSignature && !this.options.dev) {
+      console.warn(
+        "[skilled-openapi] requireSignature=false without dev=true: bundle signing is OFF. This violates the v1.2 security baseline."
+      );
+    }
+  }
+  static dynamicProviders(options) {
+    const parsed = skilledOpenApiPluginOptionsSchema.parse(options);
+    const config = new SkilledOpenApiConfig(parsed);
+    return [
+      { name: "skilled-openapi:config", provide: SkilledOpenApiConfig, useValue: config },
+      { name: "skilled-openapi:hidden-ops", provide: HiddenOpRegistry, useValue: new HiddenOpRegistry() },
+      {
+        name: "skilled-openapi:bundle-store",
+        provide: import_skills5.BundleStore,
+        // Resolve TelemetryAccessor from the scope's provider registry so the
+        // bundle-pulls counter and `skill.bundle.swap` span actually export.
+        // The accessor is structurally compatible with `BundleStoreTelemetry`.
+        // ObservabilityPlugin is an optional peer dep — when it isn't installed
+        // we resolve `undefined` and the BundleStore falls through its zero-cost
+        // no-telemetry path.
+        inject: () => [import_sdk5.ScopeEntry],
+        useFactory: (scope) => new import_skills5.BundleStore({ telemetry: resolveBundleTelemetry(scope) })
+      },
+      {
+        name: "skilled-openapi:credential-resolver",
+        provide: SkilledOpenApiCredentialResolver,
+        useValue: new MemoryCredentialResolver(parsed.credentials ?? {})
+      },
+      {
+        name: "skilled-openapi:authority-guard",
+        provide: AuthorityGuard,
+        inject: () => [import_sdk5.ScopeEntry],
+        useFactory: (scope) => new AuthorityGuard({ logger: scope.logger.child("skilled-openapi:authority") })
+      },
+      {
+        name: "skilled-openapi:bundle-sync",
+        provide: BundleSyncService,
+        inject: () => [import_sdk5.ScopeEntry, HiddenOpRegistry, import_skills5.BundleStore],
+        useFactory: async (scope, hiddenOps, bundleStore) => {
+          const logger = scope.logger.child("skilled-openapi:sync");
+          const lazySkillRegistry = new Proxy({}, {
+            get(_t, prop) {
+              const reg = scope.skills;
+              if (!reg) {
+                throw new Error(`[skilled-openapi] scope.skills not available when accessing "${String(prop)}"`);
+              }
+              const v = reg[prop];
+              return typeof v === "function" ? v.bind(reg) : v;
+            }
+          });
+          let opToolFactory;
+          if (parsed.exposeOperationsAsInternalTools) {
+            try {
+              const toolRegistry = scope.tools;
+              if (toolRegistry) {
+                opToolFactory = new OperationToolFactory({
+                  toolRegistry,
+                  // ScopeEntry exposes a ProviderRegistryInterface; the factory
+                  // needs the concrete ProviderRegistry to construct ToolInstance.
+                  // The runtime is the same class — the cast is safe by construction.
+                  providers: scope.providers,
+                  logger: logger.child("op-tool")
+                });
+              } else {
+                logger.warn(
+                  "exposeOperationsAsInternalTools=true but scope.tools is unavailable; per-op internal tools disabled"
+                );
+              }
+            } catch (e) {
+              logger.warn(
+                `failed to build OperationToolFactory: ${e.message}; per-op internal tools disabled`
+              );
+            }
+          }
+          const sync = new BundleSyncService(
+            lazySkillRegistry,
+            hiddenOps,
+            bundleStore,
+            {
+              requireSignature: parsed.requireSignature,
+              trustedKeys: parsed.trustedKeys,
+              exposeOperationsAsInternalTools: parsed.exposeOperationsAsInternalTools,
+              // Reuse the same telemetry adapter the BundleStore uses so the
+              // signature verification counters are wired through the same
+              // optional ObservabilityPlugin lookup. When observability isn't
+              // installed this is `undefined` and verifyBundleSignature skips
+              // the counter lookup entirely.
+              telemetry: resolveBundleTelemetry(scope)
+            },
+            logger,
+            opToolFactory
+          );
+          let source;
+          try {
+            source = (0, import_skills5.createBundleSource)(parsed.source, parsed.bundleCacheDir, logger);
+          } catch (e) {
+            logger.error(`failed to construct bundle source: ${e.message}`);
+            return sync;
+          }
+          source.onChange((bundle) => {
+            void sync.apply(bundle).then((result) => {
+              if (!result.applied) {
+                logger.warn(`bundle ${bundle.bundleId}@${bundle.version} not applied: ${result.reason}`);
+              }
+            }).catch((e) => {
+              logger.error(`bundle ${bundle.bundleId}@${bundle.version} apply threw: ${e.message}`);
+            });
+          });
+          const startedSource = source;
+          setImmediate(() => {
+            startedSource.start().catch((e) => {
+              logger.error(`bundle source failed to start: ${e.message}`);
+            });
+          });
+          return sync;
+        }
+      }
+    ];
+  }
+};
+SkilledOpenApiPlugin = __decorateClass([
+  (0, import_sdk5.Plugin)({
+    name: "skilled-openapi",
+    description: "Serve a customer's OpenAPI spec as signed skill bundles with hidden per-operation tools mediated by 3 meta-tools.",
+    providers: [],
+    tools: [SearchSkillTool, LoadSkillTool, ExecuteActionTool]
+  })
+], SkilledOpenApiPlugin);
+
+// plugins/plugin-skilled-openapi/src/index.ts
+var index_default = SkilledOpenApiPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SkilledOpenApiConfig,
+  SkilledOpenApiCredentialResolver,
+  SkilledOpenApiPlugin,
+  skilledOpenApiPluginOptionsSchema
+});