@travisennis/acai 0.0.11 → 0.0.13

package/dist/tools/index.d.ts

@@ -1,6 +1,7 @@
 import type { AsyncReturnType } from "@travisennis/stdlib/types";
 import type { Tool } from "ai";
 import type { WorkspaceContext } from "../index.ts";
+import { ActivatedSkillsTracker } from "../skills/activated-tracker.ts";
 export type CompleteToolSet = {
     -readonly [K in keyof AsyncReturnType<typeof initTools>]: AsyncReturnType<typeof initTools>[K];
 };
@@ -8,6 +9,11 @@ export type CompleteTools = {
     -readonly [K in keyof AsyncReturnType<typeof initTools>]: Tool<unknown, string>;
 };
 export type CompleteToolNames = keyof CompleteToolSet;
+/**
+ * Returns the activated skills tracker instance.
+ * Used to reset the tracker when a new session starts.
+ */
+export declare function getActivatedSkillsTracker(): ActivatedSkillsTracker;
 export declare function initTools({ workspace, }: {
     workspace: WorkspaceContext;
 }): Promise<{
@@ -30,7 +36,7 @@ export declare function initTools({ workspace, }: {
             description: string;
             inputSchema: import("zod").ZodObject<{
                 path: import("zod").ZodString;
-                edits: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodArray<import("zod").ZodObject<{
+                edits: import("zod").ZodPreprocess<import("zod").ZodArray<import("zod").ZodObject<{
                     oldText: import("zod").ZodString;
                     newText: import("zod").ZodString;
                 }, import("zod/v4/core").$strip>>>;
@@ -56,8 +62,8 @@ export declare function initTools({ workspace, }: {
             description: string;
             inputSchema: import("zod").ZodObject<{
                 command: import("zod").ZodString;
-                cwd: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
-                timeout: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                cwd: import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodString>>;
+                timeout: import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
                 background: import("zod").ZodOptional<import("zod").ZodBoolean>;
             }, import("zod/v4/core").$strip>;
         };
@@ -81,14 +87,14 @@ export declare function initTools({ workspace, }: {
                 path: import("zod").ZodString;
                 content: import("zod").ZodString;
                 encoding: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    base64: "base64";
+                    base64url: "base64url";
                     utf8: "utf8";
                     ascii: "ascii";
                     "utf-8": "utf-8";
                     utf16le: "utf16le";
                     ucs2: "ucs2";
                     "ucs-2": "ucs-2";
-                    base64: "base64";
-                    base64url: "base64url";
                     latin1: "latin1";
                     binary: "binary";
                     hex: "hex";
@@ -98,12 +104,12 @@ export declare function initTools({ workspace, }: {
         display({ path }: {
             path: string;
             content: string;
-            encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+            encoding: "base64" | "base64url" | "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "latin1" | "binary" | "hex";
         }): string;
         execute({ path: userPath, content, encoding }: {
             path: string;
             content: string;
-            encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+            encoding: "base64" | "base64url" | "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "latin1" | "binary" | "hex";
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
     readonly Read: {
@@ -112,128 +118,35 @@ export declare function initTools({ workspace, }: {
             inputSchema: import("zod").ZodObject<{
                 path: import("zod").ZodString;
                 encoding: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodEnum<{
+                    base64: "base64";
+                    base64url: "base64url";
                     utf8: "utf8";
                     ascii: "ascii";
                     "utf-8": "utf-8";
                     utf16le: "utf16le";
                     ucs2: "ucs2";
                     "ucs-2": "ucs-2";
-                    base64: "base64";
-                    base64url: "base64url";
                     latin1: "latin1";
                     binary: "binary";
                     hex: "hex";
                 }>>>;
-                startLine: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                lineCount: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                startLine: import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                lineCount: import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ path: providedPath, startLine, lineCount }: {
             path: string;
-            encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | null;
+            encoding: "base64" | "base64url" | "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "latin1" | "binary" | "hex" | null;
             startLine: number | null;
             lineCount: number | null;
         }): string;
         execute({ path: providedPath, encoding, startLine, lineCount, }: {
             path: string;
-            encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | null;
+            encoding: "base64" | "base64url" | "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "latin1" | "binary" | "hex" | null;
             startLine: number | null;
             lineCount: number | null;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
-    readonly Glob: {
-        toolDef: {
-            description: string;
-            inputSchema: import("zod").ZodObject<{
-                patterns: import("zod").ZodPipe<import("zod").ZodTransform<{}, unknown>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
-                path: import("zod").ZodPipe<import("zod").ZodTransform<{}, unknown>, import("zod").ZodString>;
-                gitignore: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                recursive: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                expandDirectories: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                ignoreFiles: import("zod").ZodPipe<import("zod").ZodTransform<{} | null | undefined, unknown>, import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>>;
-                cwd: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>;
-                maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, 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").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                ignoreCase: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                filePattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>;
-                contextLines: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                searchIgnored: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                literal: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, 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").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                maxDepth: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, 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;
@@ -246,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").ZodPipe<import("zod").ZodTransform<unknown, unknown>, 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;
@@ -280,33 +176,13 @@ 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;
             inputSchema: import("zod").ZodObject<{
                 query: import("zod").ZodString;
-                numResults: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-                timeout: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                numResults: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                timeout: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
                 provider: import("zod").ZodOptional<import("zod").ZodEnum<{
                     exa: "exa";
                     duckduckgo: "duckduckgo";
@@ -334,24 +210,24 @@ 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").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
-                timeout: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
-                headers: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                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>>>>;
+                headers: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
             }, import("zod/v4/core").$strip>;
         };
         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;AAoBpD,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;AAEtD,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EA"}
+{"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,32 +1,32 @@
 import { config } from "../config/index.js";
-import { AgentTool, createAgentTools } from "./agent.js";
+import { ActivatedSkillsTracker } from "../skills/activated-tracker.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";
 import { createThinkTool, ThinkTool } from "./think.js";
 import { createWebFetchTool, WebFetchTool } from "./web-fetch.js";
 import { createWebSearchTool, WebSearchTool } from "./web-search.js";
+// Singleton tracker for activated skills, reset when a new session starts
+const activatedSkillsTracker = new ActivatedSkillsTracker();
+/**
+ * Returns the activated skills tracker instance.
+ * Used to reset the tracker when a new session starts.
+ */
+export function getActivatedSkillsTracker() {
+    return activatedSkillsTracker;
+}
 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();
-    const agentTool = await createAgentTools({ workspace });
+    const skillTool = await createSkillTool(activatedSkillsTracker);
     const webSearchTool = await createWebSearchTool();
     const webFetchTool = await createWebFetchTool();
     const applyPatchTool = await createApplyPatchTool({ workspace });
@@ -38,16 +38,16 @@ 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,
         ],
+        sessionContext: {
+            sessionId: "",
+            projectDir: workspace.primaryDir,
+            agentName: "repl",
+        },
     });
     // Build tools object for AI SDK
     const tools = {
@@ -56,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

@@ -7,20 +7,20 @@ export declare const ReadFileTool: {
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
     encoding: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        base64: "base64";
+        base64url: "base64url";
         utf8: "utf8";
         ascii: "ascii";
         "utf-8": "utf-8";
         utf16le: "utf16le";
         ucs2: "ucs2";
         "ucs-2": "ucs-2";
-        base64: "base64";
-        base64url: "base64url";
         latin1: "latin1";
         binary: "binary";
         hex: "hex";
     }>>>;
-    startLine: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    lineCount: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    startLine: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    lineCount: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$strip>;
 type ReadFileInputSchema = z.infer<typeof inputSchema>;
 export declare const createReadFileTool: (options: {
@@ -31,20 +31,20 @@ export declare const createReadFileTool: (options: {
         inputSchema: z.ZodObject<{
             path: z.ZodString;
             encoding: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+                base64: "base64";
+                base64url: "base64url";
                 utf8: "utf8";
                 ascii: "ascii";
                 "utf-8": "utf-8";
                 utf16le: "utf16le";
                 ucs2: "ucs2";
                 "ucs-2": "ucs-2";
-                base64: "base64";
-                base64url: "base64url";
                 latin1: "latin1";
                 binary: "binary";
                 hex: "hex";
             }>>>;
-            startLine: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-            lineCount: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            startLine: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            lineCount: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         }, z.core.$strip>;
     };
     display({ path: providedPath, startLine, lineCount }: ReadFileInputSchema): string;

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/save-file.d.ts

@@ -8,14 +8,14 @@ declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
     content: z.ZodString;
     encoding: z.ZodDefault<z.ZodEnum<{
+        base64: "base64";
+        base64url: "base64url";
         utf8: "utf8";
         ascii: "ascii";
         "utf-8": "utf-8";
         utf16le: "utf16le";
         ucs2: "ucs2";
         "ucs-2": "ucs-2";
-        base64: "base64";
-        base64url: "base64url";
         latin1: "latin1";
         binary: "binary";
         hex: "hex";
@@ -31,14 +31,14 @@ export declare const createSaveFileTool: (options: {
             path: z.ZodString;
             content: z.ZodString;
             encoding: z.ZodDefault<z.ZodEnum<{
+                base64: "base64";
+                base64url: "base64url";
                 utf8: "utf8";
                 ascii: "ascii";
                 "utf-8": "utf-8";
                 utf16le: "utf16le";
                 ucs2: "ucs2";
                 "ucs-2": "ucs-2";
-                base64: "base64";
-                base64url: "base64url";
                 latin1: "latin1";
                 binary: "binary";
                 hex: "hex";

package/dist/tools/skill.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ActivatedSkillsTracker } from "../skills/activated-tracker.ts";
 import type { ToolExecutionOptions } from "./types.ts";
 export declare const SkillTool: {
     name: "Skill";
@@ -8,7 +9,7 @@ declare const inputSchema: z.ZodObject<{
     args: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type SkillInputSchema = z.infer<typeof inputSchema>;
-export declare function createSkillTool(): Promise<{
+export declare function createSkillTool(activatedSkillsTracker: ActivatedSkillsTracker): Promise<{
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../source/tools/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,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;AAEpD,wBAAsB,eAAe;;;;;;;;kCAWH,gBAAgB,GAAG,MAAM;wCAIzB,gBAAgB,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;GA4CrB"}
+{"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"}