agency-lang 0.6.3 → 0.6.4

package/dist/lib/optimize/baseOptimizer.js

@@ -182,8 +182,13 @@ export class BaseOptimizer {
     /** Default runInput: run the agent for one input via the eval-run subprocess path (named args). */
     async runInputViaEval(ws, entryFile, input, id) {
         // Now that eval and optimize share the Input type, the input flows straight
-        // through — we only pin the id so artifacts land in a predictable directory.
-        const spec = { ...input, id };
+        // through — we pin the id so artifacts land in a predictable directory, and
+        // default working_dir to the forked workspace. The workspace is a full copy
+        // of the source tree, so seeding each per-input workdir from it gives the
+        // agent an isolated copy of the project as its cwd; without this the workdir
+        // is created empty and relative file references (e.g. exec on a repo path)
+        // resolve against nothing. An input that names its own working_dir wins.
+        const spec = { ...input, id, working_dir: input.working_dir ?? ws.dir };
         this.runCounter += 1;
         const result = await evalRunLoadedInputs({
             agent: path.join(ws.dir, entryFile),

package/dist/lib/optimize/baseOptimizer.workdir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/optimize/baseOptimizer.workdir.test.js

@@ -0,0 +1,77 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BaseGrader } from "./grading/baseGrader.js";
+import { BaseOptimizer } from "./baseOptimizer.js";
+// Capture the spec the default eval-run path hands to the eval runner so we can
+// assert it carries a working_dir (without spawning a real agent subprocess).
+const { mockEval } = vi.hoisted(() => ({ mockEval: vi.fn() }));
+vi.mock("@/cli/eval/run.js", () => ({
+    evalRunLoadedInputs: mockEval,
+    optimizeEvalRecordExtractor: {},
+    resolveEvalRunTarget: vi.fn(),
+}));
+class FixedGrader extends BaseGrader {
+    grade;
+    defaultName = "fixed";
+    constructor(grade, options = {}) {
+        super(options);
+        this.grade = grade;
+    }
+    _run(_input) { return Promise.resolve(this.grade); }
+}
+/** Concrete subclass exposing `evaluate` so we can drive the default runInput path. */
+class Probe extends BaseOptimizer {
+    name = "probe";
+    async optimizeTargets() { return {}; }
+    evaluateAt(ws, entry, inputs) {
+        return this.evaluate(ws, entry, inputs);
+    }
+    forkAt(dir) { return this.fork(dir); }
+}
+describe("BaseOptimizer.runInputViaEval working_dir", () => {
+    let root;
+    let src;
+    beforeEach(() => {
+        root = fs.mkdtempSync(path.join(os.tmpdir(), "bo-wd-"));
+        src = path.join(root, "src");
+        fs.mkdirSync(src);
+        fs.writeFileSync(path.join(src, "agent.agency"), "node main() {}\n");
+        // A sibling file the agent would reference relative to its cwd (the workdir).
+        fs.writeFileSync(path.join(src, "data.txt"), "hello\n");
+        mockEval.mockImplementation(async (args) => {
+            const input = args.inputs[0];
+            const recordPath = path.join(root, `${args.runId}-record.json`);
+            fs.writeFileSync(recordPath, JSON.stringify({ evalOutputs: [{ value: "out" }] }));
+            return { inputs: [{ status: "success", evalRecordPath: recordPath, input }] };
+        });
+    });
+    afterEach(() => {
+        mockEval.mockReset();
+        fs.rmSync(root, { recursive: true, force: true });
+    });
+    function probe() {
+        return new Probe({ graders: [new FixedGrader({ score: { kind: "scalar", value: 1 } })], iterations: 1, config: {}, runsDir: root, runId: "r" }, { workspaceRoot: path.join(root, "ws") });
+    }
+    it("points the per-input working_dir at the forked workspace so its files land in the workdir", async () => {
+        const p = probe();
+        const ws = p.forkAt(src);
+        await p.evaluateAt(ws, "agent.agency", [{ id: "a", args: {} }]);
+        expect(mockEval).toHaveBeenCalledTimes(1);
+        const spec = mockEval.mock.calls[0][0].inputs[0];
+        // The workspace is a full copy of the source tree; the per-input workdir must
+        // be seeded from it, or relative file references resolve against an empty dir.
+        expect(spec.working_dir).toBe(ws.dir);
+        expect(fs.existsSync(path.join(ws.dir, "data.txt"))).toBe(true);
+    });
+    it("preserves an input-provided working_dir instead of overriding it", async () => {
+        const p = probe();
+        const ws = p.forkAt(src);
+        const custom = path.join(root, "custom");
+        fs.mkdirSync(custom);
+        await p.evaluateAt(ws, "agent.agency", [{ id: "a", args: {}, working_dir: custom }]);
+        const spec = mockEval.mock.calls[0][0].inputs[0];
+        expect(spec.working_dir).toBe(custom);
+    });
+});

package/dist/lib/stdlib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.4.0";
+export declare const VERSION = "0.6.4";

package/dist/lib/stdlib/version.js

@@ -1 +1 @@
-export const VERSION = "0.4.0";
+export const VERSION = "0.6.4";

package/dist/lib/typeChecker/capabilities.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/typeChecker/capabilities.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from "vitest";
+import { typecheckSource } from "./testUtils.js";
+// Errors from the raises / effect-set diagnostics only.
+function capErrors(src) {
+    return typecheckSource(src).filter((e) => /raises effect|not an effect set/.test(e.message));
+}
+const hasEffectError = (errs, effect) => errs.some((e) => e.message.includes(`raises effect '${effect}'`));
+// A node that calls the real, globally-available `read` — a pure read, and
+// the only real stdlib call these tests make — under a given raises clause.
+function nodeUsingRead(setExpr, importName) {
+    return (`import { ${importName} } from "std::capabilities"\n` +
+        `node main(): string raises ${setExpr} {\n` +
+        `  read("f.txt") with approve\n` +
+        `  return "ok"\n}`);
+}
+describe("std::capabilities — sets containing filesystem read permit a real read()", () => {
+    // Validated against reality: the real `read` raises std::read, and these
+    // sets must contain it. A broken/unresolved set would reject the call.
+    it("FileRead permits read()", () => {
+        expect(capErrors(nodeUsingRead("<FileRead>", "FileRead"))).toHaveLength(0);
+    });
+    it("FileSystem (composite of FileRead + FileWrite) permits read()", () => {
+        expect(capErrors(nodeUsingRead("<FileSystem>", "FileSystem"))).toHaveLength(0);
+    });
+});
+describe("std::capabilities — non-read sets reject read() and resolve to real members", () => {
+    // For sets with no filesystem-read member, a real read() must be rejected.
+    // Asserting the rejection message lists a REAL member proves the set
+    // actually resolved to its declared contents — if it had silently failed
+    // to resolve, the message would echo the bare alias name (e.g. `<FileWrite>`)
+    // instead of the member effects.
+    const cases = [
+        ["FileWrite", "std::write"],
+        ["Shell", "std::bash"],
+        ["Messaging", "std::sendEmail"],
+        ["Auth", "std::authorize"],
+    ];
+    cases.forEach(([set, member]) => {
+        it(`${set} rejects read() and resolves to include ${member}`, () => {
+            const errs = capErrors(nodeUsingRead(`<${set}>`, set));
+            const err = errs.find((e) => e.message.includes("raises effect 'std::read'"));
+            expect(err, `${set} should reject std::read`).toBeDefined();
+            // Proves the set resolved to its real contents, not a literal fallback.
+            expect(err.message).toContain(member);
+        });
+    });
+});
+describe("std::capabilities — read-capable non-filesystem sets permit their own read effect but exclude std::read", () => {
+    // These sets contain a read/query effect of their own. We positively
+    // confirm membership of that READ effect (synthetic raise of a read effect
+    // — no write/delete calls) AND that filesystem read is still excluded.
+    // Together this proves the set resolved correctly: it contains its member
+    // and does not contain std::read.
+    const cases = [
+        ["Network", "std::http::fetch"],
+        ["Calendar", "std::listEvents"],
+        ["Secrets", "std::getSecret"],
+        ["Memory", "std::memory::recall"],
+    ];
+    cases.forEach(([set, readEffect]) => {
+        it(`${set} permits ${readEffect} but not std::read`, () => {
+            const src = `import { ${set} } from "std::capabilities"\n` +
+                `node main(): string raises <${set}> {\n` +
+                `  raise ${readEffect}("m", {})\n` +
+                `  read("f.txt") with approve\n` +
+                `  return "ok"\n}`;
+            const errs = capErrors(src);
+            // member is allowed (no error for it) ...
+            expect(hasEffectError(errs, readEffect)).toBe(false);
+            // ... but std::read is not in the set, so it is rejected.
+            expect(hasEffectError(errs, "std::read")).toBe(true);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "The Agency language",
   "main": "lib/index.js",
   "bin": {

package/stdlib/capabilities.agency

@@ -0,0 +1,60 @@
+/** @module
+  Standard **capability** effect sets — named groups of the interrupt
+  effects the standard library raises, for use in `raises` clauses.
+
+  A `raises` clause is an *allowlist* (an upper bound), so these sets are
+  composable building blocks you union together to say what a function or
+  node is permitted to do:
+
+  ```ts
+  import { FileRead, Network } from "std::capabilities"
+
+  // may read files and make network calls — nothing else
+  node main() raises <FileRead, Network> { ... }
+
+  // read-only inspection
+  node audit() raises <FileRead> { ... }
+
+  // guaranteed to perform no interrupting actions
+  def pure() raises <> { ... }
+  ```
+
+  The sets are purely mechanical groupings by capability; they encode no
+  security judgement (e.g. there is intentionally no "read-only" set that
+  decides whether a network fetch counts as a read). Compose the pieces
+  you need.
+
+  Note: these constrain callers. Individual functions should still declare
+  the specific effect they raise (e.g. `raises <std::read>`), not a whole
+  capability set.
+*/
+
+/** Read-only filesystem access: reading files and listing/searching paths. */
+export effectSet FileRead = <std::read, std::readImage, std::ls, std::glob, std::grep>
+
+/** Filesystem mutation: creating, editing, moving, copying, and deleting. */
+export effectSet FileWrite = <std::write, std::edit, std::applyPatch, std::mkdir, std::move, std::copy, std::remove>
+
+/** All filesystem access — reads and writes. */
+export effectSet FileSystem = <FileRead, FileWrite>
+
+/** Arbitrary command / process execution. The sharpest edge — grant with care. */
+export effectSet Shell = <std::bash, std::exec, std::run>
+
+/** Anything that talks to the outside world over the network. */
+export effectSet Network = <std::http::fetch, std::http::fetchJSON, std::http::fetchMarkdown, std::search, std::weather, std::browserUse, std::wikipedia::article, std::wikipedia::search, std::wikipedia::summary>
+
+/** Sending messages to people: email, SMS, and iMessage. */
+export effectSet Messaging = <std::sendEmail, std::sendSms, std::sendIMessage>
+
+/** Reading and writing credentials in the system keyring. */
+export effectSet Secrets = <std::getSecret, std::setSecret, std::deleteSecret>
+
+/** OAuth-style authorization flows: granting, fetching, and revoking access. */
+export effectSet Auth = <std::authorize, std::getAccessToken, std::revokeAuth>
+
+/** Calendar access: listing and mutating events (incl. calendar authorization). */
+export effectSet Calendar = <std::listEvents, std::createEvent, std::updateEvent, std::deleteEvent, std::authorizeCalendar>
+
+/** Agent long-term memory: recall, remember, forget, and enable/disable. */
+export effectSet Memory = <std::memory::recall, std::memory::remember, std::memory::forget, std::memory::enableMemory, std::memory::disableMemory>

package/stdlib/capabilities.js

@@ -0,0 +1,172 @@
+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";
+import { nanoid } from "agency-lang";
+import path from "path";
+import {
+  RuntimeContext,
+  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,
+  runExportedFunction as _runExportedFunction,
+  __registerGlobalsInit,
+  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,
+    observability: true,
+    logFile: "log.jsonl"
+  },
+  smoltalkDefaults: {
+    openAiApiKey: __process.env["OPENAI_API_KEY"] || "",
+    googleApiKey: __process.env["GEMINI_API_KEY"] || "",
+    anthropicApiKey: __process.env["ANTHROPIC_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,
+  logLevel: "info",
+  traceConfig: {
+    program: "stdlib/capabilities.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))
+  );
+}
+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 }], 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(parseJSON);
+__registerTool(input);
+__registerTool(sleep);
+__registerTool(round);
+__registerTool(read);
+__registerTool(write);
+__registerTool(readImage);
+__registerTool(notify);
+__registerTool(range);
+__registerTool(mostCommon);
+__registerTool(keys);
+__registerTool(values);
+__registerTool(entries);
+__registerTool(emit);
+__registerTool(callback);
+async function __initializeGlobals(__ctx) {
+  if (__ctx.globals.isInitialized("stdlib/capabilities.agency")) {
+    return;
+  }
+  __ctx.globals.markInitialized("stdlib/capabilities.agency");
+}
+__registerGlobalsInit("stdlib/capabilities.agency", __initializeGlobals);
+async function __registerTopLevelCallbacks(__ctx) {
+  __ctx.topLevelCallbacks = [];
+}
+__functionRefReviver.registry = __toolRegistry;
+const FileRead = z.union([z.literal("std::read"), z.literal("std::readImage"), z.literal("std::ls"), z.literal("std::glob"), z.literal("std::grep")]);
+const FileWrite = z.union([z.literal("std::write"), z.literal("std::edit"), z.literal("std::applyPatch"), z.literal("std::mkdir"), z.literal("std::move"), z.literal("std::copy"), z.literal("std::remove")]);
+const FileSystem = z.union([FileRead, FileWrite]);
+const Shell = z.union([z.literal("std::bash"), z.literal("std::exec"), z.literal("std::run")]);
+const Network = z.union([z.literal("std::http::fetch"), z.literal("std::http::fetchJSON"), z.literal("std::http::fetchMarkdown"), z.literal("std::search"), z.literal("std::weather"), z.literal("std::browserUse"), z.literal("std::wikipedia::article"), z.literal("std::wikipedia::search"), z.literal("std::wikipedia::summary")]);
+const Messaging = z.union([z.literal("std::sendEmail"), z.literal("std::sendSms"), z.literal("std::sendIMessage")]);
+const Secrets = z.union([z.literal("std::getSecret"), z.literal("std::setSecret"), z.literal("std::deleteSecret")]);
+const Auth = z.union([z.literal("std::authorize"), z.literal("std::getAccessToken"), z.literal("std::revokeAuth")]);
+const Calendar = z.union([z.literal("std::listEvents"), z.literal("std::createEvent"), z.literal("std::updateEvent"), z.literal("std::deleteEvent"), z.literal("std::authorizeCalendar")]);
+const Memory = z.union([z.literal("std::memory::recall"), z.literal("std::memory::remember"), z.literal("std::memory::forget"), z.literal("std::memory::enableMemory"), z.literal("std::memory::disableMemory")]);
+var stdin_default = graph;
+const __sourceMap = {};
+export {
+  Auth,
+  Calendar,
+  FileRead,
+  FileSystem,
+  FileWrite,
+  Memory,
+  Messaging,
+  Network,
+  Secrets,
+  Shell,
+  __getCheckpoints,
+  __invokeFunction,
+  __setDebugger,
+  __setLLMClient,
+  __setTraceFile,
+  __sourceMap,
+  __toolRegistry,
+  approve,
+  stdin_default as default,
+  hasInterrupts,
+  interrupt,
+  isDebugger,
+  isInterrupt,
+  reject,
+  respondToInterrupts,
+  rewindFrom
+};