agency-lang 0.2.0 → 0.4.0

package/stdlib/cli.js

@@ -0,0 +1,718 @@
+import { pushMessage as _reexport_pushMessage, clearMessages as _reexport_clearMessages } from "agency-lang/stdlib/ui.js";
+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 { _runLineRepl } from "agency-lang/stdlib-lib/cli.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,
+  RestoreSignal,
+  GuardExceededError,
+  __registerGlobalsInit,
+  failure,
+  isFailure,
+  AgencyFunction as __AgencyFunction,
+  UNSET as __UNSET,
+  __call,
+  __stateStack,
+  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: "statelog.log"
+  },
+  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,
+  logLevel: "info",
+  traceConfig: {
+    program: "stdlib/cli.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 __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 }], 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(_reexport_pushMessage);
+__registerTool(_reexport_clearMessages);
+__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);
+async function __initializeGlobals(__ctx) {
+  if (__ctx.globals.isInitialized("stdlib/cli.agency")) {
+    return;
+  }
+  __ctx.globals.markInitialized("stdlib/cli.agency");
+}
+__registerGlobalsInit("stdlib/cli.agency", __initializeGlobals);
+async function __registerTopLevelCallbacks(__ctx) {
+  __ctx.topLevelCallbacks = [];
+}
+__functionRefReviver.registry = __toolRegistry;
+async function __pushMessage_impl(message) {
+  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 (!__ctx.globals.isInitialized("stdlib/cli.agency")) {
+    await __initializeGlobals(__ctx);
+  }
+  let __funcStartTime = performance.now();
+  __stack.args["message"] = message;
+  __self.__retryable = __self.__retryable ?? true;
+  const runner = new Runner(__ctx, __stack, { state: __stack, moduleId: "stdlib/cli.agency", scopeName: "pushMessage", threads: __setupData.threads });
+  let __resultCheckpointId = -1;
+  if (__ctx._pendingArgOverrides) {
+    const __overrides = __ctx._pendingArgOverrides;
+    __ctx._pendingArgOverrides = void 0;
+    if ("message" in __overrides) {
+      message = __overrides["message"];
+      __stack.args["message"] = message;
+    }
+  }
+  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: "pushMessage",
+            args: {
+              message
+            },
+            isBuiltin: false,
+            moduleId: "stdlib/cli.agency"
+          }
+        });
+      });
+      await runner.step(1, async (runner2) => {
+        __self.__retryable = false;
+        __functionCompleted = true;
+        runner2.halt(await __call(_reexport_pushMessage, {
+          type: "positional",
+          args: [__stack.args.message]
+        }));
+        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 GuardExceededError) {
+      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 pushMessage threw an exception (converted to Failure): " + __errMsg);
+      if (__errStack) __log.error(__errStack);
+      __ctx.statelogClient?.error?.({
+        errorType: "runtimeError",
+        message: __errMsg,
+        functionName: "pushMessage",
+        retryable: __self.__retryable
+      });
+    }
+    return failure(
+      __error instanceof Error ? __error.message : String(__error),
+      {
+        checkpoint: getRuntimeContext().ctx.getResultCheckpoint(),
+        retryable: __self.__retryable,
+        functionName: "pushMessage",
+        args: __stack.args
+      }
+    );
+  } finally {
+    __stateStack()?.pop();
+    if (__functionCompleted) {
+      await callHook({
+        name: "onFunctionEnd",
+        data: {
+          functionName: "pushMessage",
+          timeTaken: performance.now() - __funcStartTime
+        }
+      });
+    }
+  }
+}
+const pushMessage = __AgencyFunction.create({
+  name: "pushMessage",
+  module: "stdlib/cli.agency",
+  fn: __pushMessage_impl,
+  params: [{
+    name: "message",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false
+  }],
+  toolDefinition: {
+    name: "pushMessage",
+    description: "No description provided.",
+    schema: z.object({ "message": z.string() })
+  },
+  safe: false,
+  exported: true
+}, __toolRegistry);
+async function __clearMessages_impl() {
+  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 (!__ctx.globals.isInitialized("stdlib/cli.agency")) {
+    await __initializeGlobals(__ctx);
+  }
+  let __funcStartTime = performance.now();
+  __self.__retryable = __self.__retryable ?? true;
+  const runner = new Runner(__ctx, __stack, { state: __stack, moduleId: "stdlib/cli.agency", scopeName: "clearMessages", threads: __setupData.threads });
+  let __resultCheckpointId = -1;
+  if (__ctx._pendingArgOverrides) {
+    const __overrides = __ctx._pendingArgOverrides;
+    __ctx._pendingArgOverrides = void 0;
+  }
+  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: "clearMessages",
+            args: {},
+            isBuiltin: false,
+            moduleId: "stdlib/cli.agency"
+          }
+        });
+      });
+      await runner.step(1, async (runner2) => {
+        __self.__retryable = false;
+        __functionCompleted = true;
+        runner2.halt(await __call(_reexport_clearMessages, {
+          type: "positional",
+          args: []
+        }));
+        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 GuardExceededError) {
+      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 clearMessages threw an exception (converted to Failure): " + __errMsg);
+      if (__errStack) __log.error(__errStack);
+      __ctx.statelogClient?.error?.({
+        errorType: "runtimeError",
+        message: __errMsg,
+        functionName: "clearMessages",
+        retryable: __self.__retryable
+      });
+    }
+    return failure(
+      __error instanceof Error ? __error.message : String(__error),
+      {
+        checkpoint: getRuntimeContext().ctx.getResultCheckpoint(),
+        retryable: __self.__retryable,
+        functionName: "clearMessages",
+        args: __stack.args
+      }
+    );
+  } finally {
+    __stateStack()?.pop();
+    if (__functionCompleted) {
+      await callHook({
+        name: "onFunctionEnd",
+        data: {
+          functionName: "clearMessages",
+          timeTaken: performance.now() - __funcStartTime
+        }
+      });
+    }
+  }
+}
+const clearMessages = __AgencyFunction.create({
+  name: "clearMessages",
+  module: "stdlib/cli.agency",
+  fn: __clearMessages_impl,
+  params: [],
+  toolDefinition: {
+    name: "clearMessages",
+    description: "No description provided.",
+    schema: z.object({})
+  },
+  safe: false,
+  exported: true
+}, __toolRegistry);
+async function __repl_impl(status, onSubmit, prompt = __UNSET, historyFile = __UNSET, historyMax = __UNSET, paletteCommands = __UNSET) {
+  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 (!__ctx.globals.isInitialized("stdlib/cli.agency")) {
+    await __initializeGlobals(__ctx);
+  }
+  let __funcStartTime = performance.now();
+  __stack.args["status"] = status;
+  __stack.args["onSubmit"] = onSubmit;
+  __stack.args["prompt"] = prompt === __UNSET ? `> ` : prompt;
+  __stack.args["historyFile"] = historyFile === __UNSET ? `` : historyFile;
+  __stack.args["historyMax"] = historyMax === __UNSET ? 1e3 : historyMax;
+  __stack.args["paletteCommands"] = paletteCommands === __UNSET ? null : paletteCommands;
+  __self.__retryable = __self.__retryable ?? true;
+  const runner = new Runner(__ctx, __stack, { state: __stack, moduleId: "stdlib/cli.agency", scopeName: "repl", threads: __setupData.threads });
+  let __resultCheckpointId = -1;
+  if (__ctx._pendingArgOverrides) {
+    const __overrides = __ctx._pendingArgOverrides;
+    __ctx._pendingArgOverrides = void 0;
+    if ("status" in __overrides) {
+      status = __overrides["status"];
+      __stack.args["status"] = status;
+    }
+    if ("onSubmit" in __overrides) {
+      onSubmit = __overrides["onSubmit"];
+      __stack.args["onSubmit"] = onSubmit;
+    }
+    if ("prompt" in __overrides) {
+      prompt = __overrides["prompt"];
+      __stack.args["prompt"] = prompt;
+    }
+    if ("historyFile" in __overrides) {
+      historyFile = __overrides["historyFile"];
+      __stack.args["historyFile"] = historyFile;
+    }
+    if ("historyMax" in __overrides) {
+      historyMax = __overrides["historyMax"];
+      __stack.args["historyMax"] = historyMax;
+    }
+    if ("paletteCommands" in __overrides) {
+      paletteCommands = __overrides["paletteCommands"];
+      __stack.args["paletteCommands"] = paletteCommands;
+    }
+  }
+  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: "repl",
+            args: {
+              status,
+              onSubmit,
+              prompt,
+              historyFile,
+              historyMax,
+              paletteCommands
+            },
+            isBuiltin: false,
+            moduleId: "stdlib/cli.agency"
+          }
+        });
+      });
+      await runner.step(1, async (runner2) => {
+        __self.__retryable = false;
+        const __funcResult = await __call(_runLineRepl, {
+          type: "positional",
+          args: [__stack.args.status, __stack.args.onSubmit, __stack.args.prompt, __stack.args.historyFile, __stack.args.historyMax, __stack.args.paletteCommands]
+        });
+        if (hasInterrupts(__funcResult)) {
+          await getRuntimeContext().ctx.pendingPromises.awaitAll();
+          runner2.halt(__funcResult);
+          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 GuardExceededError) {
+      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 repl threw an exception (converted to Failure): " + __errMsg);
+      if (__errStack) __log.error(__errStack);
+      __ctx.statelogClient?.error?.({
+        errorType: "runtimeError",
+        message: __errMsg,
+        functionName: "repl",
+        retryable: __self.__retryable
+      });
+    }
+    return failure(
+      __error instanceof Error ? __error.message : String(__error),
+      {
+        checkpoint: getRuntimeContext().ctx.getResultCheckpoint(),
+        retryable: __self.__retryable,
+        functionName: "repl",
+        args: __stack.args
+      }
+    );
+  } finally {
+    __stateStack()?.pop();
+    if (__functionCompleted) {
+      await callHook({
+        name: "onFunctionEnd",
+        data: {
+          functionName: "repl",
+          timeTaken: performance.now() - __funcStartTime
+        }
+      });
+    }
+  }
+}
+const repl = __AgencyFunction.create({
+  name: "repl",
+  module: "stdlib/cli.agency",
+  fn: __repl_impl,
+  params: [{
+    name: "status",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false
+  }, {
+    name: "onSubmit",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false
+  }, {
+    name: "prompt",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false
+  }, {
+    name: "historyFile",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false
+  }, {
+    name: "historyMax",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false
+  }, {
+    name: "paletteCommands",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false
+  }],
+  toolDefinition: {
+    name: "repl",
+    description: `Line-mode REPL. Same call signature as \`std::ui.repl\` so swapping
+  modes is a one-line import change in the calling agent.
+
+  Per iteration: print \`prompt\`, await one line of input (via Node's
+  \`readline\` \u2014 full line editing, history, bracketed paste), call
+  \`onSubmit(line)\`. If \`onSubmit\` returns \`false\`, exit. If it
+  returns a non-empty string, print the string to stdout. Anything
+  else (e.g. the agent's \`_runTurn\` returning \`true\` after calling
+  \`pushMessage\`) is silently ignored \u2014 the reply already reached
+  stdout via the underlying \`print\` path.
+
+  Exits on \`onSubmit\` returning \`false\`, on Ctrl+D (EOF) at the
+  prompt, or on Ctrl+C at an idle prompt.
+
+  Round-one limitations (intentional, see the spec):
+  - \`status\` is accepted for signature parity but not yet rendered.
+  WL2 will turn it into a per-turn footer.
+  - \`paletteCommands\` is accepted but no tab completion yet (WL6).
+  - No spinner during the busy window (WL3).
+  - No Ctrl+C cancel of an in-flight turn (WL7).
+
+  @param status - Callback returning {left, right, context}; reserved
+  for the WL2 per-turn footer
+  @param onSubmit - Called with the submitted line; return \`false\` to
+  exit or a string to print
+  @param prompt - String shown before the input buffer (default "> ")
+  @param historyFile - Path to a newline-separated history file;
+  loaded at start and saved on exit. Empty string disables
+  persistence.
+  @param historyMax - Trim history to this many most-recent entries
+  @param paletteCommands - Map of /cmd -> description; reserved for
+  WL6 tab completion`,
+    schema: z.object({ "status": z.any(), "onSubmit": z.any(), "prompt": z.string().nullable().describe("Default: > "), "historyFile": z.string().nullable().describe("Default: "), "historyMax": z.number().nullable().describe("Default: 1000"), "paletteCommands": z.any().nullable().describe("Default: null") })
+  },
+  safe: false,
+  exported: true
+}, __toolRegistry);
+async function __clearScreen_impl() {
+  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 (!__ctx.globals.isInitialized("stdlib/cli.agency")) {
+    await __initializeGlobals(__ctx);
+  }
+  let __funcStartTime = performance.now();
+  __self.__retryable = __self.__retryable ?? true;
+  const runner = new Runner(__ctx, __stack, { state: __stack, moduleId: "stdlib/cli.agency", scopeName: "clearScreen", threads: __setupData.threads });
+  let __resultCheckpointId = -1;
+  if (__ctx._pendingArgOverrides) {
+    const __overrides = __ctx._pendingArgOverrides;
+    __ctx._pendingArgOverrides = void 0;
+  }
+  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: "clearScreen",
+            args: {},
+            isBuiltin: false,
+            moduleId: "stdlib/cli.agency"
+          }
+        });
+      });
+      await runner.step(1, async (runner2) => {
+      });
+      await runner.step(2, async (runner2) => {
+        const __funcResult = await __call(print, {
+          type: "positional",
+          args: [`\x1B[2J\x1B[H`]
+        });
+        if (hasInterrupts(__funcResult)) {
+          await getRuntimeContext().ctx.pendingPromises.awaitAll();
+          runner2.halt(__funcResult);
+          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 GuardExceededError) {
+      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 clearScreen threw an exception (converted to Failure): " + __errMsg);
+      if (__errStack) __log.error(__errStack);
+      __ctx.statelogClient?.error?.({
+        errorType: "runtimeError",
+        message: __errMsg,
+        functionName: "clearScreen",
+        retryable: __self.__retryable
+      });
+    }
+    return failure(
+      __error instanceof Error ? __error.message : String(__error),
+      {
+        checkpoint: getRuntimeContext().ctx.getResultCheckpoint(),
+        retryable: __self.__retryable,
+        functionName: "clearScreen",
+        args: __stack.args
+      }
+    );
+  } finally {
+    __stateStack()?.pop();
+    if (__functionCompleted) {
+      await callHook({
+        name: "onFunctionEnd",
+        data: {
+          functionName: "clearScreen",
+          timeTaken: performance.now() - __funcStartTime
+        }
+      });
+    }
+  }
+}
+const clearScreen = __AgencyFunction.create({
+  name: "clearScreen",
+  module: "stdlib/cli.agency",
+  fn: __clearScreen_impl,
+  params: [],
+  toolDefinition: {
+    name: "clearScreen",
+    description: "No description provided.",
+    schema: z.object({})
+  },
+  safe: false,
+  exported: true
+}, __toolRegistry);
+var stdin_default = graph;
+const __sourceMap = { "stdlib/cli.agency:pushMessage": { "1": { "line": 56, "col": 0 } }, "stdlib/cli.agency:clearMessages": { "1": { "line": 56, "col": 0 } }, "stdlib/cli.agency:repl": { "1": { "line": 100, "col": 2 } }, "stdlib/cli.agency:clearScreen": { "2": { "line": 112, "col": 2 } } };
+export {
+  __getCheckpoints,
+  __setDebugger,
+  __setLLMClient,
+  __setTraceFile,
+  __sourceMap,
+  __toolRegistry,
+  approve,
+  clearMessages,
+  clearScreen,
+  stdin_default as default,
+  hasInterrupts,
+  interrupt,
+  isDebugger,
+  isInterrupt,
+  pushMessage,
+  reject,
+  repl,
+  respondToInterrupts,
+  rewindFrom
+};