@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/tools/file/list-directory.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * List Directory Tool - Lists files and directories
+ * Wraps the SDK's cbfs.listDirectory() method
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDirectoryTool = void 0;
+const path = __importStar(require("path"));
+const paths_1 = require("../utils/paths");
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class ListDirectoryToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    toolLocations() {
+        return [{ path: this.params.path }];
+    }
+    async execute() {
+        var _a;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            // Call the SDK's fs module
+            const response = await fs_1.default.listDirectory({
+                path: this.params.path,
+                ignore: this.params.ignore,
+                show_hidden: this.params.show_hidden,
+                detailed: this.params.detailed,
+                limit: this.params.limit,
+            });
+            if (!response.success) {
+                const errorMsg = typeof response.error === 'string'
+                    ? response.error
+                    : ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown error';
+                return {
+                    llmContent: `Error listing directory: ${errorMsg}`,
+                    returnDisplay: `Error listing directory: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.LS_EXECUTION_ERROR,
+                    },
+                };
+            }
+            // Format the directory listing
+            const entries = response.entries || [];
+            let output = `Directory: ${this.params.path}\n`;
+            output += `Total entries: ${entries.length}\n\n`;
+            if (entries.length === 0) {
+                output += '(empty directory)';
+            }
+            else {
+                // Group by type
+                const dirs = entries.filter((e) => e.type === 'directory' || e.isDirectory);
+                const files = entries.filter((e) => e.type === 'file' || !e.isDirectory);
+                if (dirs.length > 0) {
+                    output += `Directories (${dirs.length}):\n`;
+                    for (const dir of dirs) {
+                        const name = dir.name || dir.path || dir;
+                        output += `  [DIR]  ${name}\n`;
+                    }
+                    output += '\n';
+                }
+                if (files.length > 0) {
+                    output += `Files (${files.length}):\n`;
+                    for (const file of files) {
+                        const name = file.name || file.path || file;
+                        if (this.params.detailed && file.size !== undefined) {
+                            const size = this.formatSize(file.size);
+                            output += `  [FILE] ${name} (${size})\n`;
+                        }
+                        else {
+                            output += `  [FILE] ${name}\n`;
+                        }
+                    }
+                }
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Listed ${entries.length} entries in ${(0, paths_1.shortenPath)(this.params.path)}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing directory: ${errorMessage}`,
+                returnDisplay: `Error listing directory: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+    formatSize(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(1)} ${units[unitIndex]}`;
+    }
+}
+/**
+ * Implementation of the ListDirectory tool logic
+ */
+class ListDirectoryTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ListDirectoryTool.Name, 'ListDirectory', `Lists files and directories in a specified path. Returns information about directory contents including file names, types, and optionally sizes. Use this to explore the file system structure.`, types_1.Kind.Read, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                path: {
+                    description: "The absolute path to the directory to list (e.g., '/home/user/project'). Relative paths are not supported.",
+                    type: 'string',
+                },
+                ignore: {
+                    description: "Optional array of glob patterns for files/directories to ignore (e.g., ['node_modules', '*.log']).",
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+                show_hidden: {
+                    description: 'Whether to show hidden files and directories (those starting with a dot). Defaults to false.',
+                    type: 'boolean',
+                },
+                detailed: {
+                    description: 'Whether to include detailed information like file sizes. Defaults to false.',
+                    type: 'boolean',
+                },
+                limit: {
+                    description: 'Maximum number of entries to return. Useful for large directories.',
+                    type: 'number',
+                },
+            },
+            required: ['path'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        const dirPath = params.path;
+        if (params.path.trim() === '') {
+            return "The 'path' parameter must be non-empty.";
+        }
+        if (!path.isAbsolute(dirPath)) {
+            return `Path must be absolute, but was relative: ${dirPath}. You must provide an absolute path.`;
+        }
+        if (params.limit !== undefined && params.limit <= 0) {
+            return 'Limit must be a positive number';
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ListDirectoryToolInvocation(params);
+    }
+}
+exports.ListDirectoryTool = ListDirectoryTool;
+ListDirectoryTool.Name = 'ls';

package/dist/tools/file/read-file.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Read File Tool - Reads and returns the content of a specified file
+ * Wraps the SDK's cbfs.readFile() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the ReadFile tool
+ */
+export interface ReadFileToolParams {
+    /**
+     * One sentence explanation of why this tool is being used
+     */
+    explanation?: string;
+    /**
+     * The absolute path to the file to read
+     */
+    absolute_path: string;
+    /**
+     * The line number to start reading from (optional, 0-based)
+     */
+    offset?: number;
+    /**
+     * The number of lines to read (optional)
+     */
+    limit?: number;
+}
+/**
+ * Implementation of the ReadFile tool logic
+ */
+export declare class ReadFileTool extends BaseDeclarativeTool<ReadFileToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ReadFileToolParams): string | null;
+    protected createInvocation(params: ReadFileToolParams): ToolInvocation<ReadFileToolParams, ToolResult>;
+}

package/dist/tools/file/read-file.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Read File Tool - Reads and returns the content of a specified file
+ * Wraps the SDK's cbfs.readFile() method
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadFileTool = void 0;
+const path = __importStar(require("path"));
+const paths_1 = require("../utils/paths");
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class ReadFileToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    toolLocations() {
+        const location = { path: this.params.absolute_path };
+        if (this.params.offset !== undefined) {
+            location.line = this.params.offset;
+        }
+        return [location];
+    }
+    async execute() {
+        var _a;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            // Call the SDK's fs module
+            const response = await fs_1.default.readFile(this.params.absolute_path);
+            if (!response.success) {
+                const errorMsg = typeof response.error === 'string'
+                    ? response.error
+                    : ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown error';
+                return {
+                    llmContent: `Error reading file: ${errorMsg}`,
+                    returnDisplay: `Error reading file: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.FILE_NOT_FOUND,
+                    },
+                };
+            }
+            let content = response.content || '';
+            let isTruncated = false;
+            let linesShown;
+            let originalLineCount;
+            // Apply offset/limit if specified (presentation logic)
+            if (this.params.offset !== undefined || this.params.limit !== undefined) {
+                const lines = content.split('\n');
+                originalLineCount = lines.length;
+                const startLine = this.params.offset || 0;
+                const endLine = this.params.limit
+                    ? Math.min(startLine + this.params.limit, lines.length)
+                    : lines.length;
+                if (startLine >= lines.length) {
+                    return {
+                        llmContent: `Error: Offset ${startLine} is beyond the file length (${lines.length} lines)`,
+                        returnDisplay: `Error: Offset out of range`,
+                        error: {
+                            message: `Offset ${startLine} is beyond file length`,
+                            type: types_1.ToolErrorType.INVALID_TOOL_PARAMS,
+                        },
+                    };
+                }
+                const selectedLines = lines.slice(startLine, endLine);
+                content = selectedLines.join('\n');
+                linesShown = [startLine + 1, endLine]; // 1-based for display
+                isTruncated = endLine < lines.length;
+            }
+            // Build response content with truncation messaging
+            let llmContent;
+            if (isTruncated && linesShown && originalLineCount) {
+                const [start, end] = linesShown;
+                const nextOffset = this.params.offset
+                    ? this.params.offset + end - start + 1
+                    : end;
+                llmContent = `
+IMPORTANT: The file content has been truncated.
+Status: Showing lines ${start}-${end} of ${originalLineCount} total lines.
+Action: To read more of the file, you can use the 'offset' and 'limit' parameters in a subsequent 'read_file' call. For example, to read the next section of the file, use offset: ${nextOffset}.
+
+--- FILE CONTENT (truncated) ---
+${content}`;
+            }
+            else {
+                llmContent = content;
+            }
+            return {
+                llmContent,
+                returnDisplay: `Successfully read ${(0, paths_1.shortenPath)(this.params.absolute_path)}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error reading file: ${errorMessage}`,
+                returnDisplay: `Error reading file: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the ReadFile tool logic
+ */
+class ReadFileTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ReadFileTool.Name, 'ReadFile', `Reads and returns the content of a specified file. If the file is large, the content will be truncated. The tool's response will clearly indicate if truncation has occurred and will provide details on how to read more of the file using the 'offset' and 'limit' parameters. Handles text files and can read specific line ranges.`, types_1.Kind.Read, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                absolute_path: {
+                    description: "The absolute path to the file to read (e.g., '/home/user/project/file.txt'). Relative paths are not supported. You must provide an absolute path.",
+                    type: 'string',
+                },
+                offset: {
+                    description: "Optional: For text files, the 0-based line number to start reading from. Requires 'limit' to be set. Use for paginating through large files.",
+                    type: 'number',
+                },
+                limit: {
+                    description: "Optional: For text files, maximum number of lines to read. Use with 'offset' to paginate through large files. If omitted, reads the entire file (if feasible, up to a default limit).",
+                    type: 'number',
+                },
+            },
+            required: ['absolute_path'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        const filePath = params.absolute_path;
+        if (params.absolute_path.trim() === '') {
+            return "The 'absolute_path' parameter must be non-empty.";
+        }
+        if (!path.isAbsolute(filePath)) {
+            return `File path must be absolute, but was relative: ${filePath}. You must provide an absolute path.`;
+        }
+        if (params.offset !== undefined && params.offset < 0) {
+            return 'Offset must be a non-negative number';
+        }
+        if (params.limit !== undefined && params.limit <= 0) {
+            return 'Limit must be a positive number';
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ReadFileToolInvocation(params);
+    }
+}
+exports.ReadFileTool = ReadFileTool;
+ReadFileTool.Name = 'read_file';

package/dist/tools/file/read-many-files.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Read Many Files Tool - Reads multiple files at once
+ * Wraps the SDK's cbfs.readManyFiles() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the ReadManyFiles tool
+ */
+export interface ReadManyFilesToolParams {
+    /**
+     * One sentence explanation of why this tool is being used
+     */
+    explanation?: string;
+    /**
+     * An array of file paths, directory paths, or glob patterns to read
+     */
+    paths: string[];
+    /**
+     * Optional glob patterns for files to include
+     */
+    include?: string[];
+    /**
+     * Optional glob patterns for files/directories to exclude
+     */
+    exclude?: string[];
+    /**
+     * Whether to search recursively through subdirectories (default: true)
+     */
+    recursive?: boolean;
+    /**
+     * Whether to use default exclusion patterns (node_modules, .git, etc.)
+     */
+    use_default_excludes?: boolean;
+    /**
+     * Maximum number of files to read
+     */
+    max_files?: number;
+    /**
+     * Maximum total size of content to read (in bytes)
+     */
+    max_total_size?: number;
+    /**
+     * Whether to include file metadata in output
+     */
+    include_metadata?: boolean;
+}
+/**
+ * Implementation of the ReadManyFiles tool logic
+ */
+export declare class ReadManyFilesTool extends BaseDeclarativeTool<ReadManyFilesToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ReadManyFilesToolParams): string | null;
+    protected createInvocation(params: ReadManyFilesToolParams): ToolInvocation<ReadManyFilesToolParams, ToolResult>;
+}

package/dist/tools/file/read-many-files.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Read Many Files Tool - Reads multiple files at once
+ * Wraps the SDK's cbfs.readManyFiles() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadManyFilesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class ReadManyFilesToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    toolLocations() {
+        return this.params.paths.map(p => ({ path: p }));
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            // Call the SDK's fs module
+            const response = await fs_1.default.readManyFiles({
+                paths: this.params.paths,
+                include: this.params.include,
+                exclude: this.params.exclude,
+                recursive: (_a = this.params.recursive) !== null && _a !== void 0 ? _a : true,
+                use_default_excludes: (_b = this.params.use_default_excludes) !== null && _b !== void 0 ? _b : true,
+                max_files: this.params.max_files,
+                max_total_size: this.params.max_total_size,
+                include_metadata: this.params.include_metadata,
+            });
+            if (!response.success) {
+                const errorMsg = response.error || response.message || 'Unknown error';
+                return {
+                    llmContent: `Error reading files: ${errorMsg}`,
+                    returnDisplay: `Error reading files: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.READ_MANY_FILES_SEARCH_ERROR,
+                    },
+                };
+            }
+            // Format the output
+            // ReadManyFilesResponse has results?: Array<{ path, content, error }>, etc.
+            const results = response.results || [];
+            const files = results.map((r) => {
+                var _a;
+                return ({
+                    filePath: r.path,
+                    content: r.content,
+                    error: r.error,
+                    success: !r.error,
+                    size: ((_a = r.content) === null || _a === void 0 ? void 0 : _a.length) || 0
+                });
+            });
+            const totalFiles = files.length;
+            const filesRead = files.filter((f) => f.success).length;
+            const totalSize = files.reduce((sum, f) => { var _a; return sum + (((_a = f.content) === null || _a === void 0 ? void 0 : _a.length) || 0); }, 0);
+            const truncated = false;
+            let output = '';
+            if (files.length === 0) {
+                output = 'No files matched the specified patterns.';
+            }
+            else {
+                // Add summary header
+                output += `=== Read ${filesRead} file(s) (Total found: ${totalFiles}) ===\n`;
+                output += '\n';
+                // Add each file's content
+                for (const file of files) {
+                    const filePath = file.filePath;
+                    // If error exists, it might be in file.error
+                    if (file.error) {
+                        output += `--- FILE: ${filePath} (ERROR) ---\n`;
+                        output += `Error: ${file.error}\n\n`;
+                        continue;
+                    }
+                    const content = file.content || '';
+                    output += `--- FILE: ${filePath} ---\n`;
+                    if (this.params.include_metadata && file.size !== undefined) {
+                        output += `Size: ${file.size} bytes\n`;
+                    }
+                    output += content;
+                    if (!content.endsWith('\n')) {
+                        output += '\n';
+                    }
+                    output += '\n';
+                }
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Read ${filesRead}/${totalFiles} file(s), ${this.formatSize(totalSize)} total`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error reading files: ${errorMessage}`,
+                returnDisplay: `Error reading files: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+    formatSize(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(1)} ${units[unitIndex]}`;
+    }
+}
+/**
+ * Implementation of the ReadManyFiles tool logic
+ */
+class ReadManyFilesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ReadManyFilesTool.Name, 'ReadManyFiles', `Reads multiple files at once based on file paths, directory paths, or glob patterns. Efficiently retrieves content from multiple files in a single operation. Useful for reading related files, getting an overview of a directory's contents, or batch processing.`, types_1.Kind.Read, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                paths: {
+                    description: "An array of file paths, directory paths, or glob patterns to read (e.g., ['/path/to/file.ts', '/path/to/dir', '**/*.json']).",
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+                include: {
+                    description: "Optional glob patterns for files to include (e.g., ['*.ts', '*.tsx']).",
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+                exclude: {
+                    description: "Optional glob patterns for files/directories to exclude (e.g., ['*.test.ts', 'node_modules']).",
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+                recursive: {
+                    description: 'Whether to search recursively through subdirectories. Defaults to true.',
+                    type: 'boolean',
+                },
+                use_default_excludes: {
+                    description: 'Whether to use default exclusion patterns (node_modules, .git, etc.). Defaults to true.',
+                    type: 'boolean',
+                },
+                max_files: {
+                    description: 'Maximum number of files to read. Useful for limiting output size.',
+                    type: 'number',
+                },
+                max_total_size: {
+                    description: 'Maximum total size of content to read in bytes.',
+                    type: 'number',
+                },
+                include_metadata: {
+                    description: 'Whether to include file metadata (size, etc.) in output.',
+                    type: 'boolean',
+                },
+            },
+            required: ['paths'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.paths || params.paths.length === 0) {
+            return "The 'paths' parameter must be a non-empty array.";
+        }
+        if (params.max_files !== undefined && params.max_files <= 0) {
+            return 'max_files must be a positive number';
+        }
+        if (params.max_total_size !== undefined && params.max_total_size <= 0) {
+            return 'max_total_size must be a positive number';
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ReadManyFilesToolInvocation(params);
+    }
+}
+exports.ReadManyFilesTool = ReadManyFilesTool;
+ReadManyFilesTool.Name = 'read_many_files';