@oflow-ai/core 0.1.0

package/dist/tools/base.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTool = void 0;
+exports.createToolResult = createToolResult;
+exports.formatToolError = formatToolError;
+class BaseTool {
+    getDefinition() {
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: this.parameters
+            }
+        };
+    }
+    validateRequired(params, required) {
+        for (const key of required) {
+            if (params[key] === undefined) {
+                throw new Error(`Missing required parameter: ${key}`);
+            }
+        }
+    }
+}
+exports.BaseTool = BaseTool;
+function createToolResult(toolCallId, content, isError = false) {
+    return {
+        toolCallId,
+        content,
+        isError
+    };
+}
+function formatToolError(error) {
+    if (error instanceof Error) {
+        return `Error: ${error.message}`;
+    }
+    return `Error: ${String(error)}`;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/glob.d.ts

@@ -0,0 +1,27 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface GlobParams {
+    pattern: string;
+    path?: string;
+}
+export declare class GlobTool extends BaseTool<GlobParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            pattern: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: GlobParams, options?: ToolExecuteOptions): Promise<string>;
+    private walkDir;
+    private matchPattern;
+}
+export {};

package/dist/tools/glob.js

@@ -0,0 +1,125 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class GlobTool extends base_1.BaseTool {
+    name = 'glob';
+    description = 'Finds files matching specific glob patterns, returning absolute paths sorted by modification time.';
+    parameters = {
+        type: 'object',
+        properties: {
+            pattern: {
+                type: 'string',
+                description: 'The glob pattern to match (e.g., **/*.ts, src/**/*.js)'
+            },
+            path: {
+                type: 'string',
+                description: 'Optional: The absolute path to search within'
+            }
+        },
+        required: ['pattern']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['pattern']);
+        const workingDir = options?.workingDirectory || process.cwd();
+        const searchPath = params.path || workingDir;
+        try {
+            const results = [];
+            await this.walkDir(searchPath, params.pattern, results);
+            if (results.length === 0) {
+                return `No files found matching pattern: ${params.pattern}`;
+            }
+            // Sort by modification time (newest first)
+            const withStats = await Promise.all(results.map(async (file) => {
+                try {
+                    const stat = await fs.stat(file);
+                    return { file, mtime: stat.mtime.getTime() };
+                }
+                catch {
+                    return { file, mtime: 0 };
+                }
+            }));
+            withStats.sort((a, b) => b.mtime - a.mtime);
+            return `Found ${withStats.length} files:\n\n${withStats.map(r => r.file).join('\n')}`;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+    async walkDir(dir, pattern, results) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip common ignored directories
+                if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) {
+                    continue;
+                }
+                await this.walkDir(fullPath, pattern, results);
+            }
+            else if (entry.isFile()) {
+                if (this.matchPattern(fullPath, pattern)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+    }
+    matchPattern(filePath, pattern) {
+        // Simple glob matching
+        const fileName = path.basename(filePath);
+        // Handle **/*.ext pattern
+        if (pattern.startsWith('**/*.')) {
+            const ext = pattern.slice(4);
+            return fileName.endsWith(ext);
+        }
+        // Handle *.ext pattern
+        if (pattern.startsWith('*.')) {
+            const ext = pattern.slice(1);
+            return fileName.endsWith(ext);
+        }
+        // Handle **/name pattern
+        if (pattern.startsWith('**/')) {
+            const name = pattern.slice(3);
+            return fileName.includes(name);
+        }
+        // Direct match
+        return fileName.includes(pattern);
+    }
+}
+exports.GlobTool = GlobTool;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"glob.js","sourceRoot":"","sources":["../../src/tools/glob.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTool, ToolExecuteOptions, formatToolError } from './base';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\ninterface GlobParams {\n  pattern: string;\n  path?: string;\n}\n\nexport class GlobTool extends BaseTool<GlobParams> {\n  name = 'glob';\n  description = 'Finds files matching specific glob patterns, returning absolute paths sorted by modification time.';\n  parameters = {\n    type: 'object',\n    properties: {\n      pattern: {\n        type: 'string',\n        description: 'The glob pattern to match (e.g., **/*.ts, src/**/*.js)'\n      },\n      path: {\n        type: 'string',\n        description: 'Optional: The absolute path to search within'\n      }\n    },\n    required: ['pattern']\n  };\n\n  async execute(params: GlobParams, options?: ToolExecuteOptions): Promise<string> {\n    this.validateRequired(params, ['pattern']);\n\n    const workingDir = options?.workingDirectory || process.cwd();\n    const searchPath = params.path || workingDir;\n\n    try {\n      const results: string[] = [];\n      await this.walkDir(searchPath, params.pattern, results);\n\n      if (results.length === 0) {\n        return `No files found matching pattern: ${params.pattern}`;\n      }\n\n      // Sort by modification time (newest first)\n      const withStats = await Promise.all(\n        results.map(async (file) => {\n          try {\n            const stat = await fs.stat(file);\n            return { file, mtime: stat.mtime.getTime() };\n          } catch {\n            return { file, mtime: 0 };\n          }\n        })\n      );\n\n      withStats.sort((a, b) => b.mtime - a.mtime);\n\n      return `Found ${withStats.length} files:\\n\\n${withStats.map(r => r.file).join('\\n')}`;\n    } catch (error) {\n      return formatToolError(error);\n    }\n  }\n\n  private async walkDir(dir: string, pattern: string, results: string[]): Promise<void> {\n    const entries = await fs.readdir(dir, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = path.join(dir, entry.name);\n\n      if (entry.isDirectory()) {\n        // Skip common ignored directories\n        if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) {\n          continue;\n        }\n        await this.walkDir(fullPath, pattern, results);\n      } else if (entry.isFile()) {\n        if (this.matchPattern(fullPath, pattern)) {\n          results.push(fullPath);\n        }\n      }\n    }\n  }\n\n  private matchPattern(filePath: string, pattern: string): boolean {\n    // Simple glob matching\n    const fileName = path.basename(filePath);\n    \n    // Handle **/*.ext pattern\n    if (pattern.startsWith('**/*.')) {\n      const ext = pattern.slice(4);\n      return fileName.endsWith(ext);\n    }\n\n    // Handle *.ext pattern\n    if (pattern.startsWith('*.')) {\n      const ext = pattern.slice(1);\n      return fileName.endsWith(ext);\n    }\n\n    // Handle **/name pattern\n    if (pattern.startsWith('**/')) {\n      const name = pattern.slice(3);\n      return fileName.includes(name);\n    }\n\n    // Direct match\n    return fileName.includes(pattern);\n  }\n}\n"]}

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

@@ -0,0 +1,42 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface ImageReadParams {
+    image_input: string;
+    prompt?: string;
+    input_type?: 'file_path' | 'base64';
+    mime_type?: string;
+    task_brief?: string;
+}
+export declare class ImageReadTool extends BaseTool<ImageReadParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            image_input: {
+                type: string;
+                description: string;
+            };
+            prompt: {
+                type: string;
+                description: string;
+            };
+            input_type: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            mime_type: {
+                type: string;
+                description: string;
+            };
+            task_brief: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: ImageReadParams, options?: ToolExecuteOptions): Promise<string>;
+    private detectMimeType;
+}
+export {};

package/dist/tools/image-read.js

@@ -0,0 +1,125 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageReadTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class ImageReadTool extends base_1.BaseTool {
+    name = 'image_read';
+    description = 'Reads image files and generates detailed contextual analysis using VL models. The tool accepts prompt information to create targeted image descriptions.';
+    parameters = {
+        type: 'object',
+        properties: {
+            image_input: {
+                type: 'string',
+                description: 'Image input: either absolute file path or base64 encoded image data'
+            },
+            prompt: {
+                type: 'string',
+                description: 'A comprehensive instruction for the VL model'
+            },
+            input_type: {
+                type: 'string',
+                enum: ['file_path', 'base64'],
+                description: 'Input type: file_path or base64'
+            },
+            mime_type: {
+                type: 'string',
+                description: 'Optional image MIME type when input_type is base64'
+            },
+            task_brief: {
+                type: 'string',
+                description: 'Brief task description'
+            }
+        },
+        required: ['image_input']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['image_input']);
+        const workingDir = options?.workingDirectory || process.cwd();
+        const inputType = params.input_type || 'file_path';
+        try {
+            let imageData;
+            let mimeType = params.mime_type || 'image/png';
+            if (inputType === 'file_path') {
+                const filePath = path.isAbsolute(params.image_input)
+                    ? params.image_input
+                    : path.join(workingDir, params.image_input);
+                // 检查文件是否存在
+                const stats = await fs.stat(filePath);
+                if (!stats.isFile()) {
+                    return `Error: ${filePath} is not a file`;
+                }
+                // 读取文件并转为base64
+                const buffer = await fs.readFile(filePath);
+                imageData = buffer.toString('base64');
+                // 检测MIME类型
+                mimeType = this.detectMimeType(filePath);
+            }
+            else {
+                imageData = params.image_input;
+            }
+            // 由于我们没有实际的VL模型，返回图片信息
+            const prompt = params.prompt || 'Describe this image';
+            return `Image Analysis Request:
+- MIME Type: ${mimeType}
+- Data Length: ${imageData.length} characters (base64)
+- Prompt: ${prompt}
+
+Note: To enable actual image analysis, configure a vision-capable AI model in settings.
+The image has been loaded and is ready for analysis.`;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+    detectMimeType(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const mimeTypes = {
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.webp': 'image/webp',
+            '.svg': 'image/svg+xml',
+            '.bmp': 'image/bmp',
+            '.ico': 'image/x-icon'
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+}
+exports.ImageReadTool = ImageReadTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/index.d.ts

@@ -0,0 +1,27 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+import { ToolDefinition, ToolResult, ToolCall } from '../types';
+export * from './base';
+export * from './read-file';
+export * from './write-file';
+export * from './list-directory';
+export * from './glob';
+export * from './search-file-content';
+export * from './run-shell-command';
+export * from './web-search';
+export * from './web-fetch';
+export * from './replace';
+export * from './image-read';
+export * from './pdf-extract';
+export * from './ask-user-question';
+export * from './task';
+export * from './save-memory';
+export declare class ToolRegistry {
+    private tools;
+    constructor();
+    register(tool: BaseTool<any>): void;
+    get(name: string): BaseTool<any> | undefined;
+    getAll(): BaseTool<any>[];
+    getDefinitions(): ToolDefinition[];
+    execute(toolCall: ToolCall, options?: ToolExecuteOptions): Promise<ToolResult>;
+}
+export declare function getToolRegistry(): ToolRegistry;

package/dist/tools/index.js

@@ -0,0 +1,127 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = void 0;
+exports.getToolRegistry = getToolRegistry;
+const read_file_1 = require("./read-file");
+const write_file_1 = require("./write-file");
+const list_directory_1 = require("./list-directory");
+const glob_1 = require("./glob");
+const search_file_content_1 = require("./search-file-content");
+const run_shell_command_1 = require("./run-shell-command");
+const web_search_1 = require("./web-search");
+const web_fetch_1 = require("./web-fetch");
+const replace_1 = require("./replace");
+const image_read_1 = require("./image-read");
+const pdf_extract_1 = require("./pdf-extract");
+const ask_user_question_1 = require("./ask-user-question");
+const task_1 = require("./task");
+const save_memory_1 = require("./save-memory");
+// Export all tools
+__exportStar(require("./base"), exports);
+__exportStar(require("./read-file"), exports);
+__exportStar(require("./write-file"), exports);
+__exportStar(require("./list-directory"), exports);
+__exportStar(require("./glob"), exports);
+__exportStar(require("./search-file-content"), exports);
+__exportStar(require("./run-shell-command"), exports);
+__exportStar(require("./web-search"), exports);
+__exportStar(require("./web-fetch"), exports);
+__exportStar(require("./replace"), exports);
+__exportStar(require("./image-read"), exports);
+__exportStar(require("./pdf-extract"), exports);
+__exportStar(require("./ask-user-question"), exports);
+__exportStar(require("./task"), exports);
+__exportStar(require("./save-memory"), exports);
+// Core tools list
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const coreTools = [
+    new read_file_1.ReadFileTool(),
+    new write_file_1.WriteFileTool(),
+    new list_directory_1.ListDirectoryTool(),
+    new glob_1.GlobTool(),
+    new search_file_content_1.SearchFileContentTool(),
+    new run_shell_command_1.RunShellCommandTool(),
+    new web_search_1.WebSearchTool(),
+    new web_fetch_1.WebFetchTool(),
+    new replace_1.ReplaceTool(),
+    new image_read_1.ImageReadTool(),
+    new pdf_extract_1.PDFExtractTool(),
+    new ask_user_question_1.AskUserQuestionTool(),
+    new task_1.TaskTool(),
+    new save_memory_1.SaveMemoryTool()
+];
+class ToolRegistry {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    tools = new Map();
+    constructor() {
+        // Register core tools
+        for (const tool of coreTools) {
+            this.register(tool);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    register(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get(name) {
+        return this.tools.get(name);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getAll() {
+        return Array.from(this.tools.values());
+    }
+    getDefinitions() {
+        return this.getAll().map(tool => tool.getDefinition());
+    }
+    async execute(toolCall, options) {
+        const tool = this.get(toolCall.function.name);
+        if (!tool) {
+            return {
+                toolCallId: toolCall.id,
+                content: `Error: Unknown tool: ${toolCall.function.name}`,
+                isError: true
+            };
+        }
+        try {
+            const params = JSON.parse(toolCall.function.arguments);
+            const result = await tool.execute(params, options);
+            return {
+                toolCallId: toolCall.id,
+                content: result,
+                isError: false
+            };
+        }
+        catch (error) {
+            return {
+                toolCallId: toolCall.id,
+                content: error instanceof Error ? error.message : String(error),
+                isError: true
+            };
+        }
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+// Singleton instance
+let toolRegistry = null;
+function getToolRegistry() {
+    if (!toolRegistry) {
+        toolRegistry = new ToolRegistry();
+    }
+    return toolRegistry;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTool, ToolExecuteOptions } from './base';\nimport { ReadFileTool } from './read-file';\nimport { WriteFileTool } from './write-file';\nimport { ListDirectoryTool } from './list-directory';\nimport { GlobTool } from './glob';\nimport { SearchFileContentTool } from './search-file-content';\nimport { RunShellCommandTool } from './run-shell-command';\nimport { WebSearchTool } from './web-search';\nimport { WebFetchTool } from './web-fetch';\nimport { ReplaceTool } from './replace';\nimport { ImageReadTool } from './image-read';\nimport { PDFExtractTool } from './pdf-extract';\nimport { AskUserQuestionTool } from './ask-user-question';\nimport { TaskTool } from './task';\nimport { SaveMemoryTool } from './save-memory';\nimport { ToolDefinition, ToolResult, ToolCall } from '../types';\n\n// Export all tools\nexport * from './base';\nexport * from './read-file';\nexport * from './write-file';\nexport * from './list-directory';\nexport * from './glob';\nexport * from './search-file-content';\nexport * from './run-shell-command';\nexport * from './web-search';\nexport * from './web-fetch';\nexport * from './replace';\nexport * from './image-read';\nexport * from './pdf-extract';\nexport * from './ask-user-question';\nexport * from './task';\nexport * from './save-memory';\n\n// Core tools list\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst coreTools: BaseTool<any>[] = [\n  new ReadFileTool(),\n  new WriteFileTool(),\n  new ListDirectoryTool(),\n  new GlobTool(),\n  new SearchFileContentTool(),\n  new RunShellCommandTool(),\n  new WebSearchTool(),\n  new WebFetchTool(),\n  new ReplaceTool(),\n  new ImageReadTool(),\n  new PDFExtractTool(),\n  new AskUserQuestionTool(),\n  new TaskTool(),\n  new SaveMemoryTool()\n];\n\nexport class ToolRegistry {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private tools: Map<string, BaseTool<any>> = new Map();\n\n  constructor() {\n    // Register core tools\n    for (const tool of coreTools) {\n      this.register(tool);\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  register(tool: BaseTool<any>): void {\n    this.tools.set(tool.name, tool);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  get(name: string): BaseTool<any> | undefined {\n    return this.tools.get(name);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  getAll(): BaseTool<any>[] {\n    return Array.from(this.tools.values());\n  }\n\n  getDefinitions(): ToolDefinition[] {\n    return this.getAll().map(tool => tool.getDefinition());\n  }\n\n  async execute(\n    toolCall: ToolCall,\n    options?: ToolExecuteOptions\n  ): Promise<ToolResult> {\n    const tool = this.get(toolCall.function.name);\n    \n    if (!tool) {\n      return {\n        toolCallId: toolCall.id,\n        content: `Error: Unknown tool: ${toolCall.function.name}`,\n        isError: true\n      };\n    }\n\n    try {\n      const params = JSON.parse(toolCall.function.arguments);\n      const result = await tool.execute(params, options);\n      \n      return {\n        toolCallId: toolCall.id,\n        content: result,\n        isError: false\n      };\n    } catch (error) {\n      return {\n        toolCallId: toolCall.id,\n        content: error instanceof Error ? error.message : String(error),\n        isError: true\n      };\n    }\n  }\n}\n\n// Singleton instance\nlet toolRegistry: ToolRegistry | null = null;\n\nexport function getToolRegistry(): ToolRegistry {\n  if (!toolRegistry) {\n    toolRegistry = new ToolRegistry();\n  }\n  return toolRegistry;\n}\n"]}

package/dist/tools/list-directory.d.ts

@@ -0,0 +1,28 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface ListDirectoryParams {
+    path: string;
+    ignore?: string[];
+}
+export declare class ListDirectoryTool extends BaseTool<ListDirectoryParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            ignore: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: ListDirectoryParams, options?: ToolExecuteOptions): Promise<string>;
+}
+export {};