@codebolt/agent 5.0.2 → 5.0.7

package/dist/unified/base/initialPromptGenerator.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InitialPromptGenerator = void 0;
 exports.createUnifiedMessageProcessor = createUnifiedMessageProcessor;
 const types_1 = require("../types/types");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 /**
  * Initial prompt generator that combines message modifiers with unified processing
  */
@@ -50,10 +54,20 @@ class InitialPromptGenerator {
                     // Continue with other modifiers
                 }
             }
-            createdMessage.message.messages.push({
-                role: 'assistant',
-                content: "Got it. Thanks for the context!"
-            });
+            const lastMessage = createdMessage.message.messages[createdMessage.message.messages.length - 1];
+            if (!lastMessage || lastMessage.role !== 'system') {
+                createdMessage.message.messages.push({
+                    role: 'assistant',
+                    content: "Got it. Thanks for the context!"
+                });
+            }
+            let { todos } = await codeboltjs_1.default.todo.getAllIncompleteTodos();
+            if (todos && todos.length == 0) {
+                createdMessage.message.messages.push({
+                    role: 'user',
+                    content: "<system-reminder>\nThis is a reminder that your todo list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a todo list please use the TodoWrite tool to create one. If not, please feel free to ignore. Again do not mention this message to the user.\n</system-reminder>"
+                });
+            }
             createdMessage.message.messages.push({
                 role: 'user',
                 content: content.trim()

package/dist/unified/base/responseExecutor.d.ts

@@ -1,10 +1,11 @@
 import { AgentResponseExecutor, PostToolCallProcessor, PreToolCallProcessor, ResponseInput, ResponseOutput } from '@codebolt/types/agent';
 export declare class ResponseExecutor implements AgentResponseExecutor {
-    private preToolCalProcessors;
+    private preToolCallProcessors;
     private postToolCallProcessors;
     private completed;
+    private finalMessage;
     constructor(options: {
-        preToolCalProcessors: PreToolCallProcessor[];
+        preToolCallProcessors: PreToolCallProcessor[];
         postToolCallProcessors: PostToolCallProcessor[];
     });
     executeResponse(input: ResponseInput): Promise<ResponseOutput>;

package/dist/unified/base/responseExecutor.js

@@ -7,15 +7,16 @@ exports.ResponseExecutor = void 0;
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 class ResponseExecutor {
     constructor(options) {
-        this.preToolCalProcessors = [];
+        this.preToolCallProcessors = [];
         this.postToolCallProcessors = [];
         this.completed = false;
-        this.preToolCalProcessors = options.preToolCalProcessors;
+        this.finalMessage = undefined;
+        this.preToolCallProcessors = options.preToolCallProcessors;
         this.postToolCallProcessors = options.postToolCallProcessors;
     }
     async executeResponse(input) {
         let nextMessage = input.nextMessage;
-        for (const preToolCallProcessor of this.preToolCalProcessors) {
+        for (const preToolCallProcessor of this.preToolCallProcessors) {
             try {
                 // TODO: Extract required properties from input for PreToolCallProcessorInput
                 let { nextPrompt, shouldExit } = await preToolCallProcessor.modify({ llmMessageSent: input.actualMessageSentToLLM, rawLLMResponseMessage: input.rawLLMOutput, nextPrompt: input.nextMessage });
@@ -81,7 +82,8 @@ class ResponseExecutor {
         return {
             completed: this.completed,
             nextMessage: nextMessage,
-            toolResults: toolResults
+            toolResults: toolResults,
+            finalMessage: this.finalMessage
         };
     }
     /**
@@ -107,9 +109,11 @@ class ResponseExecutor {
         var _a, _b;
         try {
             let fallBackMessages = [];
+            let lastMessageContent;
             for (const contentBlock of llmResponse.choices || []) {
                 if (contentBlock.message) {
                     if (contentBlock.message.content != null) {
+                        lastMessageContent = contentBlock.message.content;
                         await codeboltjs_1.default.chat.sendMessage(contentBlock.message.content, {});
                     }
                 }
@@ -120,77 +124,111 @@ class ResponseExecutor {
                 let userRejectedToolUse = false;
                 const contentBlock = (_a = llmResponse.choices) === null || _a === void 0 ? void 0 : _a[0];
                 if (contentBlock && ((_b = contentBlock.message) === null || _b === void 0 ? void 0 : _b.tool_calls)) {
+                    const toolsToExecute = [];
+                    // First pass: Parse all tools and identify "attempt_completion"
                     for (const tool of contentBlock.message.tool_calls) {
+                        const { toolInput, toolName, toolUseId } = this.getToolDetail(tool);
+                        if (toolName.includes("attempt_completion")) {
+                            taskCompletedBlock = tool;
+                            this.completed = true;
+                        }
+                        else {
+                            toolsToExecute.push({
+                                tool,
+                                toolInput,
+                                toolName,
+                                toolUseId,
+                                waitForPrevious: (toolInput === null || toolInput === void 0 ? void 0 : toolInput.waitForPreviousTools) === true
+                            });
+                        }
+                    }
+                    // Second pass: Execute tools sequentially (one by one)
+                    for (const item of toolsToExecute) {
                         try {
-                            const { toolInput, toolName, toolUseId } = this.getToolDetail(tool);
                             if (!userRejectedToolUse) {
-                                if (toolName.includes("attempt_completion")) {
-                                    taskCompletedBlock = tool;
-                                    this.completed = true;
+                                let [serverName] = item.toolName.replace('--', ':').split(':');
+                                // codebolt.chat.sendMessage(`tool call ${serverName} ${item.toolName} ${item.toolInput}`, {});
+                                if (serverName == 'subagent') {
+                                    const agentResponse = await codeboltjs_1.default.agent.startAgent(item.toolName.replace("subagent--", ''), item.toolInput.task);
+                                    const [didUserReject, result] = [false, "tool result is successful"];
+                                    let toolResult = this.parseToolResult(item.toolUseId, result);
+                                    // Handle side effects (fallback messages)
+                                    if (toolResult.userMessage) {
+                                        fallBackMessages.push({
+                                            role: "user",
+                                            content: toolResult.userMessage.toString()
+                                        });
+                                    }
+                                    if (didUserReject) {
+                                        userRejectedToolUse = true;
+                                    }
+                                    toolResults.push({
+                                        role: "tool",
+                                        tool_call_id: toolResult.tool_call_id,
+                                        content: toolResult.content,
+                                    });
+                                }
+                                else if (item.toolName == "codebolt--thread_management") {
+                                    codeboltjs_1.default.chat.sendMessage(JSON.stringify({
+                                        title: item.toolInput.title || item.toolInput.task || 'Background Thread',
+                                        description: item.toolInput.description || item.toolInput.task || '',
+                                        userMessage: item.toolInput.task || item.toolInput.userMessage || '',
+                                        selectedAgent: item.toolInput.selectedAgent,
+                                        isGrouped: item.toolInput.isGrouped,
+                                        groupId: item.toolInput.groupId,
+                                    }));
+                                    const response = await codeboltjs_1.default.thread.createThreadInBackground({
+                                        title: item.toolInput.title || item.toolInput.task || 'Background Thread',
+                                        description: item.toolInput.description || item.toolInput.task || '',
+                                        userMessage: item.toolInput.task || item.toolInput.userMessage || '',
+                                        selectedAgent: item.toolInput.selectedAgent,
+                                        isGrouped: item.toolInput.isGrouped,
+                                        groupId: item.toolInput.groupId,
+                                    });
+                                    toolResults.push({
+                                        role: "tool",
+                                        tool_call_id: item.toolUseId,
+                                        content: JSON.stringify(response),
+                                    });
                                 }
                                 else {
-                                    let [serverName] = toolName.replace('--', ':').split(':');
-                                    if (serverName == 'subagent') {
-                                        const agentResponse = await codeboltjs_1.default.agent.startAgent(toolName.replace("subagent--", ''), toolInput.task);
-                                        const [didUserReject, result] = [false, "tool result is successful"];
-                                        let toolResult = this.parseToolResult(toolUseId, result);
-                                        toolResults.push({
-                                            role: "tool",
-                                            tool_call_id: toolResult.tool_call_id,
-                                            content: toolResult.content,
+                                    const [didUserReject, result] = await this.executeTool(item.toolName, item.toolInput);
+                                    let toolResult = this.parseToolResult(item.toolUseId, result);
+                                    if (toolResult.userMessage) {
+                                        fallBackMessages.push({
+                                            role: "user",
+                                            content: toolResult.userMessage.toString()
                                         });
-                                        if (toolResult.userMessage) {
-                                            fallBackMessages.push({
-                                                role: "user",
-                                                content: toolResult.userMessage.toString()
-                                            });
-                                        }
-                                        if (didUserReject) {
-                                            userRejectedToolUse = true;
-                                        }
                                     }
-                                    else {
-                                        // console.log("Executing tool: ", toolName, toolInput);
-                                        const [didUserReject, result] = await this.executeTool(toolName, toolInput);
-                                        // console.log("Tool result: ", result);
-                                        // toolResults.push(this.parseToolResult(toolUseId, result));
-                                        let toolResult = this.parseToolResult(toolUseId, result);
-                                        toolResults.push({
-                                            role: "tool",
-                                            tool_call_id: toolResult.tool_call_id,
-                                            content: toolResult.content,
-                                        });
-                                        if (toolResult.userMessage) {
-                                            fallBackMessages.push({
-                                                role: "user",
-                                                content: toolResult.userMessage.toString()
-                                            });
-                                        }
-                                        if (didUserReject) {
-                                            userRejectedToolUse = true;
-                                        }
+                                    if (didUserReject) {
+                                        userRejectedToolUse = true;
                                     }
+                                    toolResults.push({
+                                        role: "tool",
+                                        tool_call_id: toolResult.tool_call_id,
+                                        content: toolResult.content,
+                                    });
                                 }
                             }
                             else {
-                                let toolResult = this.parseToolResult(toolUseId, "Skipping tool execution due to previous tool user rejection.");
-                                toolResults.push({
-                                    role: "tool",
-                                    tool_call_id: toolResult.tool_call_id,
-                                    content: toolResult.content,
-                                });
+                                let toolResult = this.parseToolResult(item.toolUseId, "Skipping tool execution due to previous tool user rejection.");
                                 if (toolResult.userMessage) {
                                     fallBackMessages.push({
                                         role: "user",
                                         content: toolResult.userMessage.toString()
                                     });
                                 }
+                                toolResults.push({
+                                    role: "tool",
+                                    tool_call_id: toolResult.tool_call_id,
+                                    content: toolResult.content,
+                                });
                             }
                         }
                         catch (error) {
                             toolResults.push({
                                 role: "tool",
-                                tool_call_id: tool.id,
+                                tool_call_id: item.tool.id,
                                 content: String(error),
                             });
                         }
@@ -198,9 +236,18 @@ class ResponseExecutor {
                 }
                 else {
                     this.completed = true;
+                    // Set final message from agent's last text response when completing without tool calls
+                    if (lastMessageContent) {
+                        this.finalMessage = lastMessageContent;
+                    }
                 }
                 if (taskCompletedBlock) {
-                    let [_, result] = await this.executeTool(taskCompletedBlock.function.name, JSON.parse(taskCompletedBlock.function.arguments || "{}"));
+                    const completionArgs = JSON.parse(taskCompletedBlock.function.arguments || "{}");
+                    // Capture the final message from attempt_completion
+                    if (completionArgs.result) {
+                        this.finalMessage = completionArgs.result;
+                    }
+                    let [_, result] = await this.executeTool(taskCompletedBlock.function.name, completionArgs);
                     if (result === "") {
                         // this.completed = true;
                         result = "The user is satisfied with the result.";
@@ -241,6 +288,12 @@ class ResponseExecutor {
         // console.log("Toolbox name: ", toolboxName, "Actual tool name: ", actualToolName);
         const { data } = await codeboltjs_1.default.mcp.executeTool(toolboxName, actualToolName, toolInput);
         // console.log("Tool result: ", data);
+        // Handle the case where data is an array [didUserReject, content]
+        if (Array.isArray(data) && data.length >= 2) {
+            const [didUserReject, content] = data;
+            return [Boolean(didUserReject), content];
+        }
+        // If data is not in the expected array format, return it as-is
         return [false, data];
     }
     /**
@@ -271,13 +324,13 @@ class ResponseExecutor {
         };
     }
     setPreToolCallProcessors(processors) {
-        this.preToolCalProcessors = processors;
+        this.preToolCallProcessors = processors;
     }
     setPostToolCallProcessors(processors) {
         this.postToolCallProcessors = processors;
     }
     getPreToolCallProcessors() {
-        return this.preToolCalProcessors;
+        return this.preToolCallProcessors;
     }
     getPostToolCallProcessors() {
         return this.postToolCallProcessors;

package/dist/unified/index.d.ts

@@ -14,5 +14,9 @@ export { createDefaultMessageProcessor } from './base/create/createInitialPrompt
 export { InitialPromptGenerator } from './base/initialPromptGenerator';
 export { AgentStep } from './base/agentStep';
 export { ResponseExecutor } from './base/responseExecutor';
+export { Agent } from './agent/agent';
+export { CodeboltAgent, createCodeboltAgent, type CodeboltAgentConfig } from './agent/codeboltAgent';
+export { Tool, createTool } from './agent/tools';
+export { Workflow } from './agent/workflow';
 export { type OpenAIMessage, type OpenAITool, type ToolResult, type CodeboltAPI, type AgentExecutionResult, type StreamChunk, type StreamCallback } from './types/libTypes';
 export { type LLMConfig } from './types/libTypes';

package/dist/unified/index.js

@@ -10,7 +10,7 @@
  * The framework is designed to be modular, extensible, and easy to use.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseExecutor = exports.AgentStep = exports.InitialPromptGenerator = exports.createDefaultMessageProcessor = exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
+exports.Workflow = exports.createTool = exports.Tool = exports.createCodeboltAgent = exports.CodeboltAgent = exports.Agent = exports.ResponseExecutor = exports.AgentStep = exports.InitialPromptGenerator = exports.createDefaultMessageProcessor = exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
 // Error types
 var types_1 = require("./types/types");
 Object.defineProperty(exports, "UnifiedAgentError", { enumerable: true, get: function () { return types_1.UnifiedAgentError; } });
@@ -27,6 +27,17 @@ var agentStep_1 = require("./base/agentStep");
 Object.defineProperty(exports, "AgentStep", { enumerable: true, get: function () { return agentStep_1.AgentStep; } });
 var responseExecutor_1 = require("./base/responseExecutor");
 Object.defineProperty(exports, "ResponseExecutor", { enumerable: true, get: function () { return responseExecutor_1.ResponseExecutor; } });
+// Agent framework components
+var agent_1 = require("./agent/agent");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
+var codeboltAgent_1 = require("./agent/codeboltAgent");
+Object.defineProperty(exports, "CodeboltAgent", { enumerable: true, get: function () { return codeboltAgent_1.CodeboltAgent; } });
+Object.defineProperty(exports, "createCodeboltAgent", { enumerable: true, get: function () { return codeboltAgent_1.createCodeboltAgent; } });
+var tools_1 = require("./agent/tools");
+Object.defineProperty(exports, "Tool", { enumerable: true, get: function () { return tools_1.Tool; } });
+Object.defineProperty(exports, "createTool", { enumerable: true, get: function () { return tools_1.createTool; } });
+var workflow_1 = require("./agent/workflow");
+Object.defineProperty(exports, "Workflow", { enumerable: true, get: function () { return workflow_1.Workflow; } });
 // Workflow step factories
 // Orchestrator system
 // export {

package/dist/usermessage.d.ts

@@ -0,0 +1,70 @@
+import type { UserMessageContent } from "./types/libFunctionTypes";
+import type { Agent } from "./types/commonTypes";
+import type { Message } from "./types/InternalTypes";
+/**
+ * Class that processes and manages user messages.
+ * Handles converting messages to prompts and extracting mentioned entities.
+ */
+declare class UserMessage {
+    /** The message content and metadata */
+    message: Message;
+    /** Whether to override the default prompt generation */
+    promptOverride: boolean;
+    /** Array of content blocks for the user message */
+    userMessages: UserMessageContent[];
+    /** List of MCP tools mentioned in the message */
+    mentionedMCPs: {
+        toolbox: string;
+        toolName: string;
+    }[];
+    /**
+     * Creates a new UserMessage instance.
+     *
+     * @param message - The message content and metadata
+     * @param promptOverride - Whether to override default prompt generation
+     */
+    constructor(message: Message, promptOverride?: boolean);
+    /**
+     * Gets files mentioned in the message.
+     * Currently a placeholder for implementation.
+     */
+    getFiles(): void;
+    /**
+     * Converts the user message to a prompt format.
+     *
+     * @param bAttachFiles - Whether to attach file contents
+     * @param bAttachImages - Whether to attach images
+     * @param bAttachEnvironment - Whether to attach environment details
+     * @returns Promise with an array of content blocks for the prompt
+     */
+    toPrompt(bAttachFiles?: boolean, bAttachImages?: boolean, bAttachEnvironment?: boolean, supportRemix?: boolean): Promise<UserMessageContent[]>;
+    /**
+     * Gets agents mentioned in the message.
+     *
+     * @returns Array of agent objects
+     */
+    getMentionedAgents(): Agent[];
+    /**
+     * Gets MCP tools mentioned in the message.
+     *
+     * @returns Array of MCP tool names
+     */
+    getMentionedMcps(): {
+        toolbox: string;
+        toolName: string;
+    }[];
+    /**
+     * Gets MCP tools in a format suitable for the LLM.
+     *
+     * @returns Promise with an array of MCP tools
+     */
+    getMentionedMcpsTools(): Promise<any[] | undefined>;
+    /**
+     * Gets environment details for the current working directory.
+     *
+     * @param cwd - The current working directory path
+     * @returns Promise with a string containing environment details
+     */
+    private getEnvironmentDetail;
+}
+export { UserMessage };

package/dist/usermessage.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserMessage = void 0;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const { fs: cbfs, project, mcp } = codeboltjs_1.default;
+// All interfaces moved to appropriate type files
+/**
+ * Class that processes and manages user messages.
+ * Handles converting messages to prompts and extracting mentioned entities.
+ */
+class UserMessage {
+    /**
+     * Creates a new UserMessage instance.
+     *
+     * @param message - The message content and metadata
+     * @param promptOverride - Whether to override default prompt generation
+     */
+    constructor(message, promptOverride = false) {
+        /**
+         * Gets environment details for the current working directory.
+         *
+         * @param cwd - The current working directory path
+         * @returns Promise with a string containing environment details
+         */
+        this.getEnvironmentDetail = async (cwd) => {
+            let details = "";
+            const { success, result } = await cbfs.listFile(cwd, true);
+            details += `\n\n# Current Working Directory (${cwd}) Files\n${result}
+            ? "\n(Note: Only top-level contents shown for Desktop by default. Use list_files to explore further if necessary.)"
+            : ""
+            }`;
+            return `<environment_details>\n${details.trim()}\n</environment_details>`;
+        };
+        this.message = message;
+        this.promptOverride = promptOverride;
+        this.userMessages = [];
+        this.mentionedMCPs = message.mentionedMCPs || [];
+    }
+    /**
+     * Gets files mentioned in the message.
+     * Currently a placeholder for implementation.
+     */
+    getFiles() {
+        // Implementation to be added
+    }
+    /**
+     * Converts the user message to a prompt format.
+     *
+     * @param bAttachFiles - Whether to attach file contents
+     * @param bAttachImages - Whether to attach images
+     * @param bAttachEnvironment - Whether to attach environment details
+     * @returns Promise with an array of content blocks for the prompt
+     */
+    async toPrompt(bAttachFiles = true, bAttachImages = true, bAttachEnvironment = true, supportRemix = true) {
+        var _a;
+        if (bAttachFiles) {
+            if (this.promptOverride) {
+                // Use a rendering engine
+            }
+            else {
+                let finalPrompt = `
+                    The user has sent the following query:
+                   <user_query> ${this.message.userMessage} </user_query>.
+                `;
+                if ((_a = this.message.mentionedFiles) === null || _a === void 0 ? void 0 : _a.length) {
+                    finalPrompt += `The Attached files are:`;
+                    for (const file of this.message.mentionedFiles) {
+                        let filedata = await cbfs.readFile(file);
+                        finalPrompt += `File Name: ${file}, File Path: ${file}, Filedata: ${filedata}`;
+                    }
+                }
+                this.userMessages.push({ type: "text", text: finalPrompt });
+            }
+        }
+        if (bAttachEnvironment) {
+            let { projectPath } = await project.getProjectPath();
+            if (projectPath) {
+                const environmentDetail = await this.getEnvironmentDetail(projectPath);
+                this.userMessages.push({ type: "text", text: environmentDetail });
+            }
+        }
+        if (supportRemix) {
+            if (this.message.remixPrompt)
+                this.userMessages.push({ type: "text", text: this.message.remixPrompt });
+        }
+        return this.userMessages;
+    }
+    /**
+     * Gets agents mentioned in the message.
+     *
+     * @returns Array of agent objects
+     */
+    getMentionedAgents() {
+        //TODO : get config in tool format if neede
+        return this.message.mentionedAgents || [];
+    }
+    /**
+     * Gets MCP tools mentioned in the message.
+     *
+     * @returns Array of MCP tool names
+     */
+    getMentionedMcps() {
+        return this.message.mentionedMCPs || [];
+    }
+    /**
+     * Gets MCP tools in a format suitable for the LLM.
+     *
+     * @returns Promise with an array of MCP tools
+     */
+    async getMentionedMcpsTools() {
+        if (this.mentionedMCPs.length > 0) {
+            const { data } = await mcp.getTools(this.mentionedMCPs);
+            return data;
+        }
+        else {
+            return [];
+        }
+    }
+}
+exports.UserMessage = UserMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/agent",
-  "version": "5.0.2",
+  "version": "5.0.7",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,19 +30,21 @@
   "dependencies": {
     "js-yaml": "^4.1.0",
     "zod": "^3.22.4",
-    "@codebolt/types": "1.0.22"
+    "@codebolt/types": "5.0.7"
   },
   "peerDependencies": {
-    "@codebolt/codeboltjs": "5.0.2"
+    "@codebolt/codeboltjs": "5.0.7"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.14.2",
     "@types/uri-templates": "^0.1.34",
     "@types/ws": "^8.5.10",
+    "typedoc": "0.28.16",
+    "typedoc-plugin-markdown": "4.9.0",
     "typescript": "^5.4.5",
-    "@codebolt/codeboltjs": "5.0.2",
-    "@codebolt/types": "1.0.22"
+    "@codebolt/types": "5.0.7",
+    "@codebolt/codeboltjs": "5.0.7"
   },
   "exports": {
     "./builder": {
@@ -71,6 +73,9 @@
     "clean": "rm -rf dist",
     "dev": "tsc --watch",
     "test": "echo \"No tests yet, but build passes\" && exit 0",
-    "lint:test": "eslint src/**/*.ts && tsc --noEmit"
+    "lint:test": "eslint src/**/*.ts && tsc --noEmit",
+    "docs": "node script/gen-docusaurus-agent-types.js",
+    "docs:clean": "node script/gen-docusaurus-agent-types.js --clean",
+    "docs:watch": "node script/gen-docusaurus-agent-types.js --watch"
   }
 }

package/dist/local-tools/fileTools.d.ts

@@ -1,26 +0,0 @@
-import { BaseTool } from '../processor';
-export declare class FileReadTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}
-export declare class FileWriteTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}
-export declare class FileDeleteTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}
-export declare class FileMoveTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}
-export declare class FileCopyTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}