agency-lang 0.0.46 → 0.0.48

package/dist/lib/backends/typescriptGenerator.js

@@ -3,6 +3,8 @@ import * as renderSpecialVar from "../templates/backends/graphGenerator/specialV
 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 renderInternalFunctionCall from "../templates/backends/typescriptGenerator/internalFunctionCall.js";
+import * as renderFunctionCallAssignment from "../templates/backends/typescriptGenerator/functionCallAssignment.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";
@@ -167,8 +169,12 @@ export class TypeScriptGenerator extends BaseGenerator {
             }
             // Direct assignment for other literal types
             const code = this.processNode(value);
-            return (`${this.getScopeVar()}.${variableName}${typeAnnotation} = await ${code.trim()};` +
-                "\n");
+            return renderFunctionCallAssignment.default({
+                variableName: `${this.getScopeVar()}.${variableName}`,
+                typeAnnotation,
+                functionCode: code.trim(),
+                nodeContext: this.getCurrentScope() === "node",
+            });
         }
         else if (value.type === "timeBlock") {
             const timingVarName = variableName;
@@ -314,7 +320,16 @@ export class TypeScriptGenerator extends BaseGenerator {
         let argsString = "";
         if (this.isInternalFunction(node.functionName)) {
             argsString = parts.join(", ");
-            return `${functionName}([${argsString}])`;
+            const metadata = `{
+        statelogClient,
+        graph: __graph,
+        messages: __messages,
+      }`;
+            return renderInternalFunctionCall.default({
+                functionName,
+                argsString,
+                metadata,
+            });
         }
         else {
             // must be a builtin function or imported function
@@ -424,8 +439,6 @@ export class TypeScriptGenerator extends BaseGenerator {
         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));
@@ -440,6 +453,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             tools,
             functionCalls,
             clientConfig,
+            nodeContext: this.getCurrentScope() === "node",
         });
     }
     processImportStatement(node) {

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    \n    // if `state.__metadata?.__stateStack` is set, that means we are resuming execution\n    // at this node after an interrupt. In that case, this is the line that restores the state.\n    if (state.__metadata?.__stateStack) {\n      __stateStack = structuredClone(state.__metadata.__stateStack);\n      \n      // clear the state stack from metadata so it doesn't propagate to other nodes.\n      state.__metadata.__stateStack = undefined;\n    }\n\n    // either creates a new stack for this node,\n    // or restores the stack if we're resuming after an interrupt,\n    // depending on the mode of the state stack (serialize or deserialize).\n    const __stack = __stateStack.getNewState();\n    \n    // We're going to modify __stack.step to keep track of what line we're on,\n    // but first we save this value. This will help us figure out if we should execute\n    // from the start of this node or from a specific line.\n    const __step = __stack.step;\n\n    const __self: Record<string, any> = __stack.locals;\n\n    // If we're resuming after an interrupt, these will be set.\n    // There should be a cleaner way to handle this,\n    // instead of littering this scope with these variables\n    const __interruptResponse: InterruptResponseType | undefined = state.__metadata?.interruptResponse;\n    const __toolCall: Record<string, any>|undefined = __stateStack.other?.toolCall;\n\n    // TODO pretty sure this isn't needed, check and remove\n    if (state.__metadata?.state?.global) {\n      __global = state.__metadata.state.global;\n    }\n\n    {{#hasParam}}\n    \n    const __params = {{{paramNames}}};\n    \n    // Any arguments that were passed into this node,\n    // save them onto the stack, unless we are restoring the stack after an interrupt,\n    // in which case leave as is\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 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    \n    // if `state.__metadata?.__stateStack` is set, that means we are resuming execution\n    // at this node after an interrupt. In that case, this is the line that restores the state.\n    if (state.__metadata?.__stateStack) {\n      __stateStack = state.__metadata.__stateStack;\n      \n      // restore global state\n      if (state.__metadata?.__stateStack?.global) {\n        __global = state.__metadata.__stateStack.global;\n      }\n\n      // clear the state stack from metadata so it doesn't propagate to other nodes.\n      state.__metadata.__stateStack = undefined;\n    }\n\n    // either creates a new stack for this node,\n    // or restores the stack if we're resuming after an interrupt,\n    // depending on the mode of the state stack (serialize or deserialize).\n    const __stack = __stateStack.getNewState();\n    \n    // We're going to modify __stack.step to keep track of what line we're on,\n    // but first we save this value. This will help us figure out if we should execute\n    // from the start of this node or from a specific line.\n    const __step = __stack.step;\n\n    const __self: Record<string, any> = __stack.locals;\n\n    {{#hasParam}}\n    \n    const __params = {{{paramNames}}};\n    \n    // Any arguments that were passed into this node,\n    // save them onto the stack, unless we are restoring the stack after an interrupt,\n    // in which case leave as is\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

@@ -11,8 +11,13 @@ graph.node("{{{name}}}", async (state): Promise<any> => {
     // if \`state.__metadata?.__stateStack\` is set, that means we are resuming execution
     // at this node after an interrupt. In that case, this is the line that restores the state.
     if (state.__metadata?.__stateStack) {
-      __stateStack = structuredClone(state.__metadata.__stateStack);
+      __stateStack = state.__metadata.__stateStack;
       
+      // restore global state
+      if (state.__metadata?.__stateStack?.global) {
+        __global = state.__metadata.__stateStack.global;
+      }
+
       // clear the state stack from metadata so it doesn't propagate to other nodes.
       state.__metadata.__stateStack = undefined;
     }
@@ -29,17 +34,6 @@ graph.node("{{{name}}}", async (state): Promise<any> => {
 
     const __self: Record<string, any> = __stack.locals;
 
-    // If we're resuming after an interrupt, these will be set.
-    // There should be a cleaner way to handle this,
-    // instead of littering this scope with these variables
-    const __interruptResponse: InterruptResponseType | undefined = state.__metadata?.interruptResponse;
-    const __toolCall: Record<string, any>|undefined = __stateStack.other?.toolCall;
-
-    // TODO pretty sure this isn't needed, check and remove
-    if (state.__metadata?.state?.global) {
-      __global = state.__metadata.state.global;
-    }
-
     {{#hasParam}}
     
     const __params = {{{paramNames}}};

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, 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\n  // JSONified StateStack, i.e. serialized execution state\n  __state?: Record<string, any>;\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\n  __stateStack = StateStack.fromJSON(interrupt.__state || {});\n  __stateStack.deserializeMode();\n  \n  const messages = (__stateStack.other.messages || []).map((json: any) => {\n    // create message objects from JSON\n    return messageFromJSON(json);\n  });\n\n  // start at the last node we visited\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\n    // restore args from the state stack\n    data: \"<from-stack>\"\n  });\n  return result.data;\n}\n\nexport async function approveInterrupt(interrupt: Interrupt) {\n  return await respondToInterrupt(interrupt, { type: \"approve\" });\n}\n\nexport async function rejectInterrupt(interrupt: Interrupt) {\n  return await respondToInterrupt(interrupt, { type: \"reject\" });\n}\n\ntype StackFrame = {\n  args: Record<string, any>;\n  locals: Record<string, any>;\n  step: number;\n};\n\n// See docs for notes on how this works.\nclass StateStack {\n  public stack: StackFrame[] = [];\n  private mode: \"serialize\" | \"deserialize\" = \"serialize\";\n  public globals: Record<string, any> = {};\n  public other: Record<string, any> = {};\n\n  private deserializeStackLength = 0;\n\n  constructor(stack: StackFrame[] = [], mode: \"serialize\" | \"deserialize\" = \"serialize\") {\n    this.stack = stack;\n    this.mode = mode;\n  }\n\n  getNewState(): StackFrame | null {\n    if (this.mode === \"deserialize\" && this.deserializeStackLength <= 0) {\n      console.log(\"Forcing mode to serialize, nothing left to deserialize\");\n      this.mode = \"serialize\";\n    }\n    if (this.mode === \"serialize\") {\n      const newState: StackFrame = {\n        args: {},\n        locals: {},\n        step: 0,\n      };\n      this.stack.push(newState);\n      return newState;\n    } else if (this.mode === \"deserialize\") {\n      this.deserializeStackLength -= 1;\n      const item = this.stack.shift();\n      this.stack.push(item);\n      return item;\n    }\n    return null;\n  }\n\n  deserializeMode() {\n    this.mode = \"deserialize\";\n    this.deserializeStackLength = this.stack.length;\n  }\n\n  pop(): StackFrame | 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      deserializeStackLength: this.deserializeStackLength,\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    stateStack.deserializeStackLength = json.deserializeStackLength || 0;\n    return stateStack;\n  }\n}\n\nlet __stateStack = new StateStack();";
+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\n  // JSONified StateStack, i.e. serialized execution state\n  __state?: Record<string, any>;\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;\n\nexport type InterruptResponseApprove = {\n  type: \"approve\";\n  newArguments?: Record<string, any>;\n};\nexport type InterruptResponseReject = {\n  type: \"reject\";\n};\n\nexport async function respondToInterrupt(_interrupt: Interrupt, _interruptResponse: InterruptResponseType) {\n  const interrupt = structuredClone(_interrupt);\n  const interruptResponse = structuredClone(_interruptResponse);\n\n  __stateStack = StateStack.fromJSON(interrupt.__state || {});\n  __stateStack.deserializeMode();\n  \n  const messages = (__stateStack.interruptData.messages || []).map((json: any) => {\n    // create message objects from JSON\n    return messageFromJSON(json);\n  });\n  __stateStack.interruptData.messages = messages;\n  __stateStack.interruptData.interruptResponse = interruptResponse;\n\n  if (interruptResponse.type === \"approve\" && interruptResponse.newArguments) {\n    __stateStack.interruptData.toolCall = {\n      ...__stateStack.interruptData.toolCall,\n      arguments: { ...__stateStack.interruptData.toolCall.arguments, ...interruptResponse.newArguments },\n    };\n    // Error:\n    // TypeError: Cannot set property arguments of #<ToolCall> which has only a getter\n    //         toolCall.arguments = { ...toolCall.arguments, ...interruptResponse.newArguments };\n    //\n    // const lastMessage = __stateStack.interruptData.messages[__stateStack.interruptData.messages.length - 1];\n    // if (lastMessage && lastMessage.role === \"assistant\") {\n    //   const toolCall = lastMessage.toolCalls?.[lastMessage.toolCalls.length - 1];\n    //   if (toolCall) {\n    //     toolCall.arguments = { ...toolCall.arguments, ...interruptResponse.newArguments };\n    //   }\n    // }\n  }\n\n\n  // start at the last node we visited\n  const nodesTraversed = __stateStack.interruptData.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      __stateStack: __stateStack,\n    },\n\n    // restore args from the state stack\n    data: \"<from-stack>\"\n  });\n  return result.data;\n}\n\nexport async function approveInterrupt(interrupt: Interrupt, newArguments?: Record<string, any>) {\n  return await respondToInterrupt(interrupt, { type: \"approve\", newArguments });\n}\n\nexport async function rejectInterrupt(interrupt: Interrupt) {\n  return await respondToInterrupt(interrupt, { type: \"reject\" });\n}\n\ntype StackFrame = {\n  args: Record<string, any>;\n  locals: Record<string, any>;\n  step: number;\n};\n\n// See docs for notes on how this works.\nclass StateStack {\n  public stack: StackFrame[] = [];\n  private mode: \"serialize\" | \"deserialize\" = \"serialize\";\n  public globals: Record<string, any> = {};\n  public other: Record<string, any> = {};\n  public interruptData: Record<string, any> = {};\n\n  private deserializeStackLength = 0;\n\n  constructor(stack: StackFrame[] = [], mode: \"serialize\" | \"deserialize\" = \"serialize\") {\n    this.stack = stack;\n    this.mode = mode;\n  }\n\n  getNewState(): StackFrame | null {\n    if (this.mode === \"deserialize\" && this.deserializeStackLength <= 0) {\n      console.log(\"Forcing mode to serialize, nothing left to deserialize\");\n      this.mode = \"serialize\";\n    }\n    if (this.mode === \"serialize\") {\n      const newState: StackFrame = {\n        args: {},\n        locals: {},\n        step: 0,\n      };\n      this.stack.push(newState);\n      return newState;\n    } else if (this.mode === \"deserialize\") {\n      this.deserializeStackLength -= 1;\n      const item = this.stack.shift();\n      this.stack.push(item);\n      return item;\n    }\n    return null;\n  }\n\n  deserializeMode() {\n    this.mode = \"deserialize\";\n    this.deserializeStackLength = this.stack.length;\n  }\n\n  pop(): StackFrame | 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      interruptData: this.interruptData,\n      mode: this.mode,\n      deserializeStackLength: this.deserializeStackLength,\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.interruptData = json.interruptData || {};\n    stateStack.mode = json.mode || \"serialize\";\n    stateStack.deserializeStackLength = json.deserializeStackLength || 0;\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

@@ -92,18 +92,15 @@ function printJSON(obj: any) {
   console.log(JSON.stringify(obj, null, 2));
 }
 
-export type InterruptResponseType = InterruptResponseApprove | InterruptResponseReject | InterruptResponseModify;
+export type InterruptResponseType = InterruptResponseApprove | InterruptResponseReject;
+
 export type InterruptResponseApprove = {
   type: "approve";
+  newArguments?: Record<string, any>;
 };
 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);
@@ -112,21 +109,40 @@ export async function respondToInterrupt(_interrupt: Interrupt, _interruptRespon
   __stateStack = StateStack.fromJSON(interrupt.__state || {});
   __stateStack.deserializeMode();
   
-  const messages = (__stateStack.other.messages || []).map((json: any) => {
+  const messages = (__stateStack.interruptData.messages || []).map((json: any) => {
     // create message objects from JSON
     return messageFromJSON(json);
   });
+  __stateStack.interruptData.messages = messages;
+  __stateStack.interruptData.interruptResponse = interruptResponse;
+
+  if (interruptResponse.type === "approve" && interruptResponse.newArguments) {
+    __stateStack.interruptData.toolCall = {
+      ...__stateStack.interruptData.toolCall,
+      arguments: { ...__stateStack.interruptData.toolCall.arguments, ...interruptResponse.newArguments },
+    };
+    // Error:
+    // TypeError: Cannot set property arguments of #<ToolCall> which has only a getter
+    //         toolCall.arguments = { ...toolCall.arguments, ...interruptResponse.newArguments };
+    //
+    // const lastMessage = __stateStack.interruptData.messages[__stateStack.interruptData.messages.length - 1];
+    // if (lastMessage && lastMessage.role === "assistant") {
+    //   const toolCall = lastMessage.toolCalls?.[lastMessage.toolCalls.length - 1];
+    //   if (toolCall) {
+    //     toolCall.arguments = { ...toolCall.arguments, ...interruptResponse.newArguments };
+    //   }
+    // }
+  }
+
 
   // start at the last node we visited
-  const nodesTraversed = __stateStack.other.nodesTraversed || [];
+  const nodesTraversed = __stateStack.interruptData.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,
     },
 
@@ -136,8 +152,8 @@ export async function respondToInterrupt(_interrupt: Interrupt, _interruptRespon
   return result.data;
 }
 
-export async function approveInterrupt(interrupt: Interrupt) {
-  return await respondToInterrupt(interrupt, { type: "approve" });
+export async function approveInterrupt(interrupt: Interrupt, newArguments?: Record<string, any>) {
+  return await respondToInterrupt(interrupt, { type: "approve", newArguments });
 }
 
 export async function rejectInterrupt(interrupt: Interrupt) {
@@ -156,6 +172,7 @@ class StateStack {
   private mode: "serialize" | "deserialize" = "serialize";
   public globals: Record<string, any> = {};
   public other: Record<string, any> = {};
+  public interruptData: Record<string, any> = {};
 
   private deserializeStackLength = 0;
 
@@ -200,6 +217,7 @@ class StateStack {
       stack: this.stack,
       globals: this.globals,
       other: this.other,
+      interruptData: this.interruptData,
       mode: this.mode,
       deserializeStackLength: this.deserializeStackLength,
     });
@@ -210,6 +228,7 @@ class StateStack {
     stateStack.stack = json.stack || [];
     stateStack.globals = json.globals || {};
     stateStack.other = json.other || {};
+    stateStack.interruptData = json.interruptData || {};
     stateStack.mode = json.mode || "serialize";
     stateStack.deserializeStackLength = json.deserializeStackLength || 0;
     return stateStack;

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

@@ -0,0 +1,9 @@
+export declare const template = "{{{variableName:string}}}{{{typeAnnotation:string}}} = await {{{functionCode:string}}};\n\nif (isInterrupt({{{variableName:string}}})) {\n  {{#nodeContext}}\n  return { ...state, data: {{{variableName:string}}} };\n  {{/nodeContext}}\n   {{^nodeContext}}\n   return { data: {{{variableName:string}}} };\n   {{/nodeContext}}\n}";
+export type TemplateType = {
+    variableName: string;
+    typeAnnotation: string;
+    functionCode: string;
+    nodeContext: boolean;
+};
+declare const render: (args: TemplateType) => string;
+export default render;

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

@@ -0,0 +1,18 @@
+// THIS FILE WAS AUTO-GENERATED
+// Source: lib/templates/backends/typescriptGenerator/functionCallAssignment.mustache
+// Any manual changes will be lost.
+import { apply } from "typestache";
+export const template = `{{{variableName:string}}}{{{typeAnnotation:string}}} = await {{{functionCode:string}}};
+
+if (isInterrupt({{{variableName:string}}})) {
+  {{#nodeContext}}
+  return { ...state, data: {{{variableName:string}}} };
+  {{/nodeContext}}
+   {{^nodeContext}}
+   return { data: {{{variableName:string}}} };
+   {{/nodeContext}}
+}`;
+const render = (args) => {
+    return apply(template, args);
+};
+export default render;

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

@@ -1,4 +1,4 @@
-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;\n    const __self: Record<string, any> = __stack.locals;\n\n    // TODO: Note that we don't need to use the same kind of restoration\n    // from state for arguments as we do for nodes,\n    // because the args are serialized in the tool call.\n    // But what about situations where it was a function call, not a tool call?\n    // In that case, we would want to deserialize the argument.\n    const __params = [{{{argsStr}}}];\n    (args).forEach((item, index) => {\n      __stack.args[__params[index]] = item;\n    });\n\n\n    {{{functionBody}}}\n}";
+export declare const template = "\nexport async function {{{functionName:string}}}(args, __metadata={}) : Promise<{{{returnType}}}> {\n    const __messages: Message[] = __metadata?.messages || [];\n    const __stack = __stateStack.getNewState();\n    const __step = __stack.step;\n    const __self: Record<string, any> = __stack.locals;\n    const __graph = __metadata?.graph || graph;\n    const statelogClient = __metadata?.statelogClient || __statelogClient;\n\n    // args are always set whether we're restoring from state or not.\n    // If we're not restoring from state, args were obviously passed in through the code.\n    // If we are restoring from state, the node that called this function had to have passed \n    // these arguments into this function call.\n    // if we're restoring state, this will override __stack.args (which will be set),\n    // but with the same values, so it doesn't matter that those values are being overwritten.\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;
     returnType: string | boolean | number;

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

@@ -4,16 +4,19 @@
 import { apply } from "typestache";
 export const template = `
 export async function {{{functionName:string}}}(args, __metadata={}) : Promise<{{{returnType}}}> {
-    const __messages: Message[] = [];
+    const __messages: Message[] = __metadata?.messages || [];
     const __stack = __stateStack.getNewState();
     const __step = __stack.step;
     const __self: Record<string, any> = __stack.locals;
+    const __graph = __metadata?.graph || graph;
+    const statelogClient = __metadata?.statelogClient || __statelogClient;
 
-    // TODO: Note that we don't need to use the same kind of restoration
-    // from state for arguments as we do for nodes,
-    // because the args are serialized in the tool call.
-    // But what about situations where it was a function call, not a tool call?
-    // In that case, we would want to deserialize the argument.
+    // args are always set whether we're restoring from state or not.
+    // If we're not restoring from state, args were obviously passed in through the code.
+    // If we are restoring from state, the node that called this function had to have passed 
+    // these arguments into this function call.
+    // if we're restoring state, this will override __stack.args (which will be set),
+    // but with the same values, so it doesn't matter that those values are being overwritten.
     const __params = [{{{argsStr}}}];
     (args).forEach((item, index) => {
       __stack.args[__params[index]] = item;

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

@@ -0,0 +1,8 @@
+export declare const template = "{{{functionName:string}}}([{{{argsString:string}}}], {{{metadata:string}}});";
+export type TemplateType = {
+    functionName: string;
+    argsString: string;
+    metadata: string;
+};
+declare const render: (args: TemplateType) => string;
+export default render;

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

@@ -0,0 +1,9 @@
+// THIS FILE WAS AUTO-GENERATED
+// Source: lib/templates/backends/typescriptGenerator/internalFunctionCall.mustache
+// Any manual changes will be lost.
+import { apply } from "typestache";
+export const template = `{{{functionName:string}}}([{{{argsString:string}}}], {{{metadata:string}}});`;
+const render = (args) => {
+    return apply(template, args);
+};
+export default render;

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  const __messages: Message[] = __metadata?.messages || [];\n\n  // These are to restore state after interrupt.\n  // TODO I think this could be implemented in a cleaner way.\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\n// return early from node if this is an interrupt\nif (isInterrupt(__self.{{{variableName:string}}})) {\n  return { ...state, data: __self.{{{variableName:string}}} };\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\n  // These are to restore state after interrupt.\n  // TODO I think this could be implemented in a cleaner way.\n  let __toolCalls = __stateStack.interruptData?.toolCall ? [__stateStack.interruptData.toolCall] : [];\n  const __interruptResponse:InterruptResponseType|null = __stateStack.interruptData?.interruptResponse || null;\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    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      statelogClient.debug(`Tool call interrupted execution.`, {\n        messages: __messages,\n        model: __client.getModel(),\n      });\n\n      __stateStack.interruptData = {\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    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\n// return early from node if this is an interrupt\nif (isInterrupt(__self.{{{variableName:string}}})) {\n  {{#nodeContext}}\n  return { ...state, data: __self.{{{variableName:string}}} };\n  {{/nodeContext}}\n   {{^nodeContext}}\n   return  __self.{{{variableName:string}}};\n   {{/nodeContext}}\n}";
 export type TemplateType = {
     variableName: string;
     argsStr: string;
@@ -10,6 +10,7 @@ export type TemplateType = {
     clientConfig: string;
     functionCalls: string;
     funcCallParams: string;
+    nodeContext: boolean;
 };
 declare const render: (args: TemplateType) => string;
 export default render;

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

@@ -10,8 +10,8 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
 
   // These are to restore state after interrupt.
   // TODO I think this could be implemented in a cleaner way.
-  let __toolCalls = __metadata?.toolCall ? [__metadata.toolCall] : [];
-  const __interruptResponse:InterruptResponseType|undefined = __metadata?.interruptResponse;
+  let __toolCalls = __stateStack.interruptData?.toolCall ? [__stateStack.interruptData.toolCall] : [];
+  const __interruptResponse:InterruptResponseType|null = __stateStack.interruptData?.interruptResponse || null;
   const __tools = {{{tools}}};
 
   {{#hasResponseFormat}}
@@ -38,7 +38,7 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
     });
   
     const endTime = performance.now();
-    await statelogClient.promptCompletion({
+    statelogClient.promptCompletion({
       messages: __messages,
       completion: __completion,
       model: __client.getModel(),
@@ -73,12 +73,12 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
     }
 
     if (haltExecution) {
-      await statelogClient.debug(\`Tool call interrupted execution.\`, {
+      statelogClient.debug(\`Tool call interrupted execution.\`, {
         messages: __messages,
         model: __client.getModel(),
       });
 
-      __stateStack.other = {
+      __stateStack.interruptData = {
         messages: __messages.map((msg) => msg.toJSON()),
         nodesTraversed: __graph.getNodesTraversed(),
         toolCall: haltToolCall,
@@ -96,7 +96,7 @@ async function _{{{variableName:string}}}({{{argsStr:string}}}): Promise<{{{type
 
     const nextEndTime = performance.now();
 
-    await statelogClient.promptCompletion({
+    statelogClient.promptCompletion({
       messages: __messages,
       completion: __completion,
       model: __client.getModel(),
@@ -135,7 +135,12 @@ __self.{{{variableName:string}}} = await _{{{variableName:string}}}({{{funcCallP
 
 // return early from node if this is an interrupt
 if (isInterrupt(__self.{{{variableName:string}}})) {
+  {{#nodeContext}}
   return { ...state, data: __self.{{{variableName:string}}} };
+  {{/nodeContext}}
+   {{^nodeContext}}
+   return  __self.{{{variableName:string}}};
+   {{/nodeContext}}
 }`;
 const render = (args) => {
     return apply(template, args);

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

@@ -1,4 +1,4 @@
-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 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\n  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;

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

@@ -22,7 +22,7 @@ export const template = `if (
   }
   toolCallEndTime = performance.now();
 
-await statelogClient.toolCall({
+  statelogClient.toolCall({
     toolName: "{{{name:string}}}",
     params,
     output: result,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -41,9 +41,9 @@
   "homepage": "https://github.com/egonSchiele/agency-lang#readme",
   "dependencies": {
     "egonlog": "^0.0.2",
-    "piemachine": "^0.0.6",
+    "piemachine": "^0.0.7",
     "smoltalk": "^0.0.15",
-    "statelog-client": "^0.0.34",
+    "statelog-client": "^0.0.35",
     "tarsec": "^0.1.1",
     "typestache": "^0.4.4",
     "zod": "^4.3.5"
@@ -56,4 +56,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   }
-}
+}