agency-lang 0.0.97 → 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/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.97",
+  "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,4 +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 { 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";
@@ -33,7 +33,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const __cwd = __process.cwd();
 const getDirname = () => __dirname;
-var __globalCtx = new RuntimeContext({
+const __globalCtx = new RuntimeContext({
   statelogConfig: {
     host: "https://statelog.adit.io",
     apiKey: __process.env["STATELOG_API_KEY"] || "",
@@ -58,7 +58,7 @@ var __globalCtx = new RuntimeContext({
     traceDir: "traces"
   }
 });
-var graph = __globalCtx.graph;
+const graph = __globalCtx.graph;
 function readSkill({ filepath }) {
   return _readSkillRaw({ filepath, dirname: __dirname });
 }
@@ -91,25 +91,25 @@ async function __initializeGlobals(__ctx) {
   __ctx.globals.markInitialized("stdlib/agent.agency");
   __ctx.globals.set("stdlib/agent.agency", "_todos", []);
 }
-var __todoWriteTool = {
+const __todoWriteTool = {
   name: "todoWrite",
   description: `Replace the current todo list. Each todo has an id, text, and status (one of 'pending', 'in_progress', 'completed'). Use this to track multi-step work as you go: mark a todo 'in_progress' before starting it and 'completed' when done. Returns the new list.`,
   schema: z.object({ "todos": z.array(z.object({ "id": z.string(), "text": z.string(), "status": z.union([z.literal("pending"), z.literal("in_progress"), z.literal("completed")]) })) })
 };
-var __todoWriteToolParams = ["todos"];
-var __todoListTool = {
+const __todoWriteToolParams = ["todos"];
+const __todoListTool = {
   name: "todoList",
   description: `Return the current todo list.`,
   schema: z.object({})
 };
-var __todoListToolParams = [];
-var __questionTool = {
+const __todoListToolParams = [];
+const __questionTool = {
   name: "question",
   description: `Ask the user a question and wait for their reply. Unlike input(), this raises an interrupt so the host (CLI, web UI, etc.) can present the prompt in its own way; the host resolves the interrupt with the answer string.`,
   schema: z.object({ "prompt": z.string() })
 };
-var __questionToolParams = ["prompt"];
-var __toolRegistry = {
+const __questionToolParams = ["prompt"];
+const __toolRegistry = {
   todoWrite: {
     definition: __todoWriteTool,
     handler: {
@@ -292,22 +292,22 @@ var __toolRegistry = {
   }
 };
 async function todoWrite(todos, __state = void 0) {
-  var __setupData = setupFunction({
+  const __setupData = setupFunction({
     state: __state
   });
-  var __stack = __setupData.stack;
-  var __step = __setupData.step;
-  var __self = __setupData.self;
-  var __threads = __setupData.threads;
-  var __ctx = __state?.ctx || __globalCtx;
-  var statelogClient = __ctx.statelogClient;
-  var __graph = __ctx.graph;
-  var __forked;
-  var __functionCompleted = false;
+  const __stack = __setupData.stack;
+  const __step = __setupData.step;
+  const __self = __setupData.self;
+  const __threads = __setupData.threads;
+  const __ctx = __state?.ctx || __globalCtx;
+  const statelogClient = __ctx.statelogClient;
+  const __graph = __ctx.graph;
+  let __forked;
+  let __functionCompleted = false;
   if (!__ctx.globals.isInitialized("stdlib/agent.agency")) {
     await __initializeGlobals(__ctx);
   }
-  var __funcStartTime = performance.now();
+  let __funcStartTime = performance.now();
   await callHook({
     callbacks: __ctx.callbacks,
     name: "onFunctionStart",
@@ -380,22 +380,22 @@ async function todoWrite(todos, __state = void 0) {
   }
 }
 async function todoList(__state = void 0) {
-  var __setupData = setupFunction({
+  const __setupData = setupFunction({
     state: __state
   });
-  var __stack = __setupData.stack;
-  var __step = __setupData.step;
-  var __self = __setupData.self;
-  var __threads = __setupData.threads;
-  var __ctx = __state?.ctx || __globalCtx;
-  var statelogClient = __ctx.statelogClient;
-  var __graph = __ctx.graph;
-  var __forked;
-  var __functionCompleted = false;
+  const __stack = __setupData.stack;
+  const __step = __setupData.step;
+  const __self = __setupData.self;
+  const __threads = __setupData.threads;
+  const __ctx = __state?.ctx || __globalCtx;
+  const statelogClient = __ctx.statelogClient;
+  const __graph = __ctx.graph;
+  let __forked;
+  let __functionCompleted = false;
   if (!__ctx.globals.isInitialized("stdlib/agent.agency")) {
     await __initializeGlobals(__ctx);
   }
-  var __funcStartTime = performance.now();
+  let __funcStartTime = performance.now();
   await callHook({
     callbacks: __ctx.callbacks,
     name: "onFunctionStart",
@@ -458,22 +458,22 @@ async function todoList(__state = void 0) {
   }
 }
 async function question(prompt, __state = void 0) {
-  var __setupData = setupFunction({
+  const __setupData = setupFunction({
     state: __state
   });
-  var __stack = __setupData.stack;
-  var __step = __setupData.step;
-  var __self = __setupData.self;
-  var __threads = __setupData.threads;
-  var __ctx = __state?.ctx || __globalCtx;
-  var statelogClient = __ctx.statelogClient;
-  var __graph = __ctx.graph;
-  var __forked;
-  var __functionCompleted = false;
+  const __stack = __setupData.stack;
+  const __step = __setupData.step;
+  const __self = __setupData.self;
+  const __threads = __setupData.threads;
+  const __ctx = __state?.ctx || __globalCtx;
+  const statelogClient = __ctx.statelogClient;
+  const __graph = __ctx.graph;
+  let __forked;
+  let __functionCompleted = false;
   if (!__ctx.globals.isInitialized("stdlib/agent.agency")) {
     await __initializeGlobals(__ctx);
   }
-  var __funcStartTime = performance.now();
+  let __funcStartTime = performance.now();
   await callHook({
     callbacks: __ctx.callbacks,
     name: "onFunctionStart",