agency-lang 0.1.1 → 0.1.3

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() {
+
+}