agency-lang 0.1.3 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aditya Bhargava
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -32,4 +32,4 @@ Now read [the docs](https://agency-lang.com) to learn more about the language an
 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).
+MIT. See [LICENSE](./LICENSE).

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

@@ -2,6 +2,7 @@ import { addTask, listTasks, markTaskDone } from "./subagents/task.agency"
 import { writeToPlan, readPlan } from "./subagents/plan.agency"
 import { writeCode, appendCode, readCode } from "./subagents/code.agency"
 import { syntaxHighlight } from "../../utils/agentUtils.js"
+import { systemMessage } from "std::thread"
 // todo allow this
 // import { Plan } from "./subagents/plan.agency"
 
@@ -124,7 +125,7 @@ node plan(mode, existingCode, existingFilename: string | null) {
     """
   }
   thread {
-    system("${systemPrompt}\n\n${planPrompt}${modeContext}")
+    systemMessage("${systemPrompt}\n\n${planPrompt}${modeContext}")
     userMsg = input("What would you like to accomplish today? ")
     nextAction: NextAction = { 
       type: "start"
@@ -176,7 +177,7 @@ node design(plan, mode, existingCode, existingFilename: string | null) {
     """
   }
   thread {
-    system(designPrompt)
+    systemMessage(designPrompt)
     userMsg = prompt
     nextAction: DesignAction = { 
       type: "start"

package/dist/lib/agents/judge.js

@@ -1,4 +1,4 @@
-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 { print, printJSON, parseJSON, input, sleep, round, read, write, readImage, notify, range, mostCommon, keys, values, entries, emit, callback } from "agency-lang/stdlib/index.js";
 import { fileURLToPath } from "url";
 import __process from "process";
 import { z } from "agency-lang/zod";
@@ -22,11 +22,12 @@ import {
   respondToInterrupts as _respondToInterrupts,
   rewindFrom as _rewindFrom,
   RestoreSignal,
+  GuardExceededError,
   failure,
-  readSkill as _readSkillRaw,
-  readSkillTool as __readSkillTool,
-  readSkillToolParams as __readSkillToolParams,
   AgencyFunction as __AgencyFunction,
+  __threads,
+  getRuntimeContext,
+  agencyStore,
   functionRefReviver as __functionRefReviver,
   DeterministicClient as __DeterministicClient
 } from "agency-lang/runtime";
@@ -39,7 +40,9 @@ const __globalCtx = new RuntimeContext({
     host: "https://statelog.adit.io",
     apiKey: __process.env["STATELOG_API_KEY"] || "",
     projectId: "agency-lang",
-    debugMode: false
+    debugMode: false,
+    observability: true,
+    logFile: "statelog.log"
   },
   smoltalkDefaults: {
     openAiApiKey: __process.env["OPENAI_API_KEY"] || "",
@@ -54,15 +57,13 @@ const __globalCtx = new RuntimeContext({
     }
   },
   dirname: __dirname,
+  logLevel: "info",
   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 };
 }
@@ -72,13 +73,13 @@ function 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 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 __setTraceWriter = (tw) => {
-  __globalCtx.traceWriter = tw;
+const __setTraceFile = (filePath) => {
+  __globalCtx.traceConfig.traceFile = filePath;
 };
 const __setLLMClient = (client) => {
   __globalCtx.setLLMClient(client);
@@ -111,11 +112,10 @@ function registerTools(tools) {
 }
 __registerTool(print);
 __registerTool(printJSON);
+__registerTool(parseJSON);
 __registerTool(input);
 __registerTool(sleep);
 __registerTool(round);
-__registerTool(fetch);
-__registerTool(fetchJSON);
 __registerTool(read);
 __registerTool(write);
 __registerTool(readImage);
@@ -126,51 +126,50 @@ __registerTool(keys);
 __registerTool(values);
 __registerTool(entries);
 __registerTool(emit);
+__registerTool(callback);
 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);
+async function __registerTopLevelCallbacks(__ctx) {
+  __ctx.topLevelCallbacks = [];
+}
 __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;
+  const __ctx = getRuntimeContext().ctx;
   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" });
+  const runner = new Runner(__ctx, __stack, { nodeContext: true, state: __stack, moduleId: "dist/lib/agents/judge.agency", scopeName: "judge", threads: __setupData.threads });
   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.
+    await agencyStore.run({
+      ...getRuntimeContext(),
+      ctx: __ctx,
+      stack: __ctx.stateStack,
+      threads: __setupData.threads
+    }, async () => {
+      await runner.hook(0, async () => {
+        await callHook({
+          name: "onNodeStart",
+          data: {
+            nodeName: "judge"
+          }
+        });
+      });
+      await runner.step(1, async (runner2) => {
+        __self.__removedTools = __self.__removedTools || [];
+        __stack.locals.result = await runPrompt({
+          prompt: `You are an evaluation judge. Score how well the actual output matches what was expected.
 
 Judge prompt (evaluation criteria): ${__stack.args.judgePrompt}
 
@@ -179,54 +178,58 @@ 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()
+          messages: __threads().getOrCreateActive(),
+          responseFormat: z.object({
+            response: JudgeResult
+          }),
+          clientConfig: {},
+          maxToolCallRounds: 10,
+          removedTools: __self.__removedTools,
+          checkpointInfo: runner2.getCheckpointInfo()
+        });
+        if (hasInterrupts(__stack.locals.result)) {
+          await getRuntimeContext().ctx.pendingPromises.awaitAll();
+          runner2.halt({
+            messages: __threads(),
+            data: __stack.locals.result
+          });
+          return;
+        }
       });
-      if (hasInterrupts(__stack.locals.result)) {
-        await __ctx.pendingPromises.awaitAll();
+      await runner.step(2, async (runner2) => {
         runner2.halt({
-          messages: __threads,
+          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
-      }
+    await runner.hook(3, async () => {
+      await callHook({
+        name: "onNodeEnd",
+        data: {
+          nodeName: "judge",
+          data: void 0
+        }
+      });
     });
     return {
-      messages: __threads,
+      messages: __threads(),
       data: void 0
     };
   } catch (__error) {
     if (__error instanceof RestoreSignal) {
       throw __error;
     }
+    if (__error instanceof GuardExceededError) {
+      throw __error;
+    }
     console.error(`
 Agent crashed: ${__error.message}`);
     console.error(__error.stack);
     return {
-      messages: __threads,
+      messages: __threads(),
       data: failure(__error instanceof Error ? __error.message : String(__error), { functionName: "judge" })
     };
   }
@@ -242,18 +245,20 @@ async function judge(actualOutput, expectedOutput, judgePrompt, { messages, call
     },
     messages,
     callbacks,
-    initializeGlobals: __initializeGlobals
+    initializeGlobals: __initializeGlobals,
+    registerTopLevelCallbacks: __registerTopLevelCallbacks,
+    moduleDir: __dirname
   });
 }
 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 } } };
+const __sourceMap = { "dist/lib/agents/judge.agency:judge": { "1": { "line": 6, "col": 2 }, "2": { "line": 16, "col": 2 } } };
 export {
   __getCheckpoints,
   __judgeNodeParams,
   __setDebugger,
   __setLLMClient,
-  __setTraceWriter,
+  __setTraceFile,
   __sourceMap,
   __toolRegistry,
   approve,
@@ -263,7 +268,6 @@ export {
   isDebugger,
   isInterrupt,
   judge,
-  readSkill,
   reject,
   respondToInterrupts,
   rewindFrom

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

@@ -1,77 +1,185 @@
-import { writePolicyFile } from "std::policy"
+import { map } from "std::array"
+import {
+  writePolicyFile,
+  Policy,
+  InterruptKind,
+  InterruptDataKey,
+  InterruptDataVal,
+ } from "std::policy"
+import { highlight } from "std::syntax"
 import { args } from "std::system"
+import { systemMessage, userMessage, assistantMessage } from "std::thread"
 
-systemPrompt = read("./prompts/system.md")
+callback("onToolCallStart") as data {
+  print("Calling ${data.toolName}...")
+}
+
+callback("onToolCallEnd") as data {
+  print("Finished calling ${data.toolName}.")
+}
+
+systemPrompt = read("system.md", "./prompts") with approve
+
+type Question = {
+  type: "askQuestion";
+  question: string
+}
+
+type Done = {
+  type: "done"
+}
+
+type Action = Question | Done
+
+type PolicyAction = "approve" | "reject" | "propagate"
+
+let currentPolicy: Policy = {}
+
+def addToPolicy(
+  interruptKind: InterruptKind,
+  matchArgName: InterruptDataKey,
+  matchArgValue: InterruptDataVal,
+  action: PolicyAction!,
+): Result<Policy> {
+  """
+  Add a rule to the current policy for the given interrupt kind, matching on the specified argument and value, with the specified action.
+  Use only "approve", "reject", or "propagate" as the action. DO NOT use "allow" or "deny".
+  Returns the current policy after adding the rule.
+  """
+  const match = {
+    [matchArgName]: matchArgValue
+  }
+  if (!currentPolicy[interruptKind]) {
+    currentPolicy[interruptKind] = []
+  }
+  currentPolicy[interruptKind].push({
+    match: match,
+    action: action
+  })
+
+  return success(currentPolicy)
+}
+
+def getPolicy(): Policy {
+  """
+  Get the current policy object.
+  """
+  return currentPolicy
+}
+
+def setPolicy(newPolicy: Policy): Policy {
+  """
+  Replace the current policy with a new policy object. Returns the new policy.
+
+  @param newPolicy - The new policy object to set as the current policy.
+  """
+  currentPolicy = newPolicy
+  return currentPolicy
+}
+
+def deleteFromPolicy(interruptKind: InterruptKind, index: number): boolean {
+  """
+  Delete the rule at the specified index for the given interrupt kind from the current policy.
+  Returns true if the rule was successfully deleted, or false if the index was out of bounds.
+  """
+  if (currentPolicy[interruptKind] && index < currentPolicy[interruptKind].length) {
+    currentPolicy[interruptKind].splice(index, 1)
+    return true
+  }
+  return false
+}
+
+def savePolicy(path: string) {
+  """
+  Validate and save the current policy to a JSON file.
+
+  @param path - The file path where the policy should be saved.
+  """
+  return writePolicyFile(path, currentPolicy)
+}
+
+def get(array: any[], index: number) {
+  if (index < array.length) {
+    return success(array[index])
+  }
+  return failure("Index out of bounds: ${index} >= ${array.length}")
+}
 
-type NextStep = { type: "showPolicy"; policy: object } | { type: "writePolicy"; policy: object } | { type: "askQuestion"; question: string }
+def highlightJSON(obj: Record<string, any>): string {
+  return highlight(JSON.stringify(obj, null, 2), "json")
+}
 
 node main() {
-  let cliArgs = args()
+  const 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]
+    return
   }
 
-  let interruptKinds = parseJSON(interruptKindsJson)
-  let existingPolicy = null
-  if (existingPolicyJson != "") {
-    existingPolicy = parseJSON(existingPolicyJson)
-  }
+  const interruptKinds = cliArgs[0] |> parseJSON
+  const outputPath = cliArgs[1]
+  const existingPolicy = get(cliArgs, 2) |> parseJSON
 
-  let contextMessage = "This agent can produce the following interrupts:\n"
-  for (kind in interruptKinds) {
-    contextMessage = contextMessage + "- ${kind}\n"
+  if (interruptKinds is failure(error)) {
+    print("Failed to parse interrupt kinds: ${error}")
+    return
   }
 
-  if (existingPolicy != null) {
-    contextMessage = contextMessage + """
-    Current policy:\n```json\n${printJSON(existingPolicy)}\n```\n\nWhat would you like to change?
+  let contextMessage = "This agent can produce the following interrupts:\n${map(interruptKinds.value, \kind -> "- ${kind}\n").join("")}"
+
+  if (existingPolicy is success(thePolicy)) {
+    currentPolicy = thePolicy
+    contextMessage = """
+${contextMessage}
+
+Current policy:
+```json
+${highlightJSON(currentPolicy)}
+```
+
+What would you like to change?
     """
   } else {
-    contextMessage = contextMessage + "\nWhat actions would you like to allow?"
+    contextMessage = """
+${contextMessage}
+
+What 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()
-}
+  let userInput = input("> ")
+  // didn't catch `policy` var is undefined??
+  // doesn't typecheck in string segments??
+  const prompt = """
+  Current policy: ${JSON.stringify(currentPolicy, null, 2)}
 
-node end() {
+  Decide the next step. If the user is describing what they want, build or update the policy and use addToPolicy, setPolicy, or deleteFromPolicy. Show the user the policy and get confirmation that it looks good. When you are done, return  { type: "done" }. Otherwise, ask the user a question to clarify what they want, and return { type: "askQuestion", question: "..." }.
+  """
 
+  systemMessage(systemPrompt)
+  assistantMessage(contextMessage)
+  userMessage(userInput)
+
+  const tools = [addToPolicy, getPolicy, setPolicy, deleteFromPolicy]
+
+  let action: Action = llm(prompt, {
+    tools: tools
+  })
+  while (action.type != "done") {
+    print(action.question)
+    let userInput = input("> ")
+    action: Action = llm(userInput, {
+      tools: tools
+    })
+  }
+  print("Done. Final policy:")
+  printJSON(currentPolicy)
+  const result = savePolicy(outputPath)
+  if (result is failure(error)) {
+    print("Failed to save policy: ${error}")
+    return
+  }
+  print("Saved policy to ${outputPath}.")
 }

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

@@ -37,3 +37,10 @@ Each rule has:
 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.
+
+
+## Tools you can use
+- addToPolicy: adds a new rule to the policy for a given interrupt kind
+- getPolicy: retrieves the current policy
+- setPolicy: replaces the entire policy with a new JSON object
+- deleteFromPolicy: deletes rules from the policy for a given interrupt kind

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

@@ -1,5 +1,6 @@
 import { exec } from "std::shell"
 import { args } from "std::system"
+import { systemMessage } from "std::thread"
 systemPrompt = read("./prompts/system.md")
 
 type Severity = "critical" | "warning" | "suggestion"
@@ -38,7 +39,7 @@ node main() {
   }
   // Have the LLM review the code
   thread {
-    system(systemPrompt)
+    systemMessage(systemPrompt)
     let typeErrorMessage = "The type checker found no errors."
     if (typeErrors != "") {
       typeErrorMessage = "The type checker reported the following errors:\n${typeErrors}"