agency-lang 0.6.2 → 0.6.3

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

@@ -0,0 +1,711 @@
+import { print, printJSON, parseJSON, input, sleep, round, read, write, readImage, notify, range, mostCommon, keys, values, entries, emit, callback } from "agency-lang/stdlib/index.js";
+import { pickProvider, envVarFor } from "agency-lang/stdlib/llm.js";
+import { env } from "agency-lang/stdlib/system.js";
+import { fileURLToPath } from "url";
+import __process from "process";
+import { z } from "agency-lang/zod";
+import { nanoid } from "agency-lang";
+import path from "path";
+import {
+  RuntimeContext,
+  Runner,
+  setupFunction,
+  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,
+  runExportedFunction as _runExportedFunction,
+  RestoreSignal,
+  AgencyAbort,
+  deepFreeze as __deepFreeze,
+  __UNINIT_STATIC,
+  __readStatic,
+  __registerStaticInit,
+  __registerGlobalsInit,
+  success,
+  failure,
+  isFailure,
+  AgencyFunction as __AgencyFunction,
+  __call,
+  __callMethod,
+  __stateStack,
+  __globals,
+  getRuntimeContext,
+  agencyStore,
+  functionRefReviver as __functionRefReviver,
+  DeterministicClient as __DeterministicClient,
+  createLogger as __createLogger
+} 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,
+    observability: true,
+    logFile: "log.jsonl"
+  },
+  smoltalkDefaults: {
+    openAiApiKey: __process.env["OPENAI_API_KEY"] || "",
+    googleApiKey: __process.env["GEMINI_API_KEY"] || "",
+    anthropicApiKey: __process.env["ANTHROPIC_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,
+  logLevel: "info",
+  traceConfig: {
+    program: "dist/lib/agents/agency-agent/lib/models.agency"
+  }
+});
+const graph = __globalCtx.graph;
+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, registerTopLevelCallbacks: __registerTopLevelCallbacks, moduleDir: __dirname });
+const rewindFrom = (checkpoint2, overrides, opts) => _rewindFrom({ ctx: __globalCtx, checkpoint: checkpoint2, overrides, metadata: opts?.metadata, registerTopLevelCallbacks: __registerTopLevelCallbacks, moduleDir: __dirname });
+const __invokeFunction = (fn, namedArgs) => _runExportedFunction({ ctx: __globalCtx, fn, namedArgs, initializeGlobals: __initializeGlobals, registerTopLevelCallbacks: __registerTopLevelCallbacks, moduleDir: __dirname });
+const __setDebugger = (dbg) => {
+  __globalCtx.debuggerState = dbg;
+};
+const __setTraceFile = (filePath) => {
+  __globalCtx.traceConfig.traceFile = filePath;
+};
+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 = __functionRefReviver.registry ??= {};
+function __registerTool(value, _aliasName) {
+  if (__AgencyFunction.isAgencyFunction(value)) {
+    __toolRegistry[`${value.module}:${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 }, { name: "configOverrides", hasDefault: false, defaultValue: void 0, variadic: false }, { name: "cwd", 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.module}:${tool.name}`] = tool;
+    }
+  }
+}
+__registerTool(print);
+__registerTool(printJSON);
+__registerTool(parseJSON);
+__registerTool(input);
+__registerTool(sleep);
+__registerTool(round);
+__registerTool(read);
+__registerTool(write);
+__registerTool(readImage);
+__registerTool(notify);
+__registerTool(range);
+__registerTool(mostCommon);
+__registerTool(keys);
+__registerTool(values);
+__registerTool(entries);
+__registerTool(emit);
+__registerTool(callback);
+__registerTool(pickProvider);
+__registerTool(envVarFor);
+__registerTool(env);
+let __staticInitPromise = null;
+let MODELS = __UNINIT_STATIC;
+async function __initializeStatic(__ctx) {
+  if (__staticInitPromise) {
+    return __staticInitPromise;
+  }
+  __staticInitPromise = (async () => {
+    MODELS = __deepFreeze({
+      "openai": {
+        "fast": `gpt-4o-mini`,
+        "slow": `gpt-5.5`,
+        "slowProvider": `openai-responses`
+      },
+      "anthropic": {
+        "fast": `claude-sonnet-4-6`,
+        "slow": `claude-opus-4-8`,
+        "slowProvider": `anthropic`
+      },
+      "google": {
+        "fast": `gemini-3.5-flash`,
+        "slow": `gemini-3.1-pro-preview`,
+        "slowProvider": `google`
+      }
+    });
+  })();
+  return __staticInitPromise;
+}
+function __getStaticVars() {
+  return {
+    MODELS
+  };
+}
+__globalCtx.getStaticVars = __getStaticVars;
+__registerStaticInit("dist/lib/agents/agency-agent/lib/models.agency", __initializeStatic);
+async function __initializeGlobals(__ctx) {
+  if (__ctx.globals.isInitialized("dist/lib/agents/agency-agent/lib/models.agency")) {
+    return;
+  }
+  __ctx.globals.markInitialized("dist/lib/agents/agency-agent/lib/models.agency");
+  await __initializeStatic(__ctx);
+  await __ctx.writeStaticStateToTrace(__globalCtx.getStaticVars());
+}
+__registerGlobalsInit("dist/lib/agents/agency-agent/lib/models.agency", __initializeGlobals);
+async function __registerTopLevelCallbacks(__ctx) {
+  __ctx.topLevelCallbacks = [];
+}
+__functionRefReviver.registry = __toolRegistry;
+const ProviderModels = z.object({ "fast": z.string(), "slow": z.string(), "slowProvider": z.string() });
+const ModelPlan = z.object({ "fastModel": z.string(), "fastProvider": z.string(), "slowModel": z.string(), "slowProvider": z.string() });
+async function __resolveDetected_impl(model, fast, slow, provider) {
+  const __setupData = setupFunction();
+  const __stack = __setupData.stack;
+  const __step = __setupData.step;
+  const __self = __setupData.self;
+  const __ctx = getRuntimeContext().ctx;
+  let __forked;
+  let __functionCompleted = false;
+  if (!__globals().isInitialized("dist/lib/agents/agency-agent/lib/models.agency")) {
+    await __initializeGlobals(__ctx);
+  }
+  let __funcStartTime = performance.now();
+  __stack.args["model"] = model;
+  __stack.args["fast"] = fast;
+  __stack.args["slow"] = slow;
+  __stack.args["provider"] = provider;
+  __self.__retryable = __self.__retryable ?? true;
+  const runner = new Runner(__ctx, __stack, { state: __stack, moduleId: "dist/lib/agents/agency-agent/lib/models.agency", scopeName: "resolveDetected", threads: __setupData.threads });
+  let __resultCheckpointId = -1;
+  if (__ctx._pendingArgOverrides) {
+    const __overrides = __ctx._pendingArgOverrides;
+    __ctx._pendingArgOverrides = void 0;
+    if ("model" in __overrides) {
+      model = __overrides["model"];
+      __stack.args["model"] = model;
+    }
+    if ("fast" in __overrides) {
+      fast = __overrides["fast"];
+      __stack.args["fast"] = fast;
+    }
+    if ("slow" in __overrides) {
+      slow = __overrides["slow"];
+      __stack.args["slow"] = slow;
+    }
+    if ("provider" in __overrides) {
+      provider = __overrides["provider"];
+      __stack.args["provider"] = provider;
+    }
+  }
+  try {
+    await agencyStore.run({
+      ...getRuntimeContext(),
+      ctx: __ctx,
+      stack: __setupData.stateStack,
+      threads: __setupData.threads
+    }, async () => {
+      await runner.hook(0, async () => {
+        await callHook({
+          name: "onFunctionStart",
+          data: {
+            functionName: "resolveDetected",
+            args: {
+              model,
+              fast,
+              slow,
+              provider
+            },
+            isBuiltin: false,
+            moduleId: "dist/lib/agents/agency-agent/lib/models.agency"
+          }
+        });
+      });
+      await runner.step(1, async (runner2) => {
+        __stack.locals.needFast = __stack.args.fast === `` && __stack.args.model === ``;
+      });
+      await runner.step(2, async (runner2) => {
+        __stack.locals.needSlow = __stack.args.slow === `` && __stack.args.model === ``;
+      });
+      await runner.ifElse(3, [
+        {
+          condition: async () => __stack.args.provider !== ``,
+          body: async (runner2) => {
+            await runner2.ifElse(0, [
+              {
+                condition: async () => __readStatic(MODELS, "MODELS", "dist/lib/agents/agency-agent/lib/models.agency")[__stack.args.provider] === void 0,
+                body: async (runner3) => {
+                  await runner3.step(0, async (runner4) => {
+                  });
+                  await runner3.ifElse(1, [
+                    {
+                      condition: async () => __stack.locals.needFast || __stack.locals.needSlow,
+                      body: async (runner4) => {
+                        await runner4.step(0, async (runner5) => {
+                          __stack.locals.known = await __callMethod(Object, "keys", {
+                            type: "positional",
+                            args: [__readStatic(MODELS, "MODELS", "dist/lib/agents/agency-agent/lib/models.agency")]
+                          });
+                        });
+                        await runner4.step(1, async (runner5) => {
+                          __functionCompleted = true;
+                          runner5.halt(failure(`--provider ${__stack.args.provider} has no built-in defaults; also pass --model (or --fastmodel/--slowmodel). Providers with defaults: ${await __callMethod(__stack.locals.known, "join", {
+                            type: "positional",
+                            args: [`, `]
+                          })}.`, { checkpoint: getRuntimeContext().ctx.getResultCheckpoint(), functionName: "resolveDetected", args: __stack.args }));
+                          return;
+                        });
+                      }
+                    }
+                  ]);
+                  await runner3.step(2, async (runner4) => {
+                  });
+                  await runner3.step(3, async (runner4) => {
+                    __functionCompleted = true;
+                    runner4.halt(await success(__stack.args.provider));
+                    return;
+                  });
+                }
+              }
+            ]);
+            await runner2.step(1, async (runner3) => {
+            });
+            await runner2.step(2, async (runner3) => {
+              __self.__retryable = false;
+              __stack.locals.varName = await __call(envVarFor, {
+                type: "positional",
+                args: [__stack.args.provider]
+              });
+              if (hasInterrupts(__stack.locals.varName)) {
+                await getRuntimeContext().ctx.pendingPromises.awaitAll();
+                runner3.halt(__stack.locals.varName);
+                return;
+              }
+            });
+            await runner2.ifElse(3, [
+              {
+                condition: async () => __stack.locals.varName !== `` && (await __call(env, {
+                  type: "positional",
+                  args: [__stack.locals.varName]
+                }) === null || await __call(env, {
+                  type: "positional",
+                  args: [__stack.locals.varName]
+                }) === ``),
+                body: async (runner3) => {
+                  await runner3.step(0, async (runner4) => {
+                    __functionCompleted = true;
+                    runner4.halt(failure(`No API key for provider '${__stack.args.provider}'. Set ${__stack.locals.varName}.`, { checkpoint: getRuntimeContext().ctx.getResultCheckpoint(), functionName: "resolveDetected", args: __stack.args }));
+                    return;
+                  });
+                }
+              }
+            ]);
+            await runner2.step(4, async (runner3) => {
+              __functionCompleted = true;
+              runner3.halt(await success(__stack.args.provider));
+              return;
+            });
+          }
+        }
+      ]);
+      await runner.step(4, async (runner2) => {
+        __self.__retryable = false;
+      });
+      await runner.ifElse(5, [
+        {
+          condition: async () => __stack.locals.needFast || __stack.locals.needSlow,
+          body: async (runner2) => {
+            await runner2.step(0, async (runner3) => {
+              __self.__retryable = false;
+              __functionCompleted = true;
+              runner3.halt(await __call(pickProvider, {
+                type: "positional",
+                args: []
+              }));
+              return;
+            });
+          }
+        }
+      ]);
+      await runner.step(6, async (runner2) => {
+        __self.__retryable = false;
+      });
+      await runner.step(7, async (runner2) => {
+        __functionCompleted = true;
+        runner2.halt(await success(`openai`));
+        return;
+      });
+    });
+    if (runner.halted) {
+      if (isFailure(runner.haltResult)) {
+        runner.haltResult.retryable = runner.haltResult.retryable && __self.__retryable;
+      }
+      return runner.haltResult;
+    }
+  } catch (__error) {
+    if (__error instanceof RestoreSignal) {
+      throw __error;
+    }
+    if (__error instanceof AgencyAbort) {
+      throw __error;
+    }
+    {
+      const __errMsg = __error instanceof Error ? __error.message : String(__error);
+      const __errStack = __error instanceof Error && __error.stack ? __error.stack : "";
+      const __log = __createLogger(__ctx.logLevel);
+      __log.error("Function resolveDetected threw an exception (converted to Failure): " + __errMsg);
+      if (__errStack) __log.error(__errStack);
+      __ctx.statelogClient?.error?.({
+        errorType: "runtimeError",
+        message: __errMsg,
+        functionName: "resolveDetected",
+        retryable: __self.__retryable
+      });
+    }
+    return failure(
+      __error instanceof Error ? __error.message : String(__error),
+      {
+        checkpoint: getRuntimeContext().ctx.getResultCheckpoint(),
+        retryable: __self.__retryable,
+        functionName: "resolveDetected",
+        args: __stack.args
+      }
+    );
+  } finally {
+    __stateStack()?.pop();
+    if (__functionCompleted) {
+      await callHook({
+        name: "onFunctionEnd",
+        data: {
+          functionName: "resolveDetected",
+          timeTaken: performance.now() - __funcStartTime
+        }
+      });
+    }
+  }
+}
+const resolveDetected = __AgencyFunction.create({
+  name: "resolveDetected",
+  module: "dist/lib/agents/agency-agent/lib/models.agency",
+  fn: __resolveDetected_impl,
+  params: [{
+    name: "model",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "fast",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "slow",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "provider",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }],
+  toolDefinition: {
+    name: "resolveDetected",
+    description: "No description provided.",
+    schema: z.object({ "model": z.string(), "fast": z.string(), "slow": z.string(), "provider": z.string() })
+  },
+  safe: false,
+  exported: true
+}, __toolRegistry);
+async function __planModels_impl(model, fast, slow, provider, detected) {
+  const __setupData = setupFunction();
+  const __stack = __setupData.stack;
+  const __step = __setupData.step;
+  const __self = __setupData.self;
+  const __ctx = getRuntimeContext().ctx;
+  let __forked;
+  let __functionCompleted = false;
+  if (!__globals().isInitialized("dist/lib/agents/agency-agent/lib/models.agency")) {
+    await __initializeGlobals(__ctx);
+  }
+  let __funcStartTime = performance.now();
+  __stack.args["model"] = model;
+  __stack.args["fast"] = fast;
+  __stack.args["slow"] = slow;
+  __stack.args["provider"] = provider;
+  __stack.args["detected"] = detected;
+  __self.__retryable = __self.__retryable ?? true;
+  const runner = new Runner(__ctx, __stack, { state: __stack, moduleId: "dist/lib/agents/agency-agent/lib/models.agency", scopeName: "planModels", threads: __setupData.threads });
+  let __resultCheckpointId = -1;
+  if (__ctx._pendingArgOverrides) {
+    const __overrides = __ctx._pendingArgOverrides;
+    __ctx._pendingArgOverrides = void 0;
+    if ("model" in __overrides) {
+      model = __overrides["model"];
+      __stack.args["model"] = model;
+    }
+    if ("fast" in __overrides) {
+      fast = __overrides["fast"];
+      __stack.args["fast"] = fast;
+    }
+    if ("slow" in __overrides) {
+      slow = __overrides["slow"];
+      __stack.args["slow"] = slow;
+    }
+    if ("provider" in __overrides) {
+      provider = __overrides["provider"];
+      __stack.args["provider"] = provider;
+    }
+    if ("detected" in __overrides) {
+      detected = __overrides["detected"];
+      __stack.args["detected"] = detected;
+    }
+  }
+  try {
+    await agencyStore.run({
+      ...getRuntimeContext(),
+      ctx: __ctx,
+      stack: __setupData.stateStack,
+      threads: __setupData.threads
+    }, async () => {
+      await runner.hook(0, async () => {
+        await callHook({
+          name: "onFunctionStart",
+          data: {
+            functionName: "planModels",
+            args: {
+              model,
+              fast,
+              slow,
+              provider,
+              detected
+            },
+            isBuiltin: false,
+            moduleId: "dist/lib/agents/agency-agent/lib/models.agency"
+          }
+        });
+      });
+      await runner.step(1, async (runner2) => {
+        __stack.locals.fastModel = __stack.args.fast;
+      });
+      await runner.ifElse(2, [
+        {
+          condition: async () => __stack.locals.fastModel === ``,
+          body: async (runner2) => {
+            await runner2.ifElse(0, [
+              {
+                condition: async () => __stack.args.model !== ``,
+                body: async (runner3) => {
+                  await runner3.step(0, async (runner4) => {
+                    __stack.locals.fastModel = __stack.args.model;
+                  });
+                }
+              }
+            ], async (runner3) => {
+              await runner3.step(1, async (runner4) => {
+                __stack.locals.fastModel = __readStatic(MODELS, "MODELS", "dist/lib/agents/agency-agent/lib/models.agency")[__stack.args.detected].fast;
+              });
+            });
+          }
+        }
+      ]);
+      await runner.step(3, async (runner2) => {
+        __stack.locals.slowModel = ``;
+      });
+      await runner.step(4, async (runner2) => {
+        __stack.locals.slowProvider = ``;
+      });
+      await runner.ifElse(5, [
+        {
+          condition: async () => __stack.args.slow !== ``,
+          body: async (runner2) => {
+            await runner2.step(0, async (runner3) => {
+              __stack.locals.slowModel = __stack.args.slow;
+            });
+            await runner2.step(1, async (runner3) => {
+              __stack.locals.slowProvider = __stack.args.provider;
+            });
+          }
+        },
+        {
+          condition: async () => __stack.args.model !== ``,
+          body: async (runner2) => {
+            await runner2.step(2, async (runner3) => {
+              __stack.locals.slowModel = __stack.args.model;
+            });
+            await runner2.step(3, async (runner3) => {
+              __stack.locals.slowProvider = __stack.args.provider;
+            });
+          }
+        }
+      ], async (runner2) => {
+        await runner2.step(4, async (runner3) => {
+          __stack.locals.slowModel = __readStatic(MODELS, "MODELS", "dist/lib/agents/agency-agent/lib/models.agency")[__stack.args.detected].slow;
+        });
+        await runner2.step(5, async (runner3) => {
+          __stack.locals.slowProvider = __readStatic(MODELS, "MODELS", "dist/lib/agents/agency-agent/lib/models.agency")[__stack.args.detected].slowProvider;
+        });
+      });
+      await runner.step(6, async (runner2) => {
+        __functionCompleted = true;
+        runner2.halt({
+          "fastModel": __stack.locals.fastModel,
+          "fastProvider": __stack.args.provider,
+          "slowModel": __stack.locals.slowModel,
+          "slowProvider": __stack.locals.slowProvider
+        });
+        return;
+      });
+    });
+    if (runner.halted) {
+      if (isFailure(runner.haltResult)) {
+        runner.haltResult.retryable = runner.haltResult.retryable && __self.__retryable;
+      }
+      return runner.haltResult;
+    }
+  } catch (__error) {
+    if (__error instanceof RestoreSignal) {
+      throw __error;
+    }
+    if (__error instanceof AgencyAbort) {
+      throw __error;
+    }
+    {
+      const __errMsg = __error instanceof Error ? __error.message : String(__error);
+      const __errStack = __error instanceof Error && __error.stack ? __error.stack : "";
+      const __log = __createLogger(__ctx.logLevel);
+      __log.error("Function planModels threw an exception (converted to Failure): " + __errMsg);
+      if (__errStack) __log.error(__errStack);
+      __ctx.statelogClient?.error?.({
+        errorType: "runtimeError",
+        message: __errMsg,
+        functionName: "planModels",
+        retryable: __self.__retryable
+      });
+    }
+    return failure(
+      __error instanceof Error ? __error.message : String(__error),
+      {
+        checkpoint: getRuntimeContext().ctx.getResultCheckpoint(),
+        retryable: __self.__retryable,
+        functionName: "planModels",
+        args: __stack.args
+      }
+    );
+  } finally {
+    __stateStack()?.pop();
+    if (__functionCompleted) {
+      await callHook({
+        name: "onFunctionEnd",
+        data: {
+          functionName: "planModels",
+          timeTaken: performance.now() - __funcStartTime
+        }
+      });
+    }
+  }
+}
+const planModels = __AgencyFunction.create({
+  name: "planModels",
+  module: "dist/lib/agents/agency-agent/lib/models.agency",
+  fn: __planModels_impl,
+  params: [{
+    name: "model",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "fast",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "slow",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "provider",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "detected",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }],
+  toolDefinition: {
+    name: "planModels",
+    description: "No description provided.",
+    schema: z.object({ "model": z.string(), "fast": z.string(), "slow": z.string(), "provider": z.string(), "detected": z.string() })
+  },
+  safe: false,
+  exported: true
+}, __toolRegistry);
+var stdin_default = graph;
+const __sourceMap = { "dist/lib/agents/agency-agent/lib/models.agency:resolveDetected": { "1": { "line": 77, "col": 2 }, "2": { "line": 78, "col": 2 }, "3": { "line": 80, "col": 2 }, "5": { "line": 101, "col": 2 }, "7": { "line": 105, "col": 2 }, "3.0.1.0": { "line": 84, "col": 8 }, "3.0.1.1": { "line": 85, "col": 8 }, "3.0.1": { "line": 83, "col": 6 }, "3.0.3": { "line": 90, "col": 6 }, "3.0": { "line": 81, "col": 4 }, "3.2": { "line": 94, "col": 4 }, "3.3.0": { "line": 96, "col": 6 }, "3.3": { "line": 95, "col": 4 }, "3.4": { "line": 98, "col": 4 }, "5.0": { "line": 102, "col": 4 } }, "dist/lib/agents/agency-agent/lib/models.agency:planModels": { "1": { "line": 125, "col": 2 }, "2": { "line": 126, "col": 2 }, "3": { "line": 134, "col": 2 }, "4": { "line": 135, "col": 2 }, "5": { "line": 136, "col": 2 }, "6": { "line": 147, "col": 2 }, "2.0.0": { "line": 128, "col": 6 }, "2.0.1": { "line": 130, "col": 6 }, "2.0": { "line": 127, "col": 4 }, "5.0": { "line": 137, "col": 4 }, "5.1": { "line": 138, "col": 4 }, "5.2": { "line": 140, "col": 4 }, "5.3": { "line": 141, "col": 4 }, "5.4": { "line": 143, "col": 4 }, "5.5": { "line": 144, "col": 4 } } };
+export {
+  MODELS,
+  ModelPlan,
+  __getCheckpoints,
+  __invokeFunction,
+  __setDebugger,
+  __setLLMClient,
+  __setTraceFile,
+  __sourceMap,
+  __toolRegistry,
+  approve,
+  stdin_default as default,
+  hasInterrupts,
+  interrupt,
+  isDebugger,
+  isInterrupt,
+  planModels,
+  reject,
+  resolveDetected,
+  respondToInterrupts,
+  rewindFrom
+};