agency-lang 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,35 @@
+# Getting Started
+
+Agency is a language for building agents that compiles to TypeScript.
+
+## Installation
+
+```bash
+npm install agency-lang zod
+```
+
+## Quick Start
+
+Create a file called `hello.agency`:
+
+```ts
+node main() {
+  const greeting = llm("Say hello to the world!");
+  print(greeting);
+}
+```
+
+Compile and run it:
+
+```bash
+pnpm run agency hello.agency
+```
+
+Now read [the docs](https://agency-lang.com) to learn more about the language and how to use it!
+
+## Attributions
+
+Weather data in the standard library (`std::weather`) is provided by [Open-Meteo](https://open-meteo.com/). Data is licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). The free API is for non-commercial use only; commercial use requires a [paid subscription](https://open-meteo.com/en/pricing).
+
+## License
+[FSL](https://fsl.software).

package/dist/lib/agents/judge.js

@@ -0,0 +1,270 @@
+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 { 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,
+  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,
+  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: "dist/lib/agents/judge.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);
+async function __initializeGlobals(__ctx) {
+  __ctx.globals.markInitialized("dist/lib/agents/judge.agency");
+}
+__toolRegistry["readSkill"] = __AgencyFunction.create({
+  name: "readSkill",
+  module: "dist/lib/agents/judge.agency",
+  fn: readSkill,
+  params: __readSkillToolParams.map((p) => ({ name: p, hasDefault: false, defaultValue: void 0, variadic: false })),
+  toolDefinition: __readSkillTool
+}, __toolRegistry);
+__functionRefReviver.registry = __toolRegistry;
+const JudgeResult = z.object({ "score": z.number().describe("a score from 0 to 100 where 100 means perfect match"), "reasoning": z.string().describe("brief explanation for the score") });
+graph.node("judge", 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: "judge"
+    }
+  });
+  const runner = new Runner(__ctx, __stack, { nodeContext: true, state: __stack, moduleId: "dist/lib/agents/judge.agency", scopeName: "judge" });
+  if (!__state.isResume) {
+    __stack.args["actualOutput"] = __state.data.actualOutput;
+    __stack.args["expectedOutput"] = __state.data.expectedOutput;
+    __stack.args["judgePrompt"] = __state.data.judgePrompt;
+  }
+  try {
+    await runner.step(0, async (runner2) => {
+      __self.__removedTools = __self.__removedTools || [];
+      __stack.locals.result = await runPrompt({
+        ctx: __ctx,
+        prompt: `You are an evaluation judge. Score how well the actual output matches what was expected.
+
+Judge prompt (evaluation criteria): ${__stack.args.judgePrompt}
+
+Expected output: ${__stack.args.expectedOutput}
+
+Actual output: ${__stack.args.actualOutput}
+
+Provide a score from 0 to 100 where 100 means perfect match and 0 means completely wrong. Also provide brief reasoning.`,
+        messages: __threads.getOrCreateActive(),
+        responseFormat: z.object({
+          response: JudgeResult
+        }),
+        clientConfig: {},
+        maxToolCallRounds: 10,
+        stateStack: __stateStack,
+        removedTools: __self.__removedTools,
+        checkpointInfo: runner2.getCheckpointInfo()
+      });
+      if (hasInterrupts(__stack.locals.result)) {
+        await __ctx.pendingPromises.awaitAll();
+        runner2.halt({
+          messages: __threads,
+          data: __stack.locals.result
+        });
+        return;
+      }
+    });
+    await runner.step(1, async (runner2) => {
+      runner2.halt({
+        messages: __threads,
+        data: __stack.locals.result
+      });
+      return;
+    });
+    if (runner.halted) return runner.haltResult;
+    await callHook({
+      callbacks: __ctx.callbacks,
+      name: "onNodeEnd",
+      data: {
+        nodeName: "judge",
+        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: "judge" })
+    };
+  }
+});
+async function judge(actualOutput, expectedOutput, judgePrompt, { messages, callbacks } = {}) {
+  return runNode({
+    ctx: __globalCtx,
+    nodeName: "judge",
+    data: {
+      actualOutput,
+      expectedOutput,
+      judgePrompt
+    },
+    messages,
+    callbacks,
+    initializeGlobals: __initializeGlobals
+  });
+}
+const __judgeNodeParams = ["actualOutput", "expectedOutput", "judgePrompt"];
+var stdin_default = graph;
+const __sourceMap = { "dist/lib/agents/judge.agency:judge": { "0": { "line": 6, "col": 2 }, "1": { "line": 16, "col": 2 } } };
+export {
+  __getCheckpoints,
+  __judgeNodeParams,
+  __setDebugger,
+  __setLLMClient,
+  __setTraceWriter,
+  __sourceMap,
+  __toolRegistry,
+  approve,
+  stdin_default as default,
+  hasInterrupts,
+  interrupt,
+  isDebugger,
+  isInterrupt,
+  judge,
+  readSkill,
+  reject,
+  respondToInterrupts,
+  rewindFrom
+};

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

@@ -0,0 +1,77 @@
+import { writePolicyFile } from "std::policy"
+import { args } from "std::system"
+
+systemPrompt = read("./prompts/system.md")
+
+type NextStep = { type: "showPolicy"; policy: object } | { type: "writePolicy"; policy: object } | { type: "askQuestion"; question: string }
+
+node main() {
+  let cliArgs = args()
+  if (cliArgs.length < 2) {
+    print("Usage: agency policy gen <file>")
+    return end()
+  }
+  let interruptKindsJson = cliArgs[0]
+  let outputPath = cliArgs[1]
+  let existingPolicyJson = ""
+  if (cliArgs.length >= 3) {
+    existingPolicyJson = cliArgs[2]
+  }
+
+  let interruptKinds = parseJSON(interruptKindsJson)
+  let existingPolicy = null
+  if (existingPolicyJson != "") {
+    existingPolicy = parseJSON(existingPolicyJson)
+  }
+
+  let contextMessage = "This agent can produce the following interrupts:\n"
+  for (kind in interruptKinds) {
+    contextMessage = contextMessage + "- ${kind}\n"
+  }
+
+  if (existingPolicy != null) {
+    contextMessage = contextMessage + """
+    Current policy:\n```json\n${printJSON(existingPolicy)}\n```\n\nWhat would you like to change?
+    """
+  } else {
+    contextMessage = contextMessage + "\nWhat actions would you like to allow?"
+  }
+
+  print(contextMessage)
+
+  let done = false
+  let policy = {}
+  let conversationHistory = contextMessage
+  while (!done) {
+    let userInput = input("> ")
+    conversationHistory = conversationHistory + "\nUser: ${userInput}"
+
+    thread {
+      system(systemPrompt)
+      let step: NextStep = llm("""
+      ${conversationHistory}\n\nCurrent policy: ${printJSON(policy)}\n\nDecide 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.
+      """)
+    }
+
+    if (step.type == "showPolicy") {
+      policy = step.policy
+      let policyStr = printJSON(policy)
+      print("\nProposed policy:\n```json\n${policyStr}\n```\n")
+      print("Does this look right? (say 'yes' to save, or describe changes)")
+      conversationHistory = conversationHistory + "\nAssistant: Here is the proposed policy:\n${policyStr}\nDoes this look right?"
+    } else if (step.type == "writePolicy") {
+      policy = step.policy
+      writePolicyFile(outputPath, policy)
+      print("\nPolicy written to ${outputPath}")
+      done = true
+    } else if (step.type == "askQuestion") {
+      print(step.question)
+      conversationHistory = conversationHistory + "\nAssistant: ${step.question}"
+    }
+  }
+  return end()
+}
+
+node end() {
+
+}

package/dist/lib/agents/policy/prompts/system.md

@@ -0,0 +1,39 @@
+You are a policy configuration assistant for Agency agents. Your job is to help users create interrupt policies that control what actions their agent can take autonomously.
+
+## What is a policy?
+
+A policy is a JSON object that maps interrupt kinds to ordered arrays of rules. When an agent tries to perform an action that produces an interrupt, the policy is checked. The first matching rule determines whether the action is approved or rejected.
+
+## Policy format
+
+```json
+{
+  "email::send": [
+    { "match": { "recipient": "*@company.com" }, "action": "approve" },
+    { "action": "reject" }
+  ]
+}
+```
+
+Each rule has:
+- `action`: either `"approve"` or `"reject"`
+- `match` (optional): an object where keys are interrupt data field names and values are glob patterns (using `*` for wildcards, `**` for path matching). If omitted, the rule is a catch-all.
+
+## Important rules
+
+- Rules are evaluated **in order** — the first match wins
+- Put specific rules **before** catch-all rules
+- If no rule matches an interrupt kind, the interrupt is **rejected** by default
+- Glob patterns use picomatch syntax: `*` matches anything except path separators, `**` matches anything including path separators
+
+## Your workflow
+
+1. You will be given a list of interrupt kinds that the agent can produce
+2. If an existing policy was provided, present it and ask what the user wants to change
+3. Otherwise, present the interrupt kinds and ask the user what they want to allow
+4. Build the policy based on the user's intent
+5. Show the complete policy JSON and ask for confirmation
+6. If the user approves, write the policy file using the writePolicyFile tool
+7. If the user wants changes, refine and show again
+
+Be concise. Don't over-explain the policy format unless the user asks. Focus on understanding what they want to allow or deny, then build the policy for them.