agency-lang 0.6.5 → 0.7.0

package/stdlib/messaging/sms.js

@@ -0,0 +1,429 @@
+import { print, printJSON, input, sleep, read, write, writeBinary, readBinary, range, callback, map, filter, exclude, find, findIndex, reduce, flatMap, every, some, count, sortBy, unique, groupBy } from "agency-lang/stdlib/index.js";
+import { _sendSms } from "agency-lang/stdlib-lib/sms.js";
+import { fileURLToPath } from "url";
+import __process from "process";
+import { readFileSync } from "fs";
+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,
+  isRejected,
+  isApproved,
+  interruptWithHandlers,
+  respondToInterrupts as _respondToInterrupts,
+  rewindFrom as _rewindFrom,
+  runExportedFunction as _runExportedFunction,
+  RestoreSignal,
+  AgencyAbort,
+  __registerGlobalsInit,
+  failure,
+  isFailure,
+  __tryCall,
+  AgencyFunction as __AgencyFunction,
+  UNSET as __UNSET,
+  __call,
+  __stateStack,
+  __globals,
+  getRuntimeContext,
+  agencyStore,
+  functionRefReviver as __functionRefReviver,
+  DeterministicClient as __DeterministicClient,
+  installFetchMock as __installFetchMock,
+  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: {
+    apiKey: {
+      openAi: __process.env["OPENAI_API_KEY"] || "",
+      google: __process.env["GEMINI_API_KEY"] || "",
+      anthropic: __process.env["ANTHROPIC_API_KEY"] || "",
+      openRouter: __process.env["OPENROUTER_API_KEY"] || "",
+      deepInfra: __process.env["DEEPINFRA_API_KEY"] || "",
+      liteLlm: __process.env["LITELLM_API_KEY"] || "",
+      openAiCompat: __process.env["OPENAI_COMPAT_API_KEY"] || ""
+    },
+    baseUrl: {
+      liteLlm: __process.env["LITELLM_BASE_URL"] || "",
+      openAiCompat: __process.env["OPENAI_COMPAT_BASE_URL"] || ""
+    },
+    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/messaging/sms.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))
+  );
+}
+if (__process.env.AGENCY_FETCH_MOCKS_FILE) {
+  __installFetchMock(JSON.parse(readFileSync(__process.env.AGENCY_FETCH_MOCKS_FILE, "utf-8")));
+}
+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 }, { name: "maxDepth", 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(input);
+__registerTool(sleep);
+__registerTool(read);
+__registerTool(write);
+__registerTool(writeBinary);
+__registerTool(readBinary);
+__registerTool(range);
+__registerTool(callback);
+__registerTool(map);
+__registerTool(filter);
+__registerTool(exclude);
+__registerTool(find);
+__registerTool(findIndex);
+__registerTool(reduce);
+__registerTool(flatMap);
+__registerTool(every);
+__registerTool(some);
+__registerTool(count);
+__registerTool(sortBy);
+__registerTool(unique);
+__registerTool(groupBy);
+async function __initializeGlobals(__ctx) {
+  if (__ctx.globals.isInitialized("stdlib/messaging/sms.agency")) {
+    return;
+  }
+  __ctx.globals.markInitialized("stdlib/messaging/sms.agency");
+}
+__registerGlobalsInit("stdlib/messaging/sms.agency", __initializeGlobals);
+async function __registerTopLevelCallbacks(__ctx) {
+  __ctx.topLevelCallbacks = [];
+}
+__functionRefReviver.registry = __toolRegistry;
+const SmsResult = z.object({ "sid": z.string(), "status": z.string() });
+async function __sendSms_impl(to, body, from = __UNSET, accountSid = __UNSET, authToken = __UNSET, allowList = __UNSET, blockList = __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 (!__globals().isInitialized("stdlib/messaging/sms.agency")) {
+    await __initializeGlobals(__ctx);
+  }
+  let __funcStartTime = performance.now();
+  __stack.args["to"] = to;
+  __stack.args["body"] = body;
+  __stack.args["from"] = from === __UNSET ? `` : from;
+  __stack.args["accountSid"] = accountSid === __UNSET ? `` : accountSid;
+  __stack.args["authToken"] = authToken === __UNSET ? `` : authToken;
+  __stack.args["allowList"] = allowList === __UNSET ? [] : allowList;
+  __stack.args["blockList"] = blockList === __UNSET ? [] : blockList;
+  __self.__retryable = __self.__retryable ?? true;
+  const runner = new Runner(__ctx, __stack, { state: __stack, moduleId: "stdlib/messaging/sms.agency", scopeName: "sendSms", threads: __setupData.threads });
+  let __resultCheckpointId = -1;
+  if (__ctx._pendingArgOverrides) {
+    const __overrides = __ctx._pendingArgOverrides;
+    __ctx._pendingArgOverrides = void 0;
+    if ("to" in __overrides) {
+      to = __overrides["to"];
+      __stack.args["to"] = to;
+    }
+    if ("body" in __overrides) {
+      body = __overrides["body"];
+      __stack.args["body"] = body;
+    }
+    if ("from" in __overrides) {
+      from = __overrides["from"];
+      __stack.args["from"] = from;
+    }
+    if ("accountSid" in __overrides) {
+      accountSid = __overrides["accountSid"];
+      __stack.args["accountSid"] = accountSid;
+    }
+    if ("authToken" in __overrides) {
+      authToken = __overrides["authToken"];
+      __stack.args["authToken"] = authToken;
+    }
+    if ("allowList" in __overrides) {
+      allowList = __overrides["allowList"];
+      __stack.args["allowList"] = allowList;
+    }
+    if ("blockList" in __overrides) {
+      blockList = __overrides["blockList"];
+      __stack.args["blockList"] = blockList;
+    }
+  }
+  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: "sendSms",
+            args: {
+              to,
+              body,
+              from,
+              accountSid,
+              authToken,
+              allowList,
+              blockList
+            },
+            moduleId: "stdlib/messaging/sms.agency"
+          }
+        });
+      });
+      await runner.step(1, async (runner2) => {
+        const __response = getRuntimeContext().ctx.getInterruptResponse(__self.__interruptId_1);
+        if (__response) {
+          if (__response.type === "approve") {
+          } else if (__response.type === "reject") {
+            runner2.halt(failure("interrupt rejected", { retryable: false, checkpoint: getRuntimeContext().ctx.getResultCheckpoint() }));
+            return;
+          }
+        } else {
+          const __handlerResult = await interruptWithHandlers("std::sendSms", `Are you sure you want to send this SMS?`, {
+            "to": __stack.args.to
+          }, "std::messaging/sms", __ctx, __stateStack());
+          if (isRejected(__handlerResult)) {
+            runner2.halt(failure(__handlerResult.value ?? "interrupt rejected", { retryable: false, checkpoint: getRuntimeContext().ctx.checkpoints.get(__resultCheckpointId) }));
+            return;
+          }
+          if (!isApproved(__handlerResult)) {
+            __self.__interruptId_1 = __handlerResult[0].interruptId;
+            const __checkpointId = getRuntimeContext().ctx.checkpoints.create(__stateStack(), __ctx, { moduleId: "stdlib/messaging/sms.agency", scopeName: "sendSms", stepPath: "1" });
+            __handlerResult[0].checkpointId = __checkpointId;
+            __handlerResult[0].checkpoint = getRuntimeContext().ctx.checkpoints.get(__checkpointId);
+            runner2.halt(__handlerResult);
+            return;
+          }
+        }
+      });
+      await runner.step(2, async (runner2) => {
+        __functionCompleted = true;
+        runner2.halt(await __tryCall(async () => await __call(_sendSms, {
+          type: "positional",
+          args: [__stack.args.to, __stack.args.body, {
+            "from": __stack.args.from,
+            "accountSid": __stack.args.accountSid,
+            "authToken": __stack.args.authToken,
+            "allowList": __stack.args.allowList,
+            "blockList": __stack.args.blockList
+          }]
+        }), {
+          checkpoint: getRuntimeContext().ctx.getResultCheckpoint(),
+          functionName: "sendSms",
+          args: __stack.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 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 sendSms threw an exception (converted to Failure): " + __errMsg);
+      if (__errStack) __log.error(__errStack);
+      __ctx.statelogClient?.error?.({
+        errorType: "runtimeError",
+        message: __errMsg,
+        functionName: "sendSms",
+        retryable: __self.__retryable
+      });
+    }
+    return failure(
+      __error instanceof Error ? __error.message : String(__error),
+      {
+        checkpoint: getRuntimeContext().ctx.getResultCheckpoint(),
+        retryable: __self.__retryable,
+        functionName: "sendSms",
+        args: __stack.args
+      }
+    );
+  } finally {
+    __stateStack()?.pop();
+    if (__functionCompleted) {
+      await callHook({
+        name: "onFunctionEnd",
+        data: {
+          functionName: "sendSms",
+          timeTaken: performance.now() - __funcStartTime
+        }
+      });
+    }
+  }
+}
+const sendSms = __AgencyFunction.create({
+  name: "sendSms",
+  module: "stdlib/messaging/sms.agency",
+  fn: __sendSms_impl,
+  params: [{
+    name: "to",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "body",
+    hasDefault: false,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "from",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "accountSid",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "authToken",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "allowList",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }, {
+    name: "blockList",
+    hasDefault: true,
+    defaultValue: void 0,
+    variadic: false,
+    isFunctionTyped: false
+  }],
+  toolDefinition: {
+    name: "sendSms",
+    description: `Send an SMS text message via the Twilio API.
+
+  @param to - Recipient phone number (E.164 format)
+  @param body - Message text
+  @param from - Sender phone number
+  @param accountSid - Twilio account SID
+  @param authToken - Twilio auth token
+  @param allowList - Only allow sending to these numbers
+  @param blockList - Block sending to these numbers`,
+    schema: z.object({ "to": z.string(), "body": z.string(), "from": z.string().nullable().describe("Default: "), "accountSid": z.string().nullable().describe("Default: "), "authToken": z.string().nullable().describe("Default: "), "allowList": z.array(z.string()).nullable().describe("Default: []"), "blockList": z.array(z.string()).nullable().describe("Default: []") })
+  },
+  safe: false,
+  exported: true
+}, __toolRegistry);
+var stdin_default = graph;
+const __sourceMap = { "stdlib/messaging/sms.agency:sendSms": { "1": { "line": 37, "col": 2 }, "2": { "line": 41, "col": 2 } } };
+export {
+  __getCheckpoints,
+  __invokeFunction,
+  __setDebugger,
+  __setLLMClient,
+  __setTraceFile,
+  __sourceMap,
+  __toolRegistry,
+  approve,
+  stdin_default as default,
+  hasInterrupts,
+  interrupt,
+  isDebugger,
+  isInterrupt,
+  reject,
+  respondToInterrupts,
+  rewindFrom,
+  sendSms
+};

package/stdlib/oauth.js

@@ -56,9 +56,19 @@ const __globalCtx = new RuntimeContext({
     logFile: "log.jsonl"
   },
   smoltalkDefaults: {
-    openAiApiKey: __process.env["OPENAI_API_KEY"] || "",
-    googleApiKey: __process.env["GEMINI_API_KEY"] || "",
-    anthropicApiKey: __process.env["ANTHROPIC_API_KEY"] || "",
+    apiKey: {
+      openAi: __process.env["OPENAI_API_KEY"] || "",
+      google: __process.env["GEMINI_API_KEY"] || "",
+      anthropic: __process.env["ANTHROPIC_API_KEY"] || "",
+      openRouter: __process.env["OPENROUTER_API_KEY"] || "",
+      deepInfra: __process.env["DEEPINFRA_API_KEY"] || "",
+      liteLlm: __process.env["LITELLM_API_KEY"] || "",
+      openAiCompat: __process.env["OPENAI_COMPAT_API_KEY"] || ""
+    },
+    baseUrl: {
+      liteLlm: __process.env["LITELLM_BASE_URL"] || "",
+      openAiCompat: __process.env["OPENAI_COMPAT_BASE_URL"] || ""
+    },
     model: "gpt-4o-mini",
     logLevel: "warn",
     statelog: {

package/stdlib/object.agency

@@ -1,6 +1,53 @@
+/** @module
+Helpers for working with objects: read their keys, values, and entries,
+and transform them with `mapValues`, `mapEntries`, and `filterEntries`.
+
+```ts
+import { keys, mapValues } from "std::object"
+
+node main() {
+  const scores = { alice: 1, bob: 2 }
+  print(keys(scores))   // ["alice", "bob"]
+
+  const scaled = mapValues(scores) as (value, key) {
+    return value * 10
+  }
+  print(scaled)         // { alice: 10, bob: 20 }
+}
+```
+*/
+import { _keys, _values, _entries } from "agency-lang/stdlib-lib/builtins.js"
+
+export safe def keys(obj: any): string[] {
+  """
+  Return an array of an object's own enumerable property names.
+
+  @param obj - The object
+  """
+  return _keys(obj)
+}
+
+export safe def values(obj: any): any[] {
+  """
+  Return an array of an object's own enumerable property values.
+
+  @param obj - The object
+  """
+  return _values(obj)
+}
+
+export safe def entries(obj: any): any[] {
+  """
+  Return an array of an object's own enumerable entries, each as { key, value }.
+
+  @param obj - The object
+  """
+  return _entries(obj)
+}
+
 export def mapValues(obj: any, func: (any, string) -> any): any {
   """
-  Return a new object with the same keys, but with each value transformed by the function. The function receives (value, key).
+  Return a new object with the same keys, but with each value transformed by the function.
 
   @param obj - The object to transform
   @param func - The function receiving (value, key)
@@ -14,7 +61,7 @@ export def mapValues(obj: any, func: (any, string) -> any): any {
 
 export def mapEntries(obj: any, func: (any, string) -> any): any {
   """
-  Return a new object by applying the function to each entry. The function receives (value, key) and should return { key, value }.
+  Return a new object by applying the function to each entry.
 
   @param obj - The object to transform
   @param func - The function receiving (value, key) returning {key, value}
@@ -29,7 +76,7 @@ export def mapEntries(obj: any, func: (any, string) -> any): any {
 
 export def filterEntries(obj: any, func: (any, string) -> boolean): any {
   """
-  Return a new object containing only the entries for which the function returns true. The function receives (value, key).
+  Return a new object containing only the entries for which the function returns true.
 
   @param obj - The object to filter
   @param func - The predicate receiving (value, key)
@@ -45,7 +92,7 @@ export def filterEntries(obj: any, func: (any, string) -> boolean): any {
 
 export def everyEntry(obj: any, func: (any, string) -> boolean): boolean {
   """
-  Return true if the function returns true for every entry in the object. The function receives (value, key).
+  Return true if the function returns true for every entry in the object.
 
   @param obj - The object to test
   @param func - The predicate receiving (value, key)
@@ -60,7 +107,7 @@ export def everyEntry(obj: any, func: (any, string) -> boolean): boolean {
 
 export def someEntry(obj: any, func: (any, string) -> boolean): boolean {
   """
-  Return true if the function returns true for at least one entry in the object. The function receives (value, key).
+  Return true if the function returns true for at least one entry in the object.
 
   @param obj - The object to test
   @param func - The predicate receiving (value, key)