@frontmcp/plugin-skilled-openapi 0.0.1

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@frontmcp/plugin-skilled-openapi",
+  "version": "0.0.1",
+  "description": "FrontMCP plugin: serve a customer's OpenAPI spec as skill bundles (signed, OpenAPI-Overlay-based) with hidden per-operation tools mediated by three meta-tools (search_skill / load_skill / execute_action).",
+  "author": "AgentFront <info@agentfront.dev>",
+  "license": "Apache-2.0",
+  "keywords": [
+    "mcp",
+    "frontmcp",
+    "openapi",
+    "skills",
+    "agent-skills",
+    "plugin",
+    "agentfront"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentfront/frontmcp.git",
+    "directory": "plugins/plugin-skilled-openapi"
+  },
+  "bugs": {
+    "url": "https://github.com/agentfront/frontmcp/issues"
+  },
+  "homepage": "https://github.com/agentfront/frontmcp/blob/main/plugins/plugin-skilled-openapi/README.md",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "commonjs",
+  "main": "./index.js",
+  "module": "./esm/index.mjs",
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./esm/index.mjs"
+      }
+    }
+  },
+  "dependencies": {
+    "@frontmcp/adapters": "1.0.4",
+    "@frontmcp/auth": "1.0.4",
+    "@frontmcp/protocol": "1.0.4",
+    "@frontmcp/sdk": "1.0.4",
+    "@frontmcp/utils": "1.0.4"
+  },
+  "peerDependencies": {
+    "@frontmcp/lazy-zod": "1.0.4"
+  },
+  "devDependencies": {
+    "reflect-metadata": "^0.2.2"
+  }
+}

package/registry/hidden-op.registry.d.ts

@@ -0,0 +1,52 @@
+import type { AuthBinding, OperationDescriptor, ServiceDescriptor } from '@frontmcp/adapters/skills';
+/**
+ * Plugin-private map of `(skillId, actionId) -> OperationDescriptor`.
+ *
+ * This is the SOLE resolution path for hidden operations. The registry is NOT
+ * exported from the plugin's public surface and is NOT a DI provider that
+ * other code paths can inject — it's reachable ONLY through the plugin's three
+ * meta-tools, which act as the authorization checkpoint.
+ *
+ * The registry also holds the bundle's services map and auth bindings so the
+ * executor can resolve outbound URLs and credentials from the same source of
+ * truth that gates discovery.
+ */
+export interface HiddenOpEntry {
+    /** Skill that owns this operation (used for ABAC namespacing). */
+    skillId: string;
+    /** Operation descriptor (immutable for the lifetime of this entry). */
+    op: OperationDescriptor;
+    /** Resolved service this op lives in. */
+    service: ServiceDescriptor;
+    /** Resolved auth binding for outbound credential injection. */
+    authBinding: AuthBinding;
+    /** Bundle id this entry came from. Pinned with the entry so a hot bundle-swap mid-call cannot route the op through a different bundle's credential scope. */
+    bundleId: string;
+    /** The bundle version this entry came from. Pinned at call entry to survive bundle hot-swap mid-call. */
+    bundleVersion: string;
+}
+export declare class HiddenOpRegistry {
+    private entries;
+    /** Number of entries currently registered. Used for `/healthz`. */
+    get size(): number;
+    /**
+     * 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: string, actionId: string): HiddenOpEntry | undefined;
+    /** Set or replace the entry for `(skillId, actionId)`. */
+    set(entry: HiddenOpEntry): void;
+    /** Remove the entry for `(skillId, actionId)`. Returns true if anything was removed. */
+    delete(skillId: string, actionId: string): boolean;
+    /**
+     * Remove every entry belonging to `skillId`. Used when a skill is removed
+     * by a bundle swap. Returns the number of entries removed.
+     */
+    deleteSkill(skillId: string): number;
+    /** Iterate all entries. Used by `/healthz` and audit log. */
+    values(): IterableIterator<HiddenOpEntry>;
+    /** Reset to empty state (used by tests and panic-button). */
+    clear(): void;
+}
+//# sourceMappingURL=hidden-op.registry.d.ts.map

package/registry/hidden-op.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hidden-op.registry.d.ts","sourceRoot":"","sources":["../../src/registry/hidden-op.registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAErG;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,EAAE,EAAE,mBAAmB,CAAC;IACxB,yCAAyC;IACzC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,+DAA+D;IAC/D,WAAW,EAAE,WAAW,CAAC;IACzB,6JAA6J;IAC7J,QAAQ,EAAE,MAAM,CAAC;IACjB,yGAAyG;IACzG,aAAa,EAAE,MAAM,CAAC;CACvB;AAID,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAoC;IAEnD,mEAAmE;IACnE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIjE,0DAA0D;IAC1D,GAAG,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAI/B,wFAAwF;IACxF,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlD;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAYpC,6DAA6D;IAC7D,MAAM,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAIzC,6DAA6D;IAC7D,KAAK,IAAI,IAAI;CAGd"}

package/security/authority-guard.d.ts

@@ -0,0 +1,34 @@
+import type { AuthoritiesPolicy } from '@frontmcp/adapters/skills';
+import { AuthoritiesEvaluatorRegistry, AuthoritiesProfileRegistry, type AuthoritiesResult } from '@frontmcp/auth';
+import type { FrontMcpLogger } from '@frontmcp/sdk';
+export interface AuthorityCheckArgs {
+    /** Required-authorities policy from the bundle (skill-level + op-level merged). */
+    policy: AuthoritiesPolicy | undefined;
+    /** Caller authInfo (from MCP request); shape matches libs/auth's AuthInfoLike. */
+    authInfo: Partial<{
+        user?: Record<string, unknown>;
+        extra?: Record<string, unknown>;
+    }>;
+    /** Tool/action input that ABAC predicates may reference. */
+    input: Record<string, unknown>;
+    /** Optional environment vars that ABAC predicates may reference. */
+    env?: Record<string, unknown>;
+}
+/**
+ * Default permissive guard when no policy is attached. v1.2 ships fail-closed
+ * for hidden ops: skill-level policy missing AND op-level policy missing means
+ * grant — but the meta-tool layer always requires successful skill resolution
+ * and the bundle signature verifies origin trust.
+ */
+export declare class AuthorityGuard {
+    private readonly engine;
+    private readonly contextBuilder;
+    private readonly logger;
+    constructor(opts?: {
+        profiles?: AuthoritiesProfileRegistry;
+        evaluators?: AuthoritiesEvaluatorRegistry;
+        logger?: FrontMcpLogger;
+    });
+    check(args: AuthorityCheckArgs): Promise<AuthoritiesResult>;
+}
+//# sourceMappingURL=authority-guard.d.ts.map

package/security/authority-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authority-guard.d.ts","sourceRoot":"","sources":["../../src/security/authority-guard.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAGL,4BAA4B,EAC5B,0BAA0B,EAG1B,KAAK,iBAAiB,EACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,MAAM,WAAW,kBAAkB;IACjC,mFAAmF;IACnF,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACtC,kFAAkF;IAClF,QAAQ,EAAE,OAAO,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACvF,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA4B;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;gBAGlD,IAAI,GAAE;QACJ,QAAQ,CAAC,EAAE,0BAA0B,CAAC;QACtC,UAAU,CAAC,EAAE,4BAA4B,CAAC;QAC1C,MAAM,CAAC,EAAE,cAAc,CAAC;KACpB;IASF,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAyBlE"}

package/skilled-openapi.plugin.d.ts

@@ -0,0 +1,24 @@
+import { DynamicPlugin, type ProviderType } from '@frontmcp/sdk';
+import { type SkilledOpenApiPluginOptions, type SkilledOpenApiPluginOptionsInput } from './skilled-openapi.types';
+/**
+ * `@frontmcp/plugin-skilled-openapi`
+ *
+ * Consumes signed skill bundles (OpenAPI spec + Overlay) from a configured
+ * source (static, npm, or SaaS-pull) and serves them as FrontMCP skills with
+ * three meta-tools (`search_skill`, `load_skill`, `execute_action`). Per-op
+ * REST tools stay hidden from `tools/list`.
+ *
+ * Lifecycle: `BundleSyncService` is a useFactory provider that starts the
+ * configured bundle source on first injection (lazy-boot). The meta-tools
+ * inject it implicitly via `BundleStore` / `HiddenOpRegistry`, so the first
+ * call to any meta-tool kicks off ingestion.
+ */
+export default class SkilledOpenApiPlugin extends DynamicPlugin<SkilledOpenApiPluginOptions, SkilledOpenApiPluginOptionsInput> {
+    options: SkilledOpenApiPluginOptions;
+    private cachedLogger?;
+    constructor(options: SkilledOpenApiPluginOptionsInput);
+    private getLogger;
+    private warnIfInsecureConfig;
+    static dynamicProviders(options: SkilledOpenApiPluginOptionsInput): ProviderType[];
+}
+//# sourceMappingURL=skilled-openapi.plugin.d.ts.map

package/skilled-openapi.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skilled-openapi.plugin.d.ts","sourceRoot":"","sources":["../src/skilled-openapi.plugin.ts"],"names":[],"mappings":"AASA,OAAO,EACL,aAAa,EAKb,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AAMvB,OAAO,EAEL,KAAK,2BAA2B,EAChC,KAAK,gCAAgC,EACtC,MAAM,yBAAyB,CAAC;AAmDjC;;;;;;;;;;;;GAYG;AAQH,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,aAAa,CAC7D,2BAA2B,EAC3B,gCAAgC,CACjC;IACC,OAAO,EAAE,2BAA2B,CAAC;IACrC,OAAO,CAAC,YAAY,CAAC,CAAiB;gBAE1B,OAAO,EAAE,gCAAgC;IAMrD,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,oBAAoB;WAaZ,gBAAgB,CAAC,OAAO,EAAE,gCAAgC,GAAG,YAAY,EAAE;CAsI5F"}

package/skilled-openapi.symbols.d.ts

@@ -0,0 +1,25 @@
+import { type CredentialResolver } from './executor/credential-resolver';
+import { type OutboundOptions, type SkilledOpenApiPluginOptions } from './skilled-openapi.types';
+/**
+ * Resolved-at-construction config for the plugin. Mirrors plugin options after
+ * Zod parsing so downstream services don't re-parse.
+ */
+export declare class SkilledOpenApiConfig {
+    readonly options: SkilledOpenApiPluginOptions;
+    constructor(options: SkilledOpenApiPluginOptions);
+    get outbound(): OutboundOptions;
+}
+/**
+ * Token for the plugin-private credential resolver. Production wiring backs
+ * it with `libs/auth`'s vault; v1.2.0 OSS demos use the in-memory resolver.
+ */
+export declare abstract class SkilledOpenApiCredentialResolver {
+    abstract resolve(ref: string, opts: {
+        bundleId: string;
+    }): Promise<string | undefined>;
+}
+/**
+ * Convenience: cast a CredentialResolver instance to the abstract token.
+ */
+export declare function asCredentialResolverToken(resolver: CredentialResolver): SkilledOpenApiCredentialResolver;
+//# sourceMappingURL=skilled-openapi.symbols.d.ts.map

package/skilled-openapi.symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skilled-openapi.symbols.d.ts","sourceRoot":"","sources":["../src/skilled-openapi.symbols.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAEjG;;;GAGG;AACH,qBAAa,oBAAoB;aACH,OAAO,EAAE,2BAA2B;gBAApC,OAAO,EAAE,2BAA2B;IAChE,IAAI,QAAQ,IAAI,eAAe,CAE9B;CACF;AAED;;;GAGG;AACH,8BAAsB,gCAAgC;IACpD,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;CACvF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,gCAAgC,CAExG"}

package/skilled-openapi.types.d.ts

@@ -0,0 +1,189 @@
+import { z } from '@frontmcp/lazy-zod';
+export { bundleSourceSchema, npmSourceSchema, saasSourceSchema, signatureKeySchema, staticSourceSchema, } from '@frontmcp/adapters/skills';
+export type { BundleSourceOptions, NpmSourceOptions, SaasSourceOptions, SignatureKey, StaticSourceOptions, } from '@frontmcp/adapters/skills';
+export declare const outboundOptionsSchema: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodObject<{
+    allowPrivateNetworks: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    egressProxy: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    maxConcurrencyPerHost: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+    defaultTimeoutMs: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+    defaultMaxResponseBytes: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+    allowHttp: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>;
+export type OutboundOptions = z.infer<typeof outboundOptionsSchema>;
+declare const skilledOpenApiPluginOptionsObjectSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    source: import("@frontmcp/lazy-zod").ZodDiscriminatedUnion<[import("@frontmcp/lazy-zod").ZodObject<{
+        type: import("@frontmcp/lazy-zod").ZodLiteral<"static">;
+        path: import("@frontmcp/lazy-zod").ZodString;
+        watch: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>, import("@frontmcp/lazy-zod").ZodObject<{
+        type: import("@frontmcp/lazy-zod").ZodLiteral<"npm">;
+        packageName: import("@frontmcp/lazy-zod").ZodString;
+        exportName: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+        verifyProvenance: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>, import("@frontmcp/lazy-zod").ZodObject<{
+        type: import("@frontmcp/lazy-zod").ZodLiteral<"saas">;
+        endpoint: import("@frontmcp/lazy-zod").ZodString;
+        authToken: import("@frontmcp/lazy-zod").ZodString;
+        expectedAudience: import("@frontmcp/lazy-zod").ZodString;
+        pollIntervalMs: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+        enableWebhook: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+        jwksUrl: import("@frontmcp/lazy-zod").ZodString;
+        expectedIssuer: import("@frontmcp/lazy-zod").ZodString;
+    }, import("zod/v4/core").$strip>], "type">;
+    requireSignature: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    trustedKeys: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodObject<{
+        keyId: import("@frontmcp/lazy-zod").ZodString;
+        alg: import("@frontmcp/lazy-zod").ZodEnum<{
+            RS256: "RS256";
+            EdDSA: "EdDSA";
+        }>;
+        publicKeyPem: import("@frontmcp/lazy-zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+    dev: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    outbound: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodObject<{
+        allowPrivateNetworks: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+        egressProxy: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+        maxConcurrencyPerHost: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+        defaultTimeoutMs: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+        defaultMaxResponseBytes: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+        allowHttp: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>>;
+    sourceConflictPolicy: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodEnum<{
+        "static-wins": "static-wins";
+        "last-wins": "last-wins";
+        reject: "reject";
+    }>>;
+    bundleCacheDir: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    credentials: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodString>>;
+    exposeOperationsAsInternalTools: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>;
+export declare const skilledOpenApiPluginOptionsSchema: import("zod").ZodPipe<import("@frontmcp/lazy-zod").ZodObject<{
+    source: import("@frontmcp/lazy-zod").ZodDiscriminatedUnion<[import("@frontmcp/lazy-zod").ZodObject<{
+        type: import("@frontmcp/lazy-zod").ZodLiteral<"static">;
+        path: import("@frontmcp/lazy-zod").ZodString;
+        watch: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>, import("@frontmcp/lazy-zod").ZodObject<{
+        type: import("@frontmcp/lazy-zod").ZodLiteral<"npm">;
+        packageName: import("@frontmcp/lazy-zod").ZodString;
+        exportName: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+        verifyProvenance: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>, import("@frontmcp/lazy-zod").ZodObject<{
+        type: import("@frontmcp/lazy-zod").ZodLiteral<"saas">;
+        endpoint: import("@frontmcp/lazy-zod").ZodString;
+        authToken: import("@frontmcp/lazy-zod").ZodString;
+        expectedAudience: import("@frontmcp/lazy-zod").ZodString;
+        pollIntervalMs: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+        enableWebhook: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+        jwksUrl: import("@frontmcp/lazy-zod").ZodString;
+        expectedIssuer: import("@frontmcp/lazy-zod").ZodString;
+    }, import("zod/v4/core").$strip>], "type">;
+    requireSignature: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    trustedKeys: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodObject<{
+        keyId: import("@frontmcp/lazy-zod").ZodString;
+        alg: import("@frontmcp/lazy-zod").ZodEnum<{
+            RS256: "RS256";
+            EdDSA: "EdDSA";
+        }>;
+        publicKeyPem: import("@frontmcp/lazy-zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+    dev: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    outbound: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodObject<{
+        allowPrivateNetworks: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+        egressProxy: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+        maxConcurrencyPerHost: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+        defaultTimeoutMs: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+        defaultMaxResponseBytes: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodNumber>;
+        allowHttp: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>>;
+    sourceConflictPolicy: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodEnum<{
+        "static-wins": "static-wins";
+        "last-wins": "last-wins";
+        reject: "reject";
+    }>>;
+    bundleCacheDir: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    credentials: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodString>>;
+    exposeOperationsAsInternalTools: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
+    outbound: {
+        allowPrivateNetworks: boolean;
+        maxConcurrencyPerHost: number;
+        defaultTimeoutMs: number;
+        defaultMaxResponseBytes: number;
+        allowHttp: boolean;
+        egressProxy?: string | undefined;
+    };
+    bundleCacheDir: string;
+    source: {
+        type: "static";
+        path: string;
+        watch: boolean;
+    } | {
+        type: "npm";
+        packageName: string;
+        verifyProvenance: boolean;
+        exportName?: string | undefined;
+    } | {
+        type: "saas";
+        endpoint: string;
+        authToken: string;
+        expectedAudience: string;
+        pollIntervalMs: number;
+        enableWebhook: boolean;
+        jwksUrl: string;
+        expectedIssuer: string;
+    };
+    requireSignature: boolean;
+    trustedKeys: {
+        keyId: string;
+        alg: "RS256" | "EdDSA";
+        publicKeyPem: string;
+    }[];
+    dev: boolean;
+    sourceConflictPolicy: "static-wins" | "last-wins" | "reject";
+    exposeOperationsAsInternalTools: boolean;
+    credentials?: Record<string, string> | undefined;
+}, {
+    source: {
+        type: "static";
+        path: string;
+        watch: boolean;
+    } | {
+        type: "npm";
+        packageName: string;
+        verifyProvenance: boolean;
+        exportName?: string | undefined;
+    } | {
+        type: "saas";
+        endpoint: string;
+        authToken: string;
+        expectedAudience: string;
+        pollIntervalMs: number;
+        enableWebhook: boolean;
+        jwksUrl: string;
+        expectedIssuer: string;
+    };
+    requireSignature: boolean;
+    trustedKeys: {
+        keyId: string;
+        alg: "RS256" | "EdDSA";
+        publicKeyPem: string;
+    }[];
+    dev: boolean;
+    outbound: {
+        allowPrivateNetworks: boolean;
+        maxConcurrencyPerHost: number;
+        defaultTimeoutMs: number;
+        defaultMaxResponseBytes: number;
+        allowHttp: boolean;
+        egressProxy?: string | undefined;
+    };
+    sourceConflictPolicy: "static-wins" | "last-wins" | "reject";
+    exposeOperationsAsInternalTools: boolean;
+    bundleCacheDir?: string | undefined;
+    credentials?: Record<string, string> | undefined;
+}>>;
+/** Parsed options with defaults applied — internal plugin use. */
+export type SkilledOpenApiPluginOptions = z.infer<typeof skilledOpenApiPluginOptionsSchema>;
+/** User-facing input shape — defaults are optional. */
+export type SkilledOpenApiPluginOptionsInput = z.input<typeof skilledOpenApiPluginOptionsObjectSchema>;
+//# sourceMappingURL=skilled-openapi.types.d.ts.map

package/skilled-openapi.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skilled-openapi.types.d.ts","sourceRoot":"","sources":["../src/skilled-openapi.types.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAC;AAKvC,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,GACpB,MAAM,2BAA2B,CAAC;AAInC,eAAO,MAAM,qBAAqB;;;;;;;iCAgC9B,CAAC;AAEL,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE,QAAA,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA6D3C,CAAC;AAUH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiB5C,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,uDAAuD;AACvD,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC"}

package/sync/bundle-sync.service.d.ts

@@ -0,0 +1,87 @@
+import { type BundleDiff, type BundleStore, type ResolvedBundle, type SignatureVerifyTelemetry } from '@frontmcp/adapters/skills';
+import { type FrontMcpLogger, type SkillRegistryInterface } from '@frontmcp/sdk';
+import { type HiddenOpRegistry } from '../registry/hidden-op.registry';
+import { type SignatureKey } from '../skilled-openapi.types';
+import { type OperationToolFactory } from '../tools/operation-tool.factory';
+export interface BundleSyncOptions {
+    requireSignature: boolean;
+    trustedKeys: SignatureKey[];
+    /**
+     * Optional telemetry hook for the signature verification path. When
+     * provided, every signature check increments
+     * `frontmcp_skills_signature_verifications_total{status}` and failures
+     * additionally increment `frontmcp_skills_signature_failures_total{reason}`.
+     * Wired by the plugin's DI factory when ObservabilityPlugin is installed;
+     * `undefined` in tests / hosts without observability.
+     */
+    telemetry?: SignatureVerifyTelemetry;
+    /**
+     * When true (default), each operation in the bundle is also registered as
+     * an internal tool (visibility: 'internal') in the SDK's tool registry so
+     * other tools / agents / CodeCall scripts / jobs can compose with it via
+     * `this.callTool(name, args)` from `ExecutionContextBase`. Internal tools
+     * are excluded from `tools/list` and rejected for external `tools/call`.
+     * The existing meta-tools (`search_skill` / `load_skill` / `execute_action`)
+     * are unaffected.
+     */
+    exposeOperationsAsInternalTools: boolean;
+}
+export interface BundleApplyResult {
+    applied: boolean;
+    reason?: string;
+    bundleId: string;
+    bundleVersion: string;
+    diff?: BundleDiff;
+}
+/**
+ * Glue between a `BundleSource` (or any caller producing a `ResolvedBundle`)
+ * and the SkillRegistry / HiddenOpRegistry. Enforces the v1.2 security gates
+ * (signature) and applies the diff atomically.
+ *
+ * Atomicity contract: a bundle either fully applies (every added/changed
+ * skill registered, every removed skill unregistered, hidden-op registry
+ * fully synced) OR the active bundle stays unchanged. Failures emit a
+ * structured `BundleApplyResult` with `applied: false` and a `reason`.
+ *
+ * Listeners can subscribe via the underlying BundleStore for downstream
+ * effects (audit log, OTel attributes, /healthz updates).
+ */
+export declare class BundleSyncService {
+    private readonly skillRegistry;
+    private readonly hiddenOps;
+    private readonly bundleStore;
+    private readonly options;
+    private readonly logger;
+    /**
+     * Optional factory that registers each operation as an internal SDK tool.
+     * Wired by the plugin's DI factory when `exposeOperationsAsInternalTools`
+     * is true and the SDK ToolRegistry is reachable from scope. Absent when
+     * the host opted out OR when the plugin runs in a context without a
+     * tool registry (e.g. unit tests for the sync service in isolation).
+     */
+    private readonly operationToolFactory?;
+    private skillUnregisterByBundleId;
+    constructor(skillRegistry: SkillRegistryInterface, hiddenOps: HiddenOpRegistry, bundleStore: BundleStore, options: BundleSyncOptions, logger: FrontMcpLogger, 
+    /**
+     * Optional factory that registers each operation as an internal SDK tool.
+     * Wired by the plugin's DI factory when `exposeOperationsAsInternalTools`
+     * is true and the SDK ToolRegistry is reachable from scope. Absent when
+     * the host opted out OR when the plugin runs in a context without a
+     * tool registry (e.g. unit tests for the sync service in isolation).
+     */
+    operationToolFactory?: OperationToolFactory | undefined);
+    /**
+     * 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).
+     */
+    apply(bundle: ResolvedBundle): Promise<BundleApplyResult>;
+    /**
+     * 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.
+     */
+    private toSkillContent;
+    private rebuildHiddenOps;
+}
+//# sourceMappingURL=bundle-sync.service.d.ts.map

package/sync/bundle-sync.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-sync.service.d.ts","sourceRoot":"","sources":["../../src/sync/bundle-sync.service.ts"],"names":[],"mappings":"AAEA,OAAO,EASL,KAAK,UAAU,EACf,KAAK,WAAW,EAEhB,KAAK,cAAc,EAEnB,KAAK,wBAAwB,EAC9B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,cAAc,EAAqB,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAEpG,OAAO,EAAsB,KAAK,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAC3F,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAE5E,MAAM,WAAW,iBAAiB;IAChC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,YAAY,EAAE,CAAC;IAC5B;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,wBAAwB,CAAC;IACrC;;;;;;;;OAQG;IACH,+BAA+B,EAAE,OAAO,CAAC;CAC1C;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB;IAI1B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC;IAfxC,OAAO,CAAC,yBAAyB,CAA0C;gBAGxD,aAAa,EAAE,sBAAsB,EACrC,SAAS,EAAE,gBAAgB,EAC3B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,cAAc;IACvC;;;;;;OAMG;IACc,oBAAoB,CAAC,EAAE,oBAAoB,YAAA;IAG9D;;;;OAIG;IACG,KAAK,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAoO/D;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,gBAAgB;CAmCzB"}

package/tools/execute-action.schema.d.ts

@@ -0,0 +1,26 @@
+export declare const executeActionDescription = "Execute one action of a previously loaded skill.\n\nPipeline:\n  1. Resolve (skillId, actionId) \u2192 bundled OpenAPI operation\n  2. Authorize: caller's authInfo is checked against the action's required authorities (if any)\n  3. Validate: the input is validated against the action's inputJsonSchema by the underlying executor\n  4. Outbound: an HTTPS request is built and sent to the service the action belongs to,\n     with credentials injected from the configured vault (never echoed back to you)\n  5. Response: the response body is validated against outputJsonSchema and returned in\n     a structured envelope. Failures (auth, schema, network) are returned as ok:false\n     with a structured error string \u2014 they DO NOT throw.\n\nINPUT: { skillId, actionId, input }\nOUTPUT: { ok, status, data?, contentType?, error? }";
+export declare const executeActionInputSchema: {
+    skillId: import("@frontmcp/lazy-zod").ZodString;
+    actionId: import("@frontmcp/lazy-zod").ZodString;
+    input: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnknown>>;
+};
+export declare const executeActionOutputSchema: {
+    ok: import("@frontmcp/lazy-zod").ZodBoolean;
+    status: import("@frontmcp/lazy-zod").ZodNumber;
+    data: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnknown>;
+    contentType: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    error: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+};
+export type ExecuteActionInput = {
+    skillId: string;
+    actionId: string;
+    input?: Record<string, unknown>;
+};
+export type ExecuteActionOutput = {
+    ok: boolean;
+    status: number;
+    data?: unknown;
+    contentType?: string;
+    error?: string;
+};
+//# sourceMappingURL=execute-action.schema.d.ts.map

package/tools/execute-action.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-action.schema.d.ts","sourceRoot":"","sources":["../../src/tools/execute-action.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB,q0BAae,CAAC;AAErD,eAAO,MAAM,wBAAwB;;;;CAOpC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;CAMrC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}

package/tools/execute-action.tool.d.ts

@@ -0,0 +1,6 @@
+import { ToolContext } from '@frontmcp/sdk';
+import { type ExecuteActionInput, type ExecuteActionOutput } from './execute-action.schema';
+export default class ExecuteActionTool extends ToolContext {
+    execute(input: ExecuteActionInput): Promise<ExecuteActionOutput>;
+}
+//# sourceMappingURL=execute-action.tool.d.ts.map

package/tools/execute-action.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-action.tool.d.ts","sourceRoot":"","sources":["../../src/tools/execute-action.tool.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,WAAW,EAAE,MAAM,eAAe,CAAC;AAQlD,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAC;AAajC,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,WAAW;IAClD,OAAO,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA4RvE"}

package/tools/load-skill.schema.d.ts

@@ -0,0 +1,46 @@
+export declare const loadSkillDescription = "Load the full instructions and executable actions for a specific skill.\n\nUse this AFTER `search_skill` once you've identified the right skill for the\nuser's task. The returned object contains:\n  - `instructions`: markdown the LLM should read carefully before invoking\n  - `actions`: each action's input/output JSON Schema and required authorities\n  - `bundleVersion`: changes when the bundle is hot-swapped (use it to detect drift)\n\nINPUT: { skillId }\nOUTPUT: { skill: { id, name, description, instructions, actions[] }, isComplete }";
+export declare const loadSkillInputSchema: {
+    skillId: import("@frontmcp/lazy-zod").ZodString;
+};
+export declare const loadSkillOutputSchema: {
+    skill: import("@frontmcp/lazy-zod").ZodObject<{
+        id: import("@frontmcp/lazy-zod").ZodString;
+        name: import("@frontmcp/lazy-zod").ZodString;
+        description: import("@frontmcp/lazy-zod").ZodString;
+        instructions: import("@frontmcp/lazy-zod").ZodString;
+        bundleVersion: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+        actions: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodObject<{
+            actionId: import("@frontmcp/lazy-zod").ZodString;
+            summary: import("@frontmcp/lazy-zod").ZodString;
+            description: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+            inputJsonSchema: import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnknown>;
+            outputJsonSchema: import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnknown>;
+            requiredAuthorities: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>>>;
+    }, import("zod/v4/core").$strip>;
+    isComplete: import("@frontmcp/lazy-zod").ZodBoolean;
+    warning: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+};
+export type LoadSkillInput = {
+    skillId: string;
+};
+export type LoadSkillOutput = {
+    skill: {
+        id: string;
+        name: string;
+        description: string;
+        instructions: string;
+        bundleVersion?: string;
+        actions?: Array<{
+            actionId: string;
+            summary: string;
+            description?: string;
+            inputJsonSchema: Record<string, unknown>;
+            outputJsonSchema: Record<string, unknown>;
+            requiredAuthorities?: Record<string, unknown>;
+        }>;
+    };
+    isComplete: boolean;
+    warning?: string;
+};
+//# sourceMappingURL=load-skill.schema.d.ts.map

package/tools/load-skill.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-skill.schema.d.ts","sourceRoot":"","sources":["../../src/tools/load-skill.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,miBASiD,CAAC;AAEnF,eAAO,MAAM,oBAAoB;;CAEhC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;CAsBjC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AACjD,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE;QACL,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,KAAK,CAAC;YACd,QAAQ,EAAE,MAAM,CAAC;YACjB,OAAO,EAAE,MAAM,CAAC;YAChB,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACzC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC1C,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;SAC/C,CAAC,CAAC;KACJ,CAAC;IACF,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/tools/load-skill.tool.d.ts

@@ -0,0 +1,6 @@
+import { ToolContext } from '@frontmcp/sdk';
+import { type LoadSkillInput, type LoadSkillOutput } from './load-skill.schema';
+export default class LoadSkillTool extends ToolContext {
+    execute(input: LoadSkillInput): Promise<LoadSkillOutput>;
+}
+//# sourceMappingURL=load-skill.tool.d.ts.map

package/tools/load-skill.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-skill.tool.d.ts","sourceRoot":"","sources":["../../src/tools/load-skill.tool.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsD,WAAW,EAAE,MAAM,eAAe,CAAC;AAGhG,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAY7B,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW;IAC9C,OAAO,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CA8B/D"}