@chatbotkit/agent 1.26.3 → 1.27.0

package/README.md

@@ -9,6 +9,20 @@
 
 Build autonomous AI agents that can use custom tools and execute complex tasks with the full power of the ChatBotKit platform.
 
+## Why ChatBotKit?
+
+**Build lighter, future-proof AI agents.** When you build with ChatBotKit, the heavy lifting happens on our servers—not in your application. This architectural advantage delivers:
+
+- 🪶 **Lightweight Agents**: Your agents stay lean because complex AI processing, model orchestration, and tool execution happen server-side. Less code in your app means faster load times and simpler maintenance.
+
+- 🛡️ **Robust & Streamlined**: Server-side processing provides a more reliable experience with built-in error handling, automatic retries, and consistent behavior across all platforms.
+
+- 🔄 **Backward & Forward Compatible**: As AI technology evolves—new models, new capabilities, new paradigms—your agents automatically benefit. No code changes required on your end.
+
+- 🔮 **Future-Proof**: Agents you build today will remain capable tomorrow. When we add support for new AI models or capabilities, your existing agents gain those powers without any updates to your codebase.
+
+This means you can focus on building great user experiences while ChatBotKit handles the complexity of the ever-changing AI landscape.
+
 ## Installation
 
 ```bash
@@ -178,6 +192,59 @@ The `execute` mode provides system tools for task management:
 - **`progress`** - Track completion status and blockers
 - **`exit`** - Signal task completion with status code
 
+### Skills Loading
+
+Load skills from local directories and pass them as a feature to the agent. Skills are defined using `SKILL.md` files with front matter containing name and description.
+
+```javascript
+import { execute, loadSkills, createSkillsFeature } from '@chatbotkit/agent'
+import { ChatBotKit } from '@chatbotkit/sdk'
+
+const client = new ChatBotKit({ secret: process.env.CHATBOTKIT_API_TOKEN })
+
+// Load skills from directories
+const skillsResult = await loadSkills(['./skills'], { watch: true })
+
+// Create the skills feature for the API
+const skillsFeature = createSkillsFeature(skillsResult.skills)
+
+const stream = execute({
+  client,
+  model: 'gpt-4o',
+  messages: [{ type: 'user', text: 'Help me with my task' }],
+  extensions: {
+    features: [skillsFeature],
+  },
+})
+
+for await (const event of stream) {
+  // Handle events
+}
+
+// Clean up when done
+skillsResult.close()
+```
+
+#### SKILL.md Format
+
+Create a `SKILL.md` file in each skill directory:
+
+```markdown
+---
+name: My Skill
+description: A brief description of what this skill does
+---
+
+# My Skill
+
+Additional documentation for the skill...
+```
+
+#### Skills API
+
+- **`loadSkills(directories, options)`** - Load skills from directories containing SKILL.md files
+- **`createSkillsFeature(skills)`** - Create a feature configuration for the API
+
 ## Documentation
 
 For comprehensive information about the ChatBotKit Agent SDK, including detailed documentation on its functionalities, helper methods, and configuration options, please visit our [type documentation page](https://chatbotkit.github.io/node-sdk/modules/_chatbotkit_agent.html).

package/dist/cjs/agent.cjs

@@ -5,7 +5,7 @@ exports.execute = execute;
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 async function* complete(options) {
-    const { client, tools, ...request } = options;
+    const { client, tools, abortSignal, ...request } = options;
     const channelToTool = new Map();
     const functions = tools
         ? Object.entries(tools).map(([name, tool]) => {
@@ -47,10 +47,13 @@ async function* complete(options) {
         .complete(null, {
         ...request,
         functions,
+        limits: {
+            iterations: 1,
+        },
     })
-        .stream();
+        .stream({ abortSignal });
     const toolEventQueue = [];
-    const runningTools = new Set();
+    const runningToolPromises = [];
     const executeToolAsync = async (channel, name, tool, args) => {
         try {
             let parsedArgs = args;
@@ -88,11 +91,11 @@ async function* complete(options) {
                 message: { error: errorMessage },
             });
         }
-        finally {
-            runningTools.delete(channel);
-        }
     };
     for await (const event of stream) {
+        if (abortSignal?.aborted) {
+            break;
+        }
         while (toolEventQueue.length > 0) {
             const toolEvent = toolEventQueue.shift();
             if (toolEvent) {
@@ -116,9 +119,7 @@ async function* complete(options) {
                     },
                 };
                 const toolPromise = executeToolAsync(channel, name, tool, args);
-                runningTools.add(channel);
-                toolPromise.catch(() => {
-                });
+                runningToolPromises.push(toolPromise);
             }
         }
         yield event;
@@ -129,8 +130,8 @@ async function* complete(options) {
             yield toolEvent;
         }
     }
-    while (runningTools.size > 0) {
-        await new Promise((resolve) => setTimeout(resolve, 10));
+    if (runningToolPromises.length > 0) {
+        await Promise.allSettled(runningToolPromises);
         while (toolEventQueue.length > 0) {
             const toolEvent = toolEventQueue.shift();
             if (toolEvent) {
@@ -140,9 +141,10 @@ async function* complete(options) {
     }
 }
 async function* execute(options) {
-    const { client, tools = {}, maxIterations = 50, ...request } = options;
-    const messages = [...(request.messages || [])];
+    const { client, tools = {}, maxIterations = 100, abortSignal, ...request } = options;
+    const messages = request.messages || [];
     let exitResult = null;
+    let internalAbort = null;
     const systemTools = {
         plan: {
             description: 'Create or update a plan for approaching the task. Break down the task into clear, actionable steps. Use this at the start and whenever you need to revise your approach.',
@@ -209,8 +211,29 @@ async function* execute(options) {
                 };
             },
         },
+        abort: {
+            description: 'Immediately abort the current task. Use this when the user explicitly asks you to stop, cancel, or abort what you are doing. Set hard to true to kill running processes immediately.',
+            input: zod_1.z.object({
+                reason: zod_1.z.string().optional().describe('Brief reason for aborting'),
+                hard: zod_1.z
+                    .boolean()
+                    .optional()
+                    .describe('If true, immediately kill running processes. If false (default), finish the current operation gracefully.'),
+            }),
+            handler: async (input) => {
+                const reason = input.reason || 'aborted by user request';
+                exitResult = { code: 1, message: reason };
+                if (input.hard && internalAbort) {
+                    internalAbort.abort(reason);
+                }
+                return {
+                    success: true,
+                    message: `Task aborted: ${reason}`,
+                };
+            },
+        },
     };
-    const allTools = { ...systemTools, ...tools };
+    const allTools = { ...tools, ...systemTools };
     const systemInstruction = `
 ${options.extensions?.backstory || ''}
 
@@ -222,31 +245,58 @@ The goal is to complete the assigned task efficiently and effectively. Follow th
 2. **Track Progress**: Regularly use the 'progress' function to update status and identify issues
 3. **Use Tools**: Leverage available tools to accomplish each step of your plan
 4. **Exit When Done**: Call the 'exit' function with code 0 when successful, or non-zero code if unable to complete
-5. **Be Autonomous**: Work through the task systematically without waiting for additional input
+5. **Abort**: If the user asks you to stop, cancel, or abort, call the 'abort' function immediately. Use hard=true if processes are running that need to be killed right away.
+6. **Be Autonomous**: Work through the task systematically without waiting for additional input
+7. **Be Responsive**: If the user sends a new message while you are working, acknowledge it briefly and adjust your approach if needed. Always prioritize user input over your current plan.
 `.trim();
     let iteration = 0;
     while (iteration < maxIterations && exitResult === null) {
+        if (abortSignal?.aborted) {
+            exitResult = {
+                code: 1,
+                message: 'Task execution aborted',
+            };
+            break;
+        }
         iteration++;
         yield { type: 'iteration', data: { iteration } };
+        let lastEndReason = null;
+        internalAbort = new AbortController();
+        if (abortSignal?.aborted) {
+            internalAbort.abort(abortSignal.reason);
+        }
+        else if (abortSignal) {
+            const capturedAbort = internalAbort;
+            abortSignal.addEventListener('abort', () => capturedAbort.abort(abortSignal.reason), { once: true });
+        }
+        const iterSignal = internalAbort.signal;
         for await (const event of complete({
             ...request,
             client,
             messages,
             tools: allTools,
+            abortSignal: iterSignal,
             extensions: {
                 ...options.extensions,
                 backstory: systemInstruction,
             },
         })) {
+            if (event.type === 'message') {
+                messages.push(event.data);
+            }
+            if (event.type === 'result') {
+                if (event.data.end.reason) {
+                    lastEndReason = event.data.end.reason;
+                }
+            }
             yield event;
         }
         if (exitResult) {
             break;
         }
-        messages.push({
-            type: 'user',
-            text: 'Continue with the next step of your plan. If all steps are complete, call exit with the appropriate status code.',
-        });
+        if (lastEndReason === 'stop') {
+            break;
+        }
     }
     if (exitResult === null) {
         exitResult = {

package/dist/cjs/agent.d.ts

@@ -1,11 +1,13 @@
-export function complete(options: ConversationCompleteRequest & {
+export function complete(options: Omit<ConversationCompleteRequest, "functions" | "limits"> & {
     client: ChatBotKit;
     tools?: Tools;
+    abortSignal?: AbortSignal;
 }): AsyncGenerator<ConversationCompleteStreamType | ToolCallStartEvent | ToolCallEndEvent | ToolCallErrorEvent, void, unknown>;
-export function execute(options: ConversationCompleteRequest & {
+export function execute(options: Omit<ConversationCompleteRequest, "functions" | "limits"> & {
     client: ChatBotKit;
     tools?: Tools;
     maxIterations?: number;
+    abortSignal?: AbortSignal;
 }): AsyncGenerator<ConversationCompleteStreamType | ToolCallStartEvent | ToolCallEndEvent | ToolCallErrorEvent | IterationEvent | ExitEvent, void, unknown>;
 export type ZodObject = import("zod").ZodObject<any>;
 export type ChatBotKit = import("@chatbotkit/sdk").ChatBotKit;

package/dist/cjs/index.cjs

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tools = exports.execute = exports.complete = void 0;
+exports.createSkillsFeature = exports.loadSkills = exports.tools = exports.execute = exports.complete = void 0;
 var agent_js_1 = require("./agent.cjs");
 Object.defineProperty(exports, "complete", { enumerable: true, get: function () { return agent_js_1.complete; } });
 Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return agent_js_1.execute; } });
 var tools_js_1 = require("./tools.cjs");
 Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_js_1.tools; } });
+var skills_js_1 = require("./skills.cjs");
+Object.defineProperty(exports, "loadSkills", { enumerable: true, get: function () { return skills_js_1.loadSkills; } });
+Object.defineProperty(exports, "createSkillsFeature", { enumerable: true, get: function () { return skills_js_1.createSkillsFeature; } });

package/dist/cjs/index.d.ts

@@ -1,2 +1,3 @@
 export { tools } from "./tools.js";
 export { complete, execute } from "./agent.js";
+export { loadSkills, createSkillsFeature } from "./skills.js";

package/dist/cjs/skills.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSkills = loadSkills;
+exports.createSkillsFeature = createSkillsFeature;
+const tslib_1 = require("tslib");
+const promises_1 = require("fs/promises");
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+const path_1 = require("path");
+function parseFrontMatter(content) {
+    const frontMatterRegex = /^---\s*\n([\s\S]*?)\n---/;
+    const match = content.match(frontMatterRegex);
+    if (!match) {
+        return {};
+    }
+    try {
+        const frontMatter = match[1];
+        const parsed = (js_yaml_1.default.load(frontMatter));
+        if (typeof parsed !== 'object' || parsed === null) {
+            return {};
+        }
+        return {
+            name: typeof parsed.name === 'string' ? parsed.name : undefined,
+            description: typeof parsed.description === 'string' ? parsed.description : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+async function loadSkillFromDirectory(skillDir) {
+    const skillFilePath = (0, path_1.join)(skillDir, 'SKILL.md');
+    try {
+        const content = await (0, promises_1.readFile)(skillFilePath, 'utf-8');
+        const { name, description } = parseFrontMatter(content);
+        if (!name || !description) {
+            return null;
+        }
+        return {
+            name,
+            description,
+            path: (0, path_1.resolve)(skillDir),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function loadSkills(directories, options = {}) {
+    const skills = ([]);
+    const watchControllers = ([]);
+    async function scanDirectory(baseDir) {
+        try {
+            const entries = await (0, promises_1.readdir)(baseDir);
+            for (const entry of entries) {
+                const entryPath = (0, path_1.join)(baseDir, entry);
+                const entryStat = await (0, promises_1.stat)(entryPath);
+                if (entryStat.isDirectory()) {
+                    const skill = await loadSkillFromDirectory(entryPath);
+                    if (skill) {
+                        const existingIdx = skills.findIndex((s) => s.path === skill.path);
+                        if (existingIdx !== -1) {
+                            skills[existingIdx] = skill;
+                        }
+                        else {
+                            skills.push(skill);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
+    for (const dir of directories) {
+        await scanDirectory(dir);
+    }
+    if (options.watch) {
+        for (const dir of directories) {
+            const controller = new AbortController();
+            watchControllers.push(controller);
+            (async () => {
+                try {
+                    const watcher = (0, promises_1.watch)(dir, {
+                        recursive: true,
+                        signal: controller.signal,
+                    });
+                    for await (const event of watcher) {
+                        if (event.filename?.endsWith('SKILL.md')) {
+                            await scanDirectory(dir);
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err instanceof Error &&
+                        err.name !== 'AbortError' &&
+                        !err.message.includes('AbortError')) {
+                    }
+                }
+            })();
+        }
+    }
+    return {
+        skills,
+        close: () => {
+            for (const controller of watchControllers) {
+                controller.abort();
+            }
+        },
+    };
+}
+function createSkillsFeature(skills) {
+    return {
+        name: ('skills'),
+        options: { skills },
+    };
+}

package/dist/cjs/skills.d.ts

@@ -0,0 +1,18 @@
+export function loadSkills(directories: string[], options?: {
+    watch?: boolean;
+}): Promise<SkillsResult>;
+export function createSkillsFeature(skills: SkillDefinition[]): {
+    name: "skills";
+    options: {
+        skills: SkillDefinition[];
+    };
+};
+export type SkillDefinition = {
+    name: string;
+    description: string;
+    path: string;
+};
+export type SkillsResult = {
+    skills: SkillDefinition[];
+    close: () => void;
+};

package/dist/esm/agent.d.ts

@@ -1,11 +1,13 @@
-export function complete(options: ConversationCompleteRequest & {
+export function complete(options: Omit<ConversationCompleteRequest, "functions" | "limits"> & {
     client: ChatBotKit;
     tools?: Tools;
+    abortSignal?: AbortSignal;
 }): AsyncGenerator<ConversationCompleteStreamType | ToolCallStartEvent | ToolCallEndEvent | ToolCallErrorEvent, void, unknown>;
-export function execute(options: ConversationCompleteRequest & {
+export function execute(options: Omit<ConversationCompleteRequest, "functions" | "limits"> & {
     client: ChatBotKit;
     tools?: Tools;
     maxIterations?: number;
+    abortSignal?: AbortSignal;
 }): AsyncGenerator<ConversationCompleteStreamType | ToolCallStartEvent | ToolCallEndEvent | ToolCallErrorEvent | IterationEvent | ExitEvent, void, unknown>;
 export type ZodObject = import("zod").ZodObject<any>;
 export type ChatBotKit = import("@chatbotkit/sdk").ChatBotKit;

package/dist/esm/agent.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 export async function* complete(options) {
-    const { client, tools, ...request } = options;
+    const { client, tools, abortSignal, ...request } = options;
     const channelToTool = new Map();
     const functions = tools
         ? Object.entries(tools).map(([name, tool]) => {
@@ -43,10 +43,13 @@ export async function* complete(options) {
         .complete(null, {
         ...request,
         functions,
+        limits: {
+            iterations: 1,
+        },
     })
-        .stream();
+        .stream({ abortSignal });
     const toolEventQueue = [];
-    const runningTools = new Set();
+    const runningToolPromises = [];
     const executeToolAsync = async (channel, name, tool, args) => {
         try {
             let parsedArgs = args;
@@ -84,11 +87,11 @@ export async function* complete(options) {
                 message: { error: errorMessage },
             });
         }
-        finally {
-            runningTools.delete(channel);
-        }
     };
     for await (const event of stream) {
+        if (abortSignal?.aborted) {
+            break;
+        }
         while (toolEventQueue.length > 0) {
             const toolEvent = toolEventQueue.shift();
             if (toolEvent) {
@@ -112,9 +115,7 @@ export async function* complete(options) {
                     },
                 };
                 const toolPromise = executeToolAsync(channel, name, tool, args);
-                runningTools.add(channel);
-                toolPromise.catch(() => {
-                });
+                runningToolPromises.push(toolPromise);
             }
         }
         yield event;
@@ -125,8 +126,8 @@ export async function* complete(options) {
             yield toolEvent;
         }
     }
-    while (runningTools.size > 0) {
-        await new Promise((resolve) => setTimeout(resolve, 10));
+    if (runningToolPromises.length > 0) {
+        await Promise.allSettled(runningToolPromises);
         while (toolEventQueue.length > 0) {
             const toolEvent = toolEventQueue.shift();
             if (toolEvent) {
@@ -136,9 +137,10 @@ export async function* complete(options) {
     }
 }
 export async function* execute(options) {
-    const { client, tools = {}, maxIterations = 50, ...request } = options;
-    const messages = [...(request.messages || [])];
+    const { client, tools = {}, maxIterations = 100, abortSignal, ...request } = options;
+    const messages = request.messages || [];
     let exitResult = null;
+    let internalAbort = null;
     const systemTools = {
         plan: {
             description: 'Create or update a plan for approaching the task. Break down the task into clear, actionable steps. Use this at the start and whenever you need to revise your approach.',
@@ -205,8 +207,29 @@ export async function* execute(options) {
                 };
             },
         },
+        abort: {
+            description: 'Immediately abort the current task. Use this when the user explicitly asks you to stop, cancel, or abort what you are doing. Set hard to true to kill running processes immediately.',
+            input: z.object({
+                reason: z.string().optional().describe('Brief reason for aborting'),
+                hard: z
+                    .boolean()
+                    .optional()
+                    .describe('If true, immediately kill running processes. If false (default), finish the current operation gracefully.'),
+            }),
+            handler: async (input) => {
+                const reason = input.reason || 'aborted by user request';
+                exitResult = { code: 1, message: reason };
+                if (input.hard && internalAbort) {
+                    internalAbort.abort(reason);
+                }
+                return {
+                    success: true,
+                    message: `Task aborted: ${reason}`,
+                };
+            },
+        },
     };
-    const allTools = { ...systemTools, ...tools };
+    const allTools = { ...tools, ...systemTools };
     const systemInstruction = `
 ${options.extensions?.backstory || ''}
 
@@ -218,31 +241,58 @@ The goal is to complete the assigned task efficiently and effectively. Follow th
 2. **Track Progress**: Regularly use the 'progress' function to update status and identify issues
 3. **Use Tools**: Leverage available tools to accomplish each step of your plan
 4. **Exit When Done**: Call the 'exit' function with code 0 when successful, or non-zero code if unable to complete
-5. **Be Autonomous**: Work through the task systematically without waiting for additional input
+5. **Abort**: If the user asks you to stop, cancel, or abort, call the 'abort' function immediately. Use hard=true if processes are running that need to be killed right away.
+6. **Be Autonomous**: Work through the task systematically without waiting for additional input
+7. **Be Responsive**: If the user sends a new message while you are working, acknowledge it briefly and adjust your approach if needed. Always prioritize user input over your current plan.
 `.trim();
     let iteration = 0;
     while (iteration < maxIterations && exitResult === null) {
+        if (abortSignal?.aborted) {
+            exitResult = {
+                code: 1,
+                message: 'Task execution aborted',
+            };
+            break;
+        }
         iteration++;
         yield { type: 'iteration', data: { iteration } };
+        let lastEndReason = null;
+        internalAbort = new AbortController();
+        if (abortSignal?.aborted) {
+            internalAbort.abort(abortSignal.reason);
+        }
+        else if (abortSignal) {
+            const capturedAbort = internalAbort;
+            abortSignal.addEventListener('abort', () => capturedAbort.abort(abortSignal.reason), { once: true });
+        }
+        const iterSignal = internalAbort.signal;
         for await (const event of complete({
             ...request,
             client,
             messages,
             tools: allTools,
+            abortSignal: iterSignal,
             extensions: {
                 ...options.extensions,
                 backstory: systemInstruction,
             },
         })) {
+            if (event.type === 'message') {
+                messages.push(event.data);
+            }
+            if (event.type === 'result') {
+                if (event.data.end.reason) {
+                    lastEndReason = event.data.end.reason;
+                }
+            }
             yield event;
         }
         if (exitResult) {
             break;
         }
-        messages.push({
-            type: 'user',
-            text: 'Continue with the next step of your plan. If all steps are complete, call exit with the appropriate status code.',
-        });
+        if (lastEndReason === 'stop') {
+            break;
+        }
     }
     if (exitResult === null) {
         exitResult = {

package/dist/esm/index.d.ts

@@ -1,2 +1,3 @@
 export { tools } from "./tools.js";
 export { complete, execute } from "./agent.js";
+export { loadSkills, createSkillsFeature } from "./skills.js";

package/dist/esm/index.js

@@ -1,2 +1,3 @@
 export { complete, execute } from './agent.js';
 export { tools } from './tools.js';
+export { loadSkills, createSkillsFeature } from './skills.js';

package/dist/esm/skills.d.ts

@@ -0,0 +1,18 @@
+export function loadSkills(directories: string[], options?: {
+    watch?: boolean;
+}): Promise<SkillsResult>;
+export function createSkillsFeature(skills: SkillDefinition[]): {
+    name: "skills";
+    options: {
+        skills: SkillDefinition[];
+    };
+};
+export type SkillDefinition = {
+    name: string;
+    description: string;
+    path: string;
+};
+export type SkillsResult = {
+    skills: SkillDefinition[];
+    close: () => void;
+};

package/dist/esm/skills.js

@@ -0,0 +1,111 @@
+import { readFile, readdir, stat, watch } from 'fs/promises';
+import yaml from 'js-yaml';
+import { join, resolve } from 'path';
+function parseFrontMatter(content) {
+    const frontMatterRegex = /^---\s*\n([\s\S]*?)\n---/;
+    const match = content.match(frontMatterRegex);
+    if (!match) {
+        return {};
+    }
+    try {
+        const frontMatter = match[1];
+        const parsed = (yaml.load(frontMatter));
+        if (typeof parsed !== 'object' || parsed === null) {
+            return {};
+        }
+        return {
+            name: typeof parsed.name === 'string' ? parsed.name : undefined,
+            description: typeof parsed.description === 'string' ? parsed.description : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+async function loadSkillFromDirectory(skillDir) {
+    const skillFilePath = join(skillDir, 'SKILL.md');
+    try {
+        const content = await readFile(skillFilePath, 'utf-8');
+        const { name, description } = parseFrontMatter(content);
+        if (!name || !description) {
+            return null;
+        }
+        return {
+            name,
+            description,
+            path: resolve(skillDir),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function loadSkills(directories, options = {}) {
+    const skills = ([]);
+    const watchControllers = ([]);
+    async function scanDirectory(baseDir) {
+        try {
+            const entries = await readdir(baseDir);
+            for (const entry of entries) {
+                const entryPath = join(baseDir, entry);
+                const entryStat = await stat(entryPath);
+                if (entryStat.isDirectory()) {
+                    const skill = await loadSkillFromDirectory(entryPath);
+                    if (skill) {
+                        const existingIdx = skills.findIndex((s) => s.path === skill.path);
+                        if (existingIdx !== -1) {
+                            skills[existingIdx] = skill;
+                        }
+                        else {
+                            skills.push(skill);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
+    for (const dir of directories) {
+        await scanDirectory(dir);
+    }
+    if (options.watch) {
+        for (const dir of directories) {
+            const controller = new AbortController();
+            watchControllers.push(controller);
+            (async () => {
+                try {
+                    const watcher = watch(dir, {
+                        recursive: true,
+                        signal: controller.signal,
+                    });
+                    for await (const event of watcher) {
+                        if (event.filename?.endsWith('SKILL.md')) {
+                            await scanDirectory(dir);
+                        }
+                    }
+                }
+                catch (err) {
+                    if (err instanceof Error &&
+                        err.name !== 'AbortError' &&
+                        !err.message.includes('AbortError')) {
+                    }
+                }
+            })();
+        }
+    }
+    return {
+        skills,
+        close: () => {
+            for (const controller of watchControllers) {
+                controller.abort();
+            }
+        },
+    };
+}
+export function createSkillsFeature(skills) {
+    return {
+        name: ('skills'),
+        options: { skills },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatbotkit/agent",
-  "version": "1.26.3",
+  "version": "1.27.0",
   "description": "ChatBotKit Agent implementation",
   "license": "ISC",
   "engines": {
@@ -72,6 +72,26 @@
         "default": "./dist/cjs/index.cjs"
       }
     },
+    "./skills": {
+      "import": {
+        "types": "./dist/esm/skills.d.ts",
+        "default": "./dist/esm/skills.js"
+      },
+      "require": {
+        "types": "./dist/cjs/skills.d.ts",
+        "default": "./dist/cjs/skills.cjs"
+      }
+    },
+    "./skills.js": {
+      "import": {
+        "types": "./dist/esm/skills.d.ts",
+        "default": "./dist/esm/skills.js"
+      },
+      "require": {
+        "types": "./dist/cjs/skills.d.ts",
+        "default": "./dist/cjs/skills.cjs"
+      }
+    },
     "./tools": {
       "import": {
         "types": "./dist/esm/tools.d.ts",
@@ -96,12 +116,14 @@
   },
   "types": "./dist/cjs/index.d.ts",
   "dependencies": {
+    "js-yaml": "^4.1.0",
     "tslib": "^2.6.2",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.24.6",
-    "@chatbotkit/sdk": "1.26.3"
+    "@chatbotkit/sdk": "1.27.0"
   },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "npm-run-all": "^4.1.5",
     "typedoc": "^0.28.14",
     "typedoc-plugin-markdown": "^4.9.0",