@b4run/testing 0.8.28

package/dist/matchers.js

@@ -0,0 +1,262 @@
+import { AssertionError } from "node:assert";
+import { createSafeRegexTester } from "./regex-safety.js";
+function fail(message) {
+    throw new AssertionError({ message });
+}
+function isSubsequence(actual, wanted) {
+    let i = 0;
+    for (const a of actual)
+        if (i < wanted.length && a === wanted[i])
+            i++;
+    return i === wanted.length;
+}
+function containsContiguous(actual, wanted) {
+    if (wanted.length === 0)
+        return true;
+    for (let s = 0; s + wanted.length <= actual.length; s++) {
+        let ok = true;
+        for (let j = 0; j < wanted.length; j++) {
+            if (actual[s + j] !== wanted[j]) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return true;
+    }
+    return false;
+}
+function isSubset(subset, actual) {
+    if (typeof actual !== "object" || actual === null)
+        return false;
+    const a = actual;
+    return Object.entries(subset).every(([k, v]) => typeof v === "object" && v !== null ? isSubset(v, a[k]) : a[k] === v);
+}
+export function expectToolCalled(run, name) {
+    const calls = run.toolCalls.filter((c) => c.name === name);
+    if (calls.length === 0) {
+        fail(`expected tool "${name}" to be called; tools called: ${run.toolCalls.map((c) => c.name).join(", ") || "(none)"}`);
+    }
+    return {
+        withArgs(partial) {
+            if (!calls.some((c) => isSubset(partial, c.args))) {
+                fail(`expected "${name}" called withArgs >= ${JSON.stringify(partial)}; got ${JSON.stringify(calls.map((c) => c.args))}`);
+            }
+        },
+        times(n) {
+            if (calls.length !== n)
+                fail(`expected "${name}" called ${n}x but was ${calls.length}x`);
+        },
+        never() {
+            fail(`expected "${name}" to NOT be called, but it was ${calls.length}x`);
+        },
+    };
+}
+/**
+ * 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 function expectToolSequence(run, names, opts) {
+    const actual = run.toolCalls.map((c) => c.name);
+    const ok = opts?.strict ? containsContiguous(actual, names) : isSubsequence(actual, names);
+    if (!ok) {
+        const missing = names.filter((n) => !actual.includes(n));
+        fail(`expected tool sequence ${names.join(" → ")}${opts?.strict ? " (contiguous)" : ""}; ` +
+            `got ${actual.join(" → ") || "(none)"}` +
+            (missing.length ? ` (missing: ${missing.join(", ")})` : ""));
+    }
+}
+export function expectFinalMessage(run) {
+    return {
+        toContain(s) {
+            if (!run.finalMessage.includes(s))
+                fail(`final message ${JSON.stringify(run.finalMessage)} does not contain ${JSON.stringify(s)}`);
+        },
+        toMatch(re) {
+            if (!createSafeRegexTester(re)(run.finalMessage))
+                fail(`final message ${JSON.stringify(run.finalMessage)} does not match ${re}`);
+        },
+        toEqual(s) {
+            if (run.finalMessage !== s)
+                fail(`final message ${JSON.stringify(run.finalMessage)} !== ${JSON.stringify(s)}`);
+        },
+    };
+}
+export function expectStreamedTokens(run) {
+    if (run.tokens.length === 0)
+        fail("expected >=1 streamed token, got none");
+}
+/**
+ * Resolve a message object to the `content` string, handling both the
+ * JSON-serialized AP shape (`{ id: [...], kwargs: { content } }`) and the
+ * raw LangChain BaseMessage instance shape (`{ lc_id: [...], content }`).
+ */
+function resolveMessageContent(m) {
+    // JSON-serialized AP shape: { id: ["langchain_core","messages","ToolMessage"], kwargs: { content } }
+    const kwContent = m.kwargs?.content;
+    if (typeof kwContent === "string")
+        return kwContent;
+    // Raw BaseMessage instance shape: { lc_id: [...], content }
+    const rawContent = m.content;
+    if (typeof rawContent === "string")
+        return rawContent;
+    return undefined;
+}
+/**
+ * Return true if `m` is a ToolMessage for the given tool name, regardless
+ * of whether the message is a raw LangChain BaseMessage instance or its
+ * JSON-serialized form (as produced by the AP endpoint).
+ */
+function isToolMessage(m, toolName) {
+    // JSON-serialized AP shape
+    const id = m.id;
+    const kw = m.kwargs;
+    if (Array.isArray(id) && id[2] === "ToolMessage" && kw?.name === toolName)
+        return true;
+    // Raw BaseMessage instance shape (in-process Layer A harness)
+    const lcId = m.lc_id;
+    const msgName = m.name;
+    if (Array.isArray(lcId) && lcId[2] === "ToolMessage" && msgName === toolName)
+        return true;
+    return false;
+}
+export function expectOffloaded(run, toolName) {
+    const msg = run.messages.find((m) => isToolMessage(m, toolName));
+    const content = (msg ? resolveMessageContent(msg) : undefined) ?? "";
+    if (!content.includes("Tool output offloaded")) {
+        fail(`expected "${toolName}" output to be offloaded (stub marker), got: ${content.slice(0, 120)}`);
+    }
+}
+export function expectInterrupt(run) {
+    if (run.interrupts.length === 0) {
+        fail("expected at least one interrupt, but none were captured");
+    }
+    const chain = {
+        ofKind(kind) {
+            if (!run.interrupts.some((i) => i.kind === kind)) {
+                fail(`expected an interrupt of kind "${kind}"; got: ${run.interrupts.map((i) => i.kind).join(", ") || "(none)"}`);
+            }
+            return chain;
+        },
+        withDetail(partial) {
+            const found = run.interrupts.some((i) => i.detail !== undefined && isSubset(partial, i.detail));
+            if (!found) {
+                fail(`expected an interrupt with detail >= ${JSON.stringify(partial)}; got: ${JSON.stringify(run.interrupts.map((i) => i.detail))}`);
+            }
+            return chain;
+        },
+    };
+    return chain;
+}
+export function expectNoInterrupt(run) {
+    if (run.interrupts.length > 0) {
+        fail(`expected no interrupts, but got ${run.interrupts.length}: ${run.interrupts.map((i) => i.kind).join(", ")}`);
+    }
+}
+export function expectSubagent(run, name) {
+    const sub = run.subagents.find((s) => s.name === name);
+    const chain = {
+        called() {
+            if (!sub) {
+                fail(`expected subagent "${name}" to be dispatched; subagents: ${run.subagents.map((s) => s.name).join(", ") || "(none)"}`);
+            }
+            return chain;
+        },
+        calledTool(toolName) {
+            if (!sub) {
+                fail(`expected subagent "${name}" to be dispatched (it was not)`);
+            }
+            else if (!sub.toolCalls.some((t) => t.name === toolName)) {
+                fail(`expected subagent "${name}" to call tool "${toolName}"; called: ${sub.toolCalls.map((t) => t.name).join(", ") || "(none)"}`);
+            }
+            return chain;
+        },
+        finalMessageContains(text) {
+            if (!sub) {
+                fail(`expected subagent "${name}" to be dispatched (it was not)`);
+            }
+            else if (!(sub.finalMessage ?? "").includes(text)) {
+                fail(`expected subagent "${name}" finalMessage to contain "${text}"; got: ${JSON.stringify(sub?.finalMessage)}`);
+            }
+            return chain;
+        },
+    };
+    return chain;
+}
+export function expectPlan(run) {
+    return {
+        toHaveLength(n) {
+            if (run.todos.length !== n)
+                fail(`expected ${n} todos, got ${run.todos.length}`);
+        },
+        toHaveTodo(content) {
+            if (!run.todos.some((t) => t.content === content)) {
+                fail(`expected a todo with content "${content}"; todos: ${run.todos.map((t) => t.content).join(", ") || "(none)"}`);
+            }
+        },
+        toHaveStatus(content, status) {
+            const todo = run.todos.find((t) => t.content === content);
+            if (!todo) {
+                fail(`expected a todo with content "${content}"; todos: ${run.todos.map((t) => t.content).join(", ") || "(none)"}`);
+            }
+            if (todo.status !== status) {
+                fail(`expected todo "${content}" to have status "${status}", but got "${todo.status}"`);
+            }
+        },
+    };
+}
+export function expectSystemPrompt(run) {
+    return {
+        toContain(text) {
+            if (!run.systemPrompt.includes(text)) {
+                fail(`expected systemPrompt to contain "${text}"; got: ${JSON.stringify(run.systemPrompt.slice(0, 120))}`);
+            }
+        },
+        toMatch(re) {
+            if (!createSafeRegexTester(re)(run.systemPrompt))
+                fail(`expected systemPrompt to match ${re}; got: ${JSON.stringify(run.systemPrompt.slice(0, 120))}`);
+        },
+    };
+}
+/**
+ * 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 function expectNoToolErrors(run) {
+    const errored = run.toolResults.filter((r) => r.isError);
+    if (errored.length > 0) {
+        const detail = errored
+            .map((r) => {
+            const first = typeof r.content === "string" ? (r.content.split("\n")[0] ?? "").slice(0, 140) : "";
+            return `"${r.name}" returned an error: ${first}`;
+        })
+            .join("; ");
+        fail(`expected no tool errors; ${detail}`);
+    }
+}
+export function expectState(run) {
+    const messages = Array.isArray(run.state.messages) ? run.state.messages : [];
+    return {
+        messages: {
+            toHaveLength(n) {
+                if (messages.length !== n)
+                    fail(`expected state.messages length ${n}, got ${messages.length}`);
+            },
+        },
+        field(name) {
+            const value = run.state[name];
+            return {
+                toBeTruthy() {
+                    if (!value)
+                        fail(`expected state.${name} to be truthy, got ${JSON.stringify(value)}`);
+                },
+                toEqual(expected) {
+                    if (JSON.stringify(value) !== JSON.stringify(expected)) {
+                        fail(`expected state.${name} = ${JSON.stringify(expected)}, got ${JSON.stringify(value)}`);
+                    }
+                },
+            };
+        },
+    };
+}

package/dist/memory-conformance.d.ts

@@ -0,0 +1,13 @@
+import { type MemoryStore } from "@b4run/memory";
+/**
+ * The contract every MemoryStore must satisfy. Run against sqlite (in-process,
+ * always) and pgvector (real Postgres, gated) so backends cannot drift. Pass
+ * vitest's `describe`; `makeStore` returns a FRESH empty store per call.
+ */
+export declare function runMemoryStoreConformance(opts: {
+    readonly name: string;
+    readonly makeStore: () => Promise<MemoryStore> | MemoryStore;
+    readonly describe: (name: string, fn: () => void) => void;
+    readonly close?: (store: MemoryStore) => Promise<void> | void;
+}): void;
+//# sourceMappingURL=memory-conformance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-conformance.d.ts","sourceRoot":"","sources":["../src/memory-conformance.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,eAAe,CAAA;AAqDtB;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAA;IAC5D,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,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAC9D,GAAG,IAAI,CAi1CP"}