@rulvar/testing 1.23.0 → 1.24.1

package/dist/fake-adapter-3T_w-IOY.js

@@ -0,0 +1,246 @@
+import { createCanonicalIdMinter } from "@rulvar/core";
+//#region src/fake-adapter.ts
+/**
+* FakeAdapter (M1-T14): a REAL ProviderAdapter that resolves calls from
+* declared patterns instead of the network, behind the same seam as live
+* adapters, so unit tests run through the full engine: journal, scheduler,
+* budget layers, and event stream. Calls cost zero USD. Honors the
+* caller's AbortSignal exactly like a live adapter: an abort ends the
+* stream promptly with no terminal event, so cancellation, deadline, and
+* budget tests observe the same journal shapes as production adapters.
+*/
+/** Scripts a tool-calling turn from a responder. */
+function fakeToolCalls(...calls) {
+	return {
+		__fake: "tool-calls",
+		calls
+	};
+}
+/** Scripts a typed wire failure (e.g. a retryable rate limit). */
+function fakeWireError(error) {
+	return {
+		__fake: "wire-error",
+		error
+	};
+}
+function isFakeToolCalls(value) {
+	return typeof value === "object" && value !== null && value.__fake === "tool-calls";
+}
+function isFakeWireError(value) {
+	return typeof value === "object" && value !== null && value.__fake === "wire-error";
+}
+const FAKE_MODEL = "fake-model";
+const FAKE_MODEL_REF = "fake:fake-model";
+const FAKE_CAPS = {
+	structuredOutput: "native",
+	supportsTemperature: true,
+	supportsParallelTools: true,
+	reasoningEfforts: [
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	],
+	contextWindow: 1e6,
+	maxOutputTokens: 64e3,
+	pricing: {
+		inputUsdPerMTok: 0,
+		outputUsdPerMTok: 0
+	}
+};
+/**
+* Races a responder promise against the caller's abort. On abort the
+* pending responder is detached: its eventual value is discarded and an
+* eventual rejection is swallowed (the caller cancelled; a late failure
+* of the abandoned work must not become an unhandled rejection). A
+* rejection that settles first propagates to the caller unchanged.
+*/
+async function raceAbort(pending, signal) {
+	if (signal === void 0) return {
+		aborted: false,
+		value: await pending
+	};
+	if (signal.aborted) {
+		pending.catch(() => void 0);
+		return { aborted: true };
+	}
+	let onAbort = () => void 0;
+	const abortPromise = new Promise((resolve) => {
+		onAbort = () => resolve({ aborted: true });
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		const raced = await Promise.race([pending.then((value) => ({
+			aborted: false,
+			value
+		})), abortPromise]);
+		if (raced.aborted) pending.catch(() => void 0);
+		return raced;
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+function lastUserText(req) {
+	for (let i = req.messages.length - 1; i >= 0; i -= 1) {
+		const msg = req.messages[i];
+		if (msg?.role !== "user") continue;
+		return msg.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+	}
+	return "";
+}
+var FakeAdapter = class {
+	id = "fake";
+	agents;
+	mintId = createCanonicalIdMinter();
+	/**
+	* Every request this adapter served, in order. A request whose signal
+	* was already aborted on arrival was never served and is not recorded.
+	*/
+	calls = [];
+	constructor(options) {
+		this.agents = options.agents;
+	}
+	caps() {
+		return FAKE_CAPS;
+	}
+	match(call) {
+		let fallback;
+		for (const [pattern, responder] of Object.entries(this.agents)) {
+			if (pattern === "*") {
+				fallback = responder;
+				continue;
+			}
+			if (call.agentType === pattern || call.label === pattern) return responder;
+			try {
+				if (new RegExp(pattern).test(call.prompt)) return responder;
+			} catch {}
+		}
+		return fallback;
+	}
+	async *stream(req, signal) {
+		const aborted = () => signal?.aborted === true;
+		if (aborted()) return;
+		const telemetry = req.providerOptions?.rulvar ?? {};
+		const call = {
+			prompt: lastUserText(req),
+			req,
+			...telemetry.agentType === void 0 || telemetry.agentType === "" ? {} : { agentType: telemetry.agentType },
+			...telemetry.label === void 0 ? {} : { label: telemetry.label }
+		};
+		this.calls.push(call);
+		const responder = this.match(call);
+		if (responder === void 0) {
+			yield {
+				type: "error",
+				error: {
+					code: "agent",
+					message: `FakeAdapter: no pattern matches agentType='${call.agentType ?? ""}' label='${call.label ?? ""}' prompt='${call.prompt.slice(0, 80)}'; add a '*' fallback`,
+					retryable: false,
+					data: { kind: "terminal" }
+				}
+			};
+			return;
+		}
+		let value;
+		try {
+			if (typeof responder === "function") {
+				const raced = await raceAbort(Promise.resolve(responder(call)), signal);
+				if (raced.aborted) return;
+				value = raced.value;
+			} else value = responder;
+		} catch (thrown) {
+			if (aborted()) return;
+			yield {
+				type: "error",
+				error: {
+					code: "agent",
+					message: thrown instanceof Error ? thrown.message : String(thrown),
+					retryable: false,
+					data: { kind: "terminal" }
+				}
+			};
+			return;
+		}
+		const events = [];
+		if (isFakeWireError(value)) events.push({
+			type: "error",
+			error: value.error
+		});
+		else if (isFakeToolCalls(value)) {
+			const usage = {
+				inputTokens: Math.max(1, Math.ceil(call.prompt.length / 4)),
+				outputTokens: Math.max(1, value.calls.length * 8),
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0
+			};
+			for (const toolCall of value.calls) {
+				const id = this.mintId();
+				events.push({
+					type: "tool-call-start",
+					id,
+					name: toolCall.name
+				});
+				events.push({
+					type: "tool-call-end",
+					id,
+					args: toolCall.args
+				});
+			}
+			events.push({
+				type: "finish",
+				finish: { reason: "tool-calls" },
+				usage
+			});
+		} else {
+			const text = typeof value === "string" ? value : JSON.stringify(value);
+			const usage = {
+				inputTokens: Math.max(1, Math.ceil(call.prompt.length / 4)),
+				outputTokens: Math.max(1, Math.ceil(text.length / 4)),
+				cacheReadTokens: 0,
+				cacheWriteTokens: 0
+			};
+			const forcedName = typeof req.toolChoice === "object" ? req.toolChoice.name : void 0;
+			if (forcedName !== void 0) {
+				let args = value;
+				if (typeof value === "string") try {
+					args = JSON.parse(value);
+				} catch {
+					args = { text: value };
+				}
+				const id = this.mintId();
+				events.push({
+					type: "tool-call-start",
+					id,
+					name: forcedName
+				});
+				events.push({
+					type: "tool-call-end",
+					id,
+					args
+				});
+				events.push({
+					type: "finish",
+					finish: { reason: "tool-calls" },
+					usage
+				});
+			} else {
+				events.push({
+					type: "text-delta",
+					text
+				});
+				events.push({
+					type: "finish",
+					finish: { reason: "stop" },
+					usage
+				});
+			}
+		}
+		for (const event of events) {
+			if (aborted()) return;
+			yield event;
+		}
+	}
+};
+//#endregion
+export { fakeWireError as a, fakeToolCalls as i, FAKE_MODEL_REF as n, FakeAdapter as r, FAKE_MODEL as t };

package/dist/index.d.ts

@@ -125,65 +125,6 @@ type LiveSmokeOutcome = {
 */
 declare function runLiveSmoke(adapter: Pick<ProviderAdapter, "stream">, req: ChatRequest, options?: RunLiveSmokeOptions): Promise<LiveSmokeOutcome>;
 //#endregion
-//#region src/cassettes/build-fixtures.d.ts
-/** One cassette fixture file: id, provenance note, and the journal. */
-/** @internal */
-interface CassetteFixture {
-  id: string;
-  note: string;
-  entries: JournalEntry[];
-}
-/** @internal */
-declare function buildM2CassetteFixtures(): CassetteFixture[];
-/**
-* The frozen v1 journal: a
-* round-1 JSONL file with kinds agent, step, rand, external, approval and
-* the legacy `v: 1` field (no hashVersion member). Returned as raw
-* JSON-ready objects, one per line.
-* @internal
-*/
-declare function buildFrozenV1JournalRaw(): Array<Record<string, unknown>>;
-/**
-* v2 golden identity fixtures: worked examples per spawn kind (M2-T12).
-* The keys freeze the hashVersion 2 profile; the v1 members freeze the
-* effort-insensitive projection and the incomparable domain.
-* @internal
-*/
-declare function buildV2GoldenIdentity(): Record<string, unknown>;
-//#endregion
-//#region src/cassettes/record-live.d.ts
-/** @internal */
-declare function recordLiveCassettes(): Promise<CassetteFixture[]>;
-//#endregion
-//#region src/cassettes/m6-orchestrator.d.ts
-/** @internal */
-declare const M6_ORCH_RUN_ID = "m6-orchestrator-crash";
-/** @internal */
-declare const M6_ORCH_GOAL = "m6 cassette: gather two facts";
-/** @internal */
-declare const M6_ORCH_PROFILES: {
-  worker: {
-    description: string;
-  };
-};
-/** Extracts spawn handles from the tool results the model saw. */
-/** @internal */
-declare function handlesInRequest(req: ChatRequest): number[];
-/** Fixes wall clock and spans; everything else is deterministic already. */
-/** @internal */
-declare function normalizeM6Entries(entries: readonly JournalEntry[]): JournalEntry[];
-/**
-* Phase 1: record the pre-crash journal. The transcripts store carries
-* the boundary checkpoint the resume restores from; the recorder keeps
-* it in memory because the cassette pins only journal bytes (checkpoint
-* blobs are engine-internal at-least-once state).
-* @internal
-*/
-declare function recordOrchestratorCrash(): Promise<{
-  entries: JournalEntry[]; /** Boundary checkpoint blobs by ref, base64: the resume restores from them. */
-  checkpoints: Record<string, string>;
-}>;
-//#endregion
 //#region src/vcr.d.ts
 /** One recorded exchange; a cassette is one JSON header line plus rows. */
 interface VcrRow {
@@ -250,4 +191,4 @@ declare function replay(options: {
   adapters?: ProviderAdapter[];
 }): ProviderAdapter[];
 //#endregion
-export { type CassetteFixture, type CreateTestEngineOptions, DEFAULT_LIVE_SMOKE_ATTEMPTS, FAKE_MODEL, FAKE_MODEL_REF, FakeAdapter, type FakeAdapterOptions, type FakeCall, type FakeResponder, type FakeToolCallsValue, type FakeWireErrorValue, type LiveSmokeOutcome, M6_ORCH_GOAL, M6_ORCH_PROFILES, M6_ORCH_RUN_ID, MAX_LIVE_SMOKE_ATTEMPTS, MAX_LIVE_SMOKE_DELAY_MS, RedactFn, type ReplayRunOptions, type RunLiveSmokeOptions, type TestEngine, type TestRunHandle, VcrCassette, VcrMissError, VcrRow, buildFrozenV1JournalRaw, buildM2CassetteFixtures, buildV2GoldenIdentity, createTestEngine, defaultRedact, fakeToolCalls, fakeWireError, handlesInRequest, liveTestEnabled, normalizeM6Entries, readCassette, record, recordLiveCassettes, recordOrchestratorCrash, replay, replayRun, requestHash, runLiveSmoke };
+export { type CreateTestEngineOptions, DEFAULT_LIVE_SMOKE_ATTEMPTS, FAKE_MODEL, FAKE_MODEL_REF, FakeAdapter, type FakeAdapterOptions, type FakeCall, type FakeResponder, type FakeToolCallsValue, type FakeWireErrorValue, type LiveSmokeOutcome, MAX_LIVE_SMOKE_ATTEMPTS, MAX_LIVE_SMOKE_DELAY_MS, RedactFn, type ReplayRunOptions, type RunLiveSmokeOptions, type TestEngine, type TestRunHandle, VcrCassette, VcrMissError, VcrRow, createTestEngine, defaultRedact, fakeToolCalls, fakeWireError, liveTestEnabled, readCassette, record, replay, replayRun, requestHash, runLiveSmoke };