@b4run/testing 0.8.28

package/dist/memory.d.ts

@@ -0,0 +1,11 @@
+import type { MemoryRecord, MemoryStore } from "@b4run/memory";
+type SeedInput = Partial<MemoryRecord> & Pick<MemoryRecord, "id" | "namespace" | "content"> & {
+    embedding?: Float32Array;
+    embeddingModel?: string;
+};
+/** Seed memory rows into a store (or a sqlite path) with sensible defaults for tests. */
+export declare function seedMemory(target: MemoryStore | {
+    readonly path: string;
+}, records: readonly SeedInput[]): Promise<MemoryStore>;
+export {};
+//# sourceMappingURL=memory.d.ts.map

package/dist/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAG9D,KAAK,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC,GACpC,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,WAAW,GAAG,SAAS,CAAC,GAAG;IACnD,SAAS,CAAC,EAAE,YAAY,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAEH,yFAAyF;AACzF,wBAAsB,UAAU,CAC9B,MAAM,EAAE,WAAW,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAC/C,OAAO,EAAE,SAAS,SAAS,EAAE,GAC5B,OAAO,CAAC,WAAW,CAAC,CAoBtB"}

package/dist/memory.js

@@ -0,0 +1,20 @@
+import { sqliteMemoryStore } from "@b4run/memory";
+/** Seed memory rows into a store (or a sqlite path) with sensible defaults for tests. */
+export async function seedMemory(target, records) {
+    const store = "put" in target ? target : sqliteMemoryStore(target);
+    for (const r of records) {
+        const { embedding, embeddingModel, ...record } = r;
+        await store.put({
+            kind: "semantic",
+            data: {},
+            source: { type: "eval", id: "seed" },
+            confidence: 1,
+            tags: [],
+            status: "active",
+            createdAt: "2026-01-01T00:00:00.000Z",
+            updatedAt: "2026-01-01T00:00:00.000Z",
+            ...record,
+        }, embedding && embeddingModel ? { embedding, embeddingModel } : undefined);
+    }
+    return store;
+}

package/dist/middleware-harness.d.ts

@@ -0,0 +1,11 @@
+import type { BackendContext, FilesystemBackend, FilesystemMiddleware } from "@b4run/workspace";
+export interface MiddlewareHarness {
+    readonly backend: FilesystemBackend;
+    readonly ctx: BackendContext;
+    readonly dir: string;
+    assertForwardsAll(): void;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare function createMiddlewareHarness(middleware: FilesystemMiddleware): Promise<MiddlewareHarness>;
+//# sourceMappingURL=middleware-harness.d.ts.map

package/dist/middleware-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-harness.d.ts","sourceRoot":"","sources":["../src/middleware-harness.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG/F,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAA;IACnC,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAA;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,iBAAiB,IAAI,IAAI,CAAA;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvC;AAED,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,oBAAoB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAkC5B"}

package/dist/middleware-harness.js

@@ -0,0 +1,35 @@
+import { realpathSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { localFilesystem } from "@b4run/workspace/node";
+export async function createMiddlewareHarness(middleware) {
+    const dir = realpathSync(await mkdtemp(join(tmpdir(), "b4-mw-harness-")));
+    const base = localFilesystem();
+    const backend = middleware(base);
+    const controller = new AbortController();
+    const ctx = { signal: controller.signal, workspaceRoot: dir };
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        controller.abort();
+        await rm(dir, { force: true, recursive: true });
+    };
+    return {
+        backend,
+        ctx,
+        dir,
+        assertForwardsAll() {
+            const baseMethods = Object.keys(base);
+            const missing = baseMethods.filter((method) => typeof base[method] === "function" && typeof backend[method] !== "function");
+            if (missing.length > 0) {
+                throw new Error(`Middleware dropped backend method(s) the base provides: ${missing.join(", ")}. ` +
+                    "A FilesystemMiddleware must forward every method (required and optional) it does not intercept.");
+            }
+        },
+        close,
+        [Symbol.asyncDispose]: close,
+    };
+}

package/dist/permissions-conformance.d.ts

@@ -0,0 +1,24 @@
+import type { PermissionMode, PermissionsFile, PermissionsStore } from "@b4run/permissions";
+/** What a backend needs in order to build a store: the config-seeded lists plus the resolved mode. */
+export interface PermissionsStoreInit {
+    readonly config: PermissionsFile | undefined;
+    readonly mode: PermissionMode;
+}
+/**
+ * The contract every PermissionsStore must satisfy. Run against the file-backed
+ * node store (tmpdir, always) and any other backend (e.g. Postgres, gated) so
+ * they cannot drift. Pass vitest's `describe`; `makeStore` returns a FRESH
+ * store — no config entries beyond `init.config`, no prior runtime grants.
+ *
+ * Runtime grants are seeded through `addAllow` rather than by writing the
+ * backing store directly: that is the only portable way to reach the "runtime"
+ * half of the state machine, since where those entries live (a JSON file, a
+ * table) is exactly what differs between backends.
+ */
+export declare function runPermissionsStoreConformance(opts: {
+    readonly name: string;
+    readonly makeStore: (init: PermissionsStoreInit) => Promise<PermissionsStore> | PermissionsStore;
+    readonly describe: (name: string, fn: () => void) => void;
+    readonly close?: (store: PermissionsStore) => Promise<void> | void;
+}): void;
+//# sourceMappingURL=permissions-conformance.d.ts.map

package/dist/permissions-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions-conformance.d.ts","sourceRoot":"","sources":["../src/permissions-conformance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAG3F,sGAAsG;AACtG,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAAA;IAC5C,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAC9B;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,OAAO,CAAC,gBAAgB,CAAC,GAAG,gBAAgB,CAAA;IAChG,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CACnE,GAAG,IAAI,CAmKP"}

package/dist/permissions-conformance.js

@@ -0,0 +1,156 @@
+import { expect, test } from "vitest";
+const file = (allow, deny = {}) => ({ version: 1, allow, deny });
+/**
+ * The contract every PermissionsStore must satisfy. Run against the file-backed
+ * node store (tmpdir, always) and any other backend (e.g. Postgres, gated) so
+ * they cannot drift. Pass vitest's `describe`; `makeStore` returns a FRESH
+ * store — no config entries beyond `init.config`, no prior runtime grants.
+ *
+ * Runtime grants are seeded through `addAllow` rather than by writing the
+ * backing store directly: that is the only portable way to reach the "runtime"
+ * half of the state machine, since where those entries live (a JSON file, a
+ * table) is exactly what differs between backends.
+ */
+export function runPermissionsStoreConformance(opts) {
+    const { name, makeStore, describe, close } = opts;
+    describe(`PermissionsStore conformance: ${name}`, () => {
+        async function withStore(init, fn) {
+            const store = await makeStore(init);
+            try {
+                await store.load();
+                await fn(store);
+            }
+            finally {
+                await close?.(store);
+            }
+        }
+        test("exposes the resolved mode", async () => {
+            await withStore({ config: undefined, mode: "non-interactive" }, async (s) => {
+                expect(s.mode).toBe("non-interactive");
+            });
+        });
+        test("no entries for a tool → unknown", async () => {
+            await withStore({ config: undefined, mode: "interactive" }, async (s) => {
+                expect(s.match("bash", "npm install")).toBe("unknown");
+                expect(s.match("unknownTool", "anything")).toBe("unknown");
+            });
+        });
+        test("config allow entries match by prefix", async () => {
+            await withStore({ config: file({ bash: ["npm install"] }), mode: "interactive" }, async (s) => {
+                expect(s.match("bash", "npm install react")).toBe("allow");
+                expect(s.match("bash", "npm install")).toBe("allow");
+                // The candidate must start with the pattern, not the other way round.
+                expect(s.match("bash", "npm")).toBe("unknown");
+                expect(s.match("bash", "rm -rf /")).toBe("unknown");
+            });
+        });
+        test("patterns are scoped per tool key", async () => {
+            await withStore({ config: file({ bash: ["ls"] }), mode: "interactive" }, async (s) => {
+                expect(s.match("bash", "ls -la")).toBe("allow");
+                expect(s.match("readFile", "ls -la")).toBe("unknown");
+            });
+        });
+        test("deny wins over allow", async () => {
+            await withStore({ config: file({ bash: ["rm"] }, { bash: ["rm -rf"] }), mode: "interactive" }, async (s) => {
+                expect(s.match("bash", "rm -rf /tmp")).toBe("deny");
+                expect(s.match("bash", "rm ./file")).toBe("allow");
+            });
+        });
+        test('the reserved "tool" key matches EXACTLY, never by prefix', async () => {
+            await withStore({ config: file({ tool: ["deploy"] }), mode: "interactive" }, async (s) => {
+                expect(s.match("tool", "deploy")).toBe("allow");
+                // Tool names must not prefix-match, or approving "deploy" would
+                // silently approve "deployProd".
+                expect(s.match("tool", "deployProd")).toBe("unknown");
+            });
+            await withStore({ config: file({}, { tool: ["deploy"] }), mode: "interactive" }, async (s) => {
+                expect(s.match("tool", "deploy")).toBe("deny");
+                expect(s.match("tool", "deployProd")).toBe("unknown");
+            });
+        });
+        test("bypass mode: match is always unknown, even with config allow AND deny", async () => {
+            await withStore({ config: file({ bash: ["ls"] }, { bash: ["rm"] }), mode: "bypass" }, async (s) => {
+                expect(s.match("bash", "ls -la")).toBe("unknown");
+                expect(s.match("bash", "rm -rf /")).toBe("unknown");
+                await s.addAllow("bash", "cat");
+                expect(s.match("bash", "cat x")).toBe("unknown");
+            });
+        });
+        test("non-interactive mode: config applies, runtime grants are ignored", async () => {
+            await withStore({ config: file({ bash: ["ls"] }, { bash: ["rm"] }), mode: "non-interactive" }, async (s) => {
+                expect(s.match("bash", "ls -la")).toBe("allow");
+                expect(s.match("bash", "rm -rf /")).toBe("deny");
+                await s.addAllow("bash", "npm install");
+                expect(s.match("bash", "npm install react")).toBe("unknown");
+            });
+        });
+        test("interactive mode: config and runtime grants are concatenated per tool key", async () => {
+            await withStore({ config: file({ bash: ["ls"] }), mode: "interactive" }, async (s) => {
+                await s.addAllow("bash", "npm install");
+                await s.addAllow("readFile", "/tmp/");
+                // Same key: both lists contribute. Different key: independent.
+                expect(s.match("bash", "ls -la")).toBe("allow");
+                expect(s.match("bash", "npm install react")).toBe("allow");
+                expect(s.match("readFile", "/tmp/x.txt")).toBe("allow");
+            });
+        });
+        test("interactive mode: a config deny beats a runtime allow", async () => {
+            await withStore({ config: file({}, { bash: ["rm -rf"] }), mode: "interactive" }, async (s) => {
+                await s.addAllow("bash", "rm");
+                expect(s.match("bash", "rm -rf /tmp")).toBe("deny");
+                expect(s.match("bash", "rm ./file")).toBe("allow");
+            });
+        });
+        test("addAllow is visible to match() as soon as it resolves", async () => {
+            await withStore({ config: undefined, mode: "interactive" }, async (s) => {
+                expect(s.match("bash", "npm install")).toBe("unknown");
+                await s.addAllow("bash", "npm install");
+                expect(s.match("bash", "npm install react")).toBe("allow");
+            });
+        });
+        test("addAllow is idempotent — repeating a grant changes nothing", async () => {
+            await withStore({ config: undefined, mode: "interactive" }, async (s) => {
+                await s.addAllow("bash", "ls");
+                await s.addAllow("bash", "ls");
+                // Whether the backend de-duplicates its rows is storage-internal; what
+                // the contract pins is that a repeat neither throws nor flips the
+                // decision.
+                expect(s.match("bash", "ls -la")).toBe("allow");
+            });
+        });
+        test("concurrent addAllow calls all land", async () => {
+            await withStore({ config: undefined, mode: "interactive" }, async (s) => {
+                await Promise.all([
+                    s.addAllow("bash", "ls"),
+                    s.addAllow("bash", "pwd"),
+                    s.addAllow("bash", "cat"),
+                ]);
+                expect(s.match("bash", "ls -la")).toBe("allow");
+                expect(s.match("bash", "pwd")).toBe("allow");
+                expect(s.match("bash", "cat f")).toBe("allow");
+            });
+        });
+        test('addAllow under the "tool" key stays exact', async () => {
+            await withStore({ config: undefined, mode: "interactive" }, async (s) => {
+                await s.addAllow("tool", "deploy");
+                expect(s.match("tool", "deploy")).toBe("allow");
+                expect(s.match("tool", "deployProd")).toBe("unknown");
+            });
+        });
+        test("load() is re-callable and preserves config plus runtime grants", async () => {
+            await withStore({ config: file({ bash: ["ls"] }), mode: "interactive" }, async (s) => {
+                await s.addAllow("bash", "npm install");
+                await s.load();
+                await s.load();
+                expect(s.match("bash", "ls -la")).toBe("allow");
+                expect(s.match("bash", "npm install react")).toBe("allow");
+            });
+        });
+        test("load() on a store with no config and no prior grants leaves it empty", async () => {
+            await withStore({ config: undefined, mode: "interactive" }, async (s) => {
+                await s.load();
+                expect(s.match("bash", "anything")).toBe("unknown");
+            });
+        });
+    });
+}

package/dist/record-fixtures.d.ts

@@ -0,0 +1,21 @@
+import type { AimockResponse, FixtureSet } from "./fixture-builder.js";
+/** One captured real-model exchange: the request the agent sent + the response to bake. */
+export interface Recording {
+    readonly request: {
+        readonly messages?: ReadonlyArray<{
+            readonly role: string;
+            readonly content: unknown;
+        }>;
+    };
+    readonly response: AimockResponse;
+}
+/**
+ * Convert ordered recordings (one per LLM call within a single case/thread) into
+ * a replay FixtureSet, keyed with the SAME `{userMessage,turnIndex,hasToolResult}`
+ * convention `script()` produces — so the recorded file replays through the same
+ * aimock matcher with no drift. `turnIndex` is the 0-based ordinal of the call
+ * within the thread; `userMessage` is the first user message (stable across the
+ * thread); `hasToolResult` is whether a tool-role message is already present.
+ */
+export declare function recordingsToFixtures(recordings: readonly Recording[]): FixtureSet;
+//# sourceMappingURL=record-fixtures.d.ts.map

package/dist/record-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-fixtures.d.ts","sourceRoot":"","sources":["../src/record-fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,cAAc,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAErF,2FAA2F;AAC3F,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;YAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;SAAE,CAAC,CAAA;KACxF,CAAA;IACD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;CAClC;AAaD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,UAAU,CAYjF"}

package/dist/record-fixtures.js

@@ -0,0 +1,31 @@
+function firstUserMessage(req) {
+    for (const m of req.messages ?? []) {
+        if (m.role === "user" && typeof m.content === "string")
+            return m.content;
+    }
+    return undefined;
+}
+function hasToolResult(req) {
+    return (req.messages ?? []).some((m) => m.role === "tool");
+}
+/**
+ * Convert ordered recordings (one per LLM call within a single case/thread) into
+ * a replay FixtureSet, keyed with the SAME `{userMessage,turnIndex,hasToolResult}`
+ * convention `script()` produces — so the recorded file replays through the same
+ * aimock matcher with no drift. `turnIndex` is the 0-based ordinal of the call
+ * within the thread; `userMessage` is the first user message (stable across the
+ * thread); `hasToolResult` is whether a tool-role message is already present.
+ */
+export function recordingsToFixtures(recordings) {
+    return recordings.map((rec, turnIndex) => {
+        const userMessage = firstUserMessage(rec.request);
+        return {
+            match: {
+                ...(userMessage !== undefined ? { userMessage } : {}),
+                turnIndex,
+                hasToolResult: hasToolResult(rec.request),
+            },
+            response: rec.response,
+        };
+    });
+}

package/dist/record.d.ts

@@ -0,0 +1,12 @@
+export interface RecordOptions {
+    readonly out: string;
+    /** Upstream provider base, default OpenAI. */
+    readonly provider?: string;
+}
+/**
+ * Records a real provider interaction into an aimock fixture file. LOCAL ONLY —
+ * requires a real OPENAI_API_KEY in env. Never run in CI (CI replays strict
+ * read-only). Throws on a non-zero recorder exit.
+ */
+export declare function record(opts: RecordOptions): void;
+//# sourceMappingURL=record.d.ts.map

package/dist/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAmBhD"}

package/dist/record.js

@@ -0,0 +1,22 @@
+import { spawnSync } from "node:child_process";
+/**
+ * Records a real provider interaction into an aimock fixture file. LOCAL ONLY —
+ * requires a real OPENAI_API_KEY in env. Never run in CI (CI replays strict
+ * read-only). Throws on a non-zero recorder exit.
+ */
+export function record(opts) {
+    const provider = opts.provider ?? "https://api.openai.com";
+    const result = spawnSync("npx", [
+        "-p",
+        "@copilotkit/aimock",
+        "llmock",
+        "--record",
+        "--provider-openai",
+        provider,
+        "--out",
+        opts.out,
+    ], { stdio: "inherit", env: process.env });
+    if (result.status !== 0) {
+        throw new Error(`aimock recorder exited with status ${result.status ?? "null"}`);
+    }
+}

package/dist/regex-safety.d.ts

@@ -0,0 +1,2 @@
+export declare function createSafeRegexTester(expression: RegExp): (input: string) => boolean;
+//# sourceMappingURL=regex-safety.d.ts.map

package/dist/regex-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex-safety.d.ts","sourceRoot":"","sources":["../src/regex-safety.ts"],"names":[],"mappings":"AAmDA,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CA8BpF"}

package/dist/regex-safety.js

@@ -0,0 +1,66 @@
+import { Script } from "node:vm";
+const MAX_REGEX_SOURCE_CODE_UNITS = 4_096;
+const MAX_REGEX_INPUT_CODE_UNITS = 65_536;
+const REGEX_EXECUTION_TIMEOUT_MS = 100;
+const OVERSIZED_REGEX_SOURCE_MESSAGE = "Regular expression source exceeds 4096 UTF-16 code units";
+const OVERSIZED_REGEX_INPUT_MESSAGE = "Regular expression input exceeds 65536 UTF-16 code units";
+const REGEX_TIMEOUT_MESSAGE = "Regular expression evaluation exceeded 100ms execution limit";
+const REGEX_TEST_SCRIPT = new Script("new RegExp(source, flags).test(input)", {
+    filename: "b4-regex-evaluation.vm",
+});
+function intrinsicRegExpGetter(property) {
+    const getter = Object.getOwnPropertyDescriptor(RegExp.prototype, property)?.get;
+    if (getter === undefined) {
+        throw new Error(`RegExp.prototype.${property} is unavailable`);
+    }
+    return getter;
+}
+const REGEXP_SOURCE_GETTER = intrinsicRegExpGetter("source");
+const REGEXP_FLAG_GETTERS = [
+    [intrinsicRegExpGetter("hasIndices"), "d"],
+    [intrinsicRegExpGetter("global"), "g"],
+    [intrinsicRegExpGetter("ignoreCase"), "i"],
+    [intrinsicRegExpGetter("multiline"), "m"],
+    [intrinsicRegExpGetter("dotAll"), "s"],
+    [intrinsicRegExpGetter("unicode"), "u"],
+    [intrinsicRegExpGetter("unicodeSets"), "v"],
+    [intrinsicRegExpGetter("sticky"), "y"],
+];
+function snapshotFlags(expression) {
+    let flags = "";
+    for (const [getter, flag] of REGEXP_FLAG_GETTERS) {
+        if (Reflect.apply(getter, expression, []) === true)
+            flags += flag;
+    }
+    return flags;
+}
+function isScriptExecutionTimeout(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ERR_SCRIPT_EXECUTION_TIMEOUT");
+}
+export function createSafeRegexTester(expression) {
+    const source = Reflect.apply(REGEXP_SOURCE_GETTER, expression, []);
+    const flags = snapshotFlags(expression);
+    if (source.length > MAX_REGEX_SOURCE_CODE_UNITS) {
+        throw new RangeError(OVERSIZED_REGEX_SOURCE_MESSAGE);
+    }
+    return (input) => {
+        if (input.length > MAX_REGEX_INPUT_CODE_UNITS) {
+            throw new RangeError(OVERSIZED_REGEX_INPUT_MESSAGE);
+        }
+        try {
+            return (REGEX_TEST_SCRIPT.runInNewContext({ flags, input, source }, {
+                contextCodeGeneration: { strings: false, wasm: false },
+                timeout: REGEX_EXECUTION_TIMEOUT_MS,
+            }) === true);
+        }
+        catch (error) {
+            if (isScriptExecutionTimeout(error)) {
+                throw new RangeError(REGEX_TIMEOUT_MESSAGE);
+            }
+            throw error;
+        }
+    };
+}

package/dist/run-result.d.ts

@@ -0,0 +1,111 @@
+import type { StreamChunk } from "@b4run/cli/runtime";
+export interface ObservedToolCall {
+    readonly name: string;
+    readonly args: unknown;
+    readonly id?: string;
+}
+export interface ObservedToolResult {
+    readonly name: string;
+    /** LangChain ToolMessage status, when present. */
+    readonly status?: "error" | "success";
+    /** The tool result content (string when the tool returned text/JSON). */
+    readonly content: unknown;
+    /** True when the tool reported an error (status === "error"). */
+    readonly isError: boolean;
+}
+/** Extract tool results from final conversation messages.
+ *
+ * Handles two shapes:
+ * - Serialized LangChain format: `{ lc:1, type:"constructor", id:[...,"ToolMessage"], kwargs:{name,status,content} }`
+ * - Live LangChain instance format: `{ type:"tool", name, status, content, ... }`
+ */
+export declare function deriveToolResults(messages: ReadonlyArray<Record<string, unknown>>): ObservedToolResult[];
+export interface CommandInterruptDetail {
+    readonly command: string;
+    readonly suggestedPattern: string;
+}
+export interface PathInterruptDetail {
+    readonly path: string;
+    readonly operation: "readFile" | "writeFile" | "listDir";
+    readonly suggestedPattern: string;
+}
+export interface ToolInterruptDetail {
+    readonly toolName: string;
+    readonly argsPreview: string;
+    readonly suggestedPattern: string;
+}
+export interface MemoryInterruptDetail {
+    readonly namespace: string;
+    readonly identity: string;
+    readonly oldId: string;
+    readonly oldContent: string;
+    readonly newContent: string;
+    readonly suggestedPattern: string;
+}
+export interface SubagentInterruptDetail {
+    readonly parentRouteId: string;
+    readonly subagentName: string;
+    readonly subagentRouteId: string;
+    readonly inputPreview: string;
+    readonly reason?: string;
+    readonly suggestedPattern: string;
+}
+interface InterruptInfoBase {
+    readonly interruptId: string;
+    readonly callId?: string;
+}
+export type InterruptInfo = InterruptInfoBase & ({
+    readonly kind: "command";
+    readonly detail: CommandInterruptDetail;
+} | {
+    readonly kind: "path";
+    readonly detail: PathInterruptDetail;
+} | {
+    readonly kind: "tool";
+    readonly detail: ToolInterruptDetail;
+} | {
+    readonly kind: "memory";
+    readonly detail: MemoryInterruptDetail;
+} | {
+    readonly kind: "subagent";
+    readonly detail: SubagentInterruptDetail;
+});
+export interface Todo {
+    readonly content: string;
+    readonly status: string;
+}
+export interface SubagentToolCall {
+    readonly name: string;
+    readonly args: unknown;
+}
+export interface SubagentRun {
+    readonly callId: string;
+    readonly name: string;
+    readonly toolCalls: ReadonlyArray<SubagentToolCall>;
+    readonly finalMessage?: string;
+    readonly error?: string;
+}
+export interface SubagentEvent {
+    readonly type: string;
+    readonly data: Record<string, unknown>;
+}
+export interface AgentRunResult {
+    readonly finalMessage: string;
+    readonly messages: ReadonlyArray<Record<string, unknown>>;
+    readonly toolCalls: ReadonlyArray<ObservedToolCall>;
+    readonly toolResults: ReadonlyArray<ObservedToolResult>;
+    readonly tokens: ReadonlyArray<string>;
+    readonly state: Record<string, unknown>;
+    readonly threadId: string;
+    readonly interrupts: ReadonlyArray<InterruptInfo>;
+    readonly planUpdates: ReadonlyArray<{
+        todos: ReadonlyArray<Todo>;
+    }>;
+    readonly todos: ReadonlyArray<Todo>;
+    readonly subagents: ReadonlyArray<SubagentRun>;
+    readonly subagentEvents: ReadonlyArray<SubagentEvent>;
+    readonly systemPrompt: string;
+}
+export declare function collectRunResult(stream: AsyncIterable<StreamChunk>, threadId: string): Promise<AgentRunResult>;
+export {};
+//# sourceMappingURL=run-result.d.ts.map

package/dist/run-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-result.d.ts","sourceRoot":"","sources":["../src/run-result.ts"],"names":[],"mappings":"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"}