agency-lang 0.0.94 → 0.0.96

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

@@ -28,7 +28,7 @@ export declare const comma: Parser<(string[] | ",")[]>;
 export declare const plusSign: Parser<("+" | string[])[]>;
 export declare const commaWithNewline: Parser<(string[] | ",")[]>;
 export declare const varNameChar: Parser<string>;
-export declare const AGENCY_TEMPLATE_OFFSET = 3;
+export declare const AGENCY_TEMPLATE_OFFSET = 2;
 /**
  * Wraps a parser to add a `loc` field from tarsec's withSpan.
  * Converts Span { start: Position, end: Position } to SourceLocation { line, col, start, end }.

package/dist/lib/parsers/parsers.js

@@ -23,7 +23,7 @@ export const varNameChar = oneOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRST
 However, because every agency code gets rendered in a template that imports some standard functions,
 the line numbers would be off if we didn't account for the template lines.
 */
-export const AGENCY_TEMPLATE_OFFSET = 3;
+export const AGENCY_TEMPLATE_OFFSET = 2;
 /**
  * Wraps a parser to add a `loc` field from tarsec's withSpan.
  * Converts Span { start: Position, end: Position } to SourceLocation { line, col, start, end }.

package/dist/lib/templates/backends/agency/template.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "import { print, printJSON, input, sleep, round, fetch, fetchJSON, read, write, readImage, notify, range, mostCommon, keys, values, entries } from \"std::index\";\nimport { map, filter, exclude, find, findIndex, reduce, flatMap, every, some, count, sortBy, unique, groupBy } from \"std::array\";\n\n{{{body:string}}}";
+export declare const template = "import { print, printJSON, input, sleep, round, fetch, fetchJSON, read, write, readImage, notify, range, mostCommon, keys, values, entries } from \"std::index\";\n\n{{{body:string}}}";
 export type TemplateType = {
     body: string;
 };

package/dist/lib/templates/backends/agency/template.js

@@ -3,7 +3,6 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `import { print, printJSON, input, sleep, round, fetch, fetchJSON, read, write, readImage, notify, range, mostCommon, keys, values, entries } from "std::index";
-import { map, filter, exclude, find, findIndex, reduce, flatMap, every, some, count, sortBy, unique, groupBy } from "std::array";
 
 {{{body:string}}}`;
 const render = (args) => {

package/dist/lib/version.d.ts

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

package/dist/lib/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "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",