@commandkit/ai 0.1.0-dev.20250611125312 → 0.1.0-dev.20250612020250

package/dist/plugin.js

@@ -1,144 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AiPlugin = void 0;
-exports.configureAI = configureAI;
 const plugin_1 = require("commandkit/plugin");
 const commandkit_1 = require("commandkit");
 const context_1 = require("./context");
 const discord_js_1 = require("discord.js");
 const ai_1 = require("ai");
-const zod_1 = require("zod");
 const ai_context_worker_1 = require("./ai-context-worker");
-const schema_1 = require("./schema");
-let messageFilter = null;
-let selectAiModel = null;
-let generateSystemPrompt;
-/**
- * Configures the AI plugin with the provided options.
- * This function allows you to set a message filter, select an AI model, and generate a system prompt.
- * @param config The configuration options for the AI plugin.
- */
-function configureAI(config) {
-    if (config.messageFilter) {
-        messageFilter = config.messageFilter;
-    }
-    if (config.selectAiModel) {
-        selectAiModel = config.selectAiModel;
-    }
-    if (config.systemPrompt) {
-        generateSystemPrompt = config.systemPrompt;
-    }
-}
+const get_available_commands_1 = require("./tools/get-available-commands");
+const get_channel_by_id_1 = require("./tools/get-channel-by-id");
+const get_current_client_info_1 = require("./tools/get-current-client-info");
+const get_guild_by_id_1 = require("./tools/get-guild-by-id");
+const get_user_by_id_1 = require("./tools/get-user-by-id");
+const configure_1 = require("./configure");
+const augmentation_1 = require("./augmentation");
+const defaultTools = {
+    getAvailableCommands: get_available_commands_1.getAvailableCommands,
+    getChannelById: get_channel_by_id_1.getChannelById,
+    getCurrentClientInfo: get_current_client_info_1.getCurrentClientInfo,
+    getGuildById: get_guild_by_id_1.getGuildById,
+    getUserById: get_user_by_id_1.getUserById,
+};
 class AiPlugin extends plugin_1.RuntimePlugin {
     constructor(options) {
         super(options);
         this.name = 'AiPlugin';
         this.toolsRecord = {};
-        this.defaultTools = {};
+        this.defaultTools = defaultTools;
         this.onMessageFunc = null;
     }
     async activate(ctx) {
-        this.onMessageFunc = (message) => this.handleMessage(ctx, message);
+        this.onMessageFunc = (message) => this.handleMessage(ctx.commandkit, message);
         ctx.commandkit.client.on(discord_js_1.Events.MessageCreate, this.onMessageFunc);
-        this.createDefaultTools(ctx);
+        (0, augmentation_1.augmentCommandKit)(true);
         commandkit_1.Logger.info(`Plugin ${this.name} activated`);
     }
-    createDefaultTools(ctx) {
-        const { commandkit } = ctx;
-        const client = commandkit.client;
-        this.defaultTools.getUserById = (0, ai_1.tool)({
-            description: 'Get user information by ID',
-            parameters: zod_1.z.object({
-                userId: zod_1.z
-                    .string()
-                    .describe('The ID of the user to retrieve. This is a Discord snowflake string.'),
-            }),
-            execute: async (params) => {
-                const user = await client.users.fetch(params.userId, {
-                    force: false,
-                    cache: true,
-                });
-                return user.toJSON();
-            },
-        });
-        this.defaultTools.getChannelById = (0, ai_1.tool)({
-            description: 'Get channel information by ID',
-            parameters: zod_1.z.object({
-                channelId: zod_1.z
-                    .string()
-                    .describe('The ID of the channel to retrieve. This is a Discord snowflake string.'),
-            }),
-            execute: async (params) => {
-                const channel = await client.channels.fetch(params.channelId, {
-                    force: false,
-                    cache: true,
-                });
-                if (!channel) {
-                    throw new Error(`Channel with ID ${params.channelId} not found.`);
-                }
-                return channel.toJSON();
-            },
-        });
-        this.defaultTools.getGuildById = (0, ai_1.tool)({
-            description: 'Get guild information by ID',
-            parameters: zod_1.z.object({
-                guildId: zod_1.z
-                    .string()
-                    .describe('The ID of the guild to retrieve. This is a Discord snowflake string.'),
-            }),
-            execute: async (params) => {
-                const guild = await client.guilds.fetch({
-                    guild: params.guildId,
-                    force: false,
-                    cache: true,
-                });
-                if (!guild) {
-                    throw new Error(`Guild with ID ${params.guildId} not found.`);
-                }
-                return {
-                    id: guild.id,
-                    name: guild.name,
-                    icon: guild.iconURL(),
-                    memberCount: guild.memberCount,
-                };
-            },
-        });
-        this.defaultTools.getCurrentUser = (0, ai_1.tool)({
-            description: 'Get information about the current discord bot user',
-            parameters: zod_1.z.object({}),
-            execute: async () => {
-                const user = client.user;
-                if (!user) {
-                    throw new Error('Bot user is not available.');
-                }
-                return user.toJSON();
-            },
-        });
-        this.defaultTools.getAvailableCommands = (0, ai_1.tool)({
-            description: 'Get all available commands',
-            parameters: zod_1.z.object({}),
-            execute: async () => {
-                return ctx.commandkit.commandHandler.getCommandsArray().map((cmd) => ({
-                    name: cmd.data.command.name,
-                    description: cmd.data.command.description,
-                    category: cmd.command.category,
-                }));
-            },
-        });
-    }
     async deactivate(ctx) {
         this.toolsRecord = {};
         if (this.onMessageFunc) {
             ctx.commandkit.client.off(discord_js_1.Events.MessageCreate, this.onMessageFunc);
             this.onMessageFunc = null;
         }
+        (0, augmentation_1.augmentCommandKit)(false);
         commandkit_1.Logger.info(`Plugin ${this.name} deactivated`);
     }
-    async handleMessage(pluginContext, message) {
+    async handleMessage(commandkit, message) {
         if (message.author.bot || !Object.keys(this.toolsRecord).length)
             return;
-        const aiModelSelector = selectAiModel;
-        if (!message.content?.length || !aiModelSelector)
+        const { messageFilter, selectAiModel, prepareSystemPrompt, preparePrompt, onProcessingFinish, onProcessingStart, onResult, onError, disableBuiltInTools, } = (0, configure_1.getAIConfig)();
+        if (!message.content?.length)
             return;
         if (!message.channel.isTextBased() || !message.channel.isSendable())
             return;
@@ -148,152 +58,62 @@ class AiPlugin extends plugin_1.RuntimePlugin {
         const ctx = new context_1.AiContext({
             message,
             params: {},
-            commandkit: pluginContext.commandkit,
+            commandkit: commandkit,
         });
-        const systemPrompt = (await generateSystemPrompt?.(message)) ||
-            `You are a helpful AI discord bot. Your name is ${message.client.user.username} and your id is ${message.client.user.id}.
-      You are designed to assist users with their questions and tasks. You also have access to various tools that can help you perform tasks.
-      Tools are basically like commands that you can execute to perform specific actions based on user input.
-      Keep the response short and concise, and only use tools when necessary. Keep the response length under 2000 characters.
-      Do not include your own text in the response unless necessary. For text formatting, you can use discord's markdown syntax.
-      The current channel is ${'name' in message.channel
-                ? message.channel.name
-                : message.channel.recipient?.displayName || 'DM'} whose id is ${message.channelId}. ${message.channel.isSendable()
-                ? 'You can send messages in this channel.'
-                : 'You cannot send messages in this channel.'}
-      ${message.inGuild() ? `\nYou are currently in a guild named ${message.guild.name} whose id is ${message.guildId}. While in guild, you can fetch member information if needed.` : '\nYou are currently in a direct message with the user.'}
-      If the user asks you to create a poll or embeds, create a text containing the poll or embed information as a markdown instead of json. If structured response is possible, use the structured response format instead.
-      If the user asks you to perform a task that requires a tool, use the tool to perform the task and return the result. Reject any requests that are not related to the tools you have access to.
-      `;
-        const userInfo = `<user>
-    <id>${message.author.id}</id>
-    <name>${message.author.username}</name>
-    <displayName>${message.author.displayName}</displayName>
-    <avatar>${message.author.avatarURL()}</avatar>
-    </user>`;
         await (0, ai_context_worker_1.runInAiWorkerContext)(ctx, message, async () => {
-            const channel = message.channel;
-            const stopTyping = await this.startTyping(channel);
+            const systemPrompt = await prepareSystemPrompt(ctx, message);
+            const prompt = await preparePrompt(ctx, message);
+            const { model, abortSignal, maxSteps, ...modelOptions } = await selectAiModel(ctx, message);
+            await onProcessingStart(ctx, message);
+            const tools = disableBuiltInTools
+                ? this.toolsRecord
+                : {
+                    ...this.defaultTools,
+                    ...this.toolsRecord,
+                };
             try {
-                const { model, options, objectMode = false, } = await aiModelSelector(message);
-                const originalPrompt = `${userInfo}\nUser: ${message.content}\nAI:`;
-                let result;
-                const config = {
+                const result = await (0, ai_1.generateText)({
                     model,
-                    abortSignal: AbortSignal.timeout(60000),
-                    prompt: originalPrompt,
+                    abortSignal: abortSignal ?? AbortSignal.timeout(60000),
+                    prompt,
                     system: systemPrompt,
-                    providerOptions: options,
-                };
-                if (objectMode) {
-                    result = await (0, ai_1.generateObject)({
-                        ...config,
-                        schema: schema_1.AiResponseSchema,
-                    });
-                }
-                else {
-                    result = await (0, ai_1.generateText)({
-                        ...config,
-                        tools: { ...this.toolsRecord, ...this.defaultTools },
-                        maxSteps: 5,
-                    });
-                }
-                stopTyping();
-                let structuredResult = null;
-                structuredResult = !('text' in result)
-                    ? result.object
-                    : null;
-                if (structuredResult) {
-                    const { poll, content, embed } = structuredResult;
-                    if (!poll && !content && !embed) {
-                        commandkit_1.Logger.warn('AI response did not include any content, embed, or poll.');
-                        return;
-                    }
-                    await message.reply({
-                        content: content?.substring(0, 2000),
-                        embeds: embed
-                            ? [
-                                {
-                                    title: embed.title,
-                                    description: embed.description,
-                                    url: embed.url,
-                                    color: embed.color,
-                                    image: embed.image ? { url: embed.image } : undefined,
-                                    thumbnail: embed.thumbnailImage
-                                        ? { url: embed.thumbnailImage }
-                                        : undefined,
-                                    fields: embed.fields?.map((field) => ({
-                                        name: field.name,
-                                        value: field.value,
-                                        inline: field.inline,
-                                    })),
-                                },
-                            ]
-                            : [],
-                        poll: poll
-                            ? {
-                                allowMultiselect: poll.allow_multiselect,
-                                answers: poll.answers.map((answer) => ({
-                                    text: answer.text,
-                                    emoji: answer.emoji,
-                                })),
-                                duration: poll.duration,
-                                question: { text: poll.question.text },
-                            }
-                            : undefined,
-                    });
-                }
-                else if ('text' in result && !!result.text) {
-                    await message.reply({
-                        content: result.text.substring(0, 2000),
-                        allowedMentions: { parse: [] },
-                    });
-                }
+                    maxSteps: maxSteps ?? 5,
+                    ...modelOptions,
+                    tools: {
+                        ...tools,
+                        ...modelOptions.tools,
+                    },
+                });
+                await onResult(ctx, message, result);
             }
             catch (e) {
-                commandkit_1.Logger.error(`Error processing AI message: ${e}`);
-                const channel = message.channel;
-                if (channel.isSendable()) {
-                    await message
-                        .reply({
-                        content: 'An error occurred while processing your request.',
-                        allowedMentions: { parse: [] },
-                    })
-                        .catch((e) => commandkit_1.Logger.error(`Failed to send error message: ${e}`));
-                }
+                await onError(ctx, message, e);
             }
             finally {
-                stopTyping();
+                await onProcessingFinish(ctx, message);
             }
         });
     }
-    async startTyping(channel) {
-        let stopped = false;
-        const runner = async () => {
-            if (stopped)
-                return clearInterval(typingInterval);
-            if (channel.isSendable()) {
-                await channel.sendTyping().catch(Object);
-            }
-        };
-        const typingInterval = setInterval(runner, 3000).unref();
-        await runner();
-        return () => {
-            stopped = true;
-            clearInterval(typingInterval);
-        };
+    /**
+     * Executes the AI for a given message.
+     * @param message The message to process.
+     * @param commandkit The CommandKit instance to use. If not provided, it will be inferred automatically.
+     */
+    async executeAI(message, commandkit) {
+        commandkit ?? (commandkit = (0, commandkit_1.getCommandKit)(true));
+        return this.handleMessage(commandkit, message);
     }
-    async onBeforeCommandsLoad(ctx) {
+    async onBeforeCommandsLoad() {
         this.toolsRecord = {};
     }
     async onAfterCommandsLoad(ctx) {
-        const commands = ctx.commandkit.commandHandler
+        const { commandkit } = ctx;
+        const commands = commandkit.commandHandler
             .getCommandsArray()
             .filter((command) => 'ai' in command.data &&
             typeof command.data.ai === 'function' &&
             'aiConfig' in command.data);
         if (!commands.length) {
-            commandkit_1.Logger.warn('No commands with AI functionality found. Ensure commands are properly configured.');
             return;
         }
         const tools = new discord_js_1.Collection();
@@ -305,12 +125,31 @@ class AiPlugin extends plugin_1.RuntimePlugin {
             const description = cmd.data.aiConfig.description || cmd.data.command.description;
             const cmdTool = (0, ai_1.tool)({
                 description,
-                type: 'function',
                 parameters: cmd.data.aiConfig.parameters,
                 async execute(params) {
+                    const config = (0, configure_1.getAIConfig)();
                     const ctx = (0, ai_context_worker_1.getAiWorkerContext)();
                     ctx.ctx.setParams(params);
-                    return cmd.data.ai(ctx.ctx);
+                    try {
+                        const target = await commandkit.commandHandler.prepareCommandRun(ctx.message, cmd.data.command.name);
+                        if (!target) {
+                            return {
+                                error: true,
+                                message: 'This command is not available.',
+                            };
+                        }
+                        const res = await commandkit.commandHandler.commandRunner.runCommand(target, ctx.message, {
+                            handler: 'ai',
+                        });
+                        return res === undefined ? { success: true } : res;
+                    }
+                    catch (e) {
+                        await config.onError?.(ctx.ctx, ctx.message, e);
+                        return {
+                            error: true,
+                            message: 'This tool failed with unexpected error.',
+                        };
+                    }
                 },
             });
             cmd.tool = cmdTool;
@@ -322,4 +161,4 @@ class AiPlugin extends plugin_1.RuntimePlugin {
     }
 }
 exports.AiPlugin = AiPlugin;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/system-prompt.d.ts

@@ -0,0 +1,6 @@
+import { Message } from 'discord.js';
+/**
+ * Creates the default system prompt for the AI bot based on the provided message context.
+ * This prompt includes the bot's role, current channel information, and response guidelines.
+ */
+export declare function createSystemPrompt(message: Message): string;

package/dist/system-prompt.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSystemPrompt = createSystemPrompt;
+/**
+ * Creates the default system prompt for the AI bot based on the provided message context.
+ * This prompt includes the bot's role, current channel information, and response guidelines.
+ */
+function createSystemPrompt(message) {
+    const channelInfo = 'name' in message.channel
+        ? message.channel.name
+        : message.channel.recipient?.displayName || 'DM';
+    const guildInfo = message.inGuild()
+        ? `You are in the guild "${message.guild.name}" (ID: ${message.guildId}). You can fetch member information when needed.`
+        : 'You are in a direct message with the user.';
+    return `You are ${message.client.user.username} (ID: ${message.client.user.id}), a helpful AI Discord bot.
+
+**Your Role:**
+- Assist users with questions and tasks efficiently
+- Use available tools to perform specific actions when requested
+- Keep responses under 2000 characters and concise
+
+**Current Context:**
+- Channel: "${channelInfo}" (ID: ${message.channelId})
+- Permissions: ${message.channel.isSendable() ? 'Can send messages' : 'Cannot send messages'}
+- Location: ${guildInfo}
+
+**Response Guidelines:**
+- Use Discord markdown for formatting
+- Only use tools when necessary for the task
+- Reject requests unrelated to your available tools
+
+Focus on being helpful while staying within your capabilities.`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3lzdGVtLXByb21wdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zeXN0ZW0tcHJvbXB0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBTUEsZ0RBNEJDO0FBaENEOzs7R0FHRztBQUNILFNBQWdCLGtCQUFrQixDQUFDLE9BQWdCO0lBQ2pELE1BQU0sV0FBVyxHQUNmLE1BQU0sSUFBSSxPQUFPLENBQUMsT0FBTztRQUN2QixDQUFDLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJO1FBQ3RCLENBQUMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxXQUFXLElBQUksSUFBSSxDQUFDO0lBRXJELE1BQU0sU0FBUyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUU7UUFDakMsQ0FBQyxDQUFDLHlCQUF5QixPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksVUFBVSxPQUFPLENBQUMsT0FBTyxrREFBa0Q7UUFDeEgsQ0FBQyxDQUFDLDRDQUE0QyxDQUFDO0lBRWpELE9BQU8sV0FBVyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLFNBQVMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRTs7Ozs7Ozs7Y0FRakUsV0FBVyxVQUFVLE9BQU8sQ0FBQyxTQUFTO2lCQUNuQyxPQUFPLENBQUMsT0FBTyxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUMsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLENBQUMsc0JBQXNCO2NBQzlFLFNBQVM7Ozs7Ozs7K0RBT3dDLENBQUM7QUFDaEUsQ0FBQyJ9

package/dist/tools/common/index.d.ts

@@ -0,0 +1,76 @@
+import { Schema, tool } from 'ai';
+import { AiContext } from '../../context';
+import { z } from 'zod';
+/**
+ * Utility type that represents a value that can be either synchronous or asynchronous.
+ * @template T - The type of the value
+ * @internal
+ */
+type Awaitable<T> = T | Promise<T>;
+/**
+ * Type representing the parameters schema for AI tools.
+ * Extracted from the first parameter of the `tool` function from the 'ai' library.
+ */
+export type ToolParameterType = Parameters<typeof tool>[0]['parameters'];
+/**
+ * Utility type that infers the TypeScript type from a tool parameter schema.
+ * Supports both Zod schemas and AI library schemas.
+ * @template T - The tool parameter type to infer from
+ */
+export type InferParameters<T extends ToolParameterType> = T extends Schema<any> ? T['_type'] : T extends z.ZodTypeAny ? z.infer<T> : never;
+/**
+ * Configuration options for creating an AI tool.
+ * @template T - The parameter schema type for the tool
+ * @template R - The return type of the tool's execute function
+ */
+export interface CreateToolOptions<T extends ToolParameterType, R = unknown> {
+    /** The unique name identifier for the tool */
+    name: string;
+    /** A human-readable description of what the tool does */
+    description: string;
+    /** The parameter schema that defines the tool's input structure */
+    parameters: T;
+    /** The function that executes when the tool is called */
+    execute: ToolExecuteFunction<T, R>;
+}
+/**
+ * Type definition for a tool's execute function.
+ * @template T - The parameter schema type
+ * @template R - The return type of the function
+ * @param ctx - The AI context containing request and response information
+ * @param parameters - The validated parameters passed to the tool
+ * @returns The result of the tool execution, which can be synchronous or asynchronous
+ */
+export type ToolExecuteFunction<T extends ToolParameterType, R> = (ctx: AiContext, parameters: InferParameters<T>) => Awaitable<R>;
+/**
+ * Creates a new AI tool with the specified configuration.
+ * This function wraps the underlying AI library's tool creation with additional
+ * context management and parameter validation.
+ *
+ * @template T - The parameter schema type for the tool
+ * @template R - The return type of the tool's execute function
+ * @param options - The configuration options for the tool
+ * @returns A configured AI tool ready for use
+ *
+ * @example
+ * ```typescript
+ * const myTool = createTool({
+ *   name: 'calculate',
+ *   description: 'Performs basic arithmetic calculations',
+ *   parameters: z.object({
+ *     operation: z.enum(['add', 'subtract']),
+ *     a: z.number(),
+ *     b: z.number(),
+ *   }),
+ *   execute: async (ctx, params) => {
+ *     return params.operation === 'add'
+ *       ? params.a + params.b
+ *       : params.a - params.b;
+ *   },
+ * });
+ * ```
+ */
+export declare function createTool<T extends ToolParameterType, R = unknown>(options: CreateToolOptions<T, R>): import("ai").Tool<T, R> & {
+    execute: (args: T extends Schema<any> ? T["_type"] : T extends z.ZodTypeAny ? z.TypeOf<T> : never, options: import("ai").ToolExecutionOptions) => PromiseLike<R>;
+};
+export {};

package/dist/tools/common/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTool = createTool;
+const ai_1 = require("ai");
+const ai_context_worker_1 = require("../../ai-context-worker");
+/**
+ * Creates a new AI tool with the specified configuration.
+ * This function wraps the underlying AI library's tool creation with additional
+ * context management and parameter validation.
+ *
+ * @template T - The parameter schema type for the tool
+ * @template R - The return type of the tool's execute function
+ * @param options - The configuration options for the tool
+ * @returns A configured AI tool ready for use
+ *
+ * @example
+ * ```typescript
+ * const myTool = createTool({
+ *   name: 'calculate',
+ *   description: 'Performs basic arithmetic calculations',
+ *   parameters: z.object({
+ *     operation: z.enum(['add', 'subtract']),
+ *     a: z.number(),
+ *     b: z.number(),
+ *   }),
+ *   execute: async (ctx, params) => {
+ *     return params.operation === 'add'
+ *       ? params.a + params.b
+ *       : params.a - params.b;
+ *   },
+ * });
+ * ```
+ */
+function createTool(options) {
+    // @ts-ignore - Suppressing type checking due to complex generic inference
+    const _tool = (0, ai_1.tool)({
+        name: options.name,
+        description: options.description,
+        parameters: options.parameters,
+        async execute(params) {
+            const { ctx } = (0, ai_context_worker_1.getAiWorkerContext)();
+            ctx.setParams(params);
+            return options.execute(ctx, params);
+        },
+    });
+    return _tool;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdG9vbHMvY29tbW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBdUZBLGdDQWtCQztBQXpHRCwyQkFBa0M7QUFFbEMsK0RBQTZEO0FBeUQ3RDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMkJHO0FBQ0gsU0FBZ0IsVUFBVSxDQUN4QixPQUFnQztJQUVoQywwRUFBMEU7SUFDMUUsTUFBTSxLQUFLLEdBQUcsSUFBQSxTQUFJLEVBQU87UUFDdkIsSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJO1FBQ2xCLFdBQVcsRUFBRSxPQUFPLENBQUMsV0FBVztRQUNoQyxVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVU7UUFDOUIsS0FBSyxDQUFDLE9BQU8sQ0FBQyxNQUFNO1lBQ2xCLE1BQU0sRUFBRSxHQUFHLEVBQUUsR0FBRyxJQUFBLHNDQUFrQixHQUFFLENBQUM7WUFFckMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUV0QixPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLE1BQTRCLENBQUMsQ0FBQztRQUM1RCxDQUFDO0tBQ0YsQ0FBQyxDQUFDO0lBRUgsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDIn0=

package/dist/tools/get-available-commands.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const getAvailableCommands: import("ai").Tool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {
+    name: any;
+    description: any;
+    category: string | null;
+    supportsAI: boolean;
+}[]> & {
+    execute: (args: {}, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+        name: any;
+        description: any;
+        category: string | null;
+        supportsAI: boolean;
+    }[]>;
+};

package/dist/tools/get-available-commands.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableCommands = void 0;
+const zod_1 = require("zod");
+const common_1 = require("./common");
+exports.getAvailableCommands = (0, common_1.createTool)({
+    description: 'Get a list of all available commands.',
+    name: 'getAvailableCommands',
+    parameters: zod_1.z.object({}),
+    execute(ctx, params) {
+        const { commandkit } = ctx;
+        const commands = commandkit.commandHandler
+            .getCommandsArray()
+            .map((cmd) => ({
+            name: cmd.data.command.name,
+            description: cmd.data.command.description,
+            category: cmd.command.category,
+            supportsAI: 'ai' in cmd.data && typeof cmd.data.ai === 'function',
+        }));
+        return commands;
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWF2YWlsYWJsZS1jb21tYW5kcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90b29scy9nZXQtYXZhaWxhYmxlLWNvbW1hbmRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDZCQUF3QjtBQUN4QixxQ0FBc0M7QUFFekIsUUFBQSxvQkFBb0IsR0FBRyxJQUFBLG1CQUFVLEVBQUM7SUFDN0MsV0FBVyxFQUFFLHVDQUF1QztJQUNwRCxJQUFJLEVBQUUsc0JBQXNCO0lBQzVCLFVBQVUsRUFBRSxPQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztJQUN4QixPQUFPLENBQUMsR0FBRyxFQUFFLE1BQU07UUFDakIsTUFBTSxFQUFFLFVBQVUsRUFBRSxHQUFHLEdBQUcsQ0FBQztRQUUzQixNQUFNLFFBQVEsR0FBRyxVQUFVLENBQUMsY0FBYzthQUN2QyxnQkFBZ0IsRUFBRTthQUNsQixHQUFHLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7WUFDYixJQUFJLEVBQUUsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSTtZQUMzQixXQUFXLEVBQUUsR0FBRyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsV0FBVztZQUN6QyxRQUFRLEVBQUUsR0FBRyxDQUFDLE9BQU8sQ0FBQyxRQUFRO1lBQzlCLFVBQVUsRUFBRSxJQUFJLElBQUksR0FBRyxDQUFDLElBQUksSUFBSSxPQUFPLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxLQUFLLFVBQVU7U0FDbEUsQ0FBQyxDQUFDLENBQUM7UUFFTixPQUFPLFFBQVEsQ0FBQztJQUNsQixDQUFDO0NBQ0YsQ0FBQyxDQUFDIn0=