agency-lang 0.0.94 → 0.0.95

package/dist/lib/ir/prettyPrint.js

@@ -59,7 +59,8 @@ export function printTs(node, indent = 0) {
             }
         }
         case "varDecl": {
-            let s = `${node.declKind} ${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.94";
+export declare const VERSION = "0.0.95";

package/dist/lib/version.js

@@ -1 +1 @@
-export const VERSION = "0.0.94";
+export const VERSION = "0.0.95";

package/package.json

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

package/stdlib/array.js

@@ -11,7 +11,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const __cwd = __process.cwd();
 const getDirname = () => __dirname;
-const __globalCtx = new RuntimeContext({
+var __globalCtx = new RuntimeContext({
     statelogConfig: {
         host: "https://statelog.adit.io",
         apiKey: __process.env["STATELOG_API_KEY"] || "",
@@ -36,7 +36,7 @@ const __globalCtx = new RuntimeContext({
         traceDir: "traces"
     }
 });
-const graph = __globalCtx.graph;
+var graph = __globalCtx.graph;
 // Path-dependent builtin wrappers
 export function readSkill({ filepath }) {
     return _readSkillRaw({ filepath, dirname: __dirname });
@@ -63,85 +63,85 @@ export const __getCheckpoints = () => __globalCtx.checkpoints;
 async function __initializeGlobals(__ctx) {
     __ctx.globals.markInitialized("stdlib/array.agency");
 }
-export const __mapTool = {
+export var __mapTool = {
     name: "map",
     description: `Map a function over an array, returning a new array of results.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __mapToolParams = ["arr", "func"];
-export const __filterTool = {
+export var __mapToolParams = ["arr", "func"];
+export var __filterTool = {
     name: "filter",
     description: `Return a new array containing only the elements for which the function returns true.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __filterToolParams = ["arr", "func"];
-export const __excludeTool = {
+export var __filterToolParams = ["arr", "func"];
+export var __excludeTool = {
     name: "exclude",
     description: `Return a new array excluding elements for which the function returns true. Inverse of filter.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __excludeToolParams = ["arr", "func"];
-export const __findTool = {
+export var __excludeToolParams = ["arr", "func"];
+export var __findTool = {
     name: "find",
     description: `Return the first element for which the function returns true, or null if none match.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __findToolParams = ["arr", "func"];
-export const __findIndexTool = {
+export var __findToolParams = ["arr", "func"];
+export var __findIndexTool = {
     name: "findIndex",
     description: `Return the index of the first element for which the function returns true, or -1 if none match.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __findIndexToolParams = ["arr", "func"];
-export const __reduceTool = {
+export var __findIndexToolParams = ["arr", "func"];
+export var __reduceTool = {
     name: "reduce",
     description: `Reduce an array to a single value by applying a function to an accumulator and each element.`,
     schema: z.object({ "arr": z.array(z.any()), "initial": z.any(), "func": z.string(), })
 };
-export const __reduceToolParams = ["arr", "initial", "func"];
-export const __flatMapTool = {
+export var __reduceToolParams = ["arr", "initial", "func"];
+export var __flatMapTool = {
     name: "flatMap",
     description: `Map a function over an array and flatten the results by one level.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __flatMapToolParams = ["arr", "func"];
-export const __everyTool = {
+export var __flatMapToolParams = ["arr", "func"];
+export var __everyTool = {
     name: "every",
     description: `Return true if the function returns true for every element in the array.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __everyToolParams = ["arr", "func"];
-export const __someTool = {
+export var __everyToolParams = ["arr", "func"];
+export var __someTool = {
     name: "some",
     description: `Return true if the function returns true for at least one element in the array.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __someToolParams = ["arr", "func"];
-export const __countTool = {
+export var __someToolParams = ["arr", "func"];
+export var __countTool = {
     name: "count",
     description: `Count the number of elements in the array for which the function returns true.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __countToolParams = ["arr", "func"];
-export const __sortByTool = {
+export var __countToolParams = ["arr", "func"];
+export var __sortByTool = {
     name: "sortBy",
     description: `Return a new array sorted by the values returned by the function, in ascending order.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __sortByToolParams = ["arr", "func"];
-export const __uniqueTool = {
+export var __sortByToolParams = ["arr", "func"];
+export var __uniqueTool = {
     name: "unique",
     description: `Return a new array with duplicate elements removed, using the function to determine the identity of each element.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __uniqueToolParams = ["arr", "func"];
-export const __groupByTool = {
+export var __uniqueToolParams = ["arr", "func"];
+export var __groupByTool = {
     name: "groupBy",
     description: `Group elements of an array by the value returned by the function. Returns an object where keys are group names and values are arrays of elements.`,
     schema: z.object({ "arr": z.array(z.any()), "func": z.string(), })
 };
-export const __groupByToolParams = ["arr", "func"];
-const __toolRegistry = {
+export var __groupByToolParams = ["arr", "func"];
+var __toolRegistry = {
     map: {
         definition: __mapTool,
         handler: {
@@ -414,23 +414,23 @@ const __toolRegistry = {
     }
 };
 export async function map(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -513,23 +513,23 @@ export async function map(arr, func, __state = undefined) {
     }
 }
 export async function filter(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -619,23 +619,23 @@ export async function filter(arr, func, __state = undefined) {
     }
 }
 export async function exclude(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -725,23 +725,23 @@ export async function exclude(arr, func, __state = undefined) {
     }
 }
 export async function find(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -830,23 +830,23 @@ export async function find(arr, func, __state = undefined) {
     }
 }
 export async function findIndex(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -935,23 +935,23 @@ export async function findIndex(arr, func, __state = undefined) {
     }
 }
 export async function reduce(arr, initial, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1045,23 +1045,23 @@ export async function reduce(arr, initial, func, __state = undefined) {
     }
 }
 export async function flatMap(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1154,23 +1154,23 @@ export async function flatMap(arr, func, __state = undefined) {
     }
 }
 export async function every(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1259,23 +1259,23 @@ export async function every(arr, func, __state = undefined) {
     }
 }
 export async function some(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1364,23 +1364,23 @@ export async function some(arr, func, __state = undefined) {
     }
 }
 export async function count(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1470,23 +1470,23 @@ export async function count(arr, func, __state = undefined) {
     }
 }
 export async function sortBy(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1601,23 +1601,23 @@ export async function sortBy(arr, func, __state = undefined) {
     }
 }
 export async function unique(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1736,23 +1736,23 @@ export async function unique(arr, func, __state = undefined) {
     }
 }
 export async function groupBy(arr, func, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/array.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",

package/stdlib/index.js

@@ -10,7 +10,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const __cwd = __process.cwd();
 const getDirname = () => __dirname;
-const __globalCtx = new RuntimeContext({
+var __globalCtx = new RuntimeContext({
     statelogConfig: {
         host: "https://statelog.adit.io",
         apiKey: __process.env["STATELOG_API_KEY"] || "",
@@ -35,7 +35,7 @@ const __globalCtx = new RuntimeContext({
         traceDir: "traces"
     }
 });
-const graph = __globalCtx.graph;
+var graph = __globalCtx.graph;
 // Path-dependent builtin wrappers
 export function readSkill({ filepath }) {
     return _readSkillRaw({ filepath, dirname: __dirname });
@@ -62,103 +62,103 @@ export const __getCheckpoints = () => __globalCtx.checkpoints;
 async function __initializeGlobals(__ctx) {
     __ctx.globals.markInitialized("stdlib/index.agency");
 }
-export const __printTool = {
+export var __printTool = {
     name: "print",
     description: `A tool for printing a message to the console.`,
     schema: z.object({ "messages": z.string(), })
 };
-export const __printToolParams = ["messages"];
-export const __printJSONTool = {
+export var __printToolParams = ["messages"];
+export var __printJSONTool = {
     name: "printJSON",
     description: `A tool for printing an object as formatted JSON to the console.`,
     schema: z.object({ "obj": z.string(), })
 };
-export const __printJSONToolParams = ["obj"];
-export const __inputTool = {
+export var __printJSONToolParams = ["obj"];
+export var __inputTool = {
     name: "input",
     description: `A tool for prompting the user for input and returning their response.`,
     schema: z.object({ "prompt": z.string(), })
 };
-export const __inputToolParams = ["prompt"];
-export const __sleepTool = {
+export var __inputToolParams = ["prompt"];
+export var __sleepTool = {
     name: "sleep",
     description: `A tool for pausing execution for a specified number of seconds.`,
     schema: z.object({ "seconds": z.number(), })
 };
-export const __sleepToolParams = ["seconds"];
-export const __roundTool = {
+export var __sleepToolParams = ["seconds"];
+export var __roundTool = {
     name: "round",
     description: `A tool for rounding a number to a specified number of decimal places.`,
     schema: z.object({ "num": z.number(), "precision": z.number(), })
 };
-export const __roundToolParams = ["num", "precision"];
-export const __fetchTool = {
+export var __roundToolParams = ["num", "precision"];
+export var __fetchTool = {
     name: "fetch",
     description: `A tool for fetching a URL and returning the response as text.`,
     schema: z.object({ "url": z.string(), })
 };
-export const __fetchToolParams = ["url"];
-export const __fetchJSONTool = {
+export var __fetchToolParams = ["url"];
+export var __fetchJSONTool = {
     name: "fetchJSON",
     description: `A tool for fetching a URL and returning the response as parsed JSON.`,
     schema: z.object({ "url": z.string(), })
 };
-export const __fetchJSONToolParams = ["url"];
-export const __readTool = {
+export var __fetchJSONToolParams = ["url"];
+export var __readTool = {
     name: "read",
     description: `A tool for reading the contents of a file and returning it as a string.`,
     schema: z.object({ "filename": z.string(), })
 };
-export const __readToolParams = ["filename"];
-export const __writeTool = {
+export var __readToolParams = ["filename"];
+export var __writeTool = {
     name: "write",
     description: `A tool for writing content to a file.`,
     schema: z.object({ "filename": z.string(), "content": z.string(), })
 };
-export const __writeToolParams = ["filename", "content"];
-export const __readImageTool = {
+export var __writeToolParams = ["filename", "content"];
+export var __readImageTool = {
     name: "readImage",
     description: `A tool for reading an image file and returning its contents as a Base64-encoded string.`,
     schema: z.object({ "filename": z.string(), })
 };
-export const __readImageToolParams = ["filename"];
-export const __notifyTool = {
+export var __readImageToolParams = ["filename"];
+export var __notifyTool = {
     name: "notify",
     description: `A tool for showing a native OS notification with a title and message. Returns true if the notification was sent.`,
     schema: z.object({ "title": z.string(), "message": z.string(), })
 };
-export const __notifyToolParams = ["title", "message"];
-export const __rangeTool = {
+export var __notifyToolParams = ["title", "message"];
+export var __rangeTool = {
     name: "range",
     description: `Generate an array of numbers. With one argument, generates from 0 to start-1. With two arguments, generates from start to end-1.`,
     schema: z.object({ "start": z.number(), "end": z.number().nullable().describe("Default: -1"), })
 };
-export const __rangeToolParams = ["start", "end"];
-export const __mostCommonTool = {
+export var __rangeToolParams = ["start", "end"];
+export var __mostCommonTool = {
     name: "mostCommon",
     description: `Return the most common element in an array. Uses JSON serialization for comparison.`,
     schema: z.object({ "items": z.array(z.any()), })
 };
-export const __mostCommonToolParams = ["items"];
-export const __keysTool = {
+export var __mostCommonToolParams = ["items"];
+export var __keysTool = {
     name: "keys",
     description: `Return an array of an object's own enumerable property names.`,
     schema: z.object({ "obj": z.any(), })
 };
-export const __keysToolParams = ["obj"];
-export const __valuesTool = {
+export var __keysToolParams = ["obj"];
+export var __valuesTool = {
     name: "values",
     description: `Return an array of an object's own enumerable property values.`,
     schema: z.object({ "obj": z.any(), })
 };
-export const __valuesToolParams = ["obj"];
-export const __entriesTool = {
+export var __valuesToolParams = ["obj"];
+export var __entriesTool = {
     name: "entries",
     description: `Return an array of an object's own enumerable entries, each as { key, value }.`,
     schema: z.object({ "obj": z.any(), })
 };
-export const __entriesToolParams = ["obj"];
-const __toolRegistry = {
+export var __entriesToolParams = ["obj"];
+var __toolRegistry = {
     print: {
         definition: __printTool,
         handler: {
@@ -314,23 +314,23 @@ const __toolRegistry = {
     }
 };
 export async function print(messages, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -397,23 +397,23 @@ export async function print(messages, __state = undefined) {
     }
 }
 export async function printJSON(obj, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -480,23 +480,23 @@ export async function printJSON(obj, __state = undefined) {
     }
 }
 export async function input(prompt, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -565,23 +565,23 @@ export async function input(prompt, __state = undefined) {
     }
 }
 export async function sleep(seconds, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -648,23 +648,23 @@ export async function sleep(seconds, __state = undefined) {
     }
 }
 export async function round(num, precision, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -739,23 +739,23 @@ export async function round(num, precision, __state = undefined) {
     }
 }
 export async function fetch(url, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -871,23 +871,23 @@ export async function fetch(url, __state = undefined) {
     }
 }
 export async function fetchJSON(url, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1003,23 +1003,23 @@ export async function fetchJSON(url, __state = undefined) {
     }
 }
 export async function read(filename, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1135,23 +1135,23 @@ export async function read(filename, __state = undefined) {
     }
 }
 export async function write(filename, content, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1272,23 +1272,23 @@ export async function write(filename, content, __state = undefined) {
     }
 }
 export async function readImage(filename, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1404,23 +1404,23 @@ export async function readImage(filename, __state = undefined) {
     }
 }
 export async function notify(title, message, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1543,23 +1543,23 @@ export async function notify(title, message, __state = undefined) {
     }
 }
 export async function range(start, end = null, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1646,23 +1646,23 @@ export async function range(start, end = null, __state = undefined) {
     }
 }
 export async function mostCommon(items, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1731,23 +1731,23 @@ export async function mostCommon(items, __state = undefined) {
     }
 }
 export async function keys(obj, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1816,23 +1816,23 @@ export async function keys(obj, __state = undefined) {
     }
 }
 export async function values(obj, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",
@@ -1901,23 +1901,23 @@ export async function values(obj, __state = undefined) {
     }
 }
 export async function entries(obj, __state = undefined) {
-    const __setupData = setupFunction({
+    var __setupData = setupFunction({
         state: __state
     });
     // __state will be undefined if this function is being called as a tool by an llm
-    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;
+    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;
     if (!__ctx.globals.isInitialized("stdlib/index.agency")) {
         await __initializeGlobals(__ctx);
     }
-    let __funcStartTime = performance.now();
+    var __funcStartTime = performance.now();
     await callHook({
         callbacks: __ctx.callbacks,
         name: "onFunctionStart",