@crewx/sdk 0.8.0-rc.72 → 0.8.0-rc.74

package/dist/tools/node/builtin.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Built-in tool definitions for api/* provider agents.
+ *
+ * Adapted from packages/sdk-bak/src/tools/.
+ * Uses only Node.js built-ins — no external dependencies.
+ *
+ * Each entry in BUILTIN_TOOL_REGISTRY matches Omit<ToolDefinition, 'name'>.
+ * Register via crewx.registerTool(name, BUILTIN_TOOL_REGISTRY[name]).
+ */
+type BuiltinTool = {
+    description: string;
+    parameters?: Record<string, unknown>;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+};
+/**
+ * All available built-in tools, keyed by tool name.
+ *
+ * Listed tools are registered via crewx.registerTool() when their name appears
+ * in crewx.yaml `tools.builtin` for an agent using an api/* provider.
+ */
+export declare const BUILTIN_TOOL_REGISTRY: Record<string, BuiltinTool>;
+export {};
+//# sourceMappingURL=builtin.d.ts.map

package/dist/tools/node/builtin.js

@@ -0,0 +1,547 @@
+"use strict";
+/**
+ * Built-in tool definitions for api/* provider agents.
+ *
+ * Adapted from packages/sdk-bak/src/tools/.
+ * Uses only Node.js built-ins — no external dependencies.
+ *
+ * Each entry in BUILTIN_TOOL_REGISTRY matches Omit<ToolDefinition, 'name'>.
+ * Register via crewx.registerTool(name, BUILTIN_TOOL_REGISTRY[name]).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_TOOL_REGISTRY = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+// ─────────────────────────────────────────────────────────────────────────────
+// Shared helpers
+// ─────────────────────────────────────────────────────────────────────────────
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next']);
+async function listRecursive(dirPath, basePath, maxDepth = 5, depth = 0) {
+    if (depth >= maxDepth) {
+        return [`${node_path_1.default.relative(basePath, dirPath)}/ (max depth reached)`];
+    }
+    const results = [];
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [`${node_path_1.default.relative(basePath, dirPath)}/ (permission denied)`];
+    }
+    for (const entry of entries) {
+        const fullPath = node_path_1.default.join(dirPath, entry.name);
+        const rel = node_path_1.default.relative(basePath, fullPath);
+        if (entry.isDirectory()) {
+            results.push(`${rel}/`);
+            const sub = await listRecursive(fullPath, basePath, maxDepth, depth + 1);
+            results.push(...sub);
+        }
+        else {
+            const s = await promises_1.default.stat(fullPath);
+            results.push(`${rel} (${s.size} bytes)`);
+        }
+    }
+    return results;
+}
+async function buildTreeLines(dirPath, opts) {
+    const { currentDepth, maxDepth } = opts;
+    const indent = '  '.repeat(currentDepth);
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code ?? 'unknown';
+        return [`${indent}(error: ${code})`];
+    }
+    entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    const lines = [];
+    for (const entry of entries) {
+        const fullPath = node_path_1.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            lines.push(`${indent}[DIR] ${entry.name}/`);
+            if (currentDepth < maxDepth) {
+                const child = await buildTreeLines(fullPath, {
+                    currentDepth: currentDepth + 1,
+                    maxDepth,
+                });
+                lines.push(...child);
+            }
+            else {
+                lines.push(`${'  '.repeat(currentDepth + 1)}(max depth reached)`);
+            }
+        }
+        else {
+            try {
+                const s = await promises_1.default.stat(fullPath);
+                lines.push(`${indent}[FILE] ${entry.name} (${s.size} bytes)`);
+            }
+            catch {
+                lines.push(`${indent}[FILE] ${entry.name} (stat error)`);
+            }
+        }
+    }
+    return lines;
+}
+async function searchFile(filePath, pattern, basePath) {
+    try {
+        const content = await promises_1.default.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const rel = node_path_1.default.relative(basePath, filePath);
+        return lines.flatMap((line, i) => pattern.test(line) ? [`${rel}:${i + 1}: ${line}`] : []);
+    }
+    catch {
+        return [];
+    }
+}
+async function searchRecursive(dirPath, pattern, basePath, maxDepth = 10, depth = 0) {
+    if (depth >= maxDepth)
+        return [];
+    const results = [];
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        const fullPath = node_path_1.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRS.has(entry.name)) {
+                const sub = await searchRecursive(fullPath, pattern, basePath, maxDepth, depth + 1);
+                results.push(...sub);
+            }
+        }
+        else {
+            const m = await searchFile(fullPath, pattern, basePath);
+            results.push(...m);
+        }
+    }
+    return results;
+}
+function matchWildcard(name, pattern, caseSensitive) {
+    const n = caseSensitive ? name : name.toLowerCase();
+    const p = caseSensitive ? pattern : pattern.toLowerCase();
+    const regexStr = p
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${regexStr}$`).test(n);
+}
+async function findFiles(dirPath, pattern, caseSensitive, results, maxResults, depth = 0) {
+    if (results.length >= maxResults || depth > 10)
+        return;
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (results.length >= maxResults)
+            break;
+        const fullPath = node_path_1.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRS.has(entry.name)) {
+                await findFiles(fullPath, pattern, caseSensitive, results, maxResults, depth + 1);
+            }
+        }
+        else if (matchWildcard(entry.name, pattern, caseSensitive)) {
+            results.push(fullPath);
+        }
+    }
+}
+function matchGlob(relPath, pattern) {
+    const rel = relPath.replace(/\\/g, '/');
+    const pat = pattern.replace(/\\/g, '/');
+    const regexStr = pat
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*\//g, '§§§')
+        .replace(/\*\*/g, '§§§')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/§§§/g, '.*');
+    return new RegExp(`^${regexStr}$`).test(rel);
+}
+async function globSearch(dirPath, pattern, basePath, results, maxResults, depth = 0) {
+    if (results.length >= maxResults || depth > 15)
+        return;
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (results.length >= maxResults)
+            break;
+        const fullPath = node_path_1.default.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRS.has(entry.name)) {
+                await globSearch(fullPath, pattern, basePath, results, maxResults, depth + 1);
+            }
+        }
+        else {
+            const rel = node_path_1.default.relative(basePath, fullPath).replace(/\\/g, '/');
+            if (matchGlob(rel, pattern))
+                results.push(fullPath);
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Tool definitions
+// ─────────────────────────────────────────────────────────────────────────────
+const readFileTool = {
+    description: 'Reads and returns the content of a specified file. Use offset/limit to paginate large text files.',
+    parameters: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Path to the file to read.' },
+            offset: { type: 'integer', description: 'Optional 0-based line number to start reading from.' },
+            limit: { type: 'integer', description: 'Optional maximum number of lines to read.' },
+        },
+        required: ['file_path'],
+    },
+    execute: async (args) => {
+        const filePath = args['file_path'];
+        const offset = args['offset'];
+        const limit = args['limit'];
+        if (!filePath.trim())
+            throw new Error("The 'file_path' parameter must be non-empty.");
+        const resolvedPath = node_path_1.default.resolve(filePath);
+        const content = await promises_1.default.readFile(resolvedPath, 'utf-8');
+        if (offset !== undefined || limit !== undefined) {
+            const lines = content.split('\n');
+            const start = offset ?? 0;
+            const end = limit !== undefined ? start + limit : lines.length;
+            const slice = lines.slice(start, end);
+            const truncated = end < lines.length;
+            const text = slice.join('\n');
+            if (truncated) {
+                return `IMPORTANT: Content truncated. Showing lines ${start}-${end - 1} of ${lines.length}.\n\n${text}`;
+            }
+            return text;
+        }
+        return content;
+    },
+};
+const writeFileTool = {
+    description: 'Creates a new file or overwrites an existing file with the provided content.',
+    parameters: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Path to the file to create or overwrite.' },
+            content: { type: 'string', description: 'The content to write to the file.' },
+        },
+        required: ['file_path', 'content'],
+    },
+    execute: async (args) => {
+        const filePath = args['file_path'];
+        const content = args['content'];
+        if (!filePath.trim())
+            throw new Error("The 'file_path' parameter must be non-empty.");
+        const resolvedPath = node_path_1.default.resolve(filePath);
+        await promises_1.default.mkdir(node_path_1.default.dirname(resolvedPath), { recursive: true });
+        let fileExists = false;
+        try {
+            await promises_1.default.access(resolvedPath);
+            fileExists = true;
+        }
+        catch { /* file does not exist */ }
+        await promises_1.default.writeFile(resolvedPath, content, 'utf-8');
+        const size = Buffer.byteLength(content, 'utf-8');
+        return `${fileExists ? 'Updated' : 'Created'} file: ${filePath} (${size} bytes)`;
+    },
+};
+const replaceTool = {
+    description: 'Replaces a range of lines in a file with new text. Line numbers are 1-based.',
+    parameters: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Path to the file to modify.' },
+            start_line: { type: 'integer', description: 'Starting line number (1-based, inclusive).' },
+            end_line: { type: 'integer', description: 'Ending line number (1-based, inclusive).' },
+            new_text: { type: 'string', description: 'New text to insert in place of the specified lines.' },
+        },
+        required: ['file_path', 'start_line', 'end_line', 'new_text'],
+    },
+    execute: async (args) => {
+        const filePath = args['file_path'];
+        const startLine = args['start_line'];
+        const endLine = args['end_line'];
+        const newText = args['new_text'];
+        if (!filePath.trim())
+            throw new Error("The 'file_path' parameter must be non-empty.");
+        if (startLine > endLine) {
+            throw new Error(`start_line (${startLine}) must be <= end_line (${endLine}).`);
+        }
+        const resolvedPath = node_path_1.default.resolve(filePath);
+        const content = await promises_1.default.readFile(resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        if (startLine < 1 || startLine > lines.length) {
+            throw new Error(`start_line (${startLine}) out of range. File has ${lines.length} lines.`);
+        }
+        if (endLine > lines.length) {
+            throw new Error(`end_line (${endLine}) out of range. File has ${lines.length} lines.`);
+        }
+        const newLines = newText.split('\n');
+        lines.splice(startLine - 1, endLine - startLine + 1, ...newLines);
+        await promises_1.default.writeFile(resolvedPath, lines.join('\n'), 'utf-8');
+        return `Successfully replaced lines ${startLine}-${endLine} in ${filePath}`;
+    },
+};
+const lsTool = {
+    description: "Lists contents of a directory. Shows file sizes and marks directories with trailing slashes.",
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory path to list (default: current directory).' },
+            recursive: { type: 'boolean', description: 'List contents recursively (default: false).' },
+        },
+    },
+    execute: async (args) => {
+        const dirPath = args['path'] ?? '.';
+        const recursive = args['recursive'] ?? false;
+        const resolvedPath = node_path_1.default.resolve(dirPath);
+        const stats = await promises_1.default.stat(resolvedPath);
+        if (!stats.isDirectory())
+            throw new Error(`Path is not a directory: ${dirPath}`);
+        let output = `Directory listing: ${dirPath}\n\n`;
+        if (recursive) {
+            const entries = await listRecursive(resolvedPath, resolvedPath);
+            output += entries.join('\n');
+        }
+        else {
+            const entries = await promises_1.default.readdir(resolvedPath, { withFileTypes: true });
+            const lines = [];
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    lines.push(`${entry.name}/`);
+                }
+                else {
+                    const s = await promises_1.default.stat(node_path_1.default.join(resolvedPath, entry.name));
+                    lines.push(`${entry.name} (${s.size} bytes)`);
+                }
+            }
+            output += lines.join('\n');
+        }
+        return output || 'Directory is empty';
+    },
+};
+const treeTool = {
+    description: "Displays a directory tree with [DIR]/[FILE] labels up to max_depth levels.",
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory to inspect (default: current directory).' },
+            max_depth: { type: 'integer', description: 'Maximum depth to traverse (default: 3).' },
+        },
+    },
+    execute: async (args) => {
+        const targetPath = args['path'] ?? '.';
+        const maxDepth = args['max_depth'] ?? 3;
+        const resolvedPath = node_path_1.default.resolve(targetPath);
+        const stats = await promises_1.default.stat(resolvedPath);
+        if (!stats.isDirectory())
+            throw new Error(`Path is not a directory: ${targetPath}`);
+        const relRoot = node_path_1.default.relative(process.cwd(), resolvedPath);
+        const rootLabel = relRoot === '' ? '.' : relRoot;
+        const lines = [
+            `Tree for ${rootLabel} (max depth: ${maxDepth})`,
+            `[DIR] ${rootLabel}/`,
+        ];
+        const treeLines = await buildTreeLines(resolvedPath, { currentDepth: 1, maxDepth });
+        lines.push(...treeLines);
+        return lines.join('\n');
+    },
+};
+const grepTool = {
+    description: 'Searches for a regex pattern in files. Returns matching lines with file paths and line numbers.',
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Regular expression pattern to search for.' },
+            path: { type: 'string', description: 'File or directory path to search in (default: current directory).' },
+            recursive: { type: 'boolean', description: 'Search recursively through subdirectories (default: true).' },
+        },
+        required: ['pattern'],
+    },
+    execute: async (args) => {
+        const pattern = args['pattern'];
+        const searchPath = args['path'] ?? '.';
+        const recursive = args['recursive'] ?? true;
+        if (!pattern.trim())
+            throw new Error("The 'pattern' parameter must be non-empty.");
+        let regex;
+        try {
+            regex = new RegExp(pattern);
+        }
+        catch (err) {
+            throw new Error(`Invalid regular expression: ${err.message}`);
+        }
+        const resolvedPath = node_path_1.default.resolve(searchPath);
+        const stats = await promises_1.default.stat(resolvedPath);
+        const basePath = stats.isDirectory() ? resolvedPath : node_path_1.default.dirname(resolvedPath);
+        let matches = [];
+        if (stats.isDirectory()) {
+            if (recursive) {
+                matches = await searchRecursive(resolvedPath, regex, basePath);
+            }
+            else {
+                const entries = await promises_1.default.readdir(resolvedPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory()) {
+                        const m = await searchFile(node_path_1.default.join(resolvedPath, entry.name), regex, basePath);
+                        matches.push(...m);
+                    }
+                }
+            }
+        }
+        else {
+            matches = await searchFile(resolvedPath, regex, basePath);
+        }
+        if (matches.length === 0)
+            return `No matches found for pattern: ${pattern}`;
+        const maxResults = 100;
+        const limited = matches.slice(0, maxResults);
+        let output = `Found ${matches.length} match(es) for pattern: ${pattern}\n\n${limited.join('\n')}`;
+        if (matches.length > maxResults) {
+            output += `\n\n... and ${matches.length - maxResults} more (output truncated)`;
+        }
+        return output;
+    },
+};
+const findTool = {
+    description: 'Searches for files by filename pattern. Supports * and ? wildcards.',
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Filename pattern. Supports * and ? wildcards.' },
+            dir_path: { type: 'string', description: 'Directory to search in (default: current directory).' },
+            case_sensitive: { type: 'boolean', description: 'Case-sensitive matching (default: false).' },
+            max_results: { type: 'integer', description: 'Maximum results to return (default: 50).' },
+        },
+        required: ['pattern'],
+    },
+    execute: async (args) => {
+        const pattern = args['pattern'];
+        const dirPath = args['dir_path'] ?? '.';
+        const caseSensitive = args['case_sensitive'] ?? false;
+        const maxResults = args['max_results'] ?? 50;
+        const searchDir = node_path_1.default.resolve(dirPath);
+        const matches = [];
+        await findFiles(searchDir, pattern, caseSensitive, matches, maxResults);
+        if (matches.length === 0) {
+            return `No files found matching pattern: ${pattern}\nSearched in: ${searchDir}`;
+        }
+        const lines = matches.map((p, i) => `  ${i + 1}. ${node_path_1.default.relative(process.cwd(), p)}`);
+        const footer = matches.length >= maxResults ? `\n(Limited to ${maxResults} results)` : '';
+        return `Found ${matches.length} file(s) matching "${pattern}":\n${lines.join('\n')}${footer}`;
+    },
+};
+const globTool = {
+    description: 'Finds files matching glob patterns (e.g., "**/*.ts", "src/**/*.yaml"). Returns file paths.',
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Glob pattern to match files against.' },
+            dir_path: { type: 'string', description: 'Directory to search in (default: current directory).' },
+            max_results: { type: 'integer', description: 'Maximum results to return (default: 100).' },
+        },
+        required: ['pattern'],
+    },
+    execute: async (args) => {
+        const pattern = args['pattern'];
+        const dirPath = args['dir_path'] ?? '.';
+        const maxResults = args['max_results'] ?? 100;
+        const searchDir = node_path_1.default.resolve(dirPath);
+        const matches = [];
+        await globSearch(searchDir, pattern, searchDir, matches, maxResults);
+        if (matches.length === 0) {
+            return `No files found matching pattern: ${pattern}\nSearched in: ${searchDir}`;
+        }
+        const lines = matches.map((p, i) => `  ${i + 1}. ${node_path_1.default.relative(process.cwd(), p)}`);
+        const footer = matches.length >= maxResults ? `\n(Limited to ${maxResults} results)` : '';
+        return `Found ${matches.length} file(s) matching "${pattern}":\n${lines.join('\n')}${footer}`;
+    },
+};
+const runShellCommandTool = {
+    description: 'Executes a shell command and returns its output (stdout and stderr). Use with caution.',
+    parameters: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'The shell command to execute.' },
+            timeout_seconds: { type: 'integer', description: 'Maximum execution time in seconds (default: 30).' },
+        },
+        required: ['command'],
+    },
+    execute: async (args) => {
+        const command = args['command'];
+        const timeoutSeconds = args['timeout_seconds'] ?? 30;
+        if (!command.trim())
+            throw new Error("The 'command' parameter must be non-empty.");
+        try {
+            const { stdout, stderr } = await execAsync(command, {
+                timeout: timeoutSeconds * 1000,
+                maxBuffer: 10 * 1024 * 1024,
+                cwd: process.cwd(),
+            });
+            let output = '';
+            if (stdout)
+                output += `STDOUT:\n${stdout}`;
+            if (stderr)
+                output += (stdout ? '\n\n' : '') + `STDERR:\n${stderr}`;
+            return output || 'Command executed successfully (no output)';
+        }
+        catch (err) {
+            const error = err;
+            if (error.killed && error.signal === 'SIGTERM') {
+                throw new Error(`Command timed out after ${timeoutSeconds} seconds`);
+            }
+            let msg = `Command failed: ${command}`;
+            if (error.stdout)
+                msg += `\nSTDOUT:\n${error.stdout}`;
+            if (error.stderr)
+                msg += `\nSTDERR:\n${error.stderr}`;
+            if (error.code !== undefined)
+                msg += `\nExit code: ${error.code}`;
+            throw new Error(msg);
+        }
+    },
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// Registry
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * All available built-in tools, keyed by tool name.
+ *
+ * Listed tools are registered via crewx.registerTool() when their name appears
+ * in crewx.yaml `tools.builtin` for an agent using an api/* provider.
+ */
+exports.BUILTIN_TOOL_REGISTRY = {
+    read_file: readFileTool,
+    write_file: writeFileTool,
+    replace: replaceTool,
+    ls: lsTool,
+    tree: treeTool,
+    grep: grepTool,
+    find: findTool,
+    glob: globTool,
+    run_shell_command: runShellCommandTool,
+};
+//# sourceMappingURL=builtin.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * @crewx/sdk/tools/node — Node.js built-in tools.
+ *
+ * Provides file system, shell, and search tools for api/* providers.
+ * Import this only in Node.js environments (CLI, Express server).
+ * Do NOT import in browser builds.
+ *
+ * Usage:
+ *   import { registerBuiltinTools } from '@crewx/sdk/tools/node';
+ *   const crewx = await Crewx.loadYaml('./crewx.yaml');
+ *   registerBuiltinTools(crewx);
+ */
+import type { Crewx } from '../../facade/Crewx';
+/**
+ * Register built-in Node.js tools based on agent configs in crewx.yaml.
+ *
+ * Scans all agents using api/* providers, collects tool names from
+ * options.query.tools and options.execute.tools, then registers
+ * only the matching built-in tools via crewx.registerTool().
+ */
+export declare function registerBuiltinTools(crewx: Crewx): void;
+export { BUILTIN_TOOL_REGISTRY } from './builtin';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/node/index.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * @crewx/sdk/tools/node — Node.js built-in tools.
+ *
+ * Provides file system, shell, and search tools for api/* providers.
+ * Import this only in Node.js environments (CLI, Express server).
+ * Do NOT import in browser builds.
+ *
+ * Usage:
+ *   import { registerBuiltinTools } from '@crewx/sdk/tools/node';
+ *   const crewx = await Crewx.loadYaml('./crewx.yaml');
+ *   registerBuiltinTools(crewx);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_TOOL_REGISTRY = void 0;
+exports.registerBuiltinTools = registerBuiltinTools;
+const builtin_1 = require("./builtin");
+/**
+ * Register built-in Node.js tools based on agent configs in crewx.yaml.
+ *
+ * Scans all agents using api/* providers, collects tool names from
+ * options.query.tools and options.execute.tools, then registers
+ * only the matching built-in tools via crewx.registerTool().
+ */
+function registerBuiltinTools(crewx) {
+    const config = crewx.config;
+    if (!config)
+        return;
+    const agents = config.agents ?? [];
+    // Collect all tool names referenced by api/* agents
+    const neededTools = new Set();
+    for (const agent of agents) {
+        const providers = Array.isArray(agent.provider)
+            ? agent.provider
+            : [agent.provider];
+        const isApiProvider = providers.some((p) => typeof p === 'string' && p.startsWith('api/'));
+        if (!isApiProvider)
+            continue;
+        const opts = agent.options;
+        if (Array.isArray(opts?.query?.tools)) {
+            for (const name of opts.query.tools)
+                neededTools.add(name);
+        }
+        if (Array.isArray(opts?.execute?.tools)) {
+            for (const name of opts.execute.tools)
+                neededTools.add(name);
+        }
+    }
+    // Register only the needed built-in tools
+    for (const name of neededTools) {
+        const toolDef = builtin_1.BUILTIN_TOOL_REGISTRY[name];
+        if (toolDef) {
+            crewx.registerTool(name, toolDef);
+        }
+    }
+}
+var builtin_2 = require("./builtin");
+Object.defineProperty(exports, "BUILTIN_TOOL_REGISTRY", { enumerable: true, get: function () { return builtin_2.BUILTIN_TOOL_REGISTRY; } });
+//# sourceMappingURL=index.js.map