agency-lang 0.0.41 → 0.0.43

package/dist/lib/backends/baseGenerator.d.ts

@@ -12,6 +12,7 @@ import { WhileLoop } from "../types/whileLoop.js";
 import { IfElse } from "../types/ifElse.js";
 import { TimeBlock } from "../types/timeBlock.js";
 import { AwaitStatement } from "../types/await.js";
+type Scope = "global" | "function" | "node";
 export declare class BaseGenerator {
     protected typeHints: TypeHintMap;
     protected graphNodes: GraphNodeDefinition[];
@@ -19,6 +20,7 @@ export declare class BaseGenerator {
     protected generatedTypeAliases: string[];
     protected functionScopedVariables: string[];
     protected globalScopedVariables: string[];
+    protected functionParameters: string[];
     protected toolsUsed: string[];
     protected typeAliases: Record<string, VariableType>;
     protected functionsUsed: Set<string>;
@@ -26,6 +28,7 @@ export declare class BaseGenerator {
     protected importedNodes: ImportNodeStatement[];
     protected importedTools: ImportToolStatement[];
     protected functionDefinitions: Record<string, FunctionDefinition>;
+    protected currentScope: Scope[];
     generate(program: AgencyProgram): {
         output: string;
     };
@@ -66,4 +69,8 @@ export declare class BaseGenerator {
     protected generateImports(): string;
     protected preprocess(): string;
     protected postprocess(): string;
+    protected startScope(scope: Scope): void;
+    protected endScope(): void;
+    protected getScopeVar(): string;
 }
+export {};

package/dist/lib/backends/baseGenerator.js

@@ -5,6 +5,7 @@ export class BaseGenerator {
     generatedTypeAliases = [];
     functionScopedVariables = [];
     globalScopedVariables = [];
+    functionParameters = [];
     // collect tools for a prompt
     toolsUsed = [];
     typeAliases = {};
@@ -16,6 +17,7 @@ export class BaseGenerator {
     // collect function signatures so we can implement named args
     // TODO also save return types, check if used as a tool, return type cannot be null/void/undefined
     functionDefinitions = {};
+    currentScope = ["global"];
     generate(program) {
         // Pass 1: Collect all type aliases
         for (const node of program.nodes) {
@@ -253,4 +255,20 @@ export class BaseGenerator {
     postprocess() {
         return "";
     }
+    startScope(scope) {
+        this.currentScope.push(scope);
+    }
+    endScope() {
+        this.currentScope.pop();
+    }
+    getScopeVar() {
+        const currentScope = this.currentScope[this.currentScope.length - 1];
+        switch (currentScope) {
+            case "global":
+                return "__stateStack.globals";
+            case "function":
+            case "node":
+                return "__stack.locals";
+        }
+    }
 }

package/dist/lib/backends/graphGenerator.js

@@ -39,6 +39,7 @@ export class GraphGenerator extends TypeScriptGenerator {
         this.graphNodes.push(node);
     }
     processGraphNode(node) {
+        this.startScope("node");
         const { nodeName, body, parameters } = node;
         /* if (parameters.length > 1) {
           throw new Error(
@@ -47,22 +48,22 @@ export class GraphGenerator extends TypeScriptGenerator {
         } */
         this.adjacentNodes[nodeName] = [];
         this.currentAdjacentNodes = [];
-        this.functionScopedVariables = [];
+        this.functionParameters = [];
         this.isInsideGraphNode = true;
         for (const param of parameters) {
-            this.functionScopedVariables.push(param.name);
+            this.functionParameters.push(param.name);
         }
-        const bodyCode = [];
         for (const stmt of body) {
             if (stmt.type === "functionCall" && this.isGraphNode(stmt.functionName)) {
                 throw new Error(`Call to graph node '${stmt.functionName}' inside graph node '${nodeName}' was not returned. All calls to graph nodes must be returned, eg (return ${stmt.functionName}(...)).`);
             }
-            bodyCode.push(this.processNode(stmt));
         }
-        this.functionScopedVariables = [];
+        const bodyCode = this.processBodyAsParts(body);
+        this.functionParameters = [];
         this.adjacentNodes[nodeName] = [...this.currentAdjacentNodes];
         this.isInsideGraphNode = false;
-        const paramNames = "[" + parameters.map((p) => p.name).join(", ") + "]";
+        this.endScope();
+        const paramNames = "[" + parameters.map((p) => `"${p.name}"`).join(", ") + "]";
         return renderGraphNode.default({
             name: nodeName,
             /* returnType: node.returnType

package/dist/lib/backends/typescriptGenerator.d.ts

@@ -1,17 +1,17 @@
-import { AgencyComment, AgencyProgram, Assignment, Literal, PromptLiteral, PromptSegment, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
+import { AgencyComment, AgencyNode, AgencyProgram, Assignment, Literal, PromptLiteral, PromptSegment, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
+import { AwaitStatement } from "../types/await.js";
 import { SpecialVar } from "../types/specialVar.js";
+import { TimeBlock } from "../types/timeBlock.js";
 import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
+import { IfElse } from "../types/ifElse.js";
 import { ImportNodeStatement, ImportStatement, ImportToolStatement } from "../types/importStatement.js";
 import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
 import { WhileLoop } from "../types/whileLoop.js";
-import { IfElse } from "../types/ifElse.js";
 import { BaseGenerator } from "./baseGenerator.js";
-import { TimeBlock } from "../types/timeBlock.js";
-import { AwaitStatement } from "../types/await.js";
 export declare class TypeScriptGenerator extends BaseGenerator {
     constructor();
     protected generateBuiltins(): string;
@@ -43,6 +43,7 @@ export declare class TypeScriptGenerator extends BaseGenerator {
      * Generates TypeScript expression for a function call (without semicolon)
      */
     protected generateFunctionCallExpression(node: FunctionCall): string;
+    protected generateScopedVariableName(variableName: string): string;
     protected generateLiteral(literal: Literal): string;
     protected generateImports(): string;
     buildPromptString(segments: PromptSegment[], typeHints: TypeHintMap): string;
@@ -64,5 +65,6 @@ export declare class TypeScriptGenerator extends BaseGenerator {
     protected processSpecialVar(node: SpecialVar): string;
     protected processTimeBlock(node: TimeBlock, timingVarName: string): string;
     protected processAwaitStatement(node: AwaitStatement): string;
+    protected processBodyAsParts(body: AgencyNode[]): string[];
 }
 export declare function generateTypeScript(program: AgencyProgram): string;

package/dist/lib/backends/typescriptGenerator.js

@@ -1,16 +1,17 @@
 import * as renderSpecialVar from "../templates/backends/graphGenerator/specialVar.js";
+import * as renderTime from "../templates/backends/typescriptGenerator/builtinFunctions/time.js";
 import * as builtinTools from "../templates/backends/typescriptGenerator/builtinTools.js";
 import * as renderFunctionDefinition from "../templates/backends/typescriptGenerator/functionDefinition.js";
 import * as renderImports from "../templates/backends/typescriptGenerator/imports.js";
 import * as promptFunction from "../templates/backends/typescriptGenerator/promptFunction.js";
 import * as renderTool from "../templates/backends/typescriptGenerator/tool.js";
-import * as renderTime from "../templates/backends/typescriptGenerator/builtinFunctions/time.js";
 import * as renderToolCall from "../templates/backends/typescriptGenerator/toolCall.js";
-import { escape, uniq, zip } from "../utils.js";
+import { escape, uniq } from "../utils.js";
 import { BaseGenerator } from "./baseGenerator.js";
 import { generateBuiltinHelpers, mapFunctionName, } from "./typescriptGenerator/builtins.js";
 import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
 import { DEFAULT_SCHEMA, mapTypeToZodSchema, } from "./typescriptGenerator/typeToZodSchema.js";
+import { TYPES_THAT_DONT_TRIGGER_NEW_PART } from "../config.js";
 export class TypeScriptGenerator extends BaseGenerator {
     constructor() {
         super();
@@ -58,7 +59,11 @@ export class TypeScriptGenerator extends BaseGenerator {
     }
     processReturnStatement(node) {
         const returnCode = this.processNode(node.value);
-        return `return ${returnCode}\n`;
+        if (node.value.type === "functionCall" &&
+            node.value.functionName === "interrupt") {
+            return `__stack.step++;\nreturn ${returnCode}\n`;
+        }
+        return `__stateStack.pop();\nreturn ${returnCode}\n`;
     }
     processAccessExpression(node) {
         switch (node.expression.type) {
@@ -140,7 +145,8 @@ export class TypeScriptGenerator extends BaseGenerator {
             }
             // Direct assignment for other literal types
             const code = this.processNode(value);
-            return (`const ${variableName}${typeAnnotation} = await ${code.trim()};` + "\n");
+            return (`${this.getScopeVar()}.${variableName}${typeAnnotation} = await ${code.trim()};` +
+                "\n");
         }
         else if (value.type === "timeBlock") {
             const timingVarName = variableName;
@@ -150,7 +156,8 @@ export class TypeScriptGenerator extends BaseGenerator {
         else {
             // Direct assignment for other literal types
             const code = this.processNode(value);
-            return `const ${variableName}${typeAnnotation} = ${code.trim()};` + "\n";
+            return (`${this.getScopeVar()}.${variableName}${typeAnnotation} = ${code.trim()};` +
+                "\n");
         }
     }
     /*
@@ -180,10 +187,12 @@ export class TypeScriptGenerator extends BaseGenerator {
             prompt: node,
         });
         //this.generatedStatements.push(functionCode);
-        const argsStr = [...interpolatedVars, "__messages"].join(", ");
+        //const argsStr = [...interpolatedVars, "__messages"].join(", ");
         // Generate the function call
-        return (`${functionCode}\nconst ${variableName} = await _${variableName}(${argsStr});` +
-            "\n");
+        return functionCode; /* (
+          `${functionCode}\nconst __self.${variableName} = await _${variableName}(${argsStr});` +
+          "\n"
+        ); */
     }
     processTool(node) {
         const { functionName, body, parameters } = node;
@@ -221,17 +230,19 @@ export class TypeScriptGenerator extends BaseGenerator {
      * Process a function definition node
      */
     processFunctionDefinition(node) {
+        this.startScope("function");
         const { functionName, body, parameters } = node;
+        const args = parameters.map((p) => p.name);
         this.functionScopedVariables = [...parameters.map((p) => p.name)];
-        const bodyCode = [];
-        for (const stmt of body) {
-            bodyCode.push(this.processNode(stmt));
-        }
+        this.functionParameters = args;
+        const bodyCode = this.processBodyAsParts(body);
         this.functionScopedVariables = [];
-        const args = parameters.map((p) => p.name).join(", ") || "";
+        this.functionParameters = [];
+        this.endScope();
+        const argsStr = args.map((arg) => `"${arg}"`).join(", ") || "";
         return renderFunctionDefinition.default({
             functionName,
-            args: "{" + args + "}",
+            argsStr,
             returnType: node.returnType
                 ? variableTypeToString(node.returnType, this.typeAliases)
                 : "any",
@@ -279,22 +290,32 @@ export class TypeScriptGenerator extends BaseGenerator {
             }
         });
         let argsString = "";
-        const paramNames = this.functionDefinitions[node.functionName]?.parameters.map((p) => p.name) || null;
-        if (paramNames) {
-            const partsWithNames = zip(paramNames, parts).map(([paramName, part]) => {
-                return `${paramName}: ${part}`;
-            });
-            argsString = partsWithNames.join(", ");
-            return `${functionName}({${argsString}})`;
+        const isImportedTool = this.importedTools
+            .map((node) => node.importedTools)
+            .flat()
+            .includes(node.functionName);
+        if (this.functionDefinitions[node.functionName] || isImportedTool) {
+            argsString = parts.join(", ");
+            return `${functionName}([${argsString}])`;
         }
         else {
-            // must be a builtin function or imported function,
-            // as we don't have the signature info
-            // in that case don't do named parameters
+            // must be a builtin function or imported function
             argsString = parts.join(", ");
             return `${functionName}(${argsString})`;
         }
     }
+    generateScopedVariableName(variableName) {
+        if (this.functionParameters.includes(variableName)) {
+            return `__stack.args.${variableName}`;
+        }
+        if (this.functionScopedVariables.includes(variableName)) {
+            return `__stack.locals.${variableName}`;
+        }
+        else if (this.globalScopedVariables.includes(variableName)) {
+            return `__stateStack.globals.${variableName}`;
+        }
+        return variableName;
+    }
     generateLiteral(literal) {
         switch (literal.type) {
             case "number":
@@ -304,7 +325,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             case "multiLineString":
                 return this.generateStringLiteral(literal.segments);
             case "variableName":
-                return literal.value;
+                return this.generateScopedVariableName(literal.value);
             case "prompt":
                 //return this.processPromptLiteral("asd", literal).trim();
                 // Reconstruct text for comment from segments
@@ -350,7 +371,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             }
             else {
                 // Interpolation segment
-                stringParts.push("${" + segment.variableName + "}");
+                stringParts.push("${" + this.generateScopedVariableName(segment.variableName) + "}");
             }
         }
         return "`" + stringParts.join("") + "`";
@@ -371,7 +392,7 @@ export class TypeScriptGenerator extends BaseGenerator {
         // Build prompt construction code
         const promptCode = this.buildPromptString(prompt.segments, this.typeHints);
         const parts = functionArgs.map((arg) => `${arg.replace(".", "_")}: ${variableTypeToString(this.typeHints[arg] || { type: "primitiveType", value: "string" }, this.typeAliases)}`);
-        parts.push("__messages: Message[] = []");
+        parts.push("__metadata?: Record<string, any>");
         const argsStr = parts.join(", ");
         const _tools = this.toolsUsed
             .map((toolName) => `__${toolName}Tool`)
@@ -379,16 +400,33 @@ export class TypeScriptGenerator extends BaseGenerator {
         const tools = _tools.length > 0 ? `[${_tools}]` : "undefined";
         const functionCalls = this.toolsUsed
             .map((toolName) => {
+            const func = this.functionDefinitions[toolName];
+            if (!func) {
+                throw new Error(`Tool '${toolName}' is being used but no function definition found for it. Make sure to define a function for this tool.`);
+            }
+            const paramsStr = func.parameters
+                .map((param, index) => {
+                return `args["${param.name}"]`;
+            })
+                .join(", ");
             return renderToolCall.default({
                 name: toolName,
+                paramsStr,
             });
         })
             .join("\n");
         const clientConfig = prompt.config ? this.processNode(prompt.config) : "{}";
+        const metadataObj = `{
+      messages: __messages,
+      interruptResponse: __interruptResponse,
+      toolCall: __toolCall,
+    }`;
         this.toolsUsed = []; // reset after use
+        const scopedFunctionArgs = functionArgs.map((arg) => this.generateScopedVariableName(arg));
         return promptFunction.default({
             variableName,
             argsStr,
+            funcCallParams: [...scopedFunctionArgs, metadataObj].join(", "),
             typeString,
             promptCode,
             hasResponseFormat: zodSchema !== DEFAULT_SCHEMA,
@@ -464,6 +502,28 @@ export class TypeScriptGenerator extends BaseGenerator {
         const code = this.processNode(node.expression);
         return `await ${code}`;
     }
+    processBodyAsParts(body) {
+        const parts = [[]];
+        for (const stmt of body) {
+            if (!TYPES_THAT_DONT_TRIGGER_NEW_PART.includes(stmt.type)) {
+                parts.push([]);
+            }
+            parts[parts.length - 1].push(this.processNode(stmt));
+        }
+        const bodyCode = [];
+        let partNum = 0;
+        for (const part of parts) {
+            const partCode = `
+      if (__step <= ${partNum}) {
+        ${part.join("").trimEnd()}
+        __stack.step++;
+      }
+      `;
+            bodyCode.push(partCode);
+            partNum++;
+        }
+        return bodyCode;
+    }
 }
 export function generateTypeScript(program) {
     const generator = new TypeScriptGenerator();

package/dist/lib/config.d.ts

@@ -0,0 +1,2 @@
+import { AgencyNode } from "./types.js";
+export declare const TYPES_THAT_DONT_TRIGGER_NEW_PART: AgencyNode["type"][];

package/dist/lib/config.js

@@ -0,0 +1,10 @@
+export const TYPES_THAT_DONT_TRIGGER_NEW_PART = [
+    "typeHint",
+    "typeAlias",
+    "usesTool",
+    "comment",
+    "newLine",
+    "importStatement",
+    "importNodeStatement",
+    "importToolStatement",
+];

package/dist/lib/templates/backends/graphGenerator/graphNode.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "\ngraph.node(\"{{{name}}}\", async (state): Promise<any> => {\n    const __messages: Message[] = state.messages || [];\n    const __graph = state.__metadata?.graph || graph;\n    const statelogClient = state.__metadata?.statelogClient || __statelogClient;\n    {{#hasParam}}\n    const {{{paramNames}}} = state.data;\n    {{/hasParam}}\n    {{{body}}}\n    return { ...state, data: undefined };\n});\n";
+export declare const template = "\ngraph.node(\"{{{name}}}\", async (state): Promise<any> => {\n    const __messages: Message[] = state.messages || [];\n    const __graph = state.__metadata?.graph || graph;\n    const statelogClient = state.__metadata?.statelogClient || __statelogClient;\n    if (state.__metadata?.__stateStack) {\n      __stateStack = state.__metadata.__stateStack;\n    }\n    const __stack = __stateStack.getNewState();\n    const __step = __stack.step;\n\n    const __self: Record<string, any> = __stack.locals;\n\n    const __interruptResponse: InterruptResponseType | undefined = state.__metadata?.interruptResponse;\n    const __toolCall: Record<string, any>|undefined = __stateStack.other?.toolCall;\n\n    if (state.__metadata?.state?.global) {\n      __global = state.__metadata.state.global;\n    }\n\n    {{#hasParam}}\n    \n    const __params = {{{paramNames}}};\n    if (state.data !== \"<from-stack>\") {\n      (state.data).forEach((item, index) => {\n        __stack.args[__params[index]] = item;\n      });\n    }\n    {{/hasParam}}\n    {{{body}}}\n    \n    // this is just here to have a default return value from a node if the user doesn't specify one\n    return { ...state, data: undefined };\n});\n";
 export type TemplateType = {
     name: string | boolean | number;
     hasParam: boolean;

package/dist/lib/templates/backends/graphGenerator/graphNode.js

@@ -7,10 +7,33 @@ graph.node("{{{name}}}", async (state): Promise<any> => {
     const __messages: Message[] = state.messages || [];
     const __graph = state.__metadata?.graph || graph;
     const statelogClient = state.__metadata?.statelogClient || __statelogClient;
+    if (state.__metadata?.__stateStack) {
+      __stateStack = state.__metadata.__stateStack;
+    }
+    const __stack = __stateStack.getNewState();
+    const __step = __stack.step;
+
+    const __self: Record<string, any> = __stack.locals;
+
+    const __interruptResponse: InterruptResponseType | undefined = state.__metadata?.interruptResponse;
+    const __toolCall: Record<string, any>|undefined = __stateStack.other?.toolCall;
+
+    if (state.__metadata?.state?.global) {
+      __global = state.__metadata.state.global;
+    }
+
     {{#hasParam}}
-    const {{{paramNames}}} = state.data;
+    
+    const __params = {{{paramNames}}};
+    if (state.data !== "<from-stack>") {
+      (state.data).forEach((item, index) => {
+        __stack.args[__params[index]] = item;
+      });
+    }
     {{/hasParam}}
     {{{body}}}
+    
+    // this is just here to have a default return value from a node if the user doesn't specify one
     return { ...state, data: undefined };
 });
 `;

package/dist/lib/templates/backends/graphGenerator/imports.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "import { z } from \"zod\";\nimport * as readline from \"readline\";\nimport fs from \"fs\";\nimport { PieMachine, goToNode } from \"piemachine\";\nimport { StatelogClient } from \"statelog-client\";\nimport { nanoid } from \"nanoid\";\nimport { assistantMessage, getClient, userMessage, toolMessage } from \"smoltalk\";\n\nconst statelogHost = \"https://statelog.adit.io\";\nconst traceId = nanoid();\nconst statelogConfig = {\n    host: statelogHost,\n    traceId: traceId,\n    apiKey: process.env.STATELOG_API_KEY || \"\",\n    projectId: \"agency-lang\",\n    debugMode: false,\n  };\nconst __statelogClient = new StatelogClient(statelogConfig);\nconst __model: ModelName = \"gpt-4o-mini\";\n\n\nconst getClientWithConfig = (config = {}) => {\n  const defaultConfig = {\n    openAiApiKey: process.env.OPENAI_API_KEY || \"\",\n    googleApiKey: process.env.GEMINI_API_KEY || \"\",\n    model: __model,\n    logLevel: \"warn\",\n  };\n\n  return getClient({ ...defaultConfig, ...config });\n};\n\nlet __client = getClientWithConfig();\n\ntype State = {\n  messages: string[];\n  data: any;\n}\n\n// enable debug logging\nconst graphConfig = {\n  debug: {\n    log: true,\n    logData: false,\n  },\n  statelog: statelogConfig,\n};\n\nconst graph = new PieMachine<State>(graphConfig);\n\n// builtins\n\nconst not = (val: any): boolean => !val;\nconst eq = (a: any, b: any): boolean => a === b;\nconst neq = (a: any, b: any): boolean => a !== b;\nconst lt = (a: any, b: any): boolean => a < b;\nconst lte = (a: any, b: any): boolean => a <= b;\nconst gt = (a: any, b: any): boolean => a > b;\nconst gte = (a: any, b: any): boolean => a >= b;\nconst and = (a: any, b: any): boolean => a && b;\nconst or = (a: any, b: any): boolean => a || b;\nconst head = <T>(arr: T[]): T | undefined => arr[0];\nconst tail = <T>(arr: T[]): T[] => arr.slice(1);\nconst empty = <T>(arr: T[]): boolean => arr.length === 0;\n\n// interrupts\n\ntype Interrupt<T> = {\n  type: \"interrupt\";\n  data: T;\n};\n\nfunction interrupt<T>(data: T): Interrupt<T> {\n  return {\n    type: \"interrupt\",\n    data,\n  };\n}\n\nfunction isInterrupt<T>(obj: any): obj is Interrupt<T> {\n  return obj && obj.type === \"interrupt\";\n}\n\nfunction printJSON(obj: any) {\n  console.log(JSON.stringify(obj, null, 2));\n}";
+export declare const template = "import { z } from \"zod\";\nimport * as readline from \"readline\";\nimport fs from \"fs\";\nimport { PieMachine, goToNode } from \"piemachine\";\nimport { StatelogClient } from \"statelog-client\";\nimport { nanoid } from \"nanoid\";\nimport { assistantMessage, getClient, userMessage, toolMessage, messageFromJSON } from \"smoltalk\";\nimport type { Message } from \"smoltalk\";\n\nconst statelogHost = \"https://statelog.adit.io\";\nconst traceId = nanoid();\nconst statelogConfig = {\n    host: statelogHost,\n    traceId: traceId,\n    apiKey: process.env.STATELOG_API_KEY || \"\",\n    projectId: \"agency-lang\",\n    debugMode: false,\n  };\nconst __statelogClient = new StatelogClient(statelogConfig);\nconst __model: ModelName = \"gpt-4o-mini\";\n\nconst getClientWithConfig = (config = {}) => {\n  const defaultConfig = {\n    openAiApiKey: process.env.OPENAI_API_KEY || \"\",\n    googleApiKey: process.env.GEMINI_API_KEY || \"\",\n    model: __model,\n    logLevel: \"warn\",\n  };\n\n  return getClient({ ...defaultConfig, ...config });\n};\n\nlet __client = getClientWithConfig();\n\ntype State = {\n  messages: string[];\n  data: any;\n}\n\n// enable debug logging\nconst graphConfig = {\n  debug: {\n    log: true,\n    logData: false,\n  },\n  statelog: statelogConfig,\n};\n\nconst graph = new PieMachine<State>(graphConfig);\n\n// builtins\n\nconst not = (val: any): boolean => !val;\nconst eq = (a: any, b: any): boolean => a === b;\nconst neq = (a: any, b: any): boolean => a !== b;\nconst lt = (a: any, b: any): boolean => a < b;\nconst lte = (a: any, b: any): boolean => a <= b;\nconst gt = (a: any, b: any): boolean => a > b;\nconst gte = (a: any, b: any): boolean => a >= b;\nconst and = (a: any, b: any): boolean => a && b;\nconst or = (a: any, b: any): boolean => a || b;\nconst head = <T>(arr: T[]): T | undefined => arr[0];\nconst tail = <T>(arr: T[]): T[] => arr.slice(1);\nconst empty = <T>(arr: T[]): boolean => arr.length === 0;\n\n// interrupts\n\nexport type Interrupt<T> = {\n  type: \"interrupt\";\n  data: T;\n  __state?: PackagedState;\n};\n\nexport function interrupt<T>(data: T): Interrupt<T> {\n  return {\n    type: \"interrupt\",\n    data,\n  };\n}\n\nexport function isInterrupt<T>(obj: any): obj is Interrupt<T> {\n  return obj && obj.type === \"interrupt\";\n}\n\nfunction printJSON(obj: any) {\n  console.log(JSON.stringify(obj, null, 2));\n}\n\nexport type InterruptResponseType = InterruptResponseApprove | InterruptResponseReject | InterruptResponseModify;\nexport type InterruptResponseApprove = {\n  type: \"approve\";\n};\nexport type InterruptResponseReject = {\n  type: \"reject\";\n};\nexport type InterruptResponseModify = {\n  type: \"modify\";\n  newArguments: Record<string, any>;\n};\n\n\nexport async function respondToInterrupt(_interrupt: Interrupt, _interruptResponse: InterruptResponseType) {\n  const interrupt = structuredClone(_interrupt);\n  const interruptResponse = structuredClone(_interruptResponse);\n  __stateStack = StateStack.fromJSON(interrupt.__state || {});\n  __stateStack.setMode(\"deserialize\");\n  const messages = (__stateStack.other.messages || []).map((json: any) => {\n    return messageFromJSON(json);\n  });\n\n  const nodesTraversed = __stateStack.other.nodesTraversed || [];\n  const nodeName = nodesTraversed[nodesTraversed.length - 1];\n  const result = await graph.run(nodeName, {\n    messages: messages,\n    __metadata: {\n      graph: graph,\n      statelogClient: __statelogClient,\n      interruptResponse: interruptResponse,\n      state: interrupt.__state,\n      __stateStack: __stateStack,\n    },\n    data: \"<from-stack>\"\n  });\n  //console.log(`Result of graph.run(\"${nodeName}\"):`, JSON.stringify(result, null, 2));\n  return result.data;\n}\n\n\nclass PackagedState {\n  public messages?: Message[];\n  public nodesTraversed?: string[];\n  public toolCall?: Record<string, any>;\n  public step?: number;\n  public self?: Record<string, any>;\n  public global?: Record<string, any>;\n  public args?: any;\n  constructor(_state: Record<string, any>, args?: any) {\n    const state = structuredClone(_state);\n    this.messages = state.messages;\n    this.nodesTraversed = state.graph?.getNodesTraversed();\n    this.toolCall = state.toolCall;\n    this.step = state.part;\n    this.self = state.self;\n    this.global = state.global;\n    this.args = state.args;\n  }\n\n  toJSON() {\n    return {\n      messages: this.messages,\n      nodesTraversed: this.nodesTraversed,\n      toolCall: this.toolCall,\n      step: this.step,\n      self: this.self,\n      global: this.global,\n      args: this.args,\n    };\n  }\n\n  nextStep() {\n    this.step ||= 0;\n    this.step += 1;\n  }\n}\n\n\nclass StateStack {\n  public stack: StateItem[] = [];\n  public mode: \"serialize\" | \"deserialize\" = \"serialize\";\n  public globals: Record<string, any> = {};\n  public other: Record<string, any> = {};\n\n  constructor(stack: StateItem[] = [], mode: \"serialize\" | \"deserialize\" = \"serialize\") {\n    this.stack = stack;\n    this.mode = mode;\n  }\n\n  getNewState(): StateItem | null {\n    if (this.stack.length === 0 && this.mode !== \"serialize\") {\n      console.log(\"Forcing mode to serialize, nothing left to deserialize\");\n      this.mode = \"serialize\";\n    }\n    if (this.mode === \"serialize\") {\n      const newState: StateItem = {\n        args: {},\n        locals: {},\n        step: 0,\n      };\n      this.stack.push(newState);\n      return newState;\n    } else if (this.mode === \"deserialize\") {\n      const item = this.stack.shift();\n      this.stack.push(item);\n      return item;\n    }\n    return null;\n  }\n\n  setMode(mode: \"serialize\" | \"deserialize\") {\n    this.mode = mode;\n  }\n\n  pop(): StateItem | undefined {\n    return this.stack.pop();\n  }\n\n  toJSON() {\n    return structuredClone({\n      stack: this.stack,\n      globals: this.globals,\n      other: this.other,\n      mode: this.mode,\n    });\n  }\n\n  static fromJSON(json: any): StateStack {\n    const stateStack = new StateStack([], \"serialize\");\n    stateStack.stack = json.stack || [];\n    stateStack.globals = json.globals || {};\n    stateStack.other = json.other || {};\n    stateStack.mode = json.mode || \"serialize\";\n    return stateStack;\n  }\n}\n\nlet __stateStack = new StateStack();";
 export type TemplateType = {};
 declare const render: (args: TemplateType) => string;
 export default render;

package/dist/lib/templates/backends/graphGenerator/imports.js

@@ -8,7 +8,8 @@ import fs from "fs";
 import { PieMachine, goToNode } from "piemachine";
 import { StatelogClient } from "statelog-client";
 import { nanoid } from "nanoid";
-import { assistantMessage, getClient, userMessage, toolMessage } from "smoltalk";
+import { assistantMessage, getClient, userMessage, toolMessage, messageFromJSON } from "smoltalk";
+import type { Message } from "smoltalk";
 
 const statelogHost = "https://statelog.adit.io";
 const traceId = nanoid();
@@ -22,7 +23,6 @@ const statelogConfig = {
 const __statelogClient = new StatelogClient(statelogConfig);
 const __model: ModelName = "gpt-4o-mini";
 
-
 const getClientWithConfig = (config = {}) => {
   const defaultConfig = {
     openAiApiKey: process.env.OPENAI_API_KEY || "",
@@ -69,25 +69,165 @@ const empty = <T>(arr: T[]): boolean => arr.length === 0;
 
 // interrupts
 
-type Interrupt<T> = {
+export type Interrupt<T> = {
   type: "interrupt";
   data: T;
+  __state?: PackagedState;
 };
 
-function interrupt<T>(data: T): Interrupt<T> {
+export function interrupt<T>(data: T): Interrupt<T> {
   return {
     type: "interrupt",
     data,
   };
 }
 
-function isInterrupt<T>(obj: any): obj is Interrupt<T> {
+export function isInterrupt<T>(obj: any): obj is Interrupt<T> {
   return obj && obj.type === "interrupt";
 }
 
 function printJSON(obj: any) {
   console.log(JSON.stringify(obj, null, 2));
-}`;
+}
+
+export type InterruptResponseType = InterruptResponseApprove | InterruptResponseReject | InterruptResponseModify;
+export type InterruptResponseApprove = {
+  type: "approve";
+};
+export type InterruptResponseReject = {
+  type: "reject";
+};
+export type InterruptResponseModify = {
+  type: "modify";
+  newArguments: Record<string, any>;
+};
+
+
+export async function respondToInterrupt(_interrupt: Interrupt, _interruptResponse: InterruptResponseType) {
+  const interrupt = structuredClone(_interrupt);
+  const interruptResponse = structuredClone(_interruptResponse);
+  __stateStack = StateStack.fromJSON(interrupt.__state || {});
+  __stateStack.setMode("deserialize");
+  const messages = (__stateStack.other.messages || []).map((json: any) => {
+    return messageFromJSON(json);
+  });
+
+  const nodesTraversed = __stateStack.other.nodesTraversed || [];
+  const nodeName = nodesTraversed[nodesTraversed.length - 1];
+  const result = await graph.run(nodeName, {
+    messages: messages,
+    __metadata: {
+      graph: graph,
+      statelogClient: __statelogClient,
+      interruptResponse: interruptResponse,
+      state: interrupt.__state,
+      __stateStack: __stateStack,
+    },
+    data: "<from-stack>"
+  });
+  //console.log(\`Result of graph.run("\${nodeName}"):\`, JSON.stringify(result, null, 2));
+  return result.data;
+}
+
+
+class PackagedState {
+  public messages?: Message[];
+  public nodesTraversed?: string[];
+  public toolCall?: Record<string, any>;
+  public step?: number;
+  public self?: Record<string, any>;
+  public global?: Record<string, any>;
+  public args?: any;
+  constructor(_state: Record<string, any>, args?: any) {
+    const state = structuredClone(_state);
+    this.messages = state.messages;
+    this.nodesTraversed = state.graph?.getNodesTraversed();
+    this.toolCall = state.toolCall;
+    this.step = state.part;
+    this.self = state.self;
+    this.global = state.global;
+    this.args = state.args;
+  }
+
+  toJSON() {
+    return {
+      messages: this.messages,
+      nodesTraversed: this.nodesTraversed,
+      toolCall: this.toolCall,
+      step: this.step,
+      self: this.self,
+      global: this.global,
+      args: this.args,
+    };
+  }
+
+  nextStep() {
+    this.step ||= 0;
+    this.step += 1;
+  }
+}
+
+
+class StateStack {
+  public stack: StateItem[] = [];
+  public mode: "serialize" | "deserialize" = "serialize";
+  public globals: Record<string, any> = {};
+  public other: Record<string, any> = {};
+
+  constructor(stack: StateItem[] = [], mode: "serialize" | "deserialize" = "serialize") {
+    this.stack = stack;
+    this.mode = mode;
+  }
+
+  getNewState(): StateItem | null {
+    if (this.stack.length === 0 && this.mode !== "serialize") {
+      console.log("Forcing mode to serialize, nothing left to deserialize");
+      this.mode = "serialize";
+    }
+    if (this.mode === "serialize") {
+      const newState: StateItem = {
+        args: {},
+        locals: {},
+        step: 0,
+      };
+      this.stack.push(newState);
+      return newState;
+    } else if (this.mode === "deserialize") {
+      const item = this.stack.shift();
+      this.stack.push(item);
+      return item;
+    }
+    return null;
+  }
+
+  setMode(mode: "serialize" | "deserialize") {
+    this.mode = mode;
+  }
+
+  pop(): StateItem | undefined {
+    return this.stack.pop();
+  }
+
+  toJSON() {
+    return structuredClone({
+      stack: this.stack,
+      globals: this.globals,
+      other: this.other,
+      mode: this.mode,
+    });
+  }
+
+  static fromJSON(json: any): StateStack {
+    const stateStack = new StateStack([], "serialize");
+    stateStack.stack = json.stack || [];
+    stateStack.globals = json.globals || {};
+    stateStack.other = json.other || {};
+    stateStack.mode = json.mode || "serialize";
+    return stateStack;
+  }
+}
+
+let __stateStack = new StateStack();`;
 const render = (args) => {
     return apply(template, args);
 };

package/dist/lib/templates/backends/graphGenerator/runNodeFunction.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "{{#hasArgs}}\nexport async function {{{nodeName:string}}}({{{argsStr:string}}}, { messages = [] }): Promise<{{{returnType:string}}}> {\n{{/hasArgs}}\n{{^hasArgs}}\nexport async function {{{nodeName:string}}}({ messages = [] }): Promise<{{{returnType:string}}}> {\n{{/hasArgs}}\n  const data = [ {{{argsStr:string}}} ];\n  const result = await graph.run(\"{{{nodeName:string}}}\", { messages, data });\n  return result.data;\n}\n";
+export declare const template = "{{#hasArgs}}\nexport async function {{{nodeName:string}}}({{{argsStr:string}}}, { messages } = {}): Promise<{{{returnType:string}}}> {\n{{/hasArgs}}\n{{^hasArgs}}\nexport async function {{{nodeName:string}}}({ messages } = {}): Promise<{{{returnType:string}}}> {\n{{/hasArgs}}\n  const data = [ {{{argsStr:string}}} ];\n  const result = await graph.run(\"{{{nodeName:string}}}\", { messages: messages || [], data });\n  return result.data;\n}\n";
 export type TemplateType = {
     hasArgs: boolean;
     nodeName: string;

package/dist/lib/templates/backends/graphGenerator/runNodeFunction.js

@@ -3,13 +3,13 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `{{#hasArgs}}
-export async function {{{nodeName:string}}}({{{argsStr:string}}}, { messages = [] }): Promise<{{{returnType:string}}}> {
+export async function {{{nodeName:string}}}({{{argsStr:string}}}, { messages } = {}): Promise<{{{returnType:string}}}> {
 {{/hasArgs}}
 {{^hasArgs}}
-export async function {{{nodeName:string}}}({ messages = [] }): Promise<{{{returnType:string}}}> {
+export async function {{{nodeName:string}}}({ messages } = {}): Promise<{{{returnType:string}}}> {
 {{/hasArgs}}
   const data = [ {{{argsStr:string}}} ];
-  const result = await graph.run("{{{nodeName:string}}}", { messages, data });
+  const result = await graph.run("{{{nodeName:string}}}", { messages: messages || [], data });
   return result.data;
 }
 `;

package/dist/lib/templates/backends/typescriptGenerator/functionDefinition.d.ts

@@ -1,8 +1,8 @@
-export declare const template = "\nexport async function {{{functionName:string}}}({{{args}}}) : Promise<{{{returnType}}}> {\n    const __messages: Message[] = [];\n    {{{functionBody}}}\n}";
+export declare const template = "\nexport async function {{{functionName:string}}}(args, __metadata={}) : Promise<{{{returnType}}}> {\n    const __messages: Message[] = [];\n    const __stack = __stateStack.getNewState();\n    const __step = __stack.step; // > 0 ? __stack.step + 1 : 0;\n    const __self: Record<string, any> = __stack.locals;\n\n    const __params = [{{{argsStr}}}];\n      (args).forEach((item, index) => {\n        __stack.args[__params[index]] = item;\n      });\n\n\n    {{{functionBody}}}\n}";
 export type TemplateType = {
     functionName: string;
-    args: string | boolean | number;
     returnType: string | boolean | number;
+    argsStr: string | boolean | number;
     functionBody: string | boolean | number;
 };
 declare const render: (args: TemplateType) => string;

package/dist/lib/templates/backends/typescriptGenerator/functionDefinition.js

@@ -3,8 +3,18 @@
 // Any manual changes will be lost.
 import { apply } from "typestache";
 export const template = `
-export async function {{{functionName:string}}}({{{args}}}) : Promise<{{{returnType}}}> {
+export async function {{{functionName:string}}}(args, __metadata={}) : Promise<{{{returnType}}}> {
     const __messages: Message[] = [];
+    const __stack = __stateStack.getNewState();
+    const __step = __stack.step; // > 0 ? __stack.step + 1 : 0;
+    const __self: Record<string, any> = __stack.locals;
+
+    const __params = [{{{argsStr}}}];
+      (args).forEach((item, index) => {
+        __stack.args[__params[index]] = item;
+      });
+
+
     {{{functionBody}}}
 }`;
 const render = (args) => {

package/dist/lib/templates/backends/typescriptGenerator/promptFunction.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {\n  const __prompt = {{{promptCode:string}}};\n  const startTime = performance.now();\n  __messages.push(userMessage(__prompt));\n  const __tools = {{{tools}}};\n\n  {{#hasResponseFormat}}\n  // Need to make sure this is always an object\n  const __responseFormat = z.object({\n     response: {{{zodSchema:string}}}\n  });\n  {{/hasResponseFormat}}\n  {{^hasResponseFormat}}\n  const __responseFormat = undefined;\n  {{/hasResponseFormat}}\n\n  const __client = getClientWithConfig({{{clientConfig:string}}});\n\n  let __completion = await __client.text({\n    messages: __messages,\n    tools: __tools,\n    responseFormat: __responseFormat,\n  });\n\n  const endTime = performance.now();\n  await statelogClient.promptCompletion({\n    messages: __messages,\n    completion: __completion,\n    model: __client.getModel(),\n    timeTaken: endTime - startTime,\n  });\n\n  if (!__completion.success) {\n    throw new Error(\n      `Error getting response from ${__model}: ${__completion.error}`\n    );\n  }\n\n  let responseMessage = __completion.value;\n\n  // Handle function calls\n  while (responseMessage.toolCalls.length > 0) {\n    // Add assistant's response with tool calls to message history\n    __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));\n    let toolCallStartTime, toolCallEndTime;\n    let haltExecution = false;\n\n    // Process each tool call\n    for (const toolCall of responseMessage.toolCalls) {\n      {{{functionCalls:string}}}\n    }\n\n    if (haltExecution) {\n      await statelogClient.debug(`Tool call interrupted execution.`, {\n        messages: __messages,\n        model: __client.getModel(),\n      });\n      try {\n        const obj = JSON.parse(__messages.at(-1).content);\n        obj.__messages = __messages;\n        obj.__nodesTraversed = __graph.getNodesTraversed();\n        return obj;\n      } catch (e) {\n        return __messages.at(-1).content;\n      }\n      //return __messages;\n    }\n  \n    const nextStartTime = performance.now();\n    let __completion = await __client.text({\n      messages: __messages,\n      tools: __tools,\n      responseFormat: __responseFormat,\n    });\n\n    const nextEndTime = performance.now();\n\n    await statelogClient.promptCompletion({\n      messages: __messages,\n      completion: __completion,\n      model: __client.getModel(),\n      timeTaken: nextEndTime - nextStartTime,\n    });\n\n    if (!__completion.success) {\n      throw new Error(\n        `Error getting response from ${__model}: ${__completion.error}`\n      );\n    }\n    responseMessage = __completion.value;\n  }\n\n  // Add final assistant response to history\n  // not passing tool calls back this time\n  __messages.push(assistantMessage(responseMessage.output));\n  {{#hasResponseFormat}}\n  try {\n  const result = JSON.parse(responseMessage.output || \"\");\n  return result.response;\n  } catch (e) {\n    return responseMessage.output;\n    // console.error(\"Error parsing response for variable '{{{variableName:string}}}':\", e);\n    // console.error(\"Full completion response:\", JSON.stringify(__completion, null, 2));\n    // throw e;\n  }\n  {{/hasResponseFormat}}\n\n  {{^hasResponseFormat}}\n  return responseMessage.output;\n  {{/hasResponseFormat}}\n}\n";
+export declare const template = "\nasync function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {\n  const __prompt = {{{promptCode:string}}};\n  const startTime = performance.now();\n  const __messages: Message[] = __metadata?.messages || [];\n  let __toolCalls = __metadata?.toolCall ? [__metadata.toolCall] : [];\n  const __interruptResponse:InterruptResponseType|undefined = __metadata?.interruptResponse;\n  const __tools = {{{tools}}};\n\n  {{#hasResponseFormat}}\n  // Need to make sure this is always an object\n  const __responseFormat = z.object({\n     response: {{{zodSchema:string}}}\n  });\n  {{/hasResponseFormat}}\n  {{^hasResponseFormat}}\n  const __responseFormat = undefined;\n  {{/hasResponseFormat}}\n  \n  const __client = getClientWithConfig({{{clientConfig:string}}});\n  let responseMessage:any;\n\n  if (__toolCalls.length === 0) {\n    __messages.push(userMessage(__prompt));\n  \n  \n    let __completion = await __client.text({\n      messages: __messages,\n      tools: __tools,\n      responseFormat: __responseFormat,\n    });\n  \n    const endTime = performance.now();\n    await statelogClient.promptCompletion({\n      messages: __messages,\n      completion: __completion,\n      model: __client.getModel(),\n      timeTaken: endTime - startTime,\n    });\n  \n    if (!__completion.success) {\n      throw new Error(\n        `Error getting response from ${__model}: ${__completion.error}`\n      );\n    }\n  \n    responseMessage = __completion.value;\n    __toolCalls = responseMessage.toolCalls || [];\n\n    if (__toolCalls.length > 0) {\n      // Add assistant's response with tool calls to message history\n      __messages.push(assistantMessage(responseMessage.output, { toolCalls: __toolCalls }));\n    }\n  }\n\n  // Handle function calls\n  if (__toolCalls.length > 0) {\n    let toolCallStartTime, toolCallEndTime;\n    let haltExecution = false;\n    let haltToolCall = {}\n    let haltInterrupt:any = null;\n\n    // Process each tool call\n    for (const toolCall of __toolCalls) {\n      {{{functionCalls:string}}}\n    }\n\n    if (haltExecution) {\n      await statelogClient.debug(`Tool call interrupted execution.`, {\n        messages: __messages,\n        model: __client.getModel(),\n      });\n\n      __stateStack.other = {\n        messages: __messages.map((msg) => msg.toJSON()),\n        nodesTraversed: __graph.getNodesTraversed(),\n        toolCall: haltToolCall,\n      };\n      haltInterrupt.__state = __stateStack.toJSON();\n      return haltInterrupt;\n    }\n  \n    const nextStartTime = performance.now();\n    let __completion = await __client.text({\n      messages: __messages,\n      tools: __tools,\n      responseFormat: __responseFormat,\n    });\n\n    const nextEndTime = performance.now();\n\n    await statelogClient.promptCompletion({\n      messages: __messages,\n      completion: __completion,\n      model: __client.getModel(),\n      timeTaken: nextEndTime - nextStartTime,\n    });\n\n    if (!__completion.success) {\n      throw new Error(\n        `Error getting response from ${__model}: ${__completion.error}`\n      );\n    }\n    responseMessage = __completion.value;\n  }\n\n  // Add final assistant response to history\n  // not passing tool calls back this time\n  __messages.push(assistantMessage(responseMessage.output));\n  {{#hasResponseFormat}}\n  try {\n  const result = JSON.parse(responseMessage.output || \"\");\n  return result.response;\n  } catch (e) {\n    return responseMessage.output;\n    // console.error(\"Error parsing response for variable '{{{variableName:string}}}':\", e);\n    // console.error(\"Full completion response:\", JSON.stringify(__completion, null, 2));\n    // throw e;\n  }\n  {{/hasResponseFormat}}\n\n  {{^hasResponseFormat}}\n  return responseMessage.output;\n  {{/hasResponseFormat}}\n}\n\n__self.{{{variableName:string}}} = await _{{{variableName:string}}}({{{funcCallParams:string}}});\n\nif (isInterrupt(__self.{{{variableName:string}}})) {\n  return { ...state, data: __self.{{{variableName:string}}} };\n}";
 export type TemplateType = {
     variableName: string;
     argsStr: string;
@@ -9,6 +9,7 @@ export type TemplateType = {
     zodSchema: string;
     clientConfig: string;
     functionCalls: string;
+    funcCallParams: string;
 };
 declare const render: (args: TemplateType) => string;
 export default render;

package/dist/lib/templates/backends/typescriptGenerator/promptFunction.js

@@ -6,7 +6,9 @@ export const template = `
 async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{typeString:string}}}> {
   const __prompt = {{{promptCode:string}}};
   const startTime = performance.now();
-  __messages.push(userMessage(__prompt));
+  const __messages: Message[] = __metadata?.messages || [];
+  let __toolCalls = __metadata?.toolCall ? [__metadata.toolCall] : [];
+  const __interruptResponse:InterruptResponseType|undefined = __metadata?.interruptResponse;
   const __tools = {{{tools}}};
 
   {{#hasResponseFormat}}
@@ -18,40 +20,52 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
   {{^hasResponseFormat}}
   const __responseFormat = undefined;
   {{/hasResponseFormat}}
-
+  
   const __client = getClientWithConfig({{{clientConfig:string}}});
+  let responseMessage:any;
 
-  let __completion = await __client.text({
-    messages: __messages,
-    tools: __tools,
-    responseFormat: __responseFormat,
-  });
-
-  const endTime = performance.now();
-  await statelogClient.promptCompletion({
-    messages: __messages,
-    completion: __completion,
-    model: __client.getModel(),
-    timeTaken: endTime - startTime,
-  });
+  if (__toolCalls.length === 0) {
+    __messages.push(userMessage(__prompt));
+  
+  
+    let __completion = await __client.text({
+      messages: __messages,
+      tools: __tools,
+      responseFormat: __responseFormat,
+    });
+  
+    const endTime = performance.now();
+    await statelogClient.promptCompletion({
+      messages: __messages,
+      completion: __completion,
+      model: __client.getModel(),
+      timeTaken: endTime - startTime,
+    });
+  
+    if (!__completion.success) {
+      throw new Error(
+        \`Error getting response from $\{__model\}: $\{__completion.error\}\`
+      );
+    }
+  
+    responseMessage = __completion.value;
+    __toolCalls = responseMessage.toolCalls || [];
 
-  if (!__completion.success) {
-    throw new Error(
-      \`Error getting response from $\{__model\}: $\{__completion.error\}\`
-    );
+    if (__toolCalls.length > 0) {
+      // Add assistant's response with tool calls to message history
+      __messages.push(assistantMessage(responseMessage.output, { toolCalls: __toolCalls }));
+    }
   }
 
-  let responseMessage = __completion.value;
-
   // Handle function calls
-  while (responseMessage.toolCalls.length > 0) {
-    // Add assistant's response with tool calls to message history
-    __messages.push(assistantMessage(responseMessage.output, { toolCalls: responseMessage.toolCalls }));
+  if (__toolCalls.length > 0) {
     let toolCallStartTime, toolCallEndTime;
     let haltExecution = false;
+    let haltToolCall = {}
+    let haltInterrupt:any = null;
 
     // Process each tool call
-    for (const toolCall of responseMessage.toolCalls) {
+    for (const toolCall of __toolCalls) {
       {{{functionCalls:string}}}
     }
 
@@ -60,15 +74,14 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
         messages: __messages,
         model: __client.getModel(),
       });
-      try {
-        const obj = JSON.parse(__messages.at(-1).content);
-        obj.__messages = __messages;
-        obj.__nodesTraversed = __graph.getNodesTraversed();
-        return obj;
-      } catch (e) {
-        return __messages.at(-1).content;
-      }
-      //return __messages;
+
+      __stateStack.other = {
+        messages: __messages.map((msg) => msg.toJSON()),
+        nodesTraversed: __graph.getNodesTraversed(),
+        toolCall: haltToolCall,
+      };
+      haltInterrupt.__state = __stateStack.toJSON();
+      return haltInterrupt;
     }
   
     const nextStartTime = performance.now();
@@ -114,7 +127,12 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
   return responseMessage.output;
   {{/hasResponseFormat}}
 }
-`;
+
+__self.{{{variableName:string}}} = await _{{{variableName:string}}}({{{funcCallParams:string}}});
+
+if (isInterrupt(__self.{{{variableName:string}}})) {
+  return { ...state, data: __self.{{{variableName:string}}} };
+}`;
 const render = (args) => {
     return apply(template, args);
 };

package/dist/lib/templates/backends/typescriptGenerator/toolCall.d.ts

@@ -1,6 +1,7 @@
-export declare const template = "if (\n  toolCall.name === \"{{{name:string}}}\"\n) {\n  const args = toolCall.arguments;\n\n  toolCallStartTime = performance.now();\n  const result = await {{{name}}}(args);\n  toolCallEndTime = performance.now();\n\n  // console.log(\"Tool '{{{name:string}}}' called with arguments:\", args);\n  // console.log(\"Tool '{{{name:string}}}' returned result:\", result);\n\nawait statelogClient.toolCall({\n    toolName: \"{{{name:string}}}\",\n    args,\n    output: result,\n    model: __client.getModel(),\n    timeTaken: toolCallEndTime - toolCallStartTime,\n  });\n\n  // Add function result to messages\n  __messages.push(toolMessage(result, {\n            tool_call_id: toolCall.id,\n            name: toolCall.name,\n      }));\n\n  if (isInterrupt(result)) {\n    haltExecution = true;\n    break;\n  }\n}";
+export declare const template = "if (\n  toolCall.name === \"{{{name:string}}}\"\n) {\n  const args = toolCall.arguments;\n\n  const params = [ {{{paramsStr:string}}} ];\n\n  toolCallStartTime = performance.now();\n  \n  let result: any;\n  if (__interruptResponse && __interruptResponse.type === \"reject\") {\n        __messages.push(toolMessage(\"tool call rejected\", {\n        tool_call_id: toolCall.id,\n        name: toolCall.name,\n     }));\n  } else {\n    result = await {{{name}}}(params);\n  }\n  toolCallEndTime = performance.now();\n\nawait statelogClient.toolCall({\n    toolName: \"{{{name:string}}}\",\n    params,\n    output: result,\n    model: __client.getModel(),\n    timeTaken: toolCallEndTime - toolCallStartTime,\n  });\n\n  if (isInterrupt(result)) {\n    haltInterrupt = result;\n    haltToolCall = {\n      id: toolCall.id,\n      name: toolCall.name,\n      arguments: toolCall.arguments,\n    }\n    haltExecution = true;\n    break;\n  }\n\n    // Add function result to messages\n  __messages.push(toolMessage(result, {\n        tool_call_id: toolCall.id,\n        name: toolCall.name,\n  }));\n}";
 export type TemplateType = {
     name: string;
+    paramsStr: string;
 };
 declare const render: (args: TemplateType) => string;
 export default render;

package/dist/lib/templates/backends/typescriptGenerator/toolCall.js

@@ -7,31 +7,45 @@ export const template = `if (
 ) {
   const args = toolCall.arguments;
 
+  const params = [ {{{paramsStr:string}}} ];
+
   toolCallStartTime = performance.now();
-  const result = await {{{name}}}(args);
+  
+  let result: any;
+  if (__interruptResponse && __interruptResponse.type === "reject") {
+        __messages.push(toolMessage("tool call rejected", {
+        tool_call_id: toolCall.id,
+        name: toolCall.name,
+     }));
+  } else {
+    result = await {{{name}}}(params);
+  }
   toolCallEndTime = performance.now();
 
-  // console.log("Tool '{{{name:string}}}' called with arguments:", args);
-  // console.log("Tool '{{{name:string}}}' returned result:", result);
-
 await statelogClient.toolCall({
     toolName: "{{{name:string}}}",
-    args,
+    params,
     output: result,
     model: __client.getModel(),
     timeTaken: toolCallEndTime - toolCallStartTime,
   });
 
-  // Add function result to messages
-  __messages.push(toolMessage(result, {
-            tool_call_id: toolCall.id,
-            name: toolCall.name,
-      }));
-
   if (isInterrupt(result)) {
+    haltInterrupt = result;
+    haltToolCall = {
+      id: toolCall.id,
+      name: toolCall.name,
+      arguments: toolCall.arguments,
+    }
     haltExecution = true;
     break;
   }
+
+    // Add function result to messages
+  __messages.push(toolMessage(result, {
+        tool_call_id: toolCall.id,
+        name: toolCall.name,
+  }));
 }`;
 const render = (args) => {
     return apply(template, args);

package/dist/lib/utils.js

@@ -19,3 +19,32 @@ export function zip(arr1, arr2) {
 export function uniq(arr) {
     return Array.from(new Set(arr));
 }
+class PackagedState {
+    messages;
+    nodesTraversed;
+    toolCall;
+    step;
+    selfState;
+    globalState;
+    args;
+    constructor(state, args) {
+        this.messages = state.messages;
+        this.nodesTraversed = state.graph?.getNodesTraversed();
+        this.toolCall = state.toolCall;
+        this.step = state.part;
+        this.selfState = JSON.parse(JSON.stringify(state.self));
+        this.globalState = JSON.parse(JSON.stringify(state.global));
+        this.args = args;
+    }
+    toJSON() {
+        return {
+            messages: this.messages,
+            nodesTraversed: this.nodesTraversed,
+            toolCall: this.toolCall,
+            step: this.step,
+            selfState: this.selfState,
+            globalState: this.globalState,
+            args: this.args,
+        };
+    }
+}

package/dist/scripts/agency.js

@@ -77,10 +77,11 @@ function getImports(program) {
         .filter((node) => node.type === "importNodeStatement" ||
         node.type === "importToolStatement")
         .map((node) => node.agencyFile.trim());
-    const importStatements = program.nodes
-        .filter((node) => node.type === "importStatement")
-        .map((node) => node.modulePath.trim());
-    return [...toolAndNodeImports, ...importStatements];
+    /* const importStatements = program.nodes
+      .filter((node) => node.type === "importStatement")
+      .map((node) => (node as ImportStatement).modulePath.trim());
+   */
+    return [...toolAndNodeImports]; //, ...importStatements];
 }
 const compiledFiles = new Set();
 const dirSearched = new Set();
@@ -119,6 +120,7 @@ function compile(inputFile, _outputFile, verbose = false) {
     }
     compiledFiles.add(absoluteInputFile);
     const contents = readFile(inputFile);
+    console.log(`Compiling ${inputFile}...`);
     const parsedProgram = parse(contents, verbose);
     const imports = getImports(parsedProgram);
     const inputDir = path.dirname(absoluteInputFile);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -42,7 +42,7 @@
   "dependencies": {
     "egonlog": "^0.0.2",
     "piemachine": "^0.0.6",
-    "smoltalk": "^0.0.12",
+    "smoltalk": "^0.0.15",
     "statelog-client": "^0.0.34",
     "tarsec": "^0.1.1",
     "typestache": "^0.4.4",
@@ -56,4 +56,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   }
-}
+}