agency-lang 0.2.0 → 0.3.0

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, parseJSON, 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";
@@ -60,15 +61,9 @@ const __globalCtx = new RuntimeContext({
   traceConfig: {
     program: "dist/lib/agents/judge.agency",
     traceDir: "traces"
-  },
-  memory: {
-    dir: ".agency-memory"
   }
 });
 const graph = __globalCtx.graph;
-function readSkill({ filepath }) {
-  return _readSkillRaw({ filepath, dirname: __dirname });
-}
 function approve(value) {
   return { type: "approve", value };
 }
@@ -78,8 +73,8 @@ 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;
 };
@@ -121,8 +116,6 @@ __registerTool(parseJSON);
 __registerTool(input);
 __registerTool(sleep);
 __registerTool(round);
-__registerTool(fetch);
-__registerTool(fetchJSON);
 __registerTool(read);
 __registerTool(write);
 __registerTool(readImage);
@@ -133,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}
 
@@ -186,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" })
     };
   }
@@ -249,12 +245,14 @@ 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,
@@ -270,7 +268,6 @@ export {
   isDebugger,
   isInterrupt,
   judge,
-  readSkill,
   reject,
   respondToInterrupts,
   rewindFrom

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

@@ -1,13 +1,102 @@
 import { map } from "std::array"
-import { writePolicyFile } from "std::policy"
+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"
 
-type NextStep =
-  | { type: "showPolicy"; policy: object }
-  | { type: "writePolicy"; policy: object }
-  | { type: "askQuestion"; question: string }
+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) {
@@ -16,70 +105,81 @@ def get(array: any[], index: number) {
   return failure("Index out of bounds: ${index} >= ${array.length}")
 }
 
+def highlightJSON(obj: Record<string, any>): string {
+  return highlight(JSON.stringify(obj, null, 2), "json")
+}
+
 node main() {
   const cliArgs = args()
   if (cliArgs.length < 2) {
     print("Usage: agency policy gen <file>")
-    return end()
+    return
   }
-  print(cliArgs)
 
   const interruptKinds = cliArgs[0] |> parseJSON
   const outputPath = cliArgs[1]
-  const existingPolicy = get(cliArgs, 3) |> parseJSON
+  const existingPolicy = get(cliArgs, 2) |> parseJSON
 
-  if (isFailure(interruptKinds)) {
-    print("Failed to parse interrupt kinds: ${interruptKinds.error}")
-    return null
+  if (interruptKinds is failure(error)) {
+    print("Failed to parse interrupt kinds: ${error}")
+    return
   }
 
-  let contextMessage = "This agent can produce the following interrupts:\n" + map(interruptKinds, kind -> `- ${kind}\n`).join("")
+  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)}
+```
 
-  if (existingPolicy != null) {
-    contextMessage = contextMessage + """
-                                    Current policy:\n```json\n${printJSON(existingPolicy)}\n```\n\nWhat would you like to change?
-                                    """
+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)}
+
+  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: "..." }.
+  """
 
-node end() {
+  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}"