@b4run/testing 0.8.28

package/dist/run-result.js

@@ -0,0 +1,287 @@
+/** 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 function deriveToolResults(messages) {
+    const results = [];
+    for (const m of messages) {
+        // Serialized format: id is the class-path array, name/status/content are in kwargs.
+        const id = m.id;
+        const isSerializedToolMessage = Array.isArray(id) && id[id.length - 1] === "ToolMessage";
+        // Live LangChain instance format: type property is "tool" on the live object.
+        const isLiveToolMessage = m.type === "tool";
+        if (isSerializedToolMessage) {
+            const kwargs = (m.kwargs ?? {});
+            const status = kwargs.status === "error" || kwargs.status === "success" ? kwargs.status : undefined;
+            results.push({
+                name: typeof kwargs.name === "string" ? kwargs.name : "",
+                content: kwargs.content,
+                isError: status === "error",
+                ...(status ? { status } : {}),
+            });
+        }
+        else if (isLiveToolMessage) {
+            const status = m.status === "error" || m.status === "success"
+                ? m.status
+                : undefined;
+            results.push({
+                name: typeof m.name === "string" ? m.name : "",
+                content: m.content,
+                isError: status === "error",
+                ...(status ? { status } : {}),
+            });
+        }
+    }
+    return results;
+}
+function finalMessageFrom(state) {
+    const messages = Array.isArray(state.messages)
+        ? state.messages
+        : [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        const isAi = (Array.isArray(m.id) && m.id[2] === "AIMessage") || m.type === "ai";
+        if (!isAi)
+            continue;
+        const content = m.kwargs?.content ?? m.content;
+        if (typeof content === "string")
+            return content;
+    }
+    return "";
+}
+function normalizeToolArgs(raw) {
+    // LangChain/LangGraph may deliver tool input as:
+    //   - an already-parsed object → use as-is
+    //   - a JSON string → parse
+    //   - { input: '<json-string>' } single-key envelope (LangGraph tool wrapper) → unwrap + parse
+    if (typeof raw === "string") {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return raw;
+        }
+    }
+    if (raw !== null &&
+        typeof raw === "object" &&
+        "input" in raw &&
+        Object.keys(raw).length === 1 &&
+        typeof raw.input === "string") {
+        try {
+            return JSON.parse(raw.input);
+        }
+        catch {
+            return raw;
+        }
+    }
+    return raw;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasStringFields(value, fields) {
+    return isRecord(value) && fields.every((field) => typeof value[field] === "string");
+}
+function isCommandInterruptDetail(value) {
+    return hasStringFields(value, ["command", "suggestedPattern"]);
+}
+function isPathInterruptDetail(value) {
+    return (hasStringFields(value, ["path", "operation", "suggestedPattern"]) &&
+        (value.operation === "readFile" ||
+            value.operation === "writeFile" ||
+            value.operation === "listDir"));
+}
+function isToolInterruptDetail(value) {
+    return hasStringFields(value, ["toolName", "argsPreview", "suggestedPattern"]);
+}
+function isMemoryInterruptDetail(value) {
+    return hasStringFields(value, [
+        "namespace",
+        "identity",
+        "oldId",
+        "oldContent",
+        "newContent",
+        "suggestedPattern",
+    ]);
+}
+function isSubagentInterruptDetail(value) {
+    return (hasStringFields(value, [
+        "parentRouteId",
+        "subagentName",
+        "subagentRouteId",
+        "inputPreview",
+        "suggestedPattern",
+    ]) &&
+        (!Object.hasOwn(value, "reason") || typeof value.reason === "string"));
+}
+function parseInterruptInfo(value) {
+    if (!isRecord(value))
+        throw new Error("Malformed interrupt envelope");
+    if (typeof value.interruptId !== "string" || value.interruptId === "") {
+        throw new Error("Malformed interrupt envelope: interruptId must be a non-empty string");
+    }
+    if (value.callId !== undefined && (typeof value.callId !== "string" || value.callId === "")) {
+        throw new Error("Malformed interrupt envelope: callId must be a non-empty string");
+    }
+    const base = {
+        interruptId: value.interruptId,
+        ...(value.callId !== undefined ? { callId: value.callId } : {}),
+    };
+    switch (value.kind) {
+        case "command":
+            if (!isCommandInterruptDetail(value.detail)) {
+                throw new Error('Malformed "command" interrupt detail');
+            }
+            return { ...base, kind: value.kind, detail: value.detail };
+        case "path":
+            if (!isPathInterruptDetail(value.detail)) {
+                throw new Error('Malformed "path" interrupt detail');
+            }
+            return { ...base, kind: value.kind, detail: value.detail };
+        case "tool":
+            if (!isToolInterruptDetail(value.detail)) {
+                throw new Error('Malformed "tool" interrupt detail');
+            }
+            return { ...base, kind: value.kind, detail: value.detail };
+        case "memory":
+            if (!isMemoryInterruptDetail(value.detail)) {
+                throw new Error('Malformed "memory" interrupt detail');
+            }
+            return { ...base, kind: value.kind, detail: value.detail };
+        case "subagent":
+            if (!isSubagentInterruptDetail(value.detail)) {
+                throw new Error('Malformed "subagent" interrupt detail');
+            }
+            return { ...base, kind: value.kind, detail: value.detail };
+        default:
+            throw new Error(`Unsupported interrupt kind "${String(value.kind)}"`);
+    }
+}
+export async function collectRunResult(stream, threadId) {
+    const tokens = [];
+    const toolCalls = [];
+    let state = {};
+    const interrupts = [];
+    const planUpdates = [];
+    let todos = [];
+    const subagentEvents = [];
+    // In-progress subagent runs keyed by call_id
+    const subagentMap = new Map();
+    const finishedSubagents = [];
+    function subagentFor(callId) {
+        let run = subagentMap.get(callId);
+        if (!run) {
+            run = { callId, name: callId, toolCalls: [] };
+            subagentMap.set(callId, run);
+        }
+        return run;
+    }
+    for await (const chunk of stream) {
+        if (chunk.type.startsWith("subagent.")) {
+            const data = chunk.data ?? {};
+            subagentEvents.push({ type: chunk.type, data });
+        }
+        switch (chunk.type) {
+            case "chunk":
+                if (typeof chunk.data === "string")
+                    tokens.push(chunk.data);
+                break;
+            case "tool_call": {
+                // chunk.name and chunk.input are typed on the tool_call variant
+                const c = chunk;
+                const entry = c.id !== undefined
+                    ? { name: c.name, args: normalizeToolArgs(c.input), id: c.id }
+                    : { name: c.name, args: normalizeToolArgs(c.input) };
+                toolCalls.push(entry);
+                break;
+            }
+            case "done": {
+                const out = chunk.output;
+                if (out && typeof out === "object")
+                    state = out;
+                break;
+            }
+            case "interrupt": {
+                const data = chunk.data;
+                interrupts.push(parseInterruptInfo(data));
+                break;
+            }
+            case "plan_update": {
+                const d = chunk.data ?? {};
+                const rawTodos = Array.isArray(d.todos) ? d.todos : [];
+                const update = { todos: rawTodos };
+                planUpdates.push(update);
+                todos = update.todos;
+                break;
+            }
+            case "subagent.start": {
+                const d = chunk.data ?? {};
+                const callId = String(d.call_id ?? "");
+                const run = subagentFor(callId);
+                run.name = String(d.subagent ?? callId);
+                break;
+            }
+            case "subagent.tool_call": {
+                const d = chunk.data ?? {};
+                const callId = String(d.call_id ?? "");
+                const run = subagentFor(callId);
+                run.toolCalls.push({ name: String(d.tool ?? ""), args: normalizeToolArgs(d.input) });
+                break;
+            }
+            case "subagent.end": {
+                const d = chunk.data ?? {};
+                const callId = String(d.call_id ?? "");
+                const run = subagentFor(callId);
+                if (d.final_message !== undefined) {
+                    run.finalMessage = String(d.final_message);
+                }
+                if (d.error !== undefined) {
+                    run.error = String(d.error);
+                }
+                subagentMap.delete(callId);
+                const finished = run.finalMessage !== undefined && run.error !== undefined
+                    ? {
+                        callId: run.callId,
+                        name: run.name,
+                        toolCalls: run.toolCalls,
+                        finalMessage: run.finalMessage,
+                        error: run.error,
+                    }
+                    : run.finalMessage !== undefined
+                        ? {
+                            callId: run.callId,
+                            name: run.name,
+                            toolCalls: run.toolCalls,
+                            finalMessage: run.finalMessage,
+                        }
+                        : run.error !== undefined
+                            ? { callId: run.callId, name: run.name, toolCalls: run.toolCalls, error: run.error }
+                            : { callId: run.callId, name: run.name, toolCalls: run.toolCalls };
+                finishedSubagents.push(finished);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const finalMessages = Array.isArray(state.messages)
+        ? state.messages
+        : [];
+    return {
+        threadId,
+        tokens,
+        toolCalls,
+        toolResults: deriveToolResults(finalMessages),
+        state,
+        messages: finalMessages,
+        finalMessage: finalMessageFrom(state),
+        interrupts,
+        planUpdates,
+        todos,
+        subagents: finishedSubagents,
+        subagentEvents,
+        systemPrompt: "",
+    };
+}

package/dist/subprocess.d.ts

@@ -0,0 +1,25 @@
+import { type ChildProcess } from "node:child_process";
+export interface SubprocessApp {
+    readonly baseUrl: string;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export interface TerminationTimings {
+    readonly graceMs: number;
+    readonly forceMs: number;
+    readonly probeIntervalMs: number;
+    readonly probeTimeoutMs: number;
+}
+interface TerminationDependencies {
+    readonly platform: NodeJS.Platform;
+    readonly taskkillProcessTree: (pid: number, timeoutMs: number) => Promise<void>;
+}
+export declare function terminateSubprocess(child: ChildProcess, groupPid: number, closed: Promise<void>, baseUrl: string, timings?: TerminationTimings, injectedDependencies?: Partial<TerminationDependencies>): Promise<void>;
+export declare function createSubprocessApp(opts: {
+    readonly appRoot: string;
+    readonly env?: Record<string, string>;
+    readonly port?: number;
+    readonly readyTimeoutMs?: number;
+}): Promise<SubprocessApp>;
+export {};
+//# sourceMappingURL=subprocess.d.ts.map

package/dist/subprocess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subprocess.d.ts","sourceRoot":"","sources":["../src/subprocess.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAmB,MAAM,oBAAoB,CAAA;AAMvE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAChC;AAsHD,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAA;IAClC,QAAQ,CAAC,mBAAmB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAChF;AA2CD,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,kBAAgD,EACzD,oBAAoB,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC1D,OAAO,CAAC,IAAI,CAAC,CAgDf;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CACjC,GAAG,OAAO,CAAC,aAAa,CAAC,CAiDzB"}

package/dist/subprocess.js

@@ -0,0 +1,223 @@
+import { execFile, spawn } from "node:child_process";
+import { createConnection, createServer } from "node:net";
+import { dirname, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+const DEFAULT_TERMINATION_TIMINGS = {
+    graceMs: 2_000,
+    forceMs: 2_000,
+    probeIntervalMs: 25,
+    probeTimeoutMs: 100,
+};
+/** Bind to port 0, read the OS-assigned port, release it. */
+async function getFreePort() {
+    return await new Promise((resolve, reject) => {
+        const srv = createServer();
+        srv.unref();
+        srv.on("error", reject);
+        srv.listen(0, "127.0.0.1", () => {
+            const addr = srv.address();
+            const port = typeof addr === "object" && addr ? addr.port : 0;
+            srv.close(() => resolve(port));
+        });
+    });
+}
+async function waitReady(url, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const res = await fetch(url);
+            if (res.ok) {
+                const body = (await res.json());
+                if (body.status === "ready")
+                    return;
+            }
+        }
+        catch {
+            // not up yet
+        }
+        await delay(300);
+    }
+    throw new Error(`subprocess app not ready at ${url} within ${timeoutMs}ms`);
+}
+/**
+ * Resolve the absolute path to the b4 CLI entry point so the subprocess can
+ * be spawned without relying on the probe-app's local node_modules or PATH.
+ * We look relative to this module's own location inside the testing package.
+ */
+function resolveB4CliEntry() {
+    // import.meta.url resolves to something like:
+    //   .../packages/testing/src/subprocess.ts  (ts-node / source)
+    //   .../packages/testing/dist/subprocess.js (compiled)
+    const here = dirname(fileURLToPath(import.meta.url));
+    // Climb up to packages/testing, then into node_modules/.bin b4 → ../cli/dist/index.js
+    // The shell script points at: $basedir/../@b4run/cli/dist/index.js
+    // $basedir = packages/testing/node_modules/.bin
+    // So the entry is: packages/testing/node_modules/@b4run/cli/dist/index.js
+    //
+    // "here" is either packages/testing/src or packages/testing/dist — one level below the package root.
+    const pkgRoot = resolve(here, "..");
+    return resolve(pkgRoot, "node_modules", "@b4run", "cli", "dist", "index.js");
+}
+function childClosePromise(child) {
+    return new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", () => resolve());
+    });
+}
+function portAcceptsConnections(baseUrl, timeoutMs) {
+    const url = new URL(baseUrl);
+    return new Promise((resolve) => {
+        let settled = false;
+        const socket = createConnection({ host: url.hostname, port: Number(url.port) });
+        const finish = (accepting) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(accepting);
+        };
+        const timer = setTimeout(() => finish(true), timeoutMs);
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+    });
+}
+async function waitUntilStopped(childState, baseUrl, timeoutMs, timings) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const remainingMs = Math.max(0, deadline - Date.now());
+        const accepting = await portAcceptsConnections(baseUrl, Math.min(timings.probeTimeoutMs, remainingMs));
+        if (childState.failed)
+            throw childState.error;
+        if (childState.closed && !accepting)
+            return true;
+        const waitMs = Math.min(timings.probeIntervalMs, deadline - Date.now());
+        if (waitMs <= 0)
+            return false;
+        await delay(waitMs);
+    }
+}
+function taskkillProcessTree(pid, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        execFile("taskkill.exe", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, timeout: Math.max(1, timeoutMs), maxBuffer: 64 * 1024 }, (error) => (error ? reject(error) : resolve()));
+    });
+}
+async function requestProcessTreeTermination(child, childState, groupPid, signal, timeoutMs, dispatchErrors, dependencies) {
+    if (dependencies.platform === "win32") {
+        if (childState.closed || child.exitCode !== null || child.signalCode !== null)
+            return;
+        const deadline = Date.now() + timeoutMs;
+        try {
+            await dependencies.taskkillProcessTree(groupPid, timeoutMs);
+            return;
+        }
+        catch (error) {
+            dispatchErrors.push(error);
+            if (signal !== "SIGKILL")
+                return;
+            if (Date.now() >= deadline)
+                return;
+            if (childState.closed || child.exitCode !== null || child.signalCode !== null)
+                return;
+            try {
+                child.kill(signal);
+            }
+            catch (childError) {
+                dispatchErrors.push(childError);
+            }
+            return;
+        }
+    }
+    try {
+        process.kill(-groupPid, signal);
+    }
+    catch (error) {
+        dispatchErrors.push(error);
+        try {
+            child.kill(signal);
+        }
+        catch (childError) {
+            dispatchErrors.push(childError);
+        }
+    }
+}
+export async function terminateSubprocess(child, groupPid, closed, baseUrl, timings = DEFAULT_TERMINATION_TIMINGS, injectedDependencies = {}) {
+    const dependencies = {
+        platform: injectedDependencies.platform ?? process.platform,
+        taskkillProcessTree: injectedDependencies.taskkillProcessTree ?? taskkillProcessTree,
+    };
+    const childState = {
+        closed: false,
+        failed: false,
+        error: undefined,
+    };
+    void closed.then(() => {
+        childState.closed = true;
+    }, (error) => {
+        childState.failed = true;
+        childState.error = error;
+    });
+    const portAccepting = await portAcceptsConnections(baseUrl, timings.probeTimeoutMs);
+    if (childState.failed)
+        throw childState.error;
+    if (childState.closed && !portAccepting)
+        return;
+    const dispatchErrors = [];
+    const waitForPhase = async (signal, phaseMs) => {
+        const deadline = Date.now() + phaseMs;
+        await requestProcessTreeTermination(child, childState, groupPid, signal, Math.max(0, deadline - Date.now()), dispatchErrors, dependencies);
+        return await waitUntilStopped(childState, baseUrl, Math.max(0, deadline - Date.now()), timings);
+    };
+    if (await waitForPhase("SIGTERM", timings.graceMs))
+        return;
+    if (await waitForPhase("SIGKILL", timings.forceMs))
+        return;
+    const message = `subprocess group ${groupPid} did not stop within ${timings.graceMs + timings.forceMs}ms after SIGTERM and SIGKILL`;
+    if (dispatchErrors.length === 0)
+        throw new Error(message);
+    const cause = dispatchErrors.length === 1
+        ? dispatchErrors[0]
+        : new AggregateError(dispatchErrors, "subprocess termination signal dispatch failed");
+    throw new Error(message, { cause });
+}
+export async function createSubprocessApp(opts) {
+    const port = opts.port ?? (await getFreePort());
+    const cliEntry = resolveB4CliEntry();
+    const child = spawn(process.execPath, [cliEntry, "dev", "--port", String(port)], {
+        cwd: opts.appRoot,
+        env: { ...process.env, ...opts.env },
+        stdio: "pipe",
+        detached: true,
+    });
+    const groupPid = child.pid;
+    const closed = childClosePromise(child);
+    if (groupPid === undefined) {
+        await closed;
+        throw new Error("b4 dev subprocess has no process id");
+    }
+    // surface server logs for debugging on failure
+    child.stdout?.on("data", (b) => process.stdout.write(`[b4 dev] ${b}`));
+    child.stderr?.on("data", (b) => process.stderr.write(`[b4 dev] ${b}`));
+    const baseUrl = `http://127.0.0.1:${port}`;
+    let closePromise;
+    const close = () => {
+        closePromise ??= terminateSubprocess(child, groupPid, closed, baseUrl, DEFAULT_TERMINATION_TIMINGS);
+        return closePromise;
+    };
+    try {
+        await waitReady(`${baseUrl}/healthz`, opts.readyTimeoutMs ?? 60_000);
+    }
+    catch (err) {
+        await close();
+        throw err;
+    }
+    const app = {
+        baseUrl,
+        close,
+        [Symbol.asyncDispose]() {
+            return close();
+        },
+    };
+    return app;
+}

package/dist/thread-access-harness.d.ts

@@ -0,0 +1,40 @@
+import type { ThreadAccessPolicy, ThreadAccessResult, ThreadAction, ThreadOperation, ThreadSubject } from "@b4run/sdk";
+/** A partial `ThreadAccessRequest`: only `action` is required. */
+export interface ThreadAccessCheckSpec {
+    readonly action: ThreadAction;
+    /** Defaults to the canonical operation for the action. */
+    readonly operation?: ThreadOperation;
+    readonly threadId?: string;
+    readonly thread?: ThreadSubject;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly method?: string;
+    readonly url?: string;
+    readonly requestedMetadata?: Readonly<Record<string, unknown>>;
+    /**
+     * Whether this request continues a parked turn — see
+     * `ThreadAccessRequest.resuming`. Defaults to `false`, the value every
+     * endpoint but `POST /threads/:id/resume` and a resume-carrying
+     * `POST /agui/:routeId` reports.
+     */
+    readonly resuming?: boolean;
+}
+export interface ThreadAccessHarness {
+    /**
+     * Run one request through the policy exactly as the runtime would: the same
+     * `handler ?? fallback` selection, and the same result normalization — so a
+     * handler that returns nothing on some branch denies here too.
+     */
+    check(spec: ThreadAccessCheckSpec): Promise<ThreadAccessResult>;
+}
+/**
+ * Unit-test a thread access policy without booting a server.
+ *
+ * `createAgentHarness` is blind to policies by construction — it drives
+ * `streamResolvedRoute` directly, takes no run slot and writes no threads-store
+ * row — so this and `createAgentProtocolInjector({ threadAccess })` are the two
+ * surfaces that make a policy testable.
+ */
+export declare function createThreadAccessHarness(options: {
+    readonly policy: ThreadAccessPolicy;
+}): ThreadAccessHarness;
+//# sourceMappingURL=thread-access-harness.d.ts.map

package/dist/thread-access-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread-access-harness.d.ts","sourceRoot":"","sources":["../src/thread-access-harness.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,kBAAkB,EAElB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,aAAa,EACd,MAAM,YAAY,CAAA;AAEnB,kEAAkE;AAClE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,CAAA;IACpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAA;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAC9D;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;CAChE;AAeD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IACjD,QAAQ,CAAC,MAAM,EAAE,kBAAkB,CAAA;CACpC,GAAG,mBAAmB,CAmBtB"}

package/dist/thread-access-harness.js

@@ -0,0 +1,42 @@
+import { normalizeThreadAccessResult } from "@b4run/cli/runtime";
+const DEFAULT_OPERATION = {
+    create: "thread.create",
+    delete: "thread.delete",
+    read: "thread.get",
+    update: "thread.cancel",
+};
+function defaultMethod(action) {
+    if (action === "read")
+        return "GET";
+    if (action === "delete")
+        return "DELETE";
+    return "POST";
+}
+/**
+ * Unit-test a thread access policy without booting a server.
+ *
+ * `createAgentHarness` is blind to policies by construction — it drives
+ * `streamResolvedRoute` directly, takes no run slot and writes no threads-store
+ * row — so this and `createAgentProtocolInjector({ threadAccess })` are the two
+ * surfaces that make a policy testable.
+ */
+export function createThreadAccessHarness(options) {
+    return {
+        async check(spec) {
+            const operation = spec.operation ?? DEFAULT_OPERATION[spec.action];
+            const request = {
+                action: spec.action,
+                headers: spec.headers ?? {},
+                method: spec.method ?? defaultMethod(spec.action),
+                operation,
+                requestedMetadata: spec.requestedMetadata,
+                resuming: spec.resuming ?? false,
+                thread: spec.thread,
+                threadId: spec.threadId,
+                url: spec.url ?? (spec.threadId ? `/threads/${spec.threadId}` : "/threads"),
+            };
+            const handler = options.policy[spec.action] ?? options.policy.fallback;
+            return normalizeThreadAccessResult(await handler(request), operation, spec.threadId);
+        },
+    };
+}

package/dist/threads-conformance.d.ts

@@ -0,0 +1,18 @@
+import type { ThreadsStore } from "@b4run/sqlite-storage";
+/**
+ * The contract every ThreadsStore must satisfy. Run against the sqlite store
+ * (in-process, always) and any other backend (e.g. Postgres, gated) so they
+ * cannot drift. Pass vitest's `describe`; `makeStore` returns a FRESH empty
+ * store per call.
+ *
+ * Everything here goes through the public interface — never the tables — so a
+ * backend is free to choose its own column types (sqlite keeps `metadata` as a
+ * TEXT blob, Postgres as `jsonb`) as long as the observable behavior matches.
+ */
+export declare function runThreadsStoreConformance(opts: {
+    readonly name: string;
+    readonly makeStore: () => Promise<ThreadsStore> | ThreadsStore;
+    readonly describe: (name: string, fn: () => void) => void;
+    readonly close?: (store: ThreadsStore) => Promise<void> | void;
+}): void;
+//# sourceMappingURL=threads-conformance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"threads-conformance.d.ts","sourceRoot":"","sources":["../src/threads-conformance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAYjE;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAA;IAC9D,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,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAC/D,GAAG,IAAI,CAsRP"}