@travisennis/acai 0.0.12 → 0.0.13

package/dist/tools/dynamic-tool-loader.js

@@ -109,48 +109,9 @@ export function parseTextSchema(content) {
             description = line.slice(12).trim();
             continue;
         }
-        // Parse parameters: "paramName: type [optional|required] description text"
-        const paramMatch = line.match(/^(\w+):\s*(string|number|boolean)\s+(optional|required)?\s*(.*)$/);
-        if (paramMatch) {
-            const [, paramName, paramType, requirement, paramDescription] = paramMatch;
-            parameters.push({
-                name: paramName,
-                type: paramType,
-                description: paramDescription || `Parameter ${paramName}`,
-                required: requirement !== "optional",
-            });
-            continue;
-        }
-        // Handle params without type keyword (default to string)
-        const simpleMatch = line.match(/^(\w+):\s*(.*)$/);
-        if (simpleMatch &&
-            !line.startsWith("name:") &&
-            !line.startsWith("description:")) {
-            const [, paramName, rest] = simpleMatch;
-            const typeMatch = rest.match(/^(string|number|boolean)\s*(.*)$/);
-            if (typeMatch) {
-                const [, paramType, afterType] = typeMatch;
-                const optMatch = afterType.match(/^(optional|required)\s*(.*)$/);
-                parameters.push({
-                    name: paramName,
-                    type: paramType,
-                    description: optMatch
-                        ? optMatch[2] || `Parameter ${paramName}`
-                        : afterType || `Parameter ${paramName}`,
-                    required: !optMatch || optMatch[1] !== "optional",
-                });
-            }
-            else {
-                const optMatch = rest.match(/^(optional|required)\s*(.*)$/);
-                parameters.push({
-                    name: paramName,
-                    type: "string",
-                    description: optMatch
-                        ? optMatch[2] || rest
-                        : rest || `Parameter ${paramName}`,
-                    required: !optMatch || optMatch[1] !== "optional",
-                });
-            }
+        const param = parseTextSchemaParameter(line);
+        if (param) {
+            parameters.push(param);
         }
     }
     if (!name || !description) {
@@ -168,7 +129,55 @@ export function parseTextSchema(content) {
         needsApproval: true,
     };
 }
-export function parseToolMetadata(output) {
+/**
+ * Parse a single line as a text schema parameter definition.
+ * Supports formats:
+ *   - "paramName: type [optional|required] description"
+ *   - "paramName: [optional|required] description" (type defaults to string)
+ *   - "paramName: description" (type defaults to string, required)
+ */
+function parseTextSchemaParameter(line) {
+    // Parse parameters: "paramName: type [optional|required] description text"
+    const fullMatch = line.match(/^(\w+):\s*(string|number|boolean)\s+(optional|required)?\s*(.*)$/);
+    if (fullMatch) {
+        const [, paramName, paramType, requirement, paramDescription] = fullMatch;
+        return {
+            name: paramName,
+            type: paramType,
+            description: paramDescription || `Parameter ${paramName}`,
+            required: requirement !== "optional",
+        };
+    }
+    // Handle params without type keyword (default to string)
+    const simpleMatch = line.match(/^(\w+):\s*(.*)$/);
+    if (!simpleMatch) {
+        return null;
+    }
+    const [, paramName, rest] = simpleMatch;
+    const typeMatch = rest.match(/^(string|number|boolean)\s*(.*)$/);
+    if (typeMatch) {
+        const [, paramType, afterType] = typeMatch;
+        const optMatch = afterType.match(/^(optional|required)\s*(.*)$/);
+        return {
+            name: paramName,
+            type: paramType,
+            description: optMatch
+                ? optMatch[2] || `Parameter ${paramName}`
+                : afterType || `Parameter ${paramName}`,
+            required: optMatch?.[1] !== "optional",
+        };
+    }
+    const optMatch = rest.match(/^(optional|required)\s*(.*)$/);
+    return {
+        name: paramName,
+        type: "string",
+        description: optMatch
+            ? optMatch[2] || rest
+            : rest || `Parameter ${paramName}`,
+        required: optMatch?.[1] !== "optional",
+    };
+}
+function parseToolMetadata(output) {
     try {
         const parsed = JSON.parse(output.trim());
         return toolMetadataSchema.parse(parsed);
@@ -275,6 +284,36 @@ async function getMetadata(scriptPath, sessionContext) {
         });
     });
 }
+/**
+ * Processes child process stdout/stderr into a result string.
+ * Trims, truncates oversized output, falls back to stderr or a placeholder,
+ * and attempts JSON parsing for structured output.
+ */
+export function processChildOutput(stdout, stderr) {
+    const maxOutputBytes = 2_000_000;
+    let output = stdout.trim();
+    if (output.length > maxOutputBytes) {
+        output = `${output.substring(0, maxOutputBytes)}\n[Output truncated]`;
+    }
+    if (!output) {
+        const errText = stderr.trim();
+        if (errText) {
+            output = errText;
+        }
+    }
+    if (!output) {
+        output = "[No output from dynamic tool]";
+    }
+    if (output.startsWith("{") || output.startsWith("[")) {
+        try {
+            return JSON.stringify(JSON.parse(output));
+        }
+        catch {
+            return output;
+        }
+    }
+    return output;
+}
 async function spawnChildProcess(scriptPath, params, abortSignal, sessionContext, format = "json") {
     const interpreter = resolveToolInterpreter(scriptPath);
     if (!interpreter) {
@@ -331,32 +370,7 @@ async function spawnChildProcess(scriptPath, params, abortSignal, sessionContext
             clearTimeout(timer);
             if (hasTimedOut)
                 return;
-            let output = stdout.trim();
-            const maxOutputBytes = 2000000;
-            if (output.length > maxOutputBytes) {
-                output = `${output.substring(0, maxOutputBytes)}\n[Output truncated]`;
-            }
-            // If no stdout, prefer stderr so callers get useful info
-            const errText = stderr.trim();
-            if (!output && errText) {
-                output = errText;
-            }
-            // Fallback to a non-empty placeholder to satisfy callers
-            if (!output) {
-                output = "[No output from dynamic tool]";
-            }
-            // Attempt to parse as JSON if structured
-            if (output && (output.startsWith("{") || output.startsWith("["))) {
-                try {
-                    resolve(JSON.stringify(JSON.parse(output)));
-                }
-                catch {
-                    resolve(output);
-                }
-            }
-            else {
-                resolve(output);
-            }
+            resolve(processChildOutput(stdout, stderr));
         });
         if (abortSignal) {
             abortSignal.addEventListener("abort", () => {
@@ -427,81 +441,86 @@ export async function loadDynamicTools({ baseDir, existingToolNames = [], sessio
     const projectToolsDir = path.join(baseDir, ".acai", "tools");
     const userToolsDir = path.join(os.homedir(), ".acai", "tools");
     const toolMap = new Map();
-    const scanDir = async (dir, isProject = false) => {
-        if (!fs.existsSync(dir))
-            return;
-        try {
-            const files = fs.readdirSync(dir).filter((f) => {
-                // Known extensions
-                if (KNOWN_EXTENSIONS.some((ext) => f.endsWith(ext))) {
-                    return true;
+    const filterEligibleFiles = (dir) => {
+        return fs.readdirSync(dir).filter((f) => {
+            if (KNOWN_EXTENSIONS.some((ext) => f.endsWith(ext))) {
+                return true;
+            }
+            if (!path.extname(f)) {
+                const fullPath = path.join(dir, f);
+                try {
+                    const stats = fs.statSync(fullPath);
+                    if (stats.mode & 0o111)
+                        return true;
                 }
-                // Extensionless files that are executable
-                if (!path.extname(f)) {
-                    const fullPath = path.join(dir, f);
-                    try {
-                        const stats = fs.statSync(fullPath);
-                        if (stats.mode & 0o111)
-                            return true;
-                    }
-                    catch {
-                        // Can't stat, skip
-                    }
+                catch {
+                    // Can't stat, skip
                 }
-                return false;
-            });
-            for (const file of files) {
-                // Skip .tool files, they are handled separately
-                if (file.endsWith(".tool"))
-                    continue;
-                const scriptPath = path.join(dir, file);
-                try {
-                    const metadata = await getMetadata(scriptPath, sessionContext);
-                    if (metadata) {
-                        toolMap.set(metadata.name, { path: scriptPath, metadata });
-                        logger.info(`Loaded ${isProject ? "project" : "user"} tool: ${metadata.name}`);
-                    }
-                    else {
-                        logger.warn(`Skipped invalid tool: ${file}`);
-                    }
+            }
+            return false;
+        });
+    };
+    const loadScriptTools = async (dir, files, isProject) => {
+        for (const file of files) {
+            if (file.endsWith(".tool"))
+                continue;
+            const scriptPath = path.join(dir, file);
+            try {
+                const metadata = await getMetadata(scriptPath, sessionContext);
+                if (metadata) {
+                    toolMap.set(metadata.name, { path: scriptPath, metadata });
+                    logger.info(`Loaded ${isProject ? "project" : "user"} tool: ${metadata.name}`);
                 }
-                catch (e) {
-                    logger.error(`Error scanning ${file}: ${e}`);
+                else {
+                    logger.warn(`Skipped invalid tool: ${file}`);
                 }
             }
-            // Scan for .tool files (text schema with companion executable)
-            const allDirFiles = fs.readdirSync(dir);
-            const allToolFiles = allDirFiles.filter((f) => f.endsWith(".tool"));
-            for (const toolFile of allToolFiles) {
-                const toolPath = path.join(dir, toolFile);
-                try {
-                    const content = fs.readFileSync(toolPath, "utf8");
-                    const metadata = parseTextSchema(content);
-                    if (!metadata) {
-                        logger.warn(`Failed to parse .tool file: ${toolFile}`);
-                        continue;
-                    }
-                    const baseName = toolFile.slice(0, -5); // Remove .tool extension
-                    const companionPath = findCompanion(dir, baseName);
-                    if (!companionPath) {
-                        logger.warn(`No companion executable found for ${toolFile}`);
-                        continue;
-                    }
-                    const metadataWithFormat = {
-                        ...metadata,
-                        format: "text",
-                    };
-                    toolMap.set(metadata.name, {
-                        path: companionPath,
-                        metadata: metadataWithFormat,
-                    });
-                    logger.info(`Loaded ${isProject ? "project" : "user"} tool: ${metadata.name} (from .tool file)`);
+            catch (e) {
+                logger.error(`Error scanning ${file}: ${e}`);
+            }
+        }
+    };
+    const loadDotToolFiles = async (dir, isProject) => {
+        const allDirFiles = fs.readdirSync(dir);
+        const allToolFiles = allDirFiles.filter((f) => f.endsWith(".tool"));
+        for (const toolFile of allToolFiles) {
+            const toolPath = path.join(dir, toolFile);
+            try {
+                const content = fs.readFileSync(toolPath, "utf8");
+                const metadata = parseTextSchema(content);
+                if (!metadata) {
+                    logger.warn(`Failed to parse .tool file: ${toolFile}`);
+                    continue;
                 }
-                catch (e) {
-                    logger.error(`Error reading .tool file ${toolFile}: ${e}`);
+                const baseName = toolFile.slice(0, -5);
+                const companionPath = findCompanion(dir, baseName);
+                if (!companionPath) {
+                    logger.warn(`No companion executable found for ${toolFile}`);
+                    continue;
                 }
+                const metadataWithFormat = {
+                    ...metadata,
+                    format: "text",
+                };
+                toolMap.set(metadata.name, {
+                    path: companionPath,
+                    metadata: metadataWithFormat,
+                });
+                logger.info(`Loaded ${isProject ? "project" : "user"} tool: ${metadata.name} (from .tool file)`);
+            }
+            catch (e) {
+                logger.error(`Error reading .tool file ${toolFile}: ${e}`);
             }
         }
+    };
+    const scanDir = async (dir, isProject = false) => {
+        if (!fs.existsSync(dir))
+            return;
+        try {
+            const files = filterEligibleFiles(dir);
+            await loadScriptTools(dir, files, isProject);
+            await loadDotToolFiles(dir, isProject);
+        }
         catch (e) {
             logger.error(`Error reading dir ${dir}: ${e}`);
         }

package/dist/tools/index.d.ts

@@ -147,99 +147,6 @@ export declare function initTools({ workspace, }: {
             lineCount: number | null;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
-    readonly Glob: {
-        toolDef: {
-            description: string;
-            inputSchema: import("zod").ZodObject<{
-                patterns: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>>;
-                path: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodString>>;
-                gitignore: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                recursive: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                expandDirectories: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                ignoreFiles: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>>>;
-                cwd: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>>;
-                maxResults: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-            }, import("zod/v4/core").$strip>;
-        };
-        display({ patterns, path }: {
-            patterns: string | string[];
-            path: string;
-            gitignore: boolean | null;
-            recursive: boolean | null;
-            expandDirectories: boolean | null;
-            ignoreFiles: string | string[] | null;
-            cwd: string | null;
-            maxResults: number | null;
-        }): string;
-        execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, maxResults, }: {
-            patterns: string | string[];
-            path: string;
-            gitignore: boolean | null;
-            recursive: boolean | null;
-            expandDirectories: boolean | null;
-            ignoreFiles: string | string[] | null;
-            cwd: string | null;
-            maxResults: number | null;
-        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
-    };
-    readonly Grep: {
-        toolDef: {
-            description: string;
-            inputSchema: import("zod").ZodObject<{
-                pattern: import("zod").ZodString;
-                path: import("zod").ZodString;
-                recursive: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                ignoreCase: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                filePattern: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>>;
-                contextLines: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-                searchIgnored: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                literal: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                maxResults: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-            }, import("zod/v4/core").$strip>;
-        };
-        display({ pattern, path, filePattern, recursive, ignoreCase, contextLines, }: {
-            pattern: string;
-            path: string;
-            recursive: boolean | null;
-            ignoreCase: boolean | null;
-            filePattern: string | null;
-            contextLines: number | null;
-            searchIgnored: boolean | null;
-            literal: boolean | null;
-            maxResults: number | null;
-        }): string;
-        execute({ pattern, path, recursive, ignoreCase, filePattern, contextLines, searchIgnored, literal, maxResults, }: {
-            pattern: string;
-            path: string;
-            recursive: boolean | null;
-            ignoreCase: boolean | null;
-            filePattern: string | null;
-            contextLines: number | null;
-            searchIgnored: boolean | null;
-            literal: boolean | null;
-            maxResults: number | null;
-        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
-    };
-    readonly DirectoryTree: {
-        toolDef: {
-            description: string;
-            inputSchema: import("zod").ZodObject<{
-                path: import("zod").ZodString;
-                maxResults: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-                maxDepth: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-            }, import("zod/v4/core").$strip>;
-        };
-        display({ path, maxDepth, maxResults }: {
-            path: string;
-            maxResults: number | null;
-            maxDepth: number | null;
-        }): string;
-        execute({ path, maxResults, maxDepth }: {
-            path: string;
-            maxResults: number | null;
-            maxDepth: number | null;
-        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
-    };
     readonly Think: {
         toolDef: {
             description: string;
@@ -252,23 +159,6 @@ export declare function initTools({ workspace, }: {
             thought: import("zod").ZodString;
         }, import("zod/v4/core").$strip>>, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
-    readonly LS: {
-        toolDef: {
-            description: string;
-            inputSchema: import("zod").ZodObject<{
-                path: import("zod").ZodOptional<import("zod").ZodString>;
-                limit: import("zod").ZodDefault<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-            }, import("zod/v4/core").$strip>;
-        };
-        display({ path: providedPath, limit }: {
-            limit: number | null;
-            path?: string | undefined;
-        }): string;
-        execute({ path: providedPath, limit }: {
-            limit: number | null;
-            path?: string | undefined;
-        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
-    };
     readonly Skill: {
         toolDef: {
             description: string;
@@ -286,26 +176,6 @@ export declare function initTools({ workspace, }: {
             args?: string | undefined;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
-    readonly Agent: {
-        toolDef: {
-            description: string;
-            inputSchema: import("zod").ZodObject<{
-                prompt: import("zod").ZodString;
-                type: import("zod").ZodString;
-                timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>;
-        };
-        display: ({ prompt, type }: import("zod").infer<import("zod").ZodObject<{
-            prompt: import("zod").ZodString;
-            type: import("zod").ZodString;
-            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>>) => string;
-        execute: ({ prompt, type, timeout }: import("zod").infer<import("zod").ZodObject<{
-            prompt: import("zod").ZodString;
-            type: import("zod").ZodString;
-            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>>, { abortSignal }: import("./types.ts").ToolExecutionOptions) => Promise<string>;
-    };
     readonly WebSearch: {
         toolDef: {
             description: string;
@@ -340,8 +210,8 @@ export declare function initTools({ workspace, }: {
                 output: import("zod").ZodDefault<import("zod").ZodEnum<{
                     markdown: "markdown";
                     text: "text";
-                    html: "html";
                     json: "json";
+                    html: "html";
                 }>>;
                 jina: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
                 timeout: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
@@ -350,14 +220,14 @@ export declare function initTools({ workspace, }: {
         };
         display({ url }: {
             url: string;
-            output: "markdown" | "text" | "html" | "json";
+            output: "markdown" | "text" | "json" | "html";
             jina?: boolean | null | undefined;
             timeout?: number | null | undefined;
             headers?: boolean | null | undefined;
         }): string;
         execute(options: {
             url: string;
-            output: "markdown" | "text" | "html" | "json";
+            output: "markdown" | "text" | "json" | "html";
             jina?: boolean | null | undefined;
             timeout?: number | null | undefined;
             headers?: boolean | null | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAoBxE,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,eAAe,CACvE,OAAO,SAAS,CACjB,CAAC,CAAC,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,IAAI,CAC5D,OAAO,EACP,MAAM,CACP;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,eAAe,CAAC;AAKtD;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,CAElE;AAED,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAYxE,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,eAAe,CACvE,OAAO,SAAS,CACjB,CAAC,CAAC,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,IAAI,CAC5D,OAAO,EACP,MAAM,CACP;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,eAAe,CAAC;AAKtD;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,sBAAsB,CAElE;AAED,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DA"}

package/dist/tools/index.js

@@ -1,14 +1,9 @@
 import { config } from "../config/index.js";
 import { ActivatedSkillsTracker } from "../skills/activated-tracker.js";
-import { AgentTool, createAgentTools } from "./agent.js";
 import { ApplyPatchTool, createApplyPatchTool } from "./apply-patch.js";
 import { BashTool, createBashTool } from "./bash.js";
-import { createDirectoryTreeTool, DirectoryTreeTool, } from "./directory-tree.js";
 import { loadDynamicTools } from "./dynamic-tool-loader.js";
 import { createEditFileTool, EditFileTool } from "./edit-file.js";
-import { createGlobTool, GlobTool } from "./glob.js";
-import { createGrepTool, GrepTool } from "./grep.js";
-import { createLsTool, LsTool } from "./ls.js";
 import { createReadFileTool, ReadFileTool } from "./read-file.js";
 import { createSaveFileTool, SaveFileTool } from "./save-file.js";
 import { createSkillTool, SkillTool } from "./skill.js";
@@ -28,15 +23,10 @@ export async function initTools({ workspace, }) {
     const readFileTool = await createReadFileTool({ workspace });
     const editFileTool = await createEditFileTool({ workspace });
     const saveFileTool = await createSaveFileTool({ workspace });
-    const directoryTreeTool = await createDirectoryTreeTool({ workspace });
-    const globTool = createGlobTool();
-    const grepTool = createGrepTool();
     const thinkTool = createThinkTool();
-    const lsTool = await createLsTool({ workspace });
     const projectConfig = await config.getConfig();
     const bashTool = await createBashTool({ workspace, env: projectConfig.env });
     const skillTool = await createSkillTool(activatedSkillsTracker);
-    const agentTool = await createAgentTools({ workspace });
     const webSearchTool = await createWebSearchTool();
     const webFetchTool = await createWebFetchTool();
     const applyPatchTool = await createApplyPatchTool({ workspace });
@@ -48,13 +38,8 @@ export async function initTools({ workspace, }) {
             BashTool.name,
             SaveFileTool.name,
             ReadFileTool.name,
-            GlobTool.name,
-            GrepTool.name,
-            DirectoryTreeTool.name,
             ThinkTool.name,
-            LsTool.name,
             SkillTool.name,
-            AgentTool.name,
             WebSearchTool.name,
             WebFetchTool.name,
         ],
@@ -71,13 +56,8 @@ export async function initTools({ workspace, }) {
         [BashTool.name]: bashTool,
         [SaveFileTool.name]: saveFileTool,
         [ReadFileTool.name]: readFileTool,
-        [GlobTool.name]: globTool,
-        [GrepTool.name]: grepTool,
-        [DirectoryTreeTool.name]: directoryTreeTool,
         [ThinkTool.name]: thinkTool,
-        [LsTool.name]: lsTool,
         [SkillTool.name]: skillTool,
-        [AgentTool.name]: agentTool,
         [WebSearchTool.name]: webSearchTool,
         [WebFetchTool.name]: webFetchTool,
         // Add dynamic tools - they already have toolDef structure

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

@@ -1 +1 @@
-{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAsBvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;0DAOyD,mBAAmB;qEAUpE,mBAAmB,mBACL,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAsBrB,CAAC"}
+{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAsBvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;0DAQyD,mBAAmB;qEAUpE,mBAAmB,mBACL,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAqBrB,CAAC"}

package/dist/tools/read-file.js

@@ -43,7 +43,7 @@ export const createReadFileTool = async (options) => {
     const { primaryDir } = options.workspace;
     return {
         toolDef: {
-            description: "Read the contents of a file.",
+            description: "Read the contents of a file. When you need to read multiple files, ALWAYS issue multiple Read tool calls in the same assistant message rather than reading one, waiting for the result, then reading the next. The runtime executes parallel tool calls concurrently, so batching reads is several times faster than serial reads.",
             inputSchema,
         },
         display({ path: providedPath, startLine, lineCount }) {
@@ -57,8 +57,8 @@ export const createReadFileTool = async (options) => {
             const filePath = resolveReadPath(providedPath, primaryDir);
             const effectiveEncoding = encoding ?? "utf-8";
             const file = await readFileContent(filePath, effectiveEncoding, startLine, lineCount, abortSignal);
-            validateByteLimit(file, effectiveEncoding, BYTE_LIMIT);
-            return file;
+            const totalLines = file === "" ? 0 : file.split("\n").length;
+            return applyByteLimit(file, effectiveEncoding, BYTE_LIMIT, totalLines);
         },
     };
 };
@@ -105,15 +105,34 @@ async function readFileLines(filePath, startLine, lineCount, abortSignal) {
     }
     return lines.join("\n");
 }
-// Validate that file content doesn't exceed byte limit
-function validateByteLimit(file, encoding, maxBytes) {
-    const byteLength = Buffer.byteLength(file, encoding);
-    if (byteLength > maxBytes) {
-        const fileSizeKb = (byteLength / 1024).toFixed(1);
-        const limitKb = (maxBytes / 1024).toFixed(0);
-        throw new Error(`File (${fileSizeKb}KB) exceeds the ${limitKb}KB read limit. To read this file, use one of these options:\n` +
-            "• Use startLine and lineCount to read specific portions (e.g., startLine: 1, lineCount: 100)\n" +
-            "• Use the Grep tool to search for specific content\n" +
-            `• Use the Bash tool with 'tail' or 'head' commands`);
+// Truncate content to a byte limit, safely handling multi-byte encodings.
+// Returns the truncated content with a message indicating how much remains
+// and the total number of lines in the original content.
+function applyByteLimit(content, encoding, maxBytes, totalLines) {
+    const byteLength = Buffer.byteLength(content, encoding);
+    if (byteLength <= maxBytes) {
+        return content;
     }
+    const truncated = truncateToByteLimit(content, encoding, maxBytes);
+    const truncatedBytes = Buffer.byteLength(truncated, encoding);
+    const remainingBytes = byteLength - truncatedBytes;
+    const limitKb = (maxBytes / 1024).toFixed(0);
+    const remainingKb = (remainingBytes / 1024).toFixed(1);
+    const message = [
+        "",
+        `[File truncated at ${limitKb}KB limit. ${remainingKb}KB remaining. Total lines: ${totalLines.toLocaleString()}.]`,
+        "To read more, use the startLine and lineCount parameters, or use Bash with head/tail/sed.",
+    ].join("\n");
+    return truncated + message;
+}
+// Safely truncate a string to a maximum number of bytes in the given encoding.
+// Uses TextDecoder for UTF-8 to avoid splitting multi-byte characters.
+function truncateToByteLimit(content, encoding, maxBytes) {
+    if (encoding === "utf-8" || encoding === "utf8") {
+        const decoder = new TextDecoder("utf-8");
+        return decoder.decode(Buffer.from(content, encoding).subarray(0, maxBytes), {
+            stream: true,
+        });
+    }
+    return Buffer.from(content, encoding).toString(encoding, 0, maxBytes);
 }

package/dist/tools/skill.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../source/tools/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAI7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAKf,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA+BpD,wBAAsB,eAAe,CACnC,sBAAsB,EAAE,sBAAsB;;;;;;;;kCAcd,gBAAgB,GAAG,MAAM;wCAIzB,gBAAgB,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;GA8DrB"}
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../source/tools/skill.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAK7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAKf,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA2DpD,wBAAsB,eAAe,CACnC,sBAAsB,EAAE,sBAAsB;;;;;;;;kCAcd,gBAAgB,GAAG,MAAM;wCAIzB,gBAAgB,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;GAgDrB"}