agency-lang 0.0.83 → 0.0.84

package/dist/lib/agents/agency-agent/agent.js

@@ -0,0 +1,934 @@
+import { addTask, __addTaskTool, __addTaskToolParams, listTasks, __listTasksTool, __listTasksToolParams, markTaskDone, __markTaskDoneTool, __markTaskDoneToolParams } from "./subagents/task.js";
+import { newPlan, __newPlanTool, __newPlanToolParams, getCurrentPlan, __getCurrentPlanTool, __getCurrentPlanToolParams, listPlans, __listPlansTool, __listPlansToolParams, updateCurrentPlan, __updateCurrentPlanTool, __updateCurrentPlanToolParams, updateGoal, __updateGoalTool, __updateGoalToolParams, updateActions, __updateActionsTool, __updateActionsToolParams } from "./subagents/plan.js";
+import { writeCode, __writeCodeTool, __writeCodeToolParams, appendCode, __appendCodeTool, __appendCodeToolParams, readCode, __readCodeTool, __readCodeToolParams } from "./subagents/code.js";
+import { syntaxHighlight } from "../../utils/agentUtils.js";
+import { fileURLToPath } from "url";
+import process from "process";
+import { readFileSync, writeFileSync } from "fs";
+import { z } from "zod";
+import { goToNode, color, nanoid } from "agency-lang";
+import * as smoltalk from "agency-lang";
+import path from "path";
+import {
+  RuntimeContext, MessageThread, ThreadStore,
+  setupNode, setupFunction, runNode, runPrompt, callHook,
+  interrupt, isInterrupt,
+  respondToInterrupt as _respondToInterrupt,
+  approveInterrupt as _approveInterrupt,
+  rejectInterrupt as _rejectInterrupt,
+  resolveInterrupt as _resolveInterrupt,
+  modifyInterrupt as _modifyInterrupt,
+  resumeFromState as _resumeFromState,
+  deepClone as __deepClone,
+  not, eq, neq, lt, lte, gt, gte, and, or,
+  head, tail, empty,
+  builtinFetch as _builtinFetch,
+  builtinFetchJSON as _builtinFetchJSON,
+  builtinInput as _builtinInput,
+  builtinRead as _builtinReadRaw,
+  builtinWrite as _builtinWriteRaw,
+  builtinReadImage as _builtinReadImageRaw,
+  builtinSleep as _builtinSleep,
+  builtinRound as _builtinRound,
+  printJSON as _printJSON,
+  print as _print,
+  readSkill as _readSkillRaw,
+  readSkillTool as __readSkillTool,
+  readSkillToolParams as __readSkillToolParams,
+  printTool as __printTool,
+  printToolParams as __printToolParams,
+  printJSONTool as __printJSONTool,
+  printJSONToolParams as __printJSONToolParams,
+  inputTool as __inputTool,
+  inputToolParams as __inputToolParams,
+  readTool as __readTool,
+  readToolParams as __readToolParams,
+  readImageTool as __readImageTool,
+  readImageToolParams as __readImageToolParams,
+  writeTool as __writeTool,
+  writeToolParams as __writeToolParams,
+  fetchTool as __fetchTool,
+  fetchToolParams as __fetchToolParams,
+  fetchJSONTool as __fetchJSONTool,
+  fetchJSONToolParams as __fetchJSONToolParams,
+  fetchJsonTool as __fetchJsonTool,
+  fetchJsonToolParams as __fetchJsonToolParams,
+  sleepTool as __sleepTool,
+  sleepToolParams as __sleepToolParams,
+  roundTool as __roundTool,
+  roundToolParams as __roundToolParams,
+} from "agency-lang/runtime";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const __cwd = process.cwd();
+
+const __globalCtx = new RuntimeContext({
+  statelogConfig: {
+    host: "https://agency-lang.com",
+    
+    
+    apiKey: process.env.STATELOG_API_KEY || "",
+    
+    projectId: "agency-lang",
+    debugMode: false,
+  },
+  smoltalkDefaults: {
+    
+    
+    openAiApiKey: process.env.OPENAI_API_KEY || "",
+    
+    
+    
+    googleApiKey: process.env.GEMINI_API_KEY || "",
+    
+    model: "gpt-4o-mini",
+    logLevel: "warn",
+    statelog: { 
+      host: "https://agency-lang.com",
+      projectId: "smoltalk",
+      apiKey: process.env.STATELOG_SMOLTALK_API_KEY || "",
+      traceId: nanoid()
+    }
+  },
+  dirname: __dirname,
+});
+const graph = __globalCtx.graph;
+
+// Path-dependent builtin wrappers
+function _builtinRead(filename) {
+  return _builtinReadRaw({ filename, dirname: __dirname });
+}
+function _builtinWrite(filename, content) {
+  return _builtinWriteRaw({ filename, content, dirname: __dirname });
+}
+function _builtinReadImage(filename) {
+  return _builtinReadImageRaw({ filename, dirname: __dirname });
+}
+export function readSkill({filepath}) {
+  return _readSkillRaw({ filepath, dirname: __dirname });
+}
+
+// Interrupt re-exports bound to this module's context
+export { interrupt, isInterrupt };
+export const respondToInterrupt = (i, r, m) => _respondToInterrupt({ ctx: __globalCtx, interrupt: i, interruptResponse: r, metadata: m });
+export const approveInterrupt = (i, m) => _approveInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });
+export const rejectInterrupt = (i, m) => _rejectInterrupt({ ctx: __globalCtx, interrupt: i, metadata: m });
+export const modifyInterrupt = (i, a, m) => _modifyInterrupt({ ctx: __globalCtx, interrupt: i, newArguments: a, metadata: m });
+export const resolveInterrupt = (i, v, m) => _resolveInterrupt({ ctx: __globalCtx, interrupt: i, value: v, metadata: m });
+export const __printCodeTool = {
+  name: "printCode",
+  description: `Use this tool to print code to the terminal with syntax highlighting.
+Use this to print any generated code you want the user to look at.`,
+  schema: z.object({"code": z.string(), })
+};
+
+export const __printCodeToolParams = ["code"];
+export const __writeCodeWithConfirmTool = {
+  name: "writeCodeWithConfirm",
+  description: `Use this tool to write code to a file to the filesystem. The filename should include the path and extension (e.g., 'lib/agents/myAgent.agency').`,
+  schema: z.object({"filename": z.string(), "content": z.string(), })
+};
+
+export const __writeCodeWithConfirmToolParams = ["filename","content"];
+//  todo allow this
+//  import { Plan } from "./subagents/plan.agency"
+__globalCtx.stateStack.globals.strategy = {"type": `race`, "params": {"strategies": [{"type": `fallback`, "params": {"strategies": [`gemini-2.5-flash`, `gemini-2.5-pro`], "config": {"fallbackOn": [`error`]}}}, {"type": `fallback`, "params": {"strategies": [`gemini-2.5-flash-lite`, `gemini-2.5-pro`], "config": {"fallbackOn": [`error`]}}}]}};
+__globalCtx.stateStack.globals.config = {"strategy": __globalCtx.stateStack.globals.strategy, "responseFormatOptions": {"strict": true, "numRetries": 2, "allowExtraKeys": true}};
+
+export async function printCode(code, __state=undefined) {
+    const { stack: __stack, step: __step, self: __self, threads: __threads } =
+      setupFunction({ state: __state });
+
+    // __state will be undefined if this function is
+    // being called as a tool by an llm
+    const __ctx = __state?.ctx || __globalCtx;
+    const statelogClient = __ctx.statelogClient;
+    const __graph = __ctx.graph;
+    const __funcStartTime = performance.now();
+    await callHook({ callbacks: __ctx.callbacks, name: "onFunctionStart", data: { functionName: "printCode", args: { code }, isBuiltin: false } });
+
+    // put all args on the state stack
+    __stack.args["code"] = code;
+
+    
+      if (__step <= 0) {
+        
+        __stack.step++;
+      }
+      
+
+      if (__step <= 1) {
+        await _print(syntaxHighlight(__stack.args.code, `ts`));
+        __stack.step++;
+      }
+      
+
+      if (__step <= 2) {
+        __ctx.stateStack.pop();
+return `printed code successfully`
+        __stack.step++;
+      }
+      
+
+    await callHook({ callbacks: __ctx.callbacks, name: "onFunctionEnd", data: { functionName: "printCode", timeTaken: performance.now() - __funcStartTime } });
+}
+
+export async function writeCodeWithConfirm(filename, content, __state=undefined) {
+    const { stack: __stack, step: __step, self: __self, threads: __threads } =
+      setupFunction({ state: __state });
+
+    // __state will be undefined if this function is
+    // being called as a tool by an llm
+    const __ctx = __state?.ctx || __globalCtx;
+    const statelogClient = __ctx.statelogClient;
+    const __graph = __ctx.graph;
+    const __funcStartTime = performance.now();
+    await callHook({ callbacks: __ctx.callbacks, name: "onFunctionStart", data: { functionName: "writeCodeWithConfirm", args: { filename, content }, isBuiltin: false } });
+
+    // put all args on the state stack
+    __stack.args["filename"] = filename;
+    __stack.args["content"] = content;
+
+    
+      if (__step <= 0) {
+        
+        __stack.step++;
+      }
+      
+
+      if (__step <= 1) {
+        await _print(color.yellow());
+        __stack.step++;
+      }
+      
+
+      if (__step <= 2) {
+        __stack.locals.message = `\nYou're about to write to the file ${__stack.args.filename} with the following content\n\n`;
+        __stack.step++;
+      }
+      
+
+      if (__step <= 3) {
+        // Remember this will be called both in a tool call context
+// and when the user is simply calling a function.
+
+if (__state.interruptData?.interruptResponse?.type === "approve") {
+  // approved, clear interrupt response and continue execution
+  __state.interruptData.interruptResponse = null;
+} else if (__state.interruptData?.interruptResponse?.type === "reject" && !__state.isToolCall) {
+  // rejected, clear interrupt response and return early
+  // tool calls will instead tell the llm that the call was rejected
+  __state.interruptData.interruptResponse = null;
+  
+  
+  __ctx.stateStack.pop();
+  return null;
+  
+} else if (__state.interruptData?.interruptResponse?.type === "modify") {
+  if (__state.isToolCall) {
+    // continue, args will get modified in the tool call handler
+  } else {
+    throw new Error("Interrupt response of type 'modify' is not supported outside of tool calls yet.");
+  }
+} else if (__state.interruptData?.interruptResponse?.type === "resolve") {
+  console.log(JSON.stringify(__state.interruptData, null, 2));
+  throw new Error("Interrupt response of type 'resolve' cannot be returned from an interrupt call. It can only be assigned to a variable.");
+  const __resolvedValue = __state.interruptData.interruptResponse.value;
+  
+  
+  __ctx.stateStack.pop();
+  return __resolvedValue;
+  
+} else {
+  const __interruptResult = interrupt({"tool": `writeCodeWithConfirm`, "message": __stack.locals.message, "content": __stack.args.content});
+  __ctx.stateStack.nodesTraversed = __graph.getNodesTraversed();
+  __interruptResult.state = __ctx.stateStack.toJSON();
+  
+  
+  return __interruptResult;
+  
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 4) {
+        await _builtinWrite(__stack.args.filename, __stack.args.content);
+        __stack.step++;
+      }
+      
+
+    await callHook({ callbacks: __ctx.callbacks, name: "onFunctionEnd", data: { functionName: "writeCodeWithConfirm", timeTaken: performance.now() - __funcStartTime } });
+}
+__globalCtx.stateStack.globals.systemPrompt = await await _builtinRead(`./prompts/system.md`);
+
+__globalCtx.stateStack.globals.planPrompt = await await _builtinRead(`./prompts/plan.md`);
+
+
+graph.node("main", async (__state) => {
+    const { stack: __stack, step: __step, self: __self, threads: __threads } =
+      setupNode({ state: __state });
+    const __ctx = __state.ctx;
+    const statelogClient = __ctx.statelogClient;
+    const __graph = __ctx.graph;
+    await callHook({ callbacks: __ctx.callbacks, name: "onNodeStart", data: { nodeName: "main" } });
+
+    if (__state.isResume) {
+      __globalCtx.stateStack.globals = __state.ctx.stateStack.globals;
+    }
+
+    
+    
+      if (__step <= 0) {
+        
+        __stack.step++;
+      }
+      
+
+      if (__step <= 1) {
+        await _print(color.cyan(`Welcome to the Agency Agent!`));
+        __stack.step++;
+      }
+      
+
+      if (__step <= 2) {
+        __stack.locals.action = {"type": `askUser`, "question": `What would you like to do?`};
+        __stack.step++;
+      }
+      
+
+      if (__step <= 3) {
+        
+{
+
+
+const __tid = __threads.create();
+
+__threads.pushActive(__tid);
+
+__threads.active().push(smoltalk.systemMessage(`
+${__globalCtx.stateStack.globals.systemPrompt}
+${__globalCtx.stateStack.globals.planPrompt}
+`));
+
+
+
+while (__stack.locals.action.type != `done`) {
+__stack.locals.userMsg = await _builtinInput(`\n${__stack.locals.action.question} `);
+
+
+if (isInterrupt(__stack.locals.userMsg)) {
+  
+  return { ...__state, data: __stack.locals.userMsg };
+  
+   
+}
+
+
+
+
+
+async function _response(userMsg, __metadata) {
+  return runPrompt({
+    ctx: __ctx,
+    prompt: `Respond to the user's message and decide on the next action. User message: ${userMsg}`,
+    messages: __metadata?.messages || new MessageThread(),
+    
+    responseFormat: z.object({
+      response: z.union([z.object({ "type": z.literal("askUser"), "question": z.string() }), z.object({ "type": z.literal("done") })])
+    }),
+    
+    tools: [__newPlanTool, __getCurrentPlanTool, __listPlansTool, __updateCurrentPlanTool, __updateGoalTool, __updateActionsTool, __printTool, __readTool, __writeCodeWithConfirmTool],
+    toolHandlers: [{ name: "newPlan", params: __newPlanToolParams, execute: newPlan, isBuiltin: false }, { name: "getCurrentPlan", params: __getCurrentPlanToolParams, execute: getCurrentPlan, isBuiltin: false }, { name: "listPlans", params: __listPlansToolParams, execute: listPlans, isBuiltin: false }, { name: "updateCurrentPlan", params: __updateCurrentPlanToolParams, execute: updateCurrentPlan, isBuiltin: false }, { name: "updateGoal", params: __updateGoalToolParams, execute: updateGoal, isBuiltin: false }, { name: "updateActions", params: __updateActionsToolParams, execute: updateActions, isBuiltin: false }, { name: "print", params: __printToolParams, execute: _print, isBuiltin: true }, { name: "read", params: __readToolParams, execute: _builtinRead, isBuiltin: true }, { name: "writeCodeWithConfirm", params: __writeCodeWithConfirmToolParams, execute: writeCodeWithConfirm, isBuiltin: false }],
+    clientConfig: __globalCtx.stateStack.globals.config,
+    stream: false,
+    maxToolCallRounds: 10,
+    interruptData: __state?.interruptData
+  });
+}
+
+
+
+
+__self.response = await _response(__stack.locals.userMsg, {
+      messages: __threads.getOrCreateActive()
+    });
+
+// return early from node if this is an interrupt
+if (isInterrupt(__self.response)) {
+  
+  return { messages: __threads, data: __self.response };
+  
+   
+}
+
+
+}
+
+
+
+
+__threads.popActive();
+}
+        __stack.step++;
+      }
+      
+
+    await callHook({ callbacks: __ctx.callbacks, name: "onNodeEnd", data: { nodeName: "main", data: undefined } });
+    return { messages: __threads, data: undefined };
+});
+
+graph.node("readExisting", async (__state) => {
+    const { stack: __stack, step: __step, self: __self, threads: __threads } =
+      setupNode({ state: __state });
+    const __ctx = __state.ctx;
+    const statelogClient = __ctx.statelogClient;
+    const __graph = __ctx.graph;
+    await callHook({ callbacks: __ctx.callbacks, name: "onNodeStart", data: { nodeName: "readExisting" } });
+
+    if (__state.isResume) {
+      __globalCtx.stateStack.globals = __state.ctx.stateStack.globals;
+    }
+
+    
+    
+      if (__step <= 0) {
+        
+        __stack.step++;
+      }
+      
+
+      if (__step <= 1) {
+        __stack.locals.filepath = await _builtinInput(`Enter the path to the .agency file you want to modify: `);
+
+
+if (isInterrupt(__stack.locals.filepath)) {
+  
+  return { ...__state, data: __stack.locals.filepath };
+  
+   
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 2) {
+        __stack.locals.existingCode = await await _builtinRead(__stack.locals.filepath);
+
+
+if (isInterrupt(__stack.locals.existingCode)) {
+  
+  return { ...__state, data: __stack.locals.existingCode };
+  
+   
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 3) {
+        await _print(color.cyan(`Here's the existing code:`));
+        __stack.step++;
+      }
+      
+
+      if (__step <= 4) {
+        [__self.existingCode] = await Promise.all([__self.existingCode]);
+        __stack.step++;
+      }
+      
+
+      if (__step <= 5) {
+        const __funcResult = printCode(__stack.locals.existingCode, {
+    ctx: __ctx,
+    threads: __threads,
+    interruptData: __state?.interruptData
+});
+if (isInterrupt(__funcResult)) {
+  return { ...__state, data: __funcResult };
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 6) {
+        __ctx.stateStack.pop();
+return goToNode("plan",
+  {
+    messages: __stack.messages,
+    ctx: __ctx,
+    
+    data: { mode: `modify`, existingCode: __stack.locals.existingCode, existingFilename: __stack.locals.filepath }
+    
+    
+  });
+        __stack.step++;
+      }
+      
+
+    await callHook({ callbacks: __ctx.callbacks, name: "onNodeEnd", data: { nodeName: "readExisting", data: undefined } });
+    return { messages: __threads, data: undefined };
+});
+
+graph.node("plan", async (__state) => {
+    const { stack: __stack, step: __step, self: __self, threads: __threads } =
+      setupNode({ state: __state });
+    const __ctx = __state.ctx;
+    const statelogClient = __ctx.statelogClient;
+    const __graph = __ctx.graph;
+    await callHook({ callbacks: __ctx.callbacks, name: "onNodeStart", data: { nodeName: "plan" } });
+
+    if (__state.isResume) {
+      __globalCtx.stateStack.globals = __state.ctx.stateStack.globals;
+    }
+
+    
+    if (!__state.isResume) {
+      __stack.args["mode"] = __state.data.mode;
+      __stack.args["existingCode"] = __state.data.existingCode;
+      __stack.args["existingFilename"] = __state.data.existingFilename;
+    }
+    
+    
+      if (__step <= 0) {
+        
+        __stack.step++;
+      }
+      
+
+      if (__step <= 1) {
+        await _print(color.cyan(`Let's start by coming up with a plan for what you want to accomplish.`));
+        __stack.step++;
+      }
+      
+
+      if (__step <= 2) {
+        __stack.locals.modeContext = ``;
+        __stack.step++;
+      }
+      
+
+      if (__step <= 3) {
+        if (__stack.args.mode == `modify`) {
+__stack.locals.modeContext = `
+You are in MODIFY mode. The user has an existing agent they want to modify. Here is the existing code:
+
+```
+${__stack.args.existingCode}
+```
+
+Focus on understanding what changes the user wants to make to this existing agent.
+`;
+
+
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 4) {
+        
+{
+
+
+const __tid = __threads.create();
+
+__threads.pushActive(__tid);
+
+__threads.active().push(smoltalk.systemMessage(`${__globalCtx.stateStack.globals.systemPrompt}\n\n${__globalCtx.stateStack.globals.planPrompt}${__stack.locals.modeContext}`));
+
+
+__stack.locals.userMsg = await _builtinInput(`What would you like to accomplish today? `);
+
+
+if (isInterrupt(__stack.locals.userMsg)) {
+  
+  return { ...__state, data: __stack.locals.userMsg };
+  
+   
+}
+
+
+__stack.locals.nextAction = {"type": `start`};
+
+
+while (__stack.locals.nextAction.type != `done`) {
+
+
+
+async function _nextAction(userMsg, __metadata) {
+  return runPrompt({
+    ctx: __ctx,
+    prompt: `${userMsg}`,
+    messages: __metadata?.messages || new MessageThread(),
+    
+    responseFormat: z.object({
+      response: z.union([z.object({ "type": z.literal("askUser"), "question": z.string() }), z.object({ "type": z.literal("done") })])
+    }),
+    
+    tools: [__printTool],
+    toolHandlers: [{ name: "print", params: __printToolParams, execute: _print, isBuiltin: true }],
+    clientConfig: __globalCtx.stateStack.globals.config,
+    stream: false,
+    maxToolCallRounds: 10,
+    interruptData: __state?.interruptData
+  });
+}
+
+
+
+
+__self.nextAction = await _nextAction(__stack.locals.userMsg, {
+      messages: __threads.getOrCreateActive()
+    });
+
+// return early from node if this is an interrupt
+if (isInterrupt(__self.nextAction)) {
+  
+  return { messages: __threads, data: __self.nextAction };
+  
+   
+}
+
+
+if (__stack.locals.nextAction.type == `askUser`) {
+__stack.locals.userMsg = await _builtinInput(`${__stack.locals.nextAction.question} `);
+
+
+if (isInterrupt(__stack.locals.userMsg)) {
+  
+  return { ...__state, data: __stack.locals.userMsg };
+  
+   
+}
+
+
+}
+
+
+}
+
+
+
+__stack.locals.plan = readPlan();
+
+
+if (isInterrupt(__stack.locals.plan)) {
+  
+  return { ...__state, data: __stack.locals.plan };
+  
+   
+}
+
+
+await _print(color.cyan(`Here's the plan we've come up with`))
+
+await _printJSON(__stack.locals.plan)
+
+
+
+__threads.popActive();
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 5) {
+        __ctx.stateStack.pop();
+return goToNode("design",
+  {
+    messages: __stack.messages,
+    ctx: __ctx,
+    
+    data: { plan: __stack.locals.plan, mode: __stack.args.mode, existingCode: __stack.args.existingCode, existingFilename: __stack.args.existingFilename }
+    
+    
+  });
+        __stack.step++;
+      }
+      
+
+    await callHook({ callbacks: __ctx.callbacks, name: "onNodeEnd", data: { nodeName: "plan", data: undefined } });
+    return { messages: __threads, data: undefined };
+});
+
+graph.node("design", async (__state) => {
+    const { stack: __stack, step: __step, self: __self, threads: __threads } =
+      setupNode({ state: __state });
+    const __ctx = __state.ctx;
+    const statelogClient = __ctx.statelogClient;
+    const __graph = __ctx.graph;
+    await callHook({ callbacks: __ctx.callbacks, name: "onNodeStart", data: { nodeName: "design" } });
+
+    if (__state.isResume) {
+      __globalCtx.stateStack.globals = __state.ctx.stateStack.globals;
+    }
+
+    
+    if (!__state.isResume) {
+      __stack.args["plan"] = __state.data.plan;
+      __stack.args["mode"] = __state.data.mode;
+      __stack.args["existingCode"] = __state.data.existingCode;
+      __stack.args["existingFilename"] = __state.data.existingFilename;
+    }
+    
+    
+      if (__step <= 0) {
+        
+        __stack.step++;
+      }
+      
+
+      if (__step <= 1) {
+        __stack.locals.designPrompt = await await _builtinRead(`./prompts/design.md`);
+
+
+if (isInterrupt(__stack.locals.designPrompt)) {
+  
+  return { ...__state, data: __stack.locals.designPrompt };
+  
+   
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 2) {
+        __stack.locals.prompt = ``;
+        __stack.step++;
+      }
+      
+
+      if (__step <= 3) {
+        if (__stack.args.mode == `modify`) {
+await _print(color.cyan(`Now let's modify the existing agent based on the plan.`));
+
+
+__stack.locals.prompt = `
+You are in MODIFY mode. Here is the existing agent code:
+
+```
+${__stack.args.existingCode}
+```
+
+The user wants to make the following modifications:
+Goal: ${__stack.args.plan.overallGoal}
+Desired changes: ${__stack.args.plan.desiredActions}
+
+Modify the existing code to accomplish these changes. Preserve the existing style and structure where possible.
+`;
+
+
+} else {
+await _print(color.cyan(`Now let's design an agent to accomplish that plan.`));
+
+
+__stack.locals.prompt = `
+Help the user design an agent that can accomplish the following goal: ${__stack.args.plan.overallGoal}
+with the following actions: ${__stack.args.plan.desiredActions}.
+`;
+
+
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 4) {
+        
+{
+
+
+const __tid = __threads.create();
+
+__threads.pushActive(__tid);
+
+[__self.designPrompt] = await Promise.all([__self.designPrompt]);
+__threads.active().push(smoltalk.systemMessage(__stack.locals.designPrompt));
+
+
+__stack.locals.userMsg = __stack.locals.prompt;
+
+
+__stack.locals.nextAction = {"type": `start`};
+
+
+__stack.locals.i = 0;
+
+
+while (__stack.locals.nextAction.type != `done`) {
+__stack.locals.i += 1
+
+await _print(color.blue(`Design iteration ${__stack.locals.i}`));
+
+
+
+async function _nextAction(userMsg, __metadata) {
+  return runPrompt({
+    ctx: __ctx,
+    prompt: `${userMsg}`,
+    messages: __metadata?.messages || new MessageThread(),
+    
+    responseFormat: z.object({
+      response: z.union([z.object({ "type": z.literal("askUser"), "question": z.string() }), z.object({ "type": z.literal("done"), "finalCode": z.string(), "filename": z.string() }), z.object({ "type": z.literal("start") })])
+    }),
+    
+    tools: undefined,
+    toolHandlers: [],
+    clientConfig: __globalCtx.stateStack.globals.config,
+    stream: false,
+    maxToolCallRounds: 10,
+    interruptData: __state?.interruptData
+  });
+}
+
+
+
+
+__self.nextAction = await _nextAction(__stack.locals.userMsg, {
+      messages: __threads.getOrCreateActive()
+    });
+
+// return early from node if this is an interrupt
+if (isInterrupt(__self.nextAction)) {
+  
+  return { messages: __threads, data: __self.nextAction };
+  
+   
+}
+
+
+if (__stack.locals.nextAction.type == `askUser`) {
+__stack.locals.userMsg = await _builtinInput(`\n${__stack.locals.nextAction.question} `);
+
+
+if (isInterrupt(__stack.locals.userMsg)) {
+  
+  return { ...__state, data: __stack.locals.userMsg };
+  
+   
+}
+
+
+}
+
+
+}
+
+
+
+
+__threads.popActive();
+}
+        __stack.step++;
+      }
+      
+
+      if (__step <= 5) {
+        await _print(color.green(`Great! We've designed the agent. Now let's write the code for it.`));
+        __stack.step++;
+      }
+      
+
+      if (__step <= 6) {
+        await _printJSON(color.magenta(__stack.locals.nextAction));
+        __stack.step++;
+      }
+      
+
+      if (__step <= 7) {
+        __stack.locals.nextAction.filename = __stack.locals.nextAction.filename || `agent.agency`;
+        __stack.step++;
+      }
+      
+
+      if (__step <= 8) {
+        const __funcResult = await writeCodeWithConfirm(__stack.args.existingFilename || __stack.locals.nextAction.filename, __stack.locals.nextAction.finalCode, {
+    ctx: __ctx,
+    threads: __threads,
+    interruptData: __state?.interruptData
+});
+if (isInterrupt(__funcResult)) {
+  return { ...__state, data: __funcResult };
+}
+        __stack.step++;
+      }
+      
+
+    await callHook({ callbacks: __ctx.callbacks, name: "onNodeEnd", data: { nodeName: "design", data: undefined } });
+    return { messages: __threads, data: undefined };
+});
+
+graph.conditionalEdge("readExisting", ["plan"]);
+
+graph.conditionalEdge("plan", ["design"]);
+
+
+
+export async function main({ messages, callbacks } = {}) {
+
+  return runNode({
+    ctx: __globalCtx,
+    nodeName: "main",
+    data: {  },
+    messages,
+    callbacks,
+  });
+}
+
+export const __mainNodeParams = [];
+
+
+export async function readExisting({ messages, callbacks } = {}) {
+
+  return runNode({
+    ctx: __globalCtx,
+    nodeName: "readExisting",
+    data: {  },
+    messages,
+    callbacks,
+  });
+}
+
+export const __readExistingNodeParams = [];
+
+export async function plan(mode, existingCode, existingFilename, { messages, callbacks } = {}) {
+
+
+  return runNode({
+    ctx: __globalCtx,
+    nodeName: "plan",
+    data: { mode, existingCode, existingFilename },
+    messages,
+    callbacks,
+  });
+}
+
+export const __planNodeParams = ["mode", "existingCode", "existingFilename"];
+
+export async function design(plan, mode, existingCode, existingFilename, { messages, callbacks } = {}) {
+
+
+  return runNode({
+    ctx: __globalCtx,
+    nodeName: "design",
+    data: { plan, mode, existingCode, existingFilename },
+    messages,
+    callbacks,
+  });
+}
+
+export const __designNodeParams = ["plan", "mode", "existingCode", "existingFilename"];
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    try {
+      const initialState = { messages: new ThreadStore(), data: {} };
+      await main(initialState);
+    } catch (__error) {
+      console.error(`
+Agent crashed: ${__error.message}`);
+      throw __error;
+    }
+}
+
+export default graph;