agency-lang 0.1.2 → 0.1.3

package/dist/lib/agents/policy/agent.js

@@ -0,0 +1,736 @@
+import { print, printJSON, input, sleep, round, fetch, fetchJSON, read, write, readImage, notify, range, mostCommon, keys, values, entries, emit } from "agency-lang/stdlib/index.js";
+import { writePolicyFile } from "agency-lang/stdlib/policy.js";
+import { args } from "agency-lang/stdlib/system.js";
+import { fileURLToPath } from "url";
+import __process from "process";
+import { z } from "agency-lang/zod";
+import { goToNode, nanoid } from "agency-lang";
+import { smoltalk } from "agency-lang";
+import path from "path";
+import {
+  RuntimeContext,
+  ThreadStore,
+  Runner,
+  setupNode,
+  runNode,
+  runPrompt,
+  callHook,
+  checkpoint as __checkpoint_impl,
+  getCheckpoint as __getCheckpoint_impl,
+  restore as __restore_impl,
+  _run as __runtime_run_impl,
+  interrupt,
+  isInterrupt,
+  hasInterrupts,
+  isDebugger,
+  respondToInterrupts as _respondToInterrupts,
+  rewindFrom as _rewindFrom,
+  RestoreSignal,
+  failure,
+  readSkill as _readSkillRaw,
+  readSkillTool as __readSkillTool,
+  readSkillToolParams as __readSkillToolParams,
+  AgencyFunction as __AgencyFunction,
+  __call,
+  functionRefReviver as __functionRefReviver,
+  DeterministicClient as __DeterministicClient
+} from "agency-lang/runtime";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const __cwd = __process.cwd();
+const getDirname = () => __dirname;
+const __globalCtx = new RuntimeContext({
+  statelogConfig: {
+    host: "https://statelog.adit.io",
+    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://statelog.adit.io",
+      projectId: "smoltalk",
+      apiKey: __process.env["STATELOG_SMOLTALK_API_KEY"] || "",
+      traceId: nanoid()
+    }
+  },
+  dirname: __dirname,
+  traceConfig: {
+    program: "lib/agents/policy/agent.agency",
+    traceDir: "traces"
+  }
+});
+const graph = __globalCtx.graph;
+function readSkill({ filepath }) {
+  return _readSkillRaw({ filepath, dirname: __dirname });
+}
+function approve(value) {
+  return { type: "approve", value };
+}
+function reject(value) {
+  return { type: "reject", value };
+}
+function propagate() {
+  return { type: "propagate" };
+}
+const respondToInterrupts = (interrupts, responses, opts) => _respondToInterrupts({ ctx: __globalCtx, interrupts, responses, overrides: opts?.overrides, metadata: opts?.metadata });
+const rewindFrom = (checkpoint2, overrides, opts) => _rewindFrom({ ctx: __globalCtx, checkpoint: checkpoint2, overrides, metadata: opts?.metadata });
+const __setDebugger = (dbg) => {
+  __globalCtx.debuggerState = dbg;
+};
+const __setTraceWriter = (tw) => {
+  __globalCtx.traceWriter = tw;
+};
+const __setLLMClient = (client) => {
+  __globalCtx.setLLMClient(client);
+};
+const __getCheckpoints = () => __globalCtx.checkpoints;
+if (__process.env.AGENCY_LLM_MOCKS) {
+  __globalCtx.setLLMClient(
+    new __DeterministicClient(JSON.parse(__process.env.AGENCY_LLM_MOCKS))
+  );
+}
+const __toolRegistry = {};
+function __registerTool(value, name) {
+  if (__AgencyFunction.isAgencyFunction(value)) {
+    __toolRegistry[name ?? value.name] = value;
+  }
+}
+const checkpoint = __AgencyFunction.create({ name: "checkpoint", module: "__runtime", fn: __checkpoint_impl, params: [], toolDefinition: null }, __toolRegistry);
+const getCheckpoint = __AgencyFunction.create({ name: "getCheckpoint", module: "__runtime", fn: __getCheckpoint_impl, params: [{ name: "checkpointId", hasDefault: false, defaultValue: void 0, variadic: false }], toolDefinition: null }, __toolRegistry);
+const restore = __AgencyFunction.create({ name: "restore", module: "__runtime", fn: __restore_impl, params: [{ name: "checkpointIdOrCheckpoint", hasDefault: false, defaultValue: void 0, variadic: false }, { name: "options", hasDefault: false, defaultValue: void 0, variadic: false }], toolDefinition: null }, __toolRegistry);
+const _run = __AgencyFunction.create({ name: "_run", module: "__runtime", fn: __runtime_run_impl, params: [{ name: "compiled", hasDefault: false, defaultValue: void 0, variadic: false }, { name: "node", hasDefault: false, defaultValue: void 0, variadic: false }, { name: "args", hasDefault: false, defaultValue: void 0, variadic: false }, { name: "wallClock", hasDefault: false, defaultValue: void 0, variadic: false }, { name: "memory", hasDefault: false, defaultValue: void 0, variadic: false }, { name: "ipcPayload", hasDefault: false, defaultValue: void 0, variadic: false }, { name: "stdout", hasDefault: false, defaultValue: void 0, variadic: false }], toolDefinition: null }, __toolRegistry);
+function setLLMClient(client) {
+  __globalCtx.setLLMClient(client);
+}
+function registerTools(tools) {
+  for (const tool of tools) {
+    if (__AgencyFunction.isAgencyFunction(tool)) {
+      __toolRegistry[tool.name] = tool;
+    }
+  }
+}
+__registerTool(print);
+__registerTool(printJSON);
+__registerTool(input);
+__registerTool(sleep);
+__registerTool(round);
+__registerTool(fetch);
+__registerTool(fetchJSON);
+__registerTool(read);
+__registerTool(write);
+__registerTool(readImage);
+__registerTool(notify);
+__registerTool(range);
+__registerTool(mostCommon);
+__registerTool(keys);
+__registerTool(values);
+__registerTool(entries);
+__registerTool(emit);
+__registerTool(writePolicyFile);
+__registerTool(args);
+async function __initializeGlobals(__ctx) {
+  __ctx.globals.markInitialized("lib/agents/policy/agent.agency");
+  __ctx.globals.set("lib/agents/policy/agent.agency", "systemPrompt", await __call(read, {
+    type: "positional",
+    args: [`./prompts/system.md`]
+  }, {
+    ctx: __ctx
+  }));
+}
+__toolRegistry["readSkill"] = __AgencyFunction.create({
+  name: "readSkill",
+  module: "lib/agents/policy/agent.agency",
+  fn: readSkill,
+  params: __readSkillToolParams.map((p) => ({ name: p, hasDefault: false, defaultValue: void 0, variadic: false })),
+  toolDefinition: __readSkillTool
+}, __toolRegistry);
+__functionRefReviver.registry = __toolRegistry;
+const NextStep = z.union([z.object({ "type": z.literal("showPolicy"), "policy": z.record(z.string(), z.any()) }), z.object({ "type": z.literal("writePolicy"), "policy": z.record(z.string(), z.any()) }), z.object({ "type": z.literal("askQuestion"), "question": z.string() })]);
+graph.node("main", async (__state) => {
+  const __setupData = setupNode({
+    state: __state
+  });
+  const __stateStack = __state.ctx.stateStack;
+  const __stack = __setupData.stack;
+  const __step = __setupData.step;
+  const __self = __setupData.self;
+  const __threads = __setupData.threads;
+  const __ctx = __state.ctx;
+  const statelogClient = __ctx.statelogClient;
+  const __graph = __ctx.graph;
+  let __forked;
+  let __functionCompleted = false;
+  await callHook({
+    callbacks: __ctx.callbacks,
+    name: "onNodeStart",
+    data: {
+      nodeName: "main"
+    }
+  });
+  const runner = new Runner(__ctx, __stack, { nodeContext: true, state: __stack, moduleId: "lib/agents/policy/agent.agency", scopeName: "main" });
+  try {
+    await runner.step(0, async (runner2) => {
+      __stack.locals.cliArgs = await __call(args, {
+        type: "positional",
+        args: []
+      }, {
+        ctx: __ctx,
+        threads: __threads,
+        stateStack: __stateStack
+      });
+      if (hasInterrupts(__stack.locals.cliArgs)) {
+        await __ctx.pendingPromises.awaitAll();
+        runner2.halt({
+          ...__state,
+          data: __stack.locals.cliArgs
+        });
+        return;
+      }
+    });
+    await runner.ifElse(1, [
+      {
+        condition: async () => __stack.locals.cliArgs.length < 2,
+        body: async (runner2) => {
+          await runner2.step(0, async (runner3) => {
+            const __funcResult = await __call(print, {
+              type: "positional",
+              args: [`Usage: agency policy gen <file>`]
+            }, {
+              ctx: __ctx,
+              threads: __threads,
+              stateStack: __stateStack
+            });
+            if (hasInterrupts(__funcResult)) {
+              await __ctx.pendingPromises.awaitAll();
+              runner3.halt({
+                ...__state,
+                data: __funcResult
+              });
+              return;
+            }
+          });
+          await runner2.step(1, async (runner3) => {
+            __stateStack.pop();
+            __functionCompleted = true;
+            runner3.halt(goToNode("end", {
+              messages: __threads,
+              ctx: __ctx,
+              data: {}
+            }));
+            return;
+          });
+        }
+      }
+    ]);
+    await runner.step(2, async (runner2) => {
+      __stack.locals.interruptKindsJson = __stack.locals.cliArgs[0];
+    });
+    await runner.step(3, async (runner2) => {
+      __stack.locals.outputPath = __stack.locals.cliArgs[1];
+    });
+    await runner.step(4, async (runner2) => {
+      __stack.locals.existingPolicyJson = ``;
+    });
+    await runner.ifElse(5, [
+      {
+        condition: async () => __stack.locals.cliArgs.length >= 3,
+        body: async (runner2) => {
+          await runner2.step(0, async (runner3) => {
+            __stack.locals.existingPolicyJson = __stack.locals.cliArgs[2];
+          });
+        }
+      }
+    ]);
+    await runner.step(6, async (runner2) => {
+      __stack.locals.interruptKinds = await __call(parseJSON, {
+        type: "positional",
+        args: [__stack.locals.interruptKindsJson]
+      }, {
+        ctx: __ctx,
+        threads: __threads,
+        stateStack: __stateStack
+      });
+      if (hasInterrupts(__stack.locals.interruptKinds)) {
+        await __ctx.pendingPromises.awaitAll();
+        runner2.halt({
+          ...__state,
+          data: __stack.locals.interruptKinds
+        });
+        return;
+      }
+    });
+    await runner.step(7, async (runner2) => {
+      __stack.locals.existingPolicy = null;
+    });
+    await runner.ifElse(8, [
+      {
+        condition: async () => __stack.locals.existingPolicyJson !== ``,
+        body: async (runner2) => {
+          await runner2.step(0, async (runner3) => {
+            __stack.locals.existingPolicy = await __call(parseJSON, {
+              type: "positional",
+              args: [__stack.locals.existingPolicyJson]
+            }, {
+              ctx: __ctx,
+              threads: __threads,
+              stateStack: __stateStack
+            });
+            if (hasInterrupts(__stack.locals.existingPolicy)) {
+              await __ctx.pendingPromises.awaitAll();
+              runner3.halt({
+                ...__state,
+                data: __stack.locals.existingPolicy
+              });
+              return;
+            }
+          });
+        }
+      }
+    ]);
+    await runner.step(9, async (runner2) => {
+      __stack.locals.contextMessage = `This agent can produce the following interrupts:
+`;
+    });
+    await runner.loop(10, __stack.locals.interruptKinds, async (kind, _, runner2) => {
+      await runner2.step(0, async (runner3) => {
+        __stack.locals.contextMessage = __stack.locals.contextMessage + `- ${kind}
+`;
+      });
+    });
+    await runner.ifElse(11, [
+      {
+        condition: async () => __stack.locals.existingPolicy !== null,
+        body: async (runner2) => {
+          await runner2.step(0, async (runner3) => {
+            __stack.locals.contextMessage = __stack.locals.contextMessage + `
+    Current policy:
+\`\`\`json
+${await __call(printJSON, {
+              type: "positional",
+              args: [__stack.locals.existingPolicy]
+            }, {
+              ctx: __ctx,
+              threads: __threads,
+              stateStack: __stateStack
+            })}
+\`\`\`
+
+What would you like to change?
+    `;
+          });
+        }
+      }
+    ], async (runner2) => {
+      await runner2.step(1, async (runner3) => {
+        __stack.locals.contextMessage = __stack.locals.contextMessage + `
+What actions would you like to allow?`;
+      });
+    });
+    await runner.step(12, async (runner2) => {
+      const __funcResult = await __call(print, {
+        type: "positional",
+        args: [__stack.locals.contextMessage]
+      }, {
+        ctx: __ctx,
+        threads: __threads,
+        stateStack: __stateStack
+      });
+      if (hasInterrupts(__funcResult)) {
+        await __ctx.pendingPromises.awaitAll();
+        runner2.halt({
+          ...__state,
+          data: __funcResult
+        });
+        return;
+      }
+    });
+    await runner.step(13, async (runner2) => {
+      __stack.locals.done = false;
+    });
+    await runner.step(14, async (runner2) => {
+      __stack.locals.policy = {};
+    });
+    await runner.step(15, async (runner2) => {
+      __stack.locals.conversationHistory = __stack.locals.contextMessage;
+    });
+    await runner.whileLoop(16, () => !__stack.locals.done, async (runner2) => {
+      await runner2.step(0, async (runner3) => {
+        __stack.locals.userInput = await __call(input, {
+          type: "positional",
+          args: [`> `]
+        }, {
+          ctx: __ctx,
+          threads: __threads,
+          stateStack: __stateStack
+        });
+        if (hasInterrupts(__stack.locals.userInput)) {
+          await __ctx.pendingPromises.awaitAll();
+          runner3.halt({
+            ...__state,
+            data: __stack.locals.userInput
+          });
+          return;
+        }
+      });
+      await runner2.step(1, async (runner3) => {
+        __stack.locals.conversationHistory = __stack.locals.conversationHistory + `
+User: ${__stack.locals.userInput}`;
+      });
+      await runner2.thread(2, __threads, "create", async (runner3) => {
+        await runner3.step(0, async (runner4) => {
+          const __funcResult = __threads.active().push(smoltalk.systemMessage(__ctx.globals.get("lib/agents/policy/agent.agency", "systemPrompt")));
+          if (hasInterrupts(__funcResult)) {
+            await __ctx.pendingPromises.awaitAll();
+            runner4.halt({
+              ...__state,
+              data: __funcResult
+            });
+            return;
+          }
+        });
+        await runner3.step(1, async (runner4) => {
+          __self.__removedTools = __self.__removedTools || [];
+          __stack.locals.step = await runPrompt({
+            ctx: __ctx,
+            prompt: `
+      ${__stack.locals.conversationHistory}
+
+Current policy: ${await __call(printJSON, {
+              type: "positional",
+              args: [__stack.locals.policy]
+            }, {
+              ctx: __ctx,
+              threads: __threads,
+              stateStack: __stateStack
+            })}
+
+Decide the next step. If the user is describing what they want, build or update the policy and use showPolicy. If the user approves the shown policy, use writePolicy. If you need clarification, use askQuestion.
+      `,
+            messages: __threads.getOrCreateActive(),
+            responseFormat: z.object({
+              response: NextStep
+            }),
+            clientConfig: {},
+            maxToolCallRounds: 10,
+            stateStack: __stateStack,
+            removedTools: __self.__removedTools,
+            checkpointInfo: runner4.getCheckpointInfo()
+          });
+          if (hasInterrupts(__stack.locals.step)) {
+            await __ctx.pendingPromises.awaitAll();
+            runner4.halt({
+              messages: __threads,
+              data: __stack.locals.step
+            });
+            return;
+          }
+        });
+      });
+      await runner2.ifElse(3, [
+        {
+          condition: async () => __stack.locals.step.type === `showPolicy`,
+          body: async (runner3) => {
+            await runner3.step(0, async (runner4) => {
+              __stack.locals.policy = __stack.locals.step.policy;
+            });
+            await runner3.step(1, async (runner4) => {
+              __stack.locals.policyStr = await __call(printJSON, {
+                type: "positional",
+                args: [__stack.locals.policy]
+              }, {
+                ctx: __ctx,
+                threads: __threads,
+                stateStack: __stateStack
+              });
+              if (hasInterrupts(__stack.locals.policyStr)) {
+                await __ctx.pendingPromises.awaitAll();
+                runner4.halt({
+                  ...__state,
+                  data: __stack.locals.policyStr
+                });
+                return;
+              }
+            });
+            await runner3.step(2, async (runner4) => {
+              const __funcResult = await __call(print, {
+                type: "positional",
+                args: [`
+Proposed policy:
+\`\`\`json
+${__stack.locals.policyStr}
+\`\`\`
+`]
+              }, {
+                ctx: __ctx,
+                threads: __threads,
+                stateStack: __stateStack
+              });
+              if (hasInterrupts(__funcResult)) {
+                await __ctx.pendingPromises.awaitAll();
+                runner4.halt({
+                  ...__state,
+                  data: __funcResult
+                });
+                return;
+              }
+            });
+            await runner3.step(3, async (runner4) => {
+              const __funcResult = await __call(print, {
+                type: "positional",
+                args: [`Does this look right? (say 'yes' to save, or describe changes)`]
+              }, {
+                ctx: __ctx,
+                threads: __threads,
+                stateStack: __stateStack
+              });
+              if (hasInterrupts(__funcResult)) {
+                await __ctx.pendingPromises.awaitAll();
+                runner4.halt({
+                  ...__state,
+                  data: __funcResult
+                });
+                return;
+              }
+            });
+            await runner3.step(4, async (runner4) => {
+              __stack.locals.conversationHistory = __stack.locals.conversationHistory + `
+Assistant: Here is the proposed policy:
+${__stack.locals.policyStr}
+Does this look right?`;
+            });
+          }
+        },
+        {
+          condition: async () => __stack.locals.step.type === `writePolicy`,
+          body: async (runner3) => {
+            await runner3.step(5, async (runner4) => {
+              __stack.locals.policy = __stack.locals.step.policy;
+            });
+            await runner3.step(6, async (runner4) => {
+              __self.__retryable = false;
+              const __funcResult = await __call(writePolicyFile, {
+                type: "positional",
+                args: [__stack.locals.outputPath, __stack.locals.policy]
+              }, {
+                ctx: __ctx,
+                threads: __threads,
+                stateStack: __stateStack
+              });
+              if (hasInterrupts(__funcResult)) {
+                await __ctx.pendingPromises.awaitAll();
+                runner4.halt({
+                  ...__state,
+                  data: __funcResult
+                });
+                return;
+              }
+            });
+            await runner3.step(7, async (runner4) => {
+              const __funcResult = await __call(print, {
+                type: "positional",
+                args: [`
+Policy written to ${__stack.locals.outputPath}`]
+              }, {
+                ctx: __ctx,
+                threads: __threads,
+                stateStack: __stateStack
+              });
+              if (hasInterrupts(__funcResult)) {
+                await __ctx.pendingPromises.awaitAll();
+                runner4.halt({
+                  ...__state,
+                  data: __funcResult
+                });
+                return;
+              }
+            });
+            await runner3.step(8, async (runner4) => {
+              __stack.locals.done = true;
+            });
+          }
+        },
+        {
+          condition: async () => __stack.locals.step.type === `askQuestion`,
+          body: async (runner3) => {
+            await runner3.step(9, async (runner4) => {
+              const __funcResult = await __call(print, {
+                type: "positional",
+                args: [__stack.locals.step.question]
+              }, {
+                ctx: __ctx,
+                threads: __threads,
+                stateStack: __stateStack
+              });
+              if (hasInterrupts(__funcResult)) {
+                await __ctx.pendingPromises.awaitAll();
+                runner4.halt({
+                  ...__state,
+                  data: __funcResult
+                });
+                return;
+              }
+            });
+            await runner3.step(10, async (runner4) => {
+              __stack.locals.conversationHistory = __stack.locals.conversationHistory + `
+Assistant: ${__stack.locals.step.question}`;
+            });
+          }
+        }
+      ]);
+      await runner2.step(4, async (runner3) => {
+        __self.__retryable = false;
+      });
+    });
+    await runner.step(17, async (runner2) => {
+      __self.__retryable = false;
+    });
+    await runner.step(18, async (runner2) => {
+      __stateStack.pop();
+      __functionCompleted = true;
+      runner2.halt(goToNode("end", {
+        messages: __threads,
+        ctx: __ctx,
+        data: {}
+      }));
+      return;
+    });
+    if (runner.halted) return runner.haltResult;
+    await callHook({
+      callbacks: __ctx.callbacks,
+      name: "onNodeEnd",
+      data: {
+        nodeName: "main",
+        data: void 0
+      }
+    });
+    return {
+      messages: __threads,
+      data: void 0
+    };
+  } catch (__error) {
+    if (__error instanceof RestoreSignal) {
+      throw __error;
+    }
+    console.error(`
+Agent crashed: ${__error.message}`);
+    console.error(__error.stack);
+    return {
+      messages: __threads,
+      data: failure(__error instanceof Error ? __error.message : String(__error), { functionName: "main" })
+    };
+  }
+});
+graph.node("end", async (__state) => {
+  const __setupData = setupNode({
+    state: __state
+  });
+  const __stateStack = __state.ctx.stateStack;
+  const __stack = __setupData.stack;
+  const __step = __setupData.step;
+  const __self = __setupData.self;
+  const __threads = __setupData.threads;
+  const __ctx = __state.ctx;
+  const statelogClient = __ctx.statelogClient;
+  const __graph = __ctx.graph;
+  let __forked;
+  let __functionCompleted = false;
+  await callHook({
+    callbacks: __ctx.callbacks,
+    name: "onNodeStart",
+    data: {
+      nodeName: "end"
+    }
+  });
+  const runner = new Runner(__ctx, __stack, { nodeContext: true, state: __stack, moduleId: "lib/agents/policy/agent.agency", scopeName: "end" });
+  try {
+    if (runner.halted) return runner.haltResult;
+    await callHook({
+      callbacks: __ctx.callbacks,
+      name: "onNodeEnd",
+      data: {
+        nodeName: "end",
+        data: void 0
+      }
+    });
+    return {
+      messages: __threads,
+      data: void 0
+    };
+  } catch (__error) {
+    if (__error instanceof RestoreSignal) {
+      throw __error;
+    }
+    console.error(`
+Agent crashed: ${__error.message}`);
+    console.error(__error.stack);
+    return {
+      messages: __threads,
+      data: failure(__error instanceof Error ? __error.message : String(__error), { functionName: "end" })
+    };
+  }
+});
+graph.conditionalEdge("main", ["end", "end"]);
+async function main({ messages, callbacks } = {}) {
+  return runNode({
+    ctx: __globalCtx,
+    nodeName: "main",
+    data: {},
+    messages,
+    callbacks,
+    initializeGlobals: __initializeGlobals
+  });
+}
+const __mainNodeParams = [];
+async function end({ messages, callbacks } = {}) {
+  return runNode({
+    ctx: __globalCtx,
+    nodeName: "end",
+    data: {},
+    messages,
+    callbacks,
+    initializeGlobals: __initializeGlobals
+  });
+}
+const __endNodeParams = [];
+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;
+  }
+}
+var stdin_default = graph;
+const __sourceMap = { "lib/agents/policy/agent.agency:main": { "0": { "line": 8, "col": 2 }, "1": { "line": 9, "col": 2 }, "2": { "line": 13, "col": 2 }, "3": { "line": 14, "col": 2 }, "4": { "line": 15, "col": 2 }, "5": { "line": 16, "col": 2 }, "6": { "line": 20, "col": 2 }, "7": { "line": 21, "col": 2 }, "8": { "line": 22, "col": 2 }, "9": { "line": 26, "col": 2 }, "10": { "line": 27, "col": 2 }, "11": { "line": 31, "col": 2 }, "12": { "line": 39, "col": 2 }, "13": { "line": 41, "col": 2 }, "14": { "line": 42, "col": 2 }, "15": { "line": 43, "col": 2 }, "16": { "line": 44, "col": 2 }, "18": { "line": 71, "col": 2 }, "1.0": { "line": 10, "col": 4 }, "1.1": { "line": 11, "col": 4 }, "5.0": { "line": 17, "col": 4 }, "8.0": { "line": 23, "col": 4 }, "10.0": { "line": 28, "col": 4 }, "11.0": { "line": 32, "col": 4 }, "11.1": { "line": 36, "col": 4 }, "16.0": { "line": 45, "col": 4 }, "16.1": { "line": 46, "col": 4 }, "16.2.0": { "line": 49, "col": 6 }, "16.2.1": { "line": 50, "col": 6 }, "16.2": { "line": 48, "col": 4 }, "16.3.0": { "line": 56, "col": 6 }, "16.3.1": { "line": 57, "col": 6 }, "16.3.2": { "line": 58, "col": 6 }, "16.3.3": { "line": 59, "col": 6 }, "16.3.4": { "line": 60, "col": 6 }, "16.3.5": { "line": 62, "col": 6 }, "16.3.6": { "line": 63, "col": 6 }, "16.3.7": { "line": 64, "col": 6 }, "16.3.8": { "line": 65, "col": 6 }, "16.3.9": { "line": 67, "col": 6 }, "16.3.10": { "line": 68, "col": 6 }, "16.3": { "line": 55, "col": 4 } }, "lib/agents/policy/agent.agency:end": {} };
+export {
+  __endNodeParams,
+  __getCheckpoints,
+  __mainNodeParams,
+  __setDebugger,
+  __setLLMClient,
+  __setTraceWriter,
+  __sourceMap,
+  __toolRegistry,
+  approve,
+  stdin_default as default,
+  end,
+  hasInterrupts,
+  interrupt,
+  isDebugger,
+  isInterrupt,
+  main,
+  readSkill,
+  reject,
+  respondToInterrupts,
+  rewindFrom
+};