agency-lang 0.0.96 → 0.0.98

package/dist/lib/cli/commands.js

@@ -8,7 +8,7 @@ import { spawn } from "child_process";
 import { transformSync } from "esbuild";
 import * as fs from "fs";
 import * as path from "path";
-import { getStdlibDir, isPkgImport, isStdlibImport, resolveAgencyImportPath, } from "../importPaths.js";
+import { getStdlibDir, isPkgImport, isStdlibImport, resolveAgencyImportPath, resolveFlexibleExtension, } from "../importPaths.js";
 import { parseAgency } from "../parser.js";
 import { findRecursively, getImports } from "./util.js";
 // Load configuration from agency.json
@@ -136,10 +136,31 @@ export function compile(config, inputFile, _outputFile, options) {
         }
         compile(config, absPath, undefined, { ...options, symbolTable });
     }
-    // Update the import path in the AST to reference the new .ts file
+    // Update import paths in the AST
     resolvedProgram.nodes.forEach((node) => {
-        if (node.type === "importStatement" && !isStdlibImport(node.modulePath) && !isPkgImport(node.modulePath)) {
+        if (node.type !== "importStatement")
+            return;
+        if (isStdlibImport(node.modulePath) || isPkgImport(node.modulePath))
+            return;
+        if (node.modulePath.endsWith(".agency")) {
             node.modulePath = node.modulePath.replace(".agency", ext);
+            return;
+        }
+        // For .js/.ts imports, resolve flexibly: if the specified file doesn't
+        // exist, try the other extension. This lets users write .js imports that
+        // work in dist/ while the debugger finds the .ts source (and vice versa).
+        if (node.modulePath.endsWith(".js") || node.modulePath.endsWith(".ts")) {
+            const resolved = resolveFlexibleExtension(node.modulePath, absoluteInputFile);
+            if (resolved === null) {
+                const altExt = node.modulePath.endsWith(".js") ? ".ts" : ".js";
+                const altPath = node.modulePath.replace(/\.(js|ts)$/, altExt);
+                console.error(`Error: Cannot resolve import '${node.modulePath}' from '${inputFile}'.\n` +
+                    `Tried: ${node.modulePath}, ${altPath} — neither file exists.`);
+                process.exit(1);
+            }
+            // Rewrite the import to use whatever extension actually exists on disk
+            const resolvedExt = path.extname(resolved);
+            node.modulePath = node.modulePath.replace(/\.(js|ts)$/, resolvedExt);
         }
     });
     const moduleId = path.relative(process.cwd(), absoluteInputFile);

package/dist/lib/cli/debug.d.ts

@@ -4,4 +4,5 @@ export declare function debug(config: AgencyConfig, _inputFile: string, options?
     rewindSize?: number;
     trace?: string;
     checkpoint?: string;
+    distDir?: string;
 }): Promise<void>;

package/dist/lib/cli/debug.js

@@ -77,25 +77,51 @@ export async function debug(config, _inputFile, options = {}) {
             }
             traceCheckpoints = [cp];
         }
-        // Force debugger mode so the builder emits debugStep() calls
-        const debugConfig = { ...config, debugger: true };
-        // Compile the .agency file to .js
-        const outputFile = compile(debugConfig, inputFile);
-        if (outputFile === null) {
-            console.error("Error: No output file generated.");
-            process.exit(1);
+        // Resolve distDir from CLI flag or config
+        const distDir = options.distDir ?? config.distDir;
+        let absOutput;
+        if (distDir) {
+            // distDir mode: import pre-compiled JS from the dist directory
+            const basename = path.basename(inputFile, ".agency") + ".js";
+            const compiledPath = path.resolve(distDir, basename);
+            if (!fs.existsSync(compiledPath)) {
+                console.error(`Error: Compiled file not found: ${compiledPath}\n` +
+                    `Make sure you have compiled your Agency files and that distDir is correct.`);
+                process.exit(1);
+            }
+            // Warn if source is newer than compiled output
+            const sourceMtime = fs.statSync(inputFile).mtimeMs;
+            const compiledMtime = fs.statSync(compiledPath).mtimeMs;
+            if (sourceMtime > compiledMtime) {
+                console.warn(`Warning: ${inputFile} is newer than ${compiledPath}.\n` +
+                    `You may need to recompile before debugging.`);
+            }
+            absOutput = compiledPath;
+        }
+        else {
+            // Normal mode: compile the .agency file to .js on the fly
+            const debugConfig = { ...config, debugger: true };
+            const outputFile = compile(debugConfig, inputFile);
+            if (outputFile === null) {
+                console.error("Error: No output file generated.");
+                process.exit(1);
+            }
+            absOutput = path.resolve(outputFile);
         }
         // Signal to stdlib UI components that they should fall back to console.log
         // instead of drawing their own TUI, which would conflict with the debugger.
         process.env.AGENCY_DEBUGGER = "1";
         // Dynamically import the compiled module
-        const absOutput = path.resolve(outputFile);
         const mod = await import(absOutput);
         // Get the source map from the module
         const sourceMap = mod.__sourceMap ?? {};
+        if (distDir && Object.keys(sourceMap).length === 0) {
+            console.warn("Warning: The compiled module has an empty source map. Was it compiled with instrument: false?\n" +
+                "The debugger may not be able to step through code.");
+        }
         // Parse the .agency file to get the list of graph nodes
         const contents = fs.readFileSync(inputFile, "utf-8");
-        const parseResult = parseAgency(contents, debugConfig);
+        const parseResult = parseAgency(contents, config);
         if (!parseResult.success) {
             console.error("Error: Could not parse Agency file.");
             process.exit(1);

package/dist/lib/cli/util.js

@@ -104,12 +104,27 @@ export async function promptForArgs(selectedNode) {
     return { hasArgs, argsString };
 }
 export async function executeNodeAsync({ config, agencyFile, nodeName, hasArgs, argsString, interruptHandlers, }) {
-    compile(config, agencyFile);
+    const distDir = config.distDir;
+    let compiledFilename;
+    if (distDir) {
+        // distDir mode: skip compilation, import pre-compiled JS from distDir
+        const basename = path.basename(agencyFile, ".agency") + ".js";
+        const compiledPath = path.resolve(distDir, basename);
+        if (!fs.existsSync(compiledPath)) {
+            throw new Error(`Compiled file not found: ${compiledPath}\n` +
+                `Make sure you have compiled your Agency files and that distDir is correct.`);
+        }
+        compiledFilename = compiledPath;
+    }
+    else {
+        compile(config, agencyFile);
+        compiledFilename = path.basename(agencyFile).replace(".agency", ".js");
+    }
     const baseName = agencyFile.replace(".agency", "");
     const evaluateFile = `${baseName}.evaluate.js`;
     const resultsFile = `${baseName}.evaluate.json`;
     const evaluateScript = renderEvaluate({
-        filename: path.basename(agencyFile).replace(".agency", ".js"),
+        filename: compiledFilename,
         nodeName,
         hasArgs,
         args: argsString,
@@ -137,10 +152,23 @@ export async function executeNodeAsync({ config, agencyFile, nodeName, hasArgs,
     }
 }
 export function executeNode(args) {
-    const outFile = args.agencyFile.replace(".agency", ".js");
-    compile(args.config, args.agencyFile);
+    const distDir = args.config.distDir;
+    let compiledFilename;
+    if (distDir) {
+        const basename = path.basename(args.agencyFile, ".agency") + ".js";
+        const compiledPath = path.resolve(distDir, basename);
+        if (!fs.existsSync(compiledPath)) {
+            throw new Error(`Compiled file not found: ${compiledPath}\n` +
+                `Make sure you have compiled your Agency files and that distDir is correct.`);
+        }
+        compiledFilename = compiledPath;
+    }
+    else {
+        compile(args.config, args.agencyFile);
+        compiledFilename = args.agencyFile.replace(".agency", ".js");
+    }
     const evaluateScript = renderEvaluate({
-        filename: outFile,
+        filename: compiledFilename,
         nodeName: args.nodeName,
         hasArgs: args.hasArgs,
         args: args.argsString,

package/dist/lib/config.d.ts

@@ -102,6 +102,10 @@ export interface AgencyConfig {
     /** Directory for auto-generated trace files. Each execution creates a new file
      *  named <timestamp>_<id>.agencytrace. */
     traceDir?: string;
+    /** Directory containing pre-compiled JS output (e.g., "dist").
+     *  When set, the debugger imports compiled modules from this directory
+     *  instead of compiling on the fly. Resolved relative to cwd. */
+    distDir?: string;
     /** Test runner configuration */
     test?: {
         /** Number of test files to run in parallel. Default: 1 (sequential). */

package/dist/lib/importPaths.d.ts

@@ -64,6 +64,12 @@ export declare function resolvePkgAgencyPath(importPath: string, fromFile: strin
  * - "./foo.js"       -> resolved relative to the importing file (non-agency, kept as-is)
  */
 export declare function resolveAgencyImportPath(importPath: string, fromFile: string): string;
+/**
+ * Resolve a .js or .ts import path, trying the other extension if the
+ * specified file doesn't exist. Returns the resolved absolute path, or
+ * null if neither extension exists on disk.
+ */
+export declare function resolveFlexibleExtension(importPath: string, fromFile: string): string | null;
 /**
  * Convert an Agency import path to the path that should appear in generated
  * TypeScript import statements.

package/dist/lib/importPaths.js

@@ -216,6 +216,29 @@ export function resolveAgencyImportPath(importPath, fromFile) {
     // Relative or other imports: resolve against the importing file's directory
     return path.resolve(path.dirname(fromFile), importPath);
 }
+const FLEXIBLE_EXTENSIONS = {
+    ".js": ".ts",
+    ".ts": ".js",
+};
+/**
+ * Resolve a .js or .ts import path, trying the other extension if the
+ * specified file doesn't exist. Returns the resolved absolute path, or
+ * null if neither extension exists on disk.
+ */
+export function resolveFlexibleExtension(importPath, fromFile) {
+    const ext = path.extname(importPath);
+    const altExt = FLEXIBLE_EXTENSIONS[ext];
+    if (!altExt)
+        return null; // not a .js/.ts import
+    const dir = path.dirname(fromFile);
+    const resolved = path.resolve(dir, importPath);
+    if (fs.existsSync(resolved))
+        return resolved;
+    const altPath = resolved.slice(0, -ext.length) + altExt;
+    if (fs.existsSync(altPath))
+        return altPath;
+    return null;
+}
 /**
  * Convert an Agency import path to the path that should appear in generated
  * TypeScript import statements.

package/dist/lib/importPaths.test.js

@@ -1,5 +1,5 @@
-import { describe, it, expect } from "vitest";
-import { findPackageRoot, resolveAgencyImportPath, getStdlibDir, toCompiledImportPath, isPkgImport, isAgencyImport, parsePkgImport, resolvePkgAgencyPath, } from "./importPaths.js";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { findPackageRoot, resolveAgencyImportPath, resolveFlexibleExtension, getStdlibDir, toCompiledImportPath, isPkgImport, isAgencyImport, parsePkgImport, resolvePkgAgencyPath, } from "./importPaths.js";
 import { buildSymbolTable } from "./symbolTable.js";
 import * as fs from "fs";
 import * as os from "os";
@@ -235,3 +235,52 @@ describe("buildSymbolTable with pkg:: imports", () => {
         }
     });
 });
+describe("resolveFlexibleExtension", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agency-flex-ext-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("should return the resolved path when the file exists as-is", () => {
+        const tsFile = path.join(tmpDir, "bar.ts");
+        fs.writeFileSync(tsFile, "export const x = 1;");
+        const fromFile = path.join(tmpDir, "main.agency");
+        const result = resolveFlexibleExtension("./bar.ts", fromFile);
+        expect(result).toBe(tsFile);
+    });
+    it("should fall back from .js to .ts when .js doesn't exist", () => {
+        const tsFile = path.join(tmpDir, "bar.ts");
+        fs.writeFileSync(tsFile, "export const x = 1;");
+        const fromFile = path.join(tmpDir, "main.agency");
+        const result = resolveFlexibleExtension("./bar.js", fromFile);
+        expect(result).toBe(tsFile);
+    });
+    it("should fall back from .ts to .js when .ts doesn't exist", () => {
+        const jsFile = path.join(tmpDir, "bar.js");
+        fs.writeFileSync(jsFile, "export const x = 1;");
+        const fromFile = path.join(tmpDir, "main.agency");
+        const result = resolveFlexibleExtension("./bar.ts", fromFile);
+        expect(result).toBe(jsFile);
+    });
+    it("should return null when neither .js nor .ts exists", () => {
+        const fromFile = path.join(tmpDir, "main.agency");
+        const result = resolveFlexibleExtension("./bar.js", fromFile);
+        expect(result).toBeNull();
+    });
+    it("should return null for non-.js/.ts extensions", () => {
+        const fromFile = path.join(tmpDir, "main.agency");
+        const result = resolveFlexibleExtension("./bar.css", fromFile);
+        expect(result).toBeNull();
+    });
+    it("should prefer the exact extension when both files exist", () => {
+        const jsFile = path.join(tmpDir, "bar.js");
+        const tsFile = path.join(tmpDir, "bar.ts");
+        fs.writeFileSync(jsFile, "export const x = 1;");
+        fs.writeFileSync(tsFile, "export const x = 1;");
+        const fromFile = path.join(tmpDir, "main.agency");
+        expect(resolveFlexibleExtension("./bar.js", fromFile)).toBe(jsFile);
+        expect(resolveFlexibleExtension("./bar.ts", fromFile)).toBe(tsFile);
+    });
+});

package/dist/lib/ir/prettyPrint.js

@@ -59,8 +59,8 @@ export function printTs(node, indent = 0) {
             }
         }
         case "varDecl": {
-            //let s = `${node.declKind} ${node.name}`;
-            let s = `var ${node.name}`;
+            let s = `${node.declKind} ${node.name}`;
+            // let s = `var ${node.name}`;
             if (node.typeAnnotation)
                 s += `: ${node.typeAnnotation}`;
             if (node.initializer)

package/dist/lib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.0.96";
+export declare const VERSION = "0.0.98";

package/dist/lib/version.js

@@ -1 +1 @@
-export const VERSION = "0.0.96";
+export const VERSION = "0.0.98";

package/dist/scripts/agency.js

@@ -339,6 +339,7 @@ program
     .option("--rewind-size <n>", "Rolling checkpoint window size", "30")
     .option("--trace <file>", "Load and inspect a trace file")
     .option("--checkpoint <file>", "Load and inspect a checkpoint file")
+    .option("--dist-dir <dir>", "Import pre-compiled JS from this directory instead of compiling on the fly")
     .action(async (file, options) => {
     const config = getConfig();
     await debug(config, file, {
@@ -346,6 +347,7 @@ program
         rewindSize: parseInt(options.rewindSize, 10),
         trace: options.trace,
         checkpoint: options.checkpoint,
+        distDir: options.distDir,
     });
 });
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.96",
+  "version": "0.0.98",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {

package/stdlib/_clipboard.js

@@ -0,0 +1,29 @@
+import { execFileSync } from "child_process";
+import { detectPlatform } from "./_utils.js";
+export function _copy(text) {
+    const platform = detectPlatform();
+    if (platform === "macos") {
+        execFileSync("pbcopy", [], { input: text });
+    }
+    else if (platform === "linux") {
+        execFileSync("xclip", ["-selection", "clipboard"], { input: text });
+    }
+    else {
+        console.error(`copy is not supported on platform: ${platform}. ` +
+            `Supported platforms: macOS, Linux.`);
+    }
+}
+export function _paste() {
+    const platform = detectPlatform();
+    if (platform === "macos") {
+        return execFileSync("pbpaste").toString();
+    }
+    else if (platform === "linux") {
+        return execFileSync("xclip", ["-selection", "clipboard", "-o"]).toString();
+    }
+    else {
+        console.error(`paste is not supported on platform: ${platform}. ` +
+            `Supported platforms: macOS, Linux.`);
+        return "";
+    }
+}

package/stdlib/_speech.js

@@ -0,0 +1,69 @@
+import { execFileSync } from "child_process";
+import fsSync from "fs";
+import fs from "fs/promises";
+import { nanoid } from "nanoid";
+import os from "os";
+import path from "path";
+import process from "process";
+import { detectPlatform } from "./_utils.js";
+export function _speak(text, voice, rate, outputFile) {
+    if (text === "")
+        return;
+    const platform = detectPlatform();
+    if (platform === "macos") {
+        const tmpFile = path.join(os.tmpdir(), `agency-speak-${nanoid()}.txt`);
+        try {
+            fsSync.writeFileSync(tmpFile, text, "utf8");
+            const args = ["-f", tmpFile];
+            if (voice !== "") {
+                args.push("-v", voice);
+            }
+            if (rate > 0) {
+                args.push("-r", String(rate));
+            }
+            if (outputFile !== "") {
+                args.push("-o", path.resolve(process.cwd(), outputFile));
+            }
+            execFileSync("say", args);
+        }
+        finally {
+            try {
+                fsSync.unlinkSync(tmpFile);
+            }
+            catch { }
+        }
+    }
+    else {
+        console.error(`speak is not supported on platform: ${platform}. ` +
+            `Supported platforms: macOS.`);
+    }
+}
+export async function _transcribe(filepath, language) {
+    const apiKey = process.env["OPENAI_API_KEY"];
+    if (!apiKey) {
+        throw new Error("transcribe requires an OPENAI_API_KEY environment variable to be set.");
+    }
+    const resolvedPath = path.resolve(process.cwd(), filepath);
+    const fileData = await fs.readFile(resolvedPath);
+    const filename = path.basename(resolvedPath);
+    const formData = new FormData();
+    formData.append("file", new Blob([fileData]), filename);
+    formData.append("model", "whisper-1");
+    if (language !== "") {
+        formData.append("language", language);
+    }
+    const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${apiKey}`,
+        },
+        body: formData,
+    });
+    if (!response.ok) {
+        const errorBody = await response.json();
+        const message = errorBody?.error?.message ?? JSON.stringify(errorBody);
+        throw new Error(`Whisper API error (${response.status}): ${message}`);
+    }
+    const result = await response.json();
+    return result.text;
+}

package/stdlib/_system.js

@@ -0,0 +1,29 @@
+import { execFileSync } from "child_process";
+import path from "path";
+import process from "process";
+import { detectPlatform } from "./_utils.js";
+export function _screenshot(filepath, x, y, width, height) {
+    const platform = detectPlatform();
+    const resolvedPath = path.resolve(process.cwd(), filepath);
+    const hasRegion = x >= 0 && y >= 0 && width >= 0 && height >= 0;
+    if (platform === "macos") {
+        if (hasRegion) {
+            execFileSync("screencapture", ["-R", `${x},${y},${width},${height}`, resolvedPath]);
+        }
+        else {
+            execFileSync("screencapture", ["-x", resolvedPath]);
+        }
+    }
+    else if (platform === "linux") {
+        if (hasRegion) {
+            execFileSync("import", ["-crop", `${width}x${height}+${x}+${y}`, "-window", "root", resolvedPath]);
+        }
+        else {
+            execFileSync("import", ["-window", "root", resolvedPath]);
+        }
+    }
+    else {
+        console.error(`screenshot is not supported on platform: ${platform}. ` +
+            `Supported platforms: macOS, Linux.`);
+    }
+}

package/stdlib/agent.js

@@ -1,5 +1,4 @@
-import { print, __printTool, __printToolParams, printJSON, __printJSONTool, __printJSONToolParams, input, __inputTool, __inputToolParams, sleep, __sleepTool, __sleepToolParams, round, __roundTool, __roundToolParams, fetch, __fetchTool, __fetchToolParams, fetchJSON, __fetchJSONTool, __fetchJSONToolParams, read, __readTool, __readToolParams, write, __writeTool, __writeToolParams, readImage, __readImageTool, __readImageToolParams, notify, __notifyTool, __notifyToolParams, range, __rangeTool, __rangeToolParams, mostCommon, __mostCommonTool, __mostCommonToolParams, keys, __keysTool, __keysToolParams, values, __valuesTool, __valuesToolParams, entries, __entriesTool, __entriesToolParams } from "/Users/adityabhargava/worktrees/agency-lang/stdlib/index.js";
-import { map, __mapTool, __mapToolParams, filter, __filterTool, __filterToolParams, exclude, __excludeTool, __excludeToolParams, find, __findTool, __findToolParams, findIndex, __findIndexTool, __findIndexToolParams, reduce, __reduceTool, __reduceToolParams, flatMap, __flatMapTool, __flatMapToolParams, every, __everyTool, __everyToolParams, some, __someTool, __someToolParams, count, __countTool, __countToolParams, sortBy, __sortByTool, __sortByToolParams, unique, __uniqueTool, __uniqueToolParams, groupBy, __groupByTool, __groupByToolParams } from "/Users/adityabhargava/worktrees/agency-lang/stdlib/array.js";
+import { print, __printTool, __printToolParams, printJSON, __printJSONTool, __printJSONToolParams, input, __inputTool, __inputToolParams, sleep, __sleepTool, __sleepToolParams, round, __roundTool, __roundToolParams, fetch, __fetchTool, __fetchToolParams, fetchJSON, __fetchJSONTool, __fetchJSONToolParams, read, __readTool, __readToolParams, write, __writeTool, __writeToolParams, readImage, __readImageTool, __readImageToolParams, notify, __notifyTool, __notifyToolParams, range, __rangeTool, __rangeToolParams, mostCommon, __mostCommonTool, __mostCommonToolParams, keys, __keysTool, __keysToolParams, values, __valuesTool, __valuesToolParams, entries, __entriesTool, __entriesToolParams } from "/Users/adityabhargava/worktrees/agency-lang2/stdlib/index.js";
 import { fileURLToPath } from "url";
 import __process from "process";
 import { z } from "zod";
@@ -282,123 +281,6 @@ const __toolRegistry = {
       isBuiltin: false
     }
   },
-  map: {
-    definition: __mapTool,
-    handler: {
-      name: "map",
-      params: __mapToolParams,
-      execute: map,
-      isBuiltin: false
-    }
-  },
-  filter: {
-    definition: __filterTool,
-    handler: {
-      name: "filter",
-      params: __filterToolParams,
-      execute: filter,
-      isBuiltin: false
-    }
-  },
-  exclude: {
-    definition: __excludeTool,
-    handler: {
-      name: "exclude",
-      params: __excludeToolParams,
-      execute: exclude,
-      isBuiltin: false
-    }
-  },
-  find: {
-    definition: __findTool,
-    handler: {
-      name: "find",
-      params: __findToolParams,
-      execute: find,
-      isBuiltin: false
-    }
-  },
-  findIndex: {
-    definition: __findIndexTool,
-    handler: {
-      name: "findIndex",
-      params: __findIndexToolParams,
-      execute: findIndex,
-      isBuiltin: false
-    }
-  },
-  reduce: {
-    definition: __reduceTool,
-    handler: {
-      name: "reduce",
-      params: __reduceToolParams,
-      execute: reduce,
-      isBuiltin: false
-    }
-  },
-  flatMap: {
-    definition: __flatMapTool,
-    handler: {
-      name: "flatMap",
-      params: __flatMapToolParams,
-      execute: flatMap,
-      isBuiltin: false
-    }
-  },
-  every: {
-    definition: __everyTool,
-    handler: {
-      name: "every",
-      params: __everyToolParams,
-      execute: every,
-      isBuiltin: false
-    }
-  },
-  some: {
-    definition: __someTool,
-    handler: {
-      name: "some",
-      params: __someToolParams,
-      execute: some,
-      isBuiltin: false
-    }
-  },
-  count: {
-    definition: __countTool,
-    handler: {
-      name: "count",
-      params: __countToolParams,
-      execute: count,
-      isBuiltin: false
-    }
-  },
-  sortBy: {
-    definition: __sortByTool,
-    handler: {
-      name: "sortBy",
-      params: __sortByToolParams,
-      execute: sortBy,
-      isBuiltin: false
-    }
-  },
-  unique: {
-    definition: __uniqueTool,
-    handler: {
-      name: "unique",
-      params: __uniqueToolParams,
-      execute: unique,
-      isBuiltin: false
-    }
-  },
-  groupBy: {
-    definition: __groupByTool,
-    handler: {
-      name: "groupBy",
-      params: __groupByToolParams,
-      execute: groupBy,
-      isBuiltin: false
-    }
-  },
   readSkill: {
     definition: __readSkillTool,
     handler: {