@b4run/testing 0.8.28

package/dist/fake-embedder.js

@@ -0,0 +1,38 @@
+function hash(s) {
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+/**
+ * Deterministic, network-free embedder for tests: a normalized bag-of-token-hash
+ * vector, so strings sharing tokens are nearer in cosine. NOT for production.
+ */
+export function fakeEmbedder(opts) {
+    const dims = opts?.dims ?? 64;
+    return {
+        id: `fake:${dims}`,
+        dims,
+        async embed(texts) {
+            return texts.map((t) => {
+                const v = new Float32Array(dims);
+                for (const tok of t
+                    .toLowerCase()
+                    .split(/[^a-z0-9]+/)
+                    .filter((x) => x.length > 1)) {
+                    const idx = hash(tok) % dims;
+                    v[idx] = v[idx] + 1;
+                }
+                let n = 0;
+                for (const x of v)
+                    n += x * x;
+                n = Math.sqrt(n) || 1;
+                for (let i = 0; i < dims; i++)
+                    v[i] = v[i] / n;
+                return v;
+            });
+        },
+    };
+}

package/dist/fixture-builder.d.ts

@@ -0,0 +1,29 @@
+export interface AimockToolCall {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: Record<string, unknown>;
+}
+export type AimockResponse = {
+    content: string;
+} | {
+    toolCalls: AimockToolCall[];
+};
+export interface AimockFixture {
+    readonly match: {
+        readonly userMessage?: string;
+        readonly turnIndex?: number;
+        readonly hasToolResult?: boolean;
+    };
+    readonly response: AimockResponse;
+}
+export type FixtureSet = AimockFixture[];
+export interface ScriptBuilder {
+    user(text: string): ScriptBuilder;
+    callsTool(name: string, args: Record<string, unknown>, opts?: {
+        id?: string;
+    }): ScriptBuilder;
+    replies(content: string): ScriptBuilder;
+    build(): FixtureSet;
+}
+export declare function script(): ScriptBuilder;
+//# sourceMappingURL=fixture-builder.d.ts.map

package/dist/fixture-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture-builder.d.ts","sourceRoot":"","sources":["../src/fixture-builder.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC5C;AAED,MAAM,MAAM,cAAc,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,SAAS,EAAE,cAAc,EAAE,CAAA;CAAE,CAAA;AAElF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;QAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;QAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;KACjC,CAAA;IACD,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;CAClC;AAED,MAAM,MAAM,UAAU,GAAG,aAAa,EAAE,CAAA;AAExC,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAA;IACjC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,aAAa,CAAA;IAC7F,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAAA;IACvC,KAAK,IAAI,UAAU,CAAA;CACpB;AAED,wBAAgB,MAAM,IAAI,aAAa,CA4CtC"}

package/dist/fixture-builder.js

@@ -0,0 +1,43 @@
+export function script() {
+    const fixtures = [];
+    let groupIndex = -1;
+    let currentUser;
+    let stepInGroup = 0; // kept for tool call id generation only
+    function pushResponse(response) {
+        if (currentUser === undefined) {
+            throw new Error("script(): call .user(text) before .callsTool()/.replies()");
+        }
+        // turnIndex = number of assistant messages already in the thread before this
+        // LLM call (0 for the first call, 1 for the reply-after-tool, etc.).
+        // hasToolResult = true only when there is already a tool-role message in the
+        // thread, which is the case for the post-tool reply but not the initial call.
+        // Both values are stable when the harness creates a fresh thread per test
+        // (via h.reset()), so they unambiguously select the right fixture.
+        fixtures.push({
+            match: { userMessage: currentUser, turnIndex: stepInGroup, hasToolResult: stepInGroup > 0 },
+            response,
+        });
+        stepInGroup += 1;
+    }
+    const builder = {
+        user(text) {
+            groupIndex += 1;
+            currentUser = text;
+            stepInGroup = 0;
+            return builder;
+        },
+        callsTool(name, args, opts) {
+            const id = opts?.id ?? `call_${name}_${groupIndex}_${stepInGroup}`;
+            pushResponse({ toolCalls: [{ id, name, arguments: args }] });
+            return builder;
+        },
+        replies(content) {
+            pushResponse({ content });
+            return builder;
+        },
+        build() {
+            return fixtures.slice();
+        },
+    };
+    return builder;
+}

package/dist/fixture-file.d.ts

@@ -0,0 +1,14 @@
+import type { FixtureSet, ScriptBuilder } from "./fixture-builder.js";
+/**
+ * Write a FixtureSet (or ScriptBuilder) to a JSON file.
+ * The file is written as `{ "fixtures": [...] }` (pretty-printed, 2-space indent).
+ * Parent directories are created automatically.
+ */
+export declare function writeFixtures(path: string, fixtures: FixtureSet | ScriptBuilder): void;
+/**
+ * Load a FixtureSet from a JSON file.
+ * Accepts `{ "fixtures": [...] }` (wrapped) or a bare array.
+ * Throws a clear error if the file is missing or the JSON is not a fixture set.
+ */
+export declare function loadFixtures(path: string): FixtureSet;
+//# sourceMappingURL=fixture-file.d.ts.map

package/dist/fixture-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture-file.d.ts","sourceRoot":"","sources":["../src/fixture-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAQrE;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI,CAItF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CA+BrD"}

package/dist/fixture-file.js

@@ -0,0 +1,49 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/** Normalise a ScriptBuilder or bare FixtureSet to a FixtureSet. */
+function toFixtureSet(f) {
+    if (Array.isArray(f))
+        return f;
+    return f.build();
+}
+/**
+ * Write a FixtureSet (or ScriptBuilder) to a JSON file.
+ * The file is written as `{ "fixtures": [...] }` (pretty-printed, 2-space indent).
+ * Parent directories are created automatically.
+ */
+export function writeFixtures(path, fixtures) {
+    const set = toFixtureSet(fixtures);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ fixtures: set }, null, 2), "utf-8");
+}
+/**
+ * Load a FixtureSet from a JSON file.
+ * Accepts `{ "fixtures": [...] }` (wrapped) or a bare array.
+ * Throws a clear error if the file is missing or the JSON is not a fixture set.
+ */
+export function loadFixtures(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        throw new Error(`fixture file not found: ${path}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`fixture file contains invalid JSON: ${path}`);
+    }
+    if (Array.isArray(parsed)) {
+        return parsed;
+    }
+    if (parsed !== null &&
+        typeof parsed === "object" &&
+        "fixtures" in parsed &&
+        Array.isArray(parsed.fixtures)) {
+        return parsed.fixtures;
+    }
+    throw new Error(`fixture file does not contain a fixture set (expected array or { fixtures: [...] }): ${path}`);
+}

package/dist/harness.d.ts

@@ -0,0 +1,35 @@
+import { type B4ResumeEntry } from "@b4run/cli/runtime";
+import type { FixtureSet, ScriptBuilder } from "./fixture-builder.js";
+import { type AgentRunResult } from "./run-result.js";
+export interface AgentHarnessOptions {
+    readonly appRoot: string;
+    readonly route: string;
+    readonly fixtures?: FixtureSet;
+    /**
+     * When true, proxy all LLM requests through a real upstream (OPENAI_API_KEY
+     * must be set). Requires OPENAI_API_KEY to be present in the environment.
+     */
+    readonly live?: boolean;
+    /** Capture real-model traffic for getRecordedFixtures(). Proxies to recordUpstream. */
+    readonly record?: boolean;
+    /** Upstream base URL for record mode (no /v1 suffix). Default https://api.openai.com. */
+    readonly recordUpstream?: string;
+}
+export interface AgentHarness {
+    readonly baseUrl: string;
+    run(opts: {
+        input: string;
+        fixtures?: FixtureSet | ScriptBuilder;
+    }): Promise<AgentRunResult>;
+    resume(opts: {
+        resume: readonly B4ResumeEntry[];
+        fixtures?: FixtureSet | ScriptBuilder;
+    }): Promise<AgentRunResult>;
+    reset(): void;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    /** Fixtures captured from the most recent run() (record mode only); re-keyed for replay. */
+    getRecordedFixtures(): FixtureSet;
+}
+export declare function createAgentHarness(options: AgentHarnessOptions): Promise<AgentHarness>;
+//# sourceMappingURL=harness.d.ts.map

package/dist/harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../src/harness.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,aAAa,EASnB,MAAM,oBAAoB,CAAA;AAI3B,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAErE,OAAO,EAAE,KAAK,cAAc,EAAoB,MAAM,iBAAiB,CAAA;AA0BvE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;IAC9B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;IACvB,uFAAuF;IACvF,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,yFAAyF;IACzF,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CACjC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,GAAG,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,UAAU,GAAG,aAAa,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;IAC5F,MAAM,CAAC,IAAI,EAAE;QACX,MAAM,EAAE,SAAS,aAAa,EAAE,CAAA;QAChC,QAAQ,CAAC,EAAE,UAAU,GAAG,aAAa,CAAA;KACtC,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;IAC3B,KAAK,IAAI,IAAI,CAAA;IACb,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtC,4FAA4F;IAC5F,mBAAmB,IAAI,UAAU,CAAA;CAClC;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CA2L5F"}

package/dist/harness.js

@@ -0,0 +1,211 @@
+import { randomUUID } from "node:crypto";
+import { __resetMaterializedAgentsForTests, __resetRouteLoadCachesForTests, createRuntimeRegistry, readPendingInterrupts, resolveCheckpointer, resolvePendingResume, resolveSandboxManager, runTypegen, streamResolvedRoute, } from "@b4run/cli/runtime";
+import { __clearB4ConfigCacheForTests } from "@b4run/core";
+import { discoverRoutes } from "@b4run/core/node";
+import { createAimock } from "./aimock-runner.js";
+import { recordingsToFixtures } from "./record-fixtures.js";
+import { collectRunResult } from "./run-result.js";
+/** Normalise a ScriptBuilder or bare FixtureSet to a FixtureSet. */
+function toFixtureSet(f) {
+    if (Array.isArray(f))
+        return f;
+    return f.build();
+}
+/** Extract the system prompt from a slice of aimock journal requests. */
+function systemPromptFromRequests(reqs) {
+    for (const req of reqs) {
+        const messages = req.body?.messages ?? [];
+        for (const m of messages) {
+            // OpenAI chat models use role "system"; gpt-5 / reasoning models send the
+            // system prompt under role "developer". Accept either so the captured
+            // systemPrompt is populated regardless of which model the route uses.
+            if ((m.role === "system" || m.role === "developer") && typeof m.content === "string") {
+                return m.content;
+            }
+        }
+    }
+    return "";
+}
+export async function createAgentHarness(options) {
+    const live = options.live ?? false;
+    const record = options.record ?? false;
+    // Guard: live mode requires a real API key before doing anything else.
+    if (live && !process.env.OPENAI_API_KEY) {
+        throw new Error("createAgentHarness({ live: true }) requires OPENAI_API_KEY to be set in the environment");
+    }
+    const prevBaseUrl = process.env.OPENAI_BASE_URL;
+    const prevKey = process.env.OPENAI_API_KEY;
+    // Start aimock once — port (and thus the cached agent's baseURL) stays stable for the harness lifetime.
+    // In live mode: proxy all requests through to the real OpenAI upstream.
+    // In record mode: proxy to recordUpstream and capture responses for getRecordedFixtures().
+    const aimock = live
+        ? await createAimock({ fixtures: [], proxy: { openai: "https://api.openai.com" } })
+        : record
+            ? await createAimock({
+                fixtures: [],
+                proxy: { openai: options.recordUpstream ?? "https://api.openai.com" },
+                record: true,
+            })
+            : await createAimock({ fixtures: options.fixtures ?? [] });
+    process.env.OPENAI_BASE_URL = aimock.baseUrl;
+    // Only inject a dummy key in mock mode; live and record modes use real or no key.
+    if (!live && !record) {
+        process.env.OPENAI_API_KEY = process.env.OPENAI_API_KEY ?? "test-not-used";
+    }
+    // All construction steps after aimock starts are wrapped so we can clean up on failure.
+    let resolved;
+    let sandboxManager;
+    try {
+        // typegen once → generated tool schemas exist (dev-boot fidelity)
+        const manifest = await discoverRoutes({ appRoot: options.appRoot });
+        await runTypegen({ appRoot: options.appRoot, manifest });
+        const registry = await createRuntimeRegistry(options.appRoot);
+        resolved = registry.lookup(options.route);
+        if (!resolved) {
+            throw new Error(`createAgentHarness: unknown route "${options.route}"`);
+        }
+        sandboxManager = await resolveSandboxManager(options.appRoot);
+    }
+    catch (err) {
+        // Unified cleanup: stop aimock and restore env vars before re-throwing.
+        if (sandboxManager)
+            await sandboxManager.releaseAll();
+        await aimock.close();
+        if (prevBaseUrl === undefined)
+            delete process.env.OPENAI_BASE_URL;
+        else
+            process.env.OPENAI_BASE_URL = prevBaseUrl;
+        if (prevKey === undefined)
+            delete process.env.OPENAI_API_KEY;
+        else
+            process.env.OPENAI_API_KEY = prevKey;
+        throw err;
+    }
+    const baseUrl = aimock.baseUrl;
+    let threadId = randomUUID();
+    let closed = false;
+    let lastRunJournalStart = 0;
+    let lastRunFixtureStart = 0;
+    /** Core drive helper — runs a single turn and merges systemPrompt. */
+    async function drive(driveOpts) {
+        // In live and record modes, fixtures are proxied to the upstream — skip registration.
+        if (!live && !record && driveOpts.fixtures) {
+            const newFixtures = toFixtureSet(driveOpts.fixtures);
+            if (newFixtures.length > 0) {
+                aimock.addFixtures(newFixtures);
+            }
+        }
+        const snapshotLen = aimock.getRequests().length;
+        lastRunJournalStart = snapshotLen;
+        lastRunFixtureStart = aimock.getFixtureCount();
+        const r = resolved;
+        if (!r) {
+            throw new Error(`createAgentHarness: unknown route "${options.route}"`);
+        }
+        let resolvedResume;
+        if (driveOpts.resume) {
+            const checkpointer = await resolveCheckpointer(options.appRoot);
+            const pending = await readPendingInterrupts(checkpointer, threadId);
+            if (!pending) {
+                throw new Error(`createAgentHarness: no checkpoint found for thread "${threadId}"`);
+            }
+            const resolution = resolvePendingResume(driveOpts.resume, pending);
+            if (!resolution.ok) {
+                throw new Error(`createAgentHarness: ${resolution.message} (${resolution.code})`);
+            }
+            if (resolution.mode !== "resume") {
+                throw new Error("createAgentHarness: no pending interrupts to resume");
+            }
+            resolvedResume = resolution.resume;
+        }
+        const streamArgs = {
+            appRoot: options.appRoot,
+            input: driveOpts.input !== undefined
+                ? { messages: [{ role: "user", content: driveOpts.input }] }
+                : { messages: [] },
+            routeFile: r.routeFile,
+            routeId: r.routeId,
+            routePath: r.routePath,
+            threadId,
+            ...(sandboxManager ? { sandboxManager } : {}),
+            ...(resolvedResume ? { resume: resolvedResume } : {}),
+        };
+        const stream = streamResolvedRoute(streamArgs);
+        const result = await collectRunResult(stream, threadId);
+        const turnReqs = aimock.getRequests().slice(snapshotLen);
+        return { ...result, systemPrompt: systemPromptFromRequests(turnReqs) };
+    }
+    const harness = {
+        get baseUrl() {
+            return baseUrl;
+        },
+        async run(runOpts) {
+            return drive({
+                input: runOpts.input,
+                ...(runOpts.fixtures !== undefined ? { fixtures: runOpts.fixtures } : {}),
+            });
+        },
+        async resume(resumeOpts) {
+            return drive({
+                resume: resumeOpts.resume,
+                ...(resumeOpts.fixtures !== undefined ? { fixtures: resumeOpts.fixtures } : {}),
+            });
+        },
+        reset() {
+            threadId = randomUUID();
+            // Start each scenario from a clean fixture set. Fixtures are registered
+            // additively per run() and findFixture is first-match-in-array-order, so
+            // without this a loosely-matched fixture from a prior scenario (e.g. a raw
+            // FixtureSet with no `userMessage`) would shadow the next run's turn-0
+            // call. Live mode proxies to the real upstream and registers no fixtures.
+            if (!live) {
+                aimock.clearFixtures();
+                if (options.fixtures && options.fixtures.length > 0) {
+                    aimock.addFixtures(options.fixtures);
+                }
+            }
+        },
+        getRecordedFixtures() {
+            return recordingsToFixtures(aimock.getRecordingsSince(lastRunJournalStart, lastRunFixtureStart));
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            if (sandboxManager)
+                await sandboxManager.releaseAll();
+            await aimock.close();
+            // restore env to avoid cross-test bleed
+            if (prevBaseUrl === undefined)
+                delete process.env.OPENAI_BASE_URL;
+            else
+                process.env.OPENAI_BASE_URL = prevBaseUrl;
+            if (prevKey === undefined)
+                delete process.env.OPENAI_API_KEY;
+            else
+                process.env.OPENAI_API_KEY = prevKey;
+            // Reset the per-descriptor LLM cache so the next harness constructs a
+            // fresh ChatOpenAI instance pointing to its own aimock URL. Without this,
+            // successive harnesses that share the same B4Agent descriptor object
+            // (ESM module cache returns the same export) would reuse an LLM already
+            // bound to the previous (stopped) aimock server.
+            __resetMaterializedAgentsForTests();
+            // loadB4Config is now memoized per appRoot for the process lifetime
+            // (perf(core): memoize loadB4Config per appRoot). Test suites that
+            // rewrite a fixture app's b4.config.ts and drive it again through a
+            // fresh harness in the same process (e.g. switching a memory backend
+            // via env + config) need that mutation to actually take effect — clear
+            // the memo here so the next createAgentHarness call reloads from disk.
+            __clearB4ConfigCacheForTests();
+            // Same reasoning for the per-route module cache and per-appRoot route
+            // manifest memo (perf(cli): load route modules/tools/state once per
+            // process): a fixture app mutated between harnesses (new tool file,
+            // added route) must be re-discovered by the next harness.
+            __resetRouteLoadCachesForTests();
+        },
+        [Symbol.asyncDispose]() {
+            return this.close();
+        },
+    };
+    return harness;
+}

package/dist/http-inject.d.ts

@@ -0,0 +1,22 @@
+import type { ThreadAccessPolicy } from "@b4run/sdk";
+export interface InjectResult {
+    readonly statusCode: number;
+    readonly body: string;
+    readonly headers: Record<string, unknown>;
+}
+export interface AgentProtocolInjector {
+    inject(opts: {
+        method: string;
+        url: string;
+        payload?: unknown;
+        headers?: Record<string, string>;
+    }): Promise<InjectResult>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare function createAgentProtocolInjector(options: {
+    appRoot: string;
+    /** Injected rather than probed from disk, so a test needs no policy file. */
+    threadAccess?: ThreadAccessPolicy;
+}): Promise<AgentProtocolInjector>;
+//# sourceMappingURL=http-inject.d.ts.map

package/dist/http-inject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-inject.d.ts","sourceRoot":"","sources":["../src/http-inject.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC1C;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,IAAI,EAAE;QACX,MAAM,EAAE,MAAM,CAAA;QACd,GAAG,EAAE,MAAM,CAAA;QACX,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KACjC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvC;AAED,wBAAsB,2BAA2B,CAAC,OAAO,EAAE;IACzD,OAAO,EAAE,MAAM,CAAA;IACf,6EAA6E;IAC7E,YAAY,CAAC,EAAE,kBAAkB,CAAA;CAClC,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAsDjC"}

package/dist/http-inject.js

@@ -0,0 +1,55 @@
+import { createRuntimeFetchHandler } from "@b4run/cli/runtime";
+import { __clearB4ConfigCacheForTests } from "@b4run/core";
+export async function createAgentProtocolInjector(options) {
+    const core = await createRuntimeFetchHandler({
+        appRoot: options.appRoot,
+        ...(options.threadAccess ? { threadAccess: options.threadAccess } : {}),
+    });
+    const injector = {
+        async inject(opts) {
+            const requestHeaders = new Headers({
+                "content-type": "application/json",
+                ...opts.headers,
+            });
+            const request = new Request(new URL(opts.url, "http://localhost"), {
+                headers: requestHeaders,
+                method: opts.method,
+                ...(opts.payload !== undefined ? { body: JSON.stringify(opts.payload) } : {}),
+            });
+            const response = await core.fetch(request);
+            // Read the (possibly SSE) body to completion — the harness's `inject`
+            // contract is synchronous-style, matching the pre-refactor
+            // light-my-request behavior of returning the fully buffered body.
+            const body = await response.text();
+            const headers = {};
+            for (const [key, value] of response.headers) {
+                // `getSetCookie` preserves multiple Set-Cookie headers, which
+                // `Headers` iteration would otherwise join into one comma-separated
+                // value.
+                if (key.toLowerCase() === "set-cookie")
+                    continue;
+                headers[key] = value;
+            }
+            const setCookie = response.headers.getSetCookie?.() ?? [];
+            if (setCookie.length > 0)
+                headers["set-cookie"] = setCookie;
+            return {
+                body,
+                headers,
+                statusCode: response.status,
+            };
+        },
+        async close() {
+            await core.close();
+            // See harness.ts's close() for why: loadB4Config is memoized per
+            // appRoot for the process lifetime, so a fixture app's b4.config.ts
+            // mutated and re-served through a fresh injector in the same process
+            // needs the memo cleared to pick up the change.
+            __clearB4ConfigCacheForTests();
+        },
+        [Symbol.asyncDispose]() {
+            return this.close();
+        },
+    };
+    return injector;
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export { type Aimock, createAimock } from "./aimock-runner.js";
+export { runCheckpointerConformance } from "./checkpointer-conformance.js";
+export { fakeEmbedder } from "./fake-embedder.js";
+export { type AimockFixture, type AimockResponse, type AimockToolCall, type FixtureSet, type ScriptBuilder, script, } from "./fixture-builder.js";
+export { loadFixtures, writeFixtures } from "./fixture-file.js";
+export { type AgentHarness, type AgentHarnessOptions, createAgentHarness } from "./harness.js";
+export { type AgentProtocolInjector, createAgentProtocolInjector, type InjectResult, } from "./http-inject.js";
+export { expectFinalMessage, expectInterrupt, expectNoInterrupt, expectNoToolErrors, expectOffloaded, expectPlan, expectState, expectStreamedTokens, expectSubagent, expectSystemPrompt, expectToolCalled, expectToolSequence, type InterruptInfo, type SubagentEvent, type SubagentRun, type Todo, } from "./matchers.js";
+export { seedMemory } from "./memory.js";
+export { runMemoryStoreConformance } from "./memory-conformance.js";
+export { createMiddlewareHarness, type MiddlewareHarness, } from "./middleware-harness.js";
+export { type PermissionsStoreInit, runPermissionsStoreConformance, } from "./permissions-conformance.js";
+export { type RecordOptions, record } from "./record.js";
+export { type AgentRunResult, collectRunResult, deriveToolResults, type ObservedToolCall, type ObservedToolResult, } from "./run-result.js";
+export { createSubprocessApp, type SubprocessApp } from "./subprocess.js";
+export { createThreadAccessHarness, type ThreadAccessCheckSpec, type ThreadAccessHarness, } from "./thread-access-harness.js";
+export { runThreadsStoreConformance } from "./threads-conformance.js";
+export { createToolHarness, type ToolHarness, type ToolHarnessOptions, } from "./tool-harness.js";
+export { createWorkspaceHarness, type WorkspaceHarness, type WorkspaceHarnessOptions, } from "./workspace-harness.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAC9D,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAA;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,MAAM,GACP,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAC/D,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAC9F,OAAO,EACL,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,YAAY,GAClB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,WAAW,EACX,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,IAAI,GACV,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,EACL,uBAAuB,EACvB,KAAK,iBAAiB,GACvB,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,KAAK,oBAAoB,EACzB,8BAA8B,GAC/B,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EACL,KAAK,cAAc,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACzE,OAAO,EACL,yBAAyB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAA;AACrE,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,kBAAkB,GACxB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,GAC7B,MAAM,wBAAwB,CAAA"}

package/dist/index.js

@@ -0,0 +1,19 @@
+export { createAimock } from "./aimock-runner.js";
+export { runCheckpointerConformance } from "./checkpointer-conformance.js";
+export { fakeEmbedder } from "./fake-embedder.js";
+export { script, } from "./fixture-builder.js";
+export { loadFixtures, writeFixtures } from "./fixture-file.js";
+export { createAgentHarness } from "./harness.js";
+export { createAgentProtocolInjector, } from "./http-inject.js";
+export { expectFinalMessage, expectInterrupt, expectNoInterrupt, expectNoToolErrors, expectOffloaded, expectPlan, expectState, expectStreamedTokens, expectSubagent, expectSystemPrompt, expectToolCalled, expectToolSequence, } from "./matchers.js";
+export { seedMemory } from "./memory.js";
+export { runMemoryStoreConformance } from "./memory-conformance.js";
+export { createMiddlewareHarness, } from "./middleware-harness.js";
+export { runPermissionsStoreConformance, } from "./permissions-conformance.js";
+export { record } from "./record.js";
+export { collectRunResult, deriveToolResults, } from "./run-result.js";
+export { createSubprocessApp } from "./subprocess.js";
+export { createThreadAccessHarness, } from "./thread-access-harness.js";
+export { runThreadsStoreConformance } from "./threads-conformance.js";
+export { createToolHarness, } from "./tool-harness.js";
+export { createWorkspaceHarness, } from "./workspace-harness.js";

package/dist/matchers.d.ts

@@ -0,0 +1,56 @@
+import type { AgentRunResult, InterruptInfo, SubagentEvent, SubagentRun, Todo } from "./run-result.js";
+export type { InterruptInfo, SubagentEvent, SubagentRun, Todo };
+export declare function expectToolCalled(run: AgentRunResult, name: string): {
+    withArgs(partial: Record<string, unknown>): void;
+    times(n: number): void;
+    never(): never;
+};
+/**
+ * Assert the named tools were called IN ORDER. By default a subsequence (other
+ * tool calls may appear between them); `{ strict: true }` requires them to be
+ * contiguous.
+ */
+export declare function expectToolSequence(run: AgentRunResult, names: readonly string[], opts?: {
+    readonly strict?: boolean;
+}): void;
+export declare function expectFinalMessage(run: AgentRunResult): {
+    toContain(s: string): void;
+    toMatch(re: RegExp): void;
+    toEqual(s: string): void;
+};
+export declare function expectStreamedTokens(run: AgentRunResult): void;
+export declare function expectOffloaded(run: AgentRunResult, toolName: string): void;
+export declare function expectInterrupt(run: AgentRunResult): {
+    ofKind(kind: string): /*elided*/ any;
+    withDetail(partial: Record<string, unknown>): /*elided*/ any;
+};
+export declare function expectNoInterrupt(run: AgentRunResult): void;
+export declare function expectSubagent(run: AgentRunResult, name: string): {
+    called(): /*elided*/ any;
+    calledTool(toolName: string): /*elided*/ any;
+    finalMessageContains(text: string): /*elided*/ any;
+};
+export declare function expectPlan(run: AgentRunResult): {
+    toHaveLength(n: number): void;
+    toHaveTodo(content: string): void;
+    toHaveStatus(content: string, status: string): void;
+};
+export declare function expectSystemPrompt(run: AgentRunResult): {
+    toContain(text: string): void;
+    toMatch(re: RegExp): void;
+};
+/**
+ * Assert no tool returned an error result. A HITL permission interrupt is NOT a
+ * tool error — it produces no ToolMessage, so it never appears in toolResults.
+ */
+export declare function expectNoToolErrors(run: AgentRunResult): void;
+export declare function expectState(run: AgentRunResult): {
+    messages: {
+        toHaveLength(n: number): void;
+    };
+    field(name: string): {
+        toBeTruthy(): void;
+        toEqual(expected: unknown): void;
+    };
+};
+//# sourceMappingURL=matchers.d.ts.map

package/dist/matchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../src/matchers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,aAAa,EACb,WAAW,EACX,IAAI,EACL,MAAM,iBAAiB,CAAA;AAExB,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,IAAI,EAAE,CAAA;AAmC/D,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM;IAQ9D,QAAQ,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAOzC,KAAK,IAAI,MAAM;IAGf,KAAK;EAIR;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,cAAc,EACnB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GACnC,IAAI,CAWN;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,cAAc;IAElD,SAAS,IAAI,MAAM;IAMnB,OAAO,KAAK,MAAM;IAIlB,OAAO,IAAI,MAAM;EAKpB;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAE9D;AAkCD,wBAAgB,eAAe,CAAC,GAAG,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAQ3E;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,cAAc;iBAKlC,MAAM;wBAQC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;EAa9C;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAM3D;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM;;yBAWvC,MAAM;+BAUA,MAAM;EAYpC;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,cAAc;IAE1C,YAAY,IAAI,MAAM;IAGtB,UAAU,UAAU,MAAM;IAO1B,YAAY,UAAU,MAAM,UAAU,MAAM;EAY/C;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,cAAc;IAElD,SAAS,OAAO,MAAM;IAOtB,OAAO,KAAK,MAAM;EAOrB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI,CAY5D;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,cAAc;IAG3C,QAAQ;QACN,YAAY,IAAI,MAAM;;IAKxB,KAAK,OAAO,MAAM;QAGd,UAAU;QAGV,OAAO,WAAW,OAAO;;EAUhC"}