@chatbotkit/agent 1.29.0 → 1.30.0

package/dist/esm/agent.js

@@ -1,304 +1,41 @@
-import { z } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-export async function* complete(options) {
-    const { client, tools, abortSignal, ...request } = options;
-    const channelToTool = new Map();
-    const functions = tools
-        ? Object.entries(tools).map(([name, tool]) => {
-            const randomSuffix = Math.random().toString(36).substring(2, 15);
-            const channel = `${name}_${randomSuffix}`.padEnd(16, '0');
-            channelToTool.set(channel, { name, tool });
-            if (!tool.input) {
-                return {
-                    name,
-                    description: tool.description,
-                    parameters: ({
-                        type: 'object',
-                        properties: {},
-                    }),
-                    result: {
-                        channel,
-                    },
-                };
-            }
-            const schema = (zodToJsonSchema(tool.input, { target: 'openApi3' }));
-            const parameters = {
-                type: 'object',
-                properties: schema.properties || {},
-                ...(schema.required && schema.required.length > 0
-                    ? { required: schema.required }
-                    : {}),
-            };
-            return {
-                name,
-                description: tool.description,
-                parameters: (parameters),
-                result: {
-                    channel,
-                },
-            };
-        })
-        : undefined;
-    const stream = client.conversation
-        .complete(null, {
-        ...request,
-        functions,
-        limits: {
-            iterations: 1,
-        },
-    })
-        .stream({ abortSignal });
-    const toolEventQueue = [];
-    const runningToolPromises = [];
-    const executeToolAsync = async (channel, name, tool, args) => {
-        try {
-            let parsedArgs = args;
-            if (tool.input) {
-                const parseResult = tool.input.safeParse(args);
-                if (!parseResult.success) {
-                    const errorMsg = `Invalid arguments: ${parseResult.error.message}`;
-                    toolEventQueue.push({
-                        type: 'toolCallError',
-                        data: { name, error: errorMsg },
-                    });
-                    await client.channel.publish(String(channel), {
-                        message: { error: errorMsg },
-                    });
-                    return;
-                }
-                parsedArgs = parseResult.data;
-            }
-            const result = await tool.handler(parsedArgs);
-            toolEventQueue.push({
-                type: 'toolCallEnd',
-                data: { name, result },
-            });
-            await client.channel.publish(String(channel), {
-                message: { data: result },
-            });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            toolEventQueue.push({
-                type: 'toolCallError',
-                data: { name, error: errorMessage },
-            });
-            await client.channel.publish(String(channel), {
-                message: { error: errorMessage },
-            });
-        }
-    };
-    for await (const event of stream) {
-        if (abortSignal?.aborted) {
-            break;
-        }
-        while (toolEventQueue.length > 0) {
-            const toolEvent = toolEventQueue.shift();
-            if (toolEvent) {
-                yield toolEvent;
-            }
-        }
-        if (event.type === 'waitForChannelMessageBegin' &&
-            event.data &&
-            'channel' in event.data &&
-            'function' in event.data) {
-            const channel = (event.data.channel);
-            const args = (event.data.function).args;
-            const toolInfo = channelToTool.get(String(channel));
-            if (toolInfo) {
-                const { name, tool } = toolInfo;
-                yield {
-                    type: 'toolCallStart',
-                    data: {
-                        name,
-                        args,
-                    },
-                };
-                const toolPromise = executeToolAsync(channel, name, tool, args);
-                runningToolPromises.push(toolPromise);
-            }
-        }
-        yield event;
+import { readFile } from 'fs/promises';
+import yaml from 'js-yaml';
+import { resolve } from 'path';
+function parseAgentFile(content) {
+    const frontMatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)/;
+    const match = content.match(frontMatterRegex);
+    if (!match) {
+        return { frontMatter: {}, body: content.trim() };
     }
-    while (toolEventQueue.length > 0) {
-        const toolEvent = toolEventQueue.shift();
-        if (toolEvent) {
-            yield toolEvent;
+    let frontMatter = ({});
+    try {
+        const parsed = yaml.load(match[1]);
+        if (typeof parsed === 'object' && parsed !== null) {
+            frontMatter = (parsed);
         }
     }
-    if (runningToolPromises.length > 0) {
-        await Promise.allSettled(runningToolPromises);
-        while (toolEventQueue.length > 0) {
-            const toolEvent = toolEventQueue.shift();
-            if (toolEvent) {
-                yield toolEvent;
-            }
-        }
+    catch {
     }
+    return { frontMatter, body: match[2].trim() };
 }
-export async function* execute(options) {
-    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.',
-            input: z.object({
-                steps: z
-                    .array(z.string())
-                    .describe('Array of step descriptions in order of execution'),
-                rationale: z
-                    .string()
-                    .optional()
-                    .describe('Brief explanation of the plan approach'),
-            }),
-            handler: async (input) => {
-                return {
-                    success: true,
-                    message: `Plan created with ${input.steps.length} steps${input.rationale ? ': ' + input.rationale : ''}`,
-                };
-            },
-        },
-        progress: {
-            description: 'Update progress on the current task. Use this to track completed steps, report current status, and identify blockers.',
-            input: z.object({
-                completed: z
-                    .array(z.string())
-                    .optional()
-                    .describe('Steps that have been completed'),
-                current: z.string().optional().describe('Current step being worked on'),
-                blockers: z
-                    .array(z.string())
-                    .optional()
-                    .describe('Any issues preventing progress'),
-                nextSteps: z
-                    .array(z.string())
-                    .optional()
-                    .describe('Next actions to take'),
-            }),
-            handler: async (input) => {
-                return {
-                    success: true,
-                    message: 'Progress updated',
-                    ...input,
-                };
-            },
-        },
-        exit: {
-            description: 'Exit the task execution with a status code and optional message. Status code 0 indicates success, non-zero indicates failure. Use this when all the tasks are complete or cannot proceed.',
-            input: z.object({
-                code: z
-                    .number()
-                    .int()
-                    .min(0)
-                    .max(255)
-                    .describe('Exit status code (0 = success, non-zero = failure)'),
-                message: z
-                    .string()
-                    .optional()
-                    .describe('Optional message explaining the exit reason'),
-            }),
-            handler: async (input) => {
-                exitResult = { code: input.code, message: input.message };
-                return {
-                    success: true,
-                    message: `Task exiting with code ${input.code}${input.message ? ': ' + input.message : ''}`,
-                };
-            },
-        },
-        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 = { ...tools, ...systemTools };
-    const systemInstruction = `
-${options.extensions?.backstory || ''}
-
-# Task Execution Guidelines
-
-The goal is to complete the assigned task efficiently and effectively. Follow these guidelines:
-
-1. **Plan First**: Use the 'plan' function to create a clear strategy before starting work
-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. **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;
-        }
-        if (lastEndReason === 'stop') {
-            break;
-        }
-    }
-    if (exitResult === null) {
-        exitResult = {
-            code: 1,
-            message: `Task did not complete within ${maxIterations} iterations`,
-        };
-    }
-    yield { type: 'exit', data: exitResult };
+export async function loadAgent(filePath) {
+    const resolvedPath = resolve(process.cwd(), filePath);
+    const content = await readFile(resolvedPath, 'utf-8');
+    const { frontMatter, body } = parseAgentFile(content);
+    const name = typeof frontMatter.name === 'string' ? frontMatter.name : undefined;
+    const description = typeof frontMatter.description === 'string'
+        ? frontMatter.description
+        : undefined;
+    const model = typeof frontMatter.model === 'string' ? frontMatter.model : undefined;
+    const botId = typeof frontMatter.botId === 'string' ? frontMatter.botId : undefined;
+    const skillsetId = typeof frontMatter.skillsetId === 'string'
+        ? frontMatter.skillsetId
+        : undefined;
+    const datasetId = typeof frontMatter.datasetId === 'string'
+        ? frontMatter.datasetId
+        : undefined;
+    const frontMatterBackstory = typeof frontMatter.backstory === 'string' ? frontMatter.backstory : '';
+    const backstoryParts = [frontMatterBackstory, body].filter(Boolean);
+    const backstory = backstoryParts.length > 0 ? backstoryParts.join('\n\n') : undefined;
+    return { name, description, backstory, model, botId, skillsetId, datasetId };
 }

package/dist/esm/execute.d.ts

@@ -0,0 +1,56 @@
+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: 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;
+export type ConversationCompleteRequest = import("@chatbotkit/sdk/conversation/v1").ConversationCompleteRequest;
+export type ConversationCompleteStreamType = import("@chatbotkit/sdk/conversation/v1").ConversationCompleteStreamType;
+export type ToolDefinition<T extends ZodObject> = {
+    description: string;
+    input?: T;
+    handler: (input: any) => Promise<any>;
+};
+export type Tools = Record<string, ToolDefinition<ZodObject>>;
+export type ExitResult = {
+    code: number;
+    message?: string;
+};
+export type ToolCallStartEvent = {
+    type: "toolCallStart";
+    data: {
+        name: string;
+        args: any;
+    };
+};
+export type ToolCallEndEvent = {
+    type: "toolCallEnd";
+    data: {
+        name: string;
+        result: any;
+    };
+};
+export type ToolCallErrorEvent = {
+    type: "toolCallError";
+    data: {
+        name: string;
+        error: string;
+    };
+};
+export type IterationEvent = {
+    type: "iteration";
+    data: {
+        iteration: number;
+    };
+};
+export type ExitEvent = {
+    type: "exit";
+    data: ExitResult;
+};