@frontmcp/sdk 0.7.2 → 0.8.0

package/skill/flows/load-skill.flow.d.ts

@@ -0,0 +1,169 @@
+import { FlowBase, FlowRunOptions } from '../../common';
+import { z } from 'zod';
+import type { SkillLoadResult } from '../skill-storage.interface';
+import type { SkillActivationResult } from '../session/skill-session.types';
+declare const inputSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        method: z.ZodLiteral<"skills/load">;
+        params: z.ZodObject<{
+            skillIds: z.ZodArray<z.ZodString>;
+            format: z.ZodDefault<z.ZodEnum<{
+                full: "full";
+                "instructions-only": "instructions-only";
+            }>>;
+            activateSession: z.ZodDefault<z.ZodBoolean>;
+            policyMode: z.ZodOptional<z.ZodEnum<{
+                strict: "strict";
+                approval: "approval";
+                permissive: "permissive";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    ctx: z.ZodUnknown;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodObject<{
+    skills: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        instructions: z.ZodString;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            purpose: z.ZodOptional<z.ZodString>;
+            available: z.ZodBoolean;
+            inputSchema: z.ZodOptional<z.ZodUnknown>;
+            outputSchema: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+        parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        availableTools: z.ZodArray<z.ZodString>;
+        missingTools: z.ZodArray<z.ZodString>;
+        isComplete: z.ZodBoolean;
+        warning: z.ZodOptional<z.ZodString>;
+        formattedContent: z.ZodString;
+        session: z.ZodOptional<z.ZodObject<{
+            activated: z.ZodBoolean;
+            sessionId: z.ZodOptional<z.ZodString>;
+            policyMode: z.ZodOptional<z.ZodEnum<{
+                strict: "strict";
+                approval: "approval";
+                permissive: "permissive";
+            }>>;
+            allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        totalSkills: z.ZodNumber;
+        totalTools: z.ZodNumber;
+        allToolsAvailable: z.ZodBoolean;
+        combinedWarnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    nextSteps: z.ZodString;
+}, z.core.$strip>;
+interface LoadResultWithActivation {
+    loadResult: SkillLoadResult;
+    activationResult?: SkillActivationResult;
+}
+declare const stateSchema: z.ZodObject<{
+    skillIds: z.ZodArray<z.ZodString>;
+    format: z.ZodEnum<{
+        full: "full";
+        "instructions-only": "instructions-only";
+    }>;
+    activateSession: z.ZodBoolean;
+    policyMode: z.ZodOptional<z.ZodEnum<{
+        strict: "strict";
+        approval: "approval";
+        permissive: "permissive";
+    }>>;
+    loadResults: z.ZodType<LoadResultWithActivation[] | undefined>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    output: z.ZodOptional<z.ZodObject<{
+        skills: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            instructions: z.ZodString;
+            tools: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                purpose: z.ZodOptional<z.ZodString>;
+                available: z.ZodBoolean;
+                inputSchema: z.ZodOptional<z.ZodUnknown>;
+                outputSchema: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>;
+            parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                type: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            availableTools: z.ZodArray<z.ZodString>;
+            missingTools: z.ZodArray<z.ZodString>;
+            isComplete: z.ZodBoolean;
+            warning: z.ZodOptional<z.ZodString>;
+            formattedContent: z.ZodString;
+            session: z.ZodOptional<z.ZodObject<{
+                activated: z.ZodBoolean;
+                sessionId: z.ZodOptional<z.ZodString>;
+                policyMode: z.ZodOptional<z.ZodEnum<{
+                    strict: "strict";
+                    approval: "approval";
+                    permissive: "permissive";
+                }>>;
+                allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        summary: z.ZodObject<{
+            totalSkills: z.ZodNumber;
+            totalTools: z.ZodNumber;
+            allToolsAvailable: z.ZodBoolean;
+            combinedWarnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        nextSteps: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const plan: {
+    readonly pre: ["parseInput"];
+    readonly execute: ["loadSkills", "activateSessions"];
+    readonly finalize: ["finalize"];
+};
+declare global {
+    interface ExtendFlows {
+        'skills:load': FlowRunOptions<LoadSkillFlow, typeof plan, typeof inputSchema, typeof outputSchema, typeof stateSchema>;
+    }
+}
+declare const name: "skills:load";
+/**
+ * Flow for loading one or more skills' full content.
+ *
+ * This flow retrieves skill instructions, tool requirements, and parameters.
+ * Use this after searching for skills to get the detailed workflow guides.
+ *
+ * @example MCP Request
+ * ```json
+ * {
+ *   "method": "skills/load",
+ *   "params": {
+ *     "skillIds": ["review-pr", "suggest-fixes"],
+ *     "format": "full"
+ *   }
+ * }
+ * ```
+ */
+export default class LoadSkillFlow extends FlowBase<typeof name> {
+    logger: import("../../common").FrontMcpLogger;
+    parseInput(): Promise<void>;
+    loadSkills(): Promise<void>;
+    /**
+     * Activate skill sessions for tool authorization enforcement.
+     * This stage only runs if activateSession is true in the input.
+     */
+    activateSessions(): Promise<void>;
+    finalize(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=load-skill.flow.d.ts.map

package/skill/flows/load-skill.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-skill.flow.d.ts","sourceRoot":"","sources":["../../../src/skill/flows/load-skill.flow.ts"],"names":[],"mappings":"AAEA,OAAO,EAAQ,QAAQ,EAAyB,cAAc,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE,OAAO,KAAK,EAAmB,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAI7F,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;iBAoBf,CAAC;AA4CH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAShB,CAAC;AAMH,UAAU,wBAAwB;IAChC,UAAU,EAAE,eAAe,CAAC;IAC5B,gBAAgB,CAAC,EAAE,qBAAqB,CAAC;CAC1C;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;iBAKwB,CAAC,CAAC,OAAO,CAAC,wBAAwB,EAAE,GAAG,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGxF,CAAC;AAEH,QAAA,MAAM,IAAI;;;;CAI2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,aAAa,EAAE,cAAc,CAC3B,aAAa,EACb,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,aAAsB,CAAC;AAGpC;;;;;;;;;;;;;;;;GAgBG;AAQH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAC9D,MAAM,wCAA2C;IAG3C,UAAU;IAkBV,UAAU;IA2BhB;;;OAGG;IAEG,gBAAgB;IA+ChB,QAAQ;CAyJf"}

package/skill/flows/search-skills.flow.d.ts

@@ -0,0 +1,101 @@
+import { FlowBase, FlowRunOptions } from '../../common';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    request: z.ZodObject<{
+        method: z.ZodLiteral<"skills/search">;
+        params: z.ZodObject<{
+            query: z.ZodString;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            requireAllTools: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    ctx: z.ZodUnknown;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodObject<{
+    skills: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        score: z.ZodNumber;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            available: z.ZodBoolean;
+        }, z.core.$strip>>;
+        source: z.ZodEnum<{
+            local: "local";
+            external: "external";
+        }>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+declare const stateSchema: z.ZodObject<{
+    query: z.ZodString;
+    options: z.ZodObject<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        topK: z.ZodOptional<z.ZodNumber>;
+        requireAllTools: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    results: z.ZodArray<z.ZodAny>;
+    output: z.ZodObject<{
+        skills: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            score: z.ZodNumber;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            tools: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                available: z.ZodBoolean;
+            }, z.core.$strip>>;
+            source: z.ZodEnum<{
+                local: "local";
+                external: "external";
+            }>;
+        }, z.core.$strip>>;
+        total: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const plan: {
+    readonly pre: ["parseInput"];
+    readonly execute: ["search"];
+    readonly finalize: ["finalize"];
+};
+declare global {
+    interface ExtendFlows {
+        'skills:search': FlowRunOptions<SearchSkillsFlow, typeof plan, typeof inputSchema, typeof outputSchema, typeof stateSchema>;
+    }
+}
+declare const name: "skills:search";
+/**
+ * Flow for searching skills.
+ *
+ * This flow handles skill discovery by searching through both local
+ * and external skill providers. Results include relevance scores
+ * and tool availability information.
+ *
+ * @example MCP Request
+ * ```json
+ * {
+ *   "method": "skills/search",
+ *   "params": {
+ *     "query": "review pull request",
+ *     "tags": ["github"],
+ *     "limit": 10
+ *   }
+ * }
+ * ```
+ */
+export default class SearchSkillsFlow extends FlowBase<typeof name> {
+    logger: import("../../common").FrontMcpLogger;
+    parseInput(): Promise<void>;
+    search(): Promise<void>;
+    finalize(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=search-skills.flow.d.ts.map

package/skill/flows/search-skills.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-skills.flow.d.ts","sourceRoot":"","sources":["../../../src/skill/flows/search-skills.flow.ts"],"names":[],"mappings":"AAEA,OAAO,EAAQ,QAAQ,EAAyB,cAAc,EAAoB,MAAM,cAAc,CAAC;AACvG,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,QAAA,MAAM,WAAW;;;;;;;;;;;;iBAYf,CAAC;AAGH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;iBAmBhB,CAAC;AAKH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUf,CAAC;AAEH,QAAA,MAAM,IAAI;;;;CAI2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,eAAe,EAAE,cAAc,CAC7B,gBAAgB,EAChB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,eAAwB,CAAC;AAGtC;;;;;;;;;;;;;;;;;;GAkBG;AAQH,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IACjE,MAAM,wCAA8C;IAG9C,UAAU;IAyBV,MAAM;IAoBN,QAAQ;CA6Df"}

package/skill/guards/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tool-authorization.guard';
+//# sourceMappingURL=index.d.ts.map

package/skill/guards/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/skill/guards/index.ts"],"names":[],"mappings":"AAEA,cAAc,4BAA4B,CAAC"}

package/skill/guards/tool-authorization.guard.d.ts

@@ -0,0 +1,87 @@
+import type { FrontMcpLogger } from '../../common';
+import type { SkillSessionManager } from '../session/skill-session.manager';
+import type { ToolAuthorizationResult, SkillPolicyMode } from '../session/skill-session.types';
+/**
+ * Options for the ToolAuthorizationGuard.
+ */
+export interface ToolAuthorizationGuardOptions {
+    /**
+     * Whether to throw an error when a tool is not allowed.
+     * If false, returns the authorization result without throwing.
+     * @default true
+     */
+    throwOnDenied?: boolean;
+    /**
+     * Callback for handling approval requests.
+     * Called when policyMode is 'approval' and tool is not in allowlist.
+     */
+    onApprovalRequired?: (toolName: string, skillId: string | undefined) => Promise<boolean>;
+    /**
+     * Callback for logging tool authorization attempts.
+     */
+    onAuthorizationCheck?: (result: ToolAuthorizationResult) => void;
+}
+/**
+ * Guard that checks tool authorization against the active skill session.
+ *
+ * This guard is used to enforce tool allowlists defined by skills.
+ * It integrates with the SkillSessionManager to check if a tool
+ * is authorized for the current skill session.
+ *
+ * @example
+ * ```typescript
+ * const guard = new ToolAuthorizationGuard(sessionManager, logger);
+ *
+ * // Before executing a tool
+ * await guard.check('github_get_pr');  // Throws if not allowed in strict mode
+ *
+ * // Or get the result without throwing
+ * const result = await guard.check('github_get_pr', { throwOnDenied: false });
+ * if (!result.allowed) {
+ *   // Handle denial
+ * }
+ * ```
+ */
+export declare class ToolAuthorizationGuard {
+    private readonly sessionManager;
+    private readonly logger?;
+    private readonly defaultOptions;
+    constructor(sessionManager: SkillSessionManager, logger?: FrontMcpLogger, options?: ToolAuthorizationGuardOptions);
+    /**
+     * Check if a tool is authorized for the current skill session.
+     *
+     * @param toolName - Name of the tool to check
+     * @param options - Override options for this check
+     * @returns Authorization result
+     * @throws ToolNotAllowedError if tool is not allowed and throwOnDenied is true
+     * @throws ToolApprovalRequiredError if approval is required and not granted
+     */
+    check(toolName: string, options?: ToolAuthorizationGuardOptions): Promise<ToolAuthorizationResult>;
+    /**
+     * Check authorization and return a simple boolean.
+     * Does not throw errors.
+     */
+    isAllowed(toolName: string): Promise<boolean>;
+    /**
+     * Get the current policy mode.
+     */
+    getPolicyMode(): SkillPolicyMode;
+    /**
+     * Check if there's an active skill session.
+     */
+    hasActiveSkill(): boolean;
+    /**
+     * Get the tool allowlist for the current skill.
+     */
+    getAllowlist(): string[];
+    /**
+     * Approve a tool for the current session.
+     * Used when handling manual approval flows.
+     */
+    approveTool(toolName: string): void;
+    /**
+     * Deny a tool for the current session.
+     */
+    denyTool(toolName: string): void;
+}
+//# sourceMappingURL=tool-authorization.guard.d.ts.map

package/skill/guards/tool-authorization.guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-authorization.guard.d.ts","sourceRoot":"","sources":["../../../src/skill/guards/tool-authorization.guard.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,KAAK,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAG/F;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAEzF;;OAEG;IACH,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,CAAC;CAClE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsB;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgC;gBAEnD,cAAc,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,6BAA6B;IASjH;;;;;;;;OAQG;IACG,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,6BAA6B,GAAG,OAAO,CAAC,uBAAuB,CAAC;IA0DxG;;;OAGG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKnD;;OAEG;IACH,aAAa,IAAI,eAAe;IAIhC;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAKnC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAIjC"}

package/skill/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { createSkillToolGuardHook, type SkillToolGuardHookOptions, type SkillToolGuardHookClass, } from './skill-tool.hook';
+//# sourceMappingURL=index.d.ts.map

package/skill/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/skill/hooks/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,wBAAwB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,GAC7B,MAAM,mBAAmB,CAAC"}

package/skill/hooks/skill-tool.hook.d.ts

@@ -0,0 +1,52 @@
+import { type FrontMcpLogger } from '../../common';
+import type { SkillSessionManager } from '../session/skill-session.manager';
+/**
+ * Options for configuring the SkillToolGuardHook.
+ */
+export interface SkillToolGuardHookOptions {
+    /**
+     * Logger instance for debugging and audit logging.
+     */
+    logger?: FrontMcpLogger;
+    /**
+     * Callback invoked when tool approval is required in 'approval' mode.
+     * Should return true if approved, false if denied.
+     * If not provided, ToolApprovalRequiredError will be thrown.
+     */
+    onApprovalRequired?: (toolName: string, skillId: string) => Promise<boolean>;
+    /**
+     * Whether to track tool calls for rate limiting.
+     * @default true
+     */
+    trackToolCalls?: boolean;
+}
+/**
+ * Base interface for the skill tool guard hook class.
+ */
+export interface SkillToolGuardHookClass {
+    new (): {
+        checkSkillToolAuthorization(): Promise<void>;
+    };
+}
+/**
+ * Creates a skill-based tool authorization guard hook.
+ *
+ * This hook integrates with the call-tool flow to enforce tool allowlists
+ * when a skill is active. It runs BEFORE the existing checkToolAuthorization
+ * stage to provide skill-level security.
+ *
+ * @example
+ * ```typescript
+ * const sessionManager = new SkillSessionManager({ defaultPolicyMode: 'strict' });
+ * const hook = createSkillToolGuardHook(sessionManager, { logger });
+ *
+ * // Register with hook registry
+ * scope.hooks.register(hook);
+ * ```
+ *
+ * @param sessionManager - The skill session manager instance
+ * @param options - Configuration options
+ * @returns Hook class that can be registered with the hook registry
+ */
+export declare function createSkillToolGuardHook(sessionManager: SkillSessionManager, options?: SkillToolGuardHookOptions): SkillToolGuardHookClass;
+//# sourceMappingURL=skill-tool.hook.d.ts.map

package/skill/hooks/skill-tool.hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-tool.hook.d.ts","sourceRoot":"","sources":["../../../src/skill/hooks/skill-tool.hook.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAEhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAK5E;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;IAExB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7E;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAaD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ;QAAE,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;CAC1D;AA8DD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,mBAAmB,EACnC,OAAO,GAAE,yBAA8B,GACtC,uBAAuB,CA8EzB"}

package/skill/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Skills Module
+ *
+ * Skills are modular knowledge/workflow packages that teach AI how to perform
+ * multi-step tasks using tools. Unlike tools (individual actions), skills are
+ * recipes/playbooks that combine tools into coherent workflows.
+ *
+ * @example Defining a skill with decorator
+ * ```typescript
+ * @Skill({
+ *   name: 'review-pr',
+ *   description: 'Review a GitHub pull request',
+ *   instructions: `
+ *     1. Fetch the PR details using github_get_pr
+ *     2. Review each changed file...
+ *   `,
+ *   tools: ['github_get_pr', 'github_add_comment'],
+ * })
+ * class ReviewPRSkill extends SkillContext { ... }
+ * ```
+ *
+ * @example Defining a skill with helper
+ * ```typescript
+ * const deploySkill = skill({
+ *   name: 'deploy-app',
+ *   description: 'Deploy application to production',
+ *   instructions: { file: './skills/deploy.md' },
+ *   tools: ['docker_build', 'k8s_apply'],
+ * });
+ * ```
+ *
+ * @module skill
+ */
+export { default as SkillRegistry } from './skill.registry';
+export type { SkillRegistryInterface, IndexedSkill, SkillRegistryOptions, GetSkillsOptions } from './skill.registry';
+export { SkillInstance, createSkillInstance } from './skill.instance';
+export { SkillEmitter } from './skill.events';
+export type { SkillChangeEvent, SkillChangeKind, SkillChangeScope } from './skill.events';
+export type { SkillStorageProvider, SkillStorageProviderType, SkillSearchOptions, SkillSearchResult, SkillLoadResult, SkillListOptions, SkillListResult, MutableSkillStorageProvider, } from './skill-storage.interface';
+export { MemorySkillProvider } from './providers/memory-skill.provider';
+export type { MemorySkillProviderOptions } from './providers/memory-skill.provider';
+export { ExternalSkillProviderBase } from './providers/external-skill.provider';
+export type { ExternalSkillMode, ExternalSkillProviderOptions, ExternalSkillSearchOptions, ExternalSkillListOptions, } from './providers/external-skill.provider';
+export { SkillToolValidator } from './skill-validator';
+export type { ToolValidationResult } from './skill-validator';
+export { createSkillStorageProvider, createMemorySkillProvider } from './skill-storage.factory';
+export type { SkillStorageFactoryOptions, SkillStorageFactoryResult, VectorDBSkillProviderOptions, ExternalSkillProviderConfig, ExtendedSkillStorageFactoryResult, } from './skill-storage.factory';
+export { computeSkillHash, computeSkillHashComponents, areSkillsEqual, createEmptySyncState, serializeSyncState, deserializeSyncState, MemorySyncStateStore, } from './sync';
+export type { SkillHashComponents, SkillSyncStatus, SkillSyncEntry, SkillSyncState, SerializedSkillSyncState, SkillSyncStateStore, SyncResult, } from './sync';
+export { normalizeSkill, isSkillRecord, skillDiscoveryDeps, collectSkillMetadata, loadInstructions, buildSkillContent, formatSkillForLLM, } from './skill.utils';
+export { formatSkillsForLlmCompact, formatSkillsForLlmFull, formatSkillForLLMWithSchemas, skillToApiResponse, filterSkillsByVisibility, } from './skill-http.utils';
+export type { CompactSkillSummary } from './skill-http.utils';
+export { SearchSkillsFlow, LoadSkillFlow } from './flows';
+export { SearchSkillsTool, LoadSkillsTool, LoadSkillTool, getSkillTools } from './tools';
+export { SkillSessionManager } from './session/skill-session.manager';
+export { MemorySkillSessionStore, createSkillSessionStore } from './session/skill-session-store.interface';
+export type { SkillSessionStore } from './session/skill-session-store.interface';
+export { serializeSessionState, deserializeSessionState, createEmptySessionState } from './session/skill-session.types';
+export type { SkillSessionState, SkillSessionOptions, SkillActivationResult, ToolAuthorizationResult, SkillSessionEvent, SkillSecurityPolicy, SkillPolicyMode, SerializedSkillSessionState, } from './session/skill-session.types';
+export { ToolAuthorizationGuard } from './guards/tool-authorization.guard';
+export type { ToolAuthorizationGuardOptions } from './guards/tool-authorization.guard';
+export { createSkillToolGuardHook, type SkillToolGuardHookOptions, type SkillToolGuardHookClass } from './hooks';
+export { ToolNotAllowedError, ToolApprovalRequiredError } from './errors/tool-not-allowed.error';
+export { SkillValidationError } from './errors/skill-validation.error';
+export type { SkillValidationResult, SkillValidationReport } from './errors/skill-validation.error';
+export { registerSkillCapabilities } from './skill-scope.helper';
+export type { SkillScopeRegistrationOptions } from './skill-scope.helper';
+export { detectSkillsOnlyMode, isSkillsOnlySession } from './skill-mode.utils';
+export type { SkillsOnlySessionPayload } from './skill-mode.utils';
+export { SkillHttpAuthValidator, createSkillHttpAuthValidator } from './auth';
+export type { SkillHttpAuthContext, SkillHttpAuthResult, SkillHttpAuthValidatorOptions } from './auth';
+export { SkillHttpCache, MemorySkillHttpCache, RedisSkillHttpCache, createSkillHttpCache, getSkillHttpCache, invalidateScopeCache, invalidateSkillInCache, disposeAllCaches, } from './cache';
+export type { SkillHttpCacheOptions, SkillHttpCacheResult } from './cache';
+//# sourceMappingURL=index.d.ts.map

package/skill/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/skill/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC5D,YAAY,EAAE,sBAAsB,EAAE,YAAY,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGrH,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGtE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAG1F,YAAY,EACV,oBAAoB,EACpB,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,2BAA2B,GAC5B,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,YAAY,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAChF,YAAY,EACV,iBAAiB,EACjB,4BAA4B,EAC5B,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAG9D,OAAO,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAChG,YAAY,EACV,0BAA0B,EAC1B,yBAAyB,EACzB,4BAA4B,EAC5B,2BAA2B,EAC3B,iCAAiC,GAClC,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,QAAQ,CAAC;AAChB,YAAY,EACV,mBAAmB,EACnB,eAAe,EACf,cAAc,EACd,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,UAAU,GACX,MAAM,QAAQ,CAAC;AAGhB,OAAO,EACL,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,yBAAyB,EACzB,sBAAsB,EACtB,4BAA4B,EAC5B,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG9D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG1D,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGzF,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAC3G,YAAY,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxH,YAAY,EACV,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,2BAA2B,GAC5B,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,YAAY,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAGvF,OAAO,EAAE,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,KAAK,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAGjH,OAAO,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjG,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,YAAY,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGpG,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,YAAY,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAG1E,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAGnE,OAAO,EAAE,sBAAsB,EAAE,4BAA4B,EAAE,MAAM,QAAQ,CAAC;AAC9E,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,6BAA6B,EAAE,MAAM,QAAQ,CAAC;AAGvG,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC"}