@tangle-network/agent-eval 0.144.5 → 0.144.7

package/dist/prime-protocol-BfSalTfR.js

@@ -0,0 +1,453 @@
+import { c as ValidationError } from "./errors-D-LKuDhb.js";
+import { createHash } from "node:crypto";
+//#region src/analyst/equal-terms.ts
+/**
+* Refuses a comparison whose arms are not on equal terms: an empty set, a
+* duplicated id, or unequal repair turns — a retry is a second sample the
+* other arms never got. `noun` names the arm kind in every message so a
+* refusal reads in the caller's vocabulary.
+*/
+function assertEqualDeclarativeTerms(noun, terms) {
+	if (terms.length === 0) throw new ValidationError(`a ${noun} comparison needs at least one ${noun}`);
+	const ids = terms.map((term) => term.id);
+	const duplicate = ids.find((id, index) => ids.indexOf(id) !== index);
+	if (duplicate !== void 0) throw new ValidationError(`${noun} '${duplicate}' is declared twice`);
+	const repairTurns = terms[0].repairTurns;
+	const unequal = terms.find((term) => term.repairTurns !== repairTurns);
+	if (unequal) throw new ValidationError(`${noun} '${unequal.id}' gets ${unequal.repairTurns} bounded repair turns and ${noun} '${terms[0].id}' gets ${repairTurns}; a retry is a second sample the other arms never got`);
+	return {
+		ids,
+		repairTurns
+	};
+}
+//#endregion
+//#region src/analyst/prime-protocol.ts
+function buildPrimePrompt(spec) {
+	return [
+		`QUESTION: ${spec.question}`,
+		"",
+		...spec.taskDefinition === void 0 ? [] : [
+			"TASK DEFINITION:",
+			spec.taskDefinition,
+			""
+		],
+		...spec.contractLines,
+		"",
+		spec.trajectoryHeader,
+		spec.renderedTrajectory,
+		...spec.trailer === void 0 ? [] : ["", spec.trailer]
+	].join("\n");
+}
+/** Carries the malformed reply and the contract — never the trajectory. */
+function buildPrimeRepairPrompt(spec) {
+	return [
+		"Your previous reply to a trace-analysis task was structurally malformed and could not be parsed",
+		`(${spec.defect}). Below is your previous reply verbatim. Re-emit ONLY the corrected JSON — one`,
+		"fenced ```json block, no other text, no tools. The JSON object has exactly two fields:",
+		...spec.repairContractLines,
+		"",
+		"PREVIOUS REPLY:",
+		spec.previousReply
+	].join("\n");
+}
+/**
+* Recover the reply's JSON object.
+*
+* Distinct from `extractJsonPayload` in ../llm-client, which serves a response
+* that DECLARES a JSON root and therefore must not scan onward. A prime reply
+* is prose plus a fenced block, and when the model emits several fences the
+* last one is its answer — so fences are scanned in reverse, and only then is a
+* brace-to-brace slice tried.
+*/
+function extractPrimeJsonObject(text) {
+	const direct = parsePrimeJsonObject(text);
+	if (direct) return direct;
+	const fenced = [...text.matchAll(/```(?:json)?\s*\n?([\s\S]*?)```/g)];
+	for (let index = fenced.length - 1; index >= 0; index -= 1) {
+		const candidate = parsePrimeJsonObject(fenced[index][1]);
+		if (candidate) return candidate;
+	}
+	const start = text.indexOf("{");
+	const end = text.lastIndexOf("}");
+	if (start >= 0 && end > start) {
+		const candidate = parsePrimeJsonObject(text.slice(start, end + 1));
+		if (candidate) return candidate;
+	}
+	return null;
+}
+/** Why the reply cannot be read as a prime answer, or null when it can. */
+function primeReplyDefect(parsed, rowsField) {
+	if (parsed === null) return "no parseable JSON object";
+	if (!Array.isArray(parsed[rowsField])) return `JSON has no "${rowsField}" array`;
+	return null;
+}
+function parsePrimeJsonObject(text) {
+	try {
+		const value = JSON.parse(text.trim());
+		return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+	} catch {
+		return null;
+	}
+}
+function emptyPrimeRawUsage() {
+	return {
+		calls: null,
+		inputTokens: null,
+		outputTokens: null,
+		bridgeEstimated: false
+	};
+}
+/** Read the bridge's OpenAI-shaped `usage` object. */
+function normalizePrimeUsage(raw) {
+	if (typeof raw !== "object" || raw === null) return emptyPrimeRawUsage();
+	const record = raw;
+	return {
+		calls: tokenCountOrNull(record.model_requests),
+		inputTokens: tokenCountOrNull(record.prompt_tokens),
+		outputTokens: tokenCountOrNull(record.completion_tokens),
+		bridgeEstimated: record.estimated === true
+	};
+}
+/**
+* Sum two turns. Each side poisons independently: two turns that both report
+* input and neither report output yield a real input total beside a null
+* output, because discarding a measured count is as wrong as inventing one.
+*/
+function mergePrimeRawUsage(a, b) {
+	return {
+		calls: sumOrNull(a.calls, b.calls),
+		inputTokens: sumOrNull(a.inputTokens, b.inputTokens),
+		outputTokens: sumOrNull(a.outputTokens, b.outputTokens),
+		bridgeEstimated: a.bridgeEstimated || b.bridgeEstimated
+	};
+}
+function sumOrNull(a, b) {
+	return a !== null && b !== null ? a + b : null;
+}
+function tokenCountOrNull(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+/**
+* Bind raw prime usage to agent-eval's typed receipt.
+*
+* `RunTokenUsage.input` and `.output` are non-nullable, so a one-sided count
+* cannot round-trip through `tokens` without writing a zero nobody measured.
+* The complete-accounting field therefore stays null, the reported side is
+* carried verbatim in `partialTokens`, and its price becomes the receipt's
+* `knownCostUsd` lower bound.
+*
+* Only agent-eval calls this; consumers with no pricing table read
+* `PrimeRawUsage` directly.
+*/
+function analystUsageReceiptFromPrimeUsage(usage, pricing) {
+	const { calls, inputTokens, outputTokens, bridgeEstimated } = usage;
+	const estimatedTokens = bridgeEstimated ? { tokensEstimated: true } : {};
+	if (inputTokens !== null && outputTokens !== null) return {
+		calls,
+		tokens: {
+			input: inputTokens,
+			output: outputTokens
+		},
+		cost: {
+			kind: "estimated",
+			usd: priceTokens(inputTokens, outputTokens, pricing)
+		},
+		...estimatedTokens
+	};
+	if (inputTokens === null && outputTokens === null) return {
+		calls,
+		tokens: null,
+		cost: {
+			kind: "uncaptured",
+			usd: null
+		},
+		...estimatedTokens
+	};
+	return {
+		calls,
+		tokens: null,
+		partialTokens: {
+			input: inputTokens,
+			output: outputTokens
+		},
+		cost: {
+			kind: "uncaptured",
+			usd: null
+		},
+		knownCostUsd: priceTokens(inputTokens ?? 0, outputTokens ?? 0, pricing),
+		...estimatedTokens
+	};
+}
+function priceTokens(input, output, pricing) {
+	return (input * pricing.inputUsdPerMillion + output * pricing.outputUsdPerMillion) / 1e6;
+}
+/**
+* Run the protocol: one call, one bounded repair turn on a structurally
+* malformed reply, then decode. Zero valid rows from a well-formed reply is an
+* honest null, not a failure.
+*/
+async function runPrimeExchange(options) {
+	const { contract } = options;
+	const turns = [];
+	const repair = {
+		attempted: false,
+		succeeded: null
+	};
+	const first = await callPrimeTurn(options, options.prompt);
+	if (!first.ok) return {
+		ok: false,
+		failure: first.failure,
+		usage: mergeTurns(turns),
+		turns,
+		repair
+	};
+	turns.push({
+		turn: "first",
+		usage: first.usage,
+		rawUsage: first.rawUsage
+	});
+	let reply = first.content;
+	let parsed = extractPrimeJsonObject(reply);
+	let defect = primeReplyDefect(parsed, contract.rowsField);
+	if (defect !== null && options.repair) {
+		repair.attempted = true;
+		const second = await callPrimeTurn(options, buildPrimeRepairPrompt({
+			defect,
+			previousReply: reply,
+			repairContractLines: contract.repairContractLines
+		}));
+		if (!second.ok) return {
+			ok: false,
+			failure: second.failure,
+			usage: mergeTurns(turns),
+			turns,
+			repair,
+			reply
+		};
+		turns.push({
+			turn: "repair",
+			usage: second.usage,
+			rawUsage: second.rawUsage
+		});
+		reply = second.content;
+		parsed = extractPrimeJsonObject(reply);
+		defect = primeReplyDefect(parsed, contract.rowsField);
+		repair.succeeded = defect === null;
+	}
+	const usage = mergeTurns(turns);
+	if (defect !== null) return {
+		ok: false,
+		failure: {
+			kind: "malformed-reply",
+			message: `${defect} in prime reply${repair.attempted ? " even after the bounded repair turn" : ""}`
+		},
+		usage,
+		turns,
+		repair,
+		reply
+	};
+	const rawRows = parsed[contract.rowsField];
+	const rows = [];
+	const rejected = [];
+	let overflow = 0;
+	rawRows.forEach((row, index) => {
+		const decoded = contract.decodeRow(row, index);
+		if (!decoded.ok) {
+			rejected.push({
+				index,
+				reason: decoded.reason
+			});
+			return;
+		}
+		if (contract.maxRows !== void 0 && rows.length >= contract.maxRows) {
+			overflow += 1;
+			return;
+		}
+		rows.push(decoded.row);
+	});
+	const answer = parsed.answer;
+	return {
+		ok: true,
+		answer: typeof answer === "string" ? answer : null,
+		rows,
+		rejected,
+		reportedRows: rawRows.length,
+		overflow,
+		usage,
+		turns,
+		repair,
+		reply
+	};
+}
+async function callPrimeTurn(options, content) {
+	const { transport, url, model, timeoutMs, signal } = options;
+	const controller = new AbortController();
+	const forwardAbort = () => controller.abort(signal?.reason);
+	if (signal?.aborted) controller.abort(signal.reason);
+	else signal?.addEventListener("abort", forwardAbort, { once: true });
+	const deadline = setTimeout(() => controller.abort(), timeoutMs);
+	let result;
+	try {
+		result = await transport({
+			url,
+			body: {
+				model,
+				messages: [{
+					role: "user",
+					content
+				}]
+			},
+			signal: controller.signal
+		});
+	} catch (error) {
+		if (signal?.aborted) return {
+			ok: false,
+			failure: {
+				kind: "aborted",
+				message: "prime exchange cancelled by the caller",
+				cause: error
+			}
+		};
+		if (controller.signal.aborted) return {
+			ok: false,
+			failure: {
+				kind: "deadline",
+				message: `bridge call exceeded ${timeoutMs}ms`
+			}
+		};
+		return {
+			ok: false,
+			failure: {
+				kind: "transport",
+				message: `bridge transport failure: ${error instanceof Error ? error.message : String(error)}`
+			}
+		};
+	} finally {
+		clearTimeout(deadline);
+		signal?.removeEventListener("abort", forwardAbort);
+	}
+	if (result.status !== 200) {
+		const bodySnippet = result.text.slice(0, 500);
+		return {
+			ok: false,
+			failure: {
+				kind: "http-status",
+				message: `bridge HTTP ${result.status}: ${bodySnippet}`,
+				status: result.status,
+				bodySnippet
+			}
+		};
+	}
+	let response;
+	try {
+		response = JSON.parse(result.text);
+	} catch {
+		return {
+			ok: false,
+			failure: {
+				kind: "unparseable-json",
+				message: `bridge returned unparseable JSON (${result.text.length} bytes)`
+			}
+		};
+	}
+	const replyContent = primeReplyContent(response);
+	if (replyContent === null) return {
+		ok: false,
+		failure: {
+			kind: "no-content",
+			message: "bridge reply carries no message content"
+		}
+	};
+	const rawUsage = primeReplyUsage(response);
+	return {
+		ok: true,
+		content: replyContent,
+		usage: normalizePrimeUsage(rawUsage),
+		rawUsage
+	};
+}
+/**
+* Fold from the FIRST turn, never from an empty receipt: an all-null identity
+* would poison every side it merged with and erase counts the bridge reported.
+*/
+function mergeTurns(turns) {
+	if (turns.length === 0) return emptyPrimeRawUsage();
+	return turns.slice(1).reduce((total, turn) => mergePrimeRawUsage(total, turn.usage), turns[0].usage);
+}
+function primeReplyContent(response) {
+	if (typeof response !== "object" || response === null) return null;
+	const choices = response.choices;
+	if (!Array.isArray(choices) || choices.length === 0) return null;
+	const message = choices[0]?.message;
+	if (typeof message !== "object" || message === null) return null;
+	const content = message.content;
+	return typeof content === "string" && content.length > 0 ? content : null;
+}
+function primeReplyUsage(response) {
+	if (typeof response !== "object" || response === null) return null;
+	return response.usage ?? null;
+}
+/**
+* Render, measure, fall back to the capped projection, re-measure, fail loud.
+*
+* Inline is the only delivery prime has, so an oversized trajectory is a
+* refusal rather than a silent truncation: dropping spans would understate the
+* trajectory and the analyst would answer a question about a different run.
+*/
+async function projectPrimeTrajectory(source, limits) {
+	let fetch = "full";
+	let items = await source.full();
+	if (items === null) {
+		fetch = "capped";
+		items = await source.capped();
+	}
+	let rendered = JSON.stringify(items);
+	if (rendered.length > limits.maxInlineChars && fetch === "full") {
+		fetch = "capped";
+		items = await source.capped();
+		rendered = JSON.stringify(items);
+	}
+	if (rendered.length > limits.maxInlineChars) return {
+		ok: false,
+		reason: `trajectory renders to ${rendered.length} chars even at ${source.cappedDescription}; inline delivery impossible`,
+		renderedChars: rendered.length
+	};
+	return {
+		ok: true,
+		items,
+		rendered,
+		delivery: {
+			mode: "inline-json",
+			fetch,
+			renderedChars: rendered.length
+		}
+	};
+}
+/**
+* Digest of everything a consumer can send to the bridge under the prime
+* protocol, recorded per observation so a prime result names the exact contract
+* that produced it.
+*
+* Computed over the ACTUALLY composed contract, so two consumers that both
+* stamp `analyst_id: 'prime'` while asking materially different questions get
+* different digests by construction. That is what makes 'prime' a reproducible
+* claim rather than a label.
+*/
+function primeProtocolSha256(identity) {
+	return createHash("sha256").update(JSON.stringify({
+		kind: "prime-analyst-protocol",
+		question: identity.question,
+		taskPrompt: identity.taskDefinition ?? null,
+		outputContract: identity.contractLines,
+		repairContract: buildPrimeRepairPrompt({
+			defect: "<defect>",
+			previousReply: "<previous-reply>",
+			repairContractLines: identity.repairContractLines
+		}),
+		limits: identity.limits
+	})).digest("hex");
+}
+//#endregion
+export { extractPrimeJsonObject as a, primeProtocolSha256 as c, runPrimeExchange as d, assertEqualDeclarativeTerms as f, emptyPrimeRawUsage as i, primeReplyDefect as l, buildPrimePrompt as n, mergePrimeRawUsage as o, buildPrimeRepairPrompt as r, normalizePrimeUsage as s, analystUsageReceiptFromPrimeUsage as t, projectPrimeTrajectory as u };
+
+//# sourceMappingURL=prime-protocol-BfSalTfR.js.map

package/dist/prime-protocol-BfSalTfR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prime-protocol-BfSalTfR.js","names":[],"sources":["../src/analyst/equal-terms.ts","../src/analyst/prime-protocol.ts"],"sourcesContent":["import { ValidationError } from '../errors'\n\n/**\n * The terms every declarative-arm comparison must hold equal before any\n * per-kind check runs. Arm kinds (analyst definitions, repair arms) extend\n * the comparison with their own fields; the refusals here are the floor.\n */\nexport interface DeclarativeArmTerms {\n  readonly id: string\n  /** Bounded repair turns the arm earns on a malformed reply. */\n  readonly repairTurns: number\n}\n\nexport interface EqualDeclarativeTerms {\n  readonly ids: readonly string[]\n  readonly repairTurns: number\n}\n\n/**\n * Refuses a comparison whose arms are not on equal terms: an empty set, a\n * duplicated id, or unequal repair turns — a retry is a second sample the\n * other arms never got. `noun` names the arm kind in every message so a\n * refusal reads in the caller's vocabulary.\n */\nexport function assertEqualDeclarativeTerms(\n  noun: string,\n  terms: ReadonlyArray<DeclarativeArmTerms>,\n): EqualDeclarativeTerms {\n  if (terms.length === 0) {\n    throw new ValidationError(`a ${noun} comparison needs at least one ${noun}`)\n  }\n  const ids = terms.map((term) => term.id)\n  const duplicate = ids.find((id, index) => ids.indexOf(id) !== index)\n  if (duplicate !== undefined) {\n    throw new ValidationError(`${noun} '${duplicate}' is declared twice`)\n  }\n  const repairTurns = terms[0]!.repairTurns\n  const unequal = terms.find((term) => term.repairTurns !== repairTurns)\n  if (unequal) {\n    throw new ValidationError(\n      `${noun} '${unequal.id}' gets ${unequal.repairTurns} bounded repair turns and ` +\n        `${noun} '${terms[0]!.id}' gets ${repairTurns}; a retry is a second sample ` +\n        'the other arms never got',\n    )\n  }\n  return { ids, repairTurns }\n}\n","import { createHash } from 'node:crypto'\nimport type { CustomTokenPricing } from '../cost-ledger'\nimport type { PrimeBridgeTransport, PrimeBridgeTransportResult } from './prime-bridge-transport'\nimport type { ReplyContract, ReplyRowDecoded } from './reply-contract'\nimport type { AnalystUsageReceipt } from './types'\n\n/**\n * The prime analyst protocol: a one-shot RLM reached through an\n * OpenAI-compatible bridge, given the whole trajectory inline because it has no\n * REPL and no trace tools, answering in one fenced JSON block of short strings.\n *\n * This module owns every part of that protocol that does not depend on what the\n * rows MEAN: prompt and contract composition, the bounded repair turn, reply\n * extraction, row decoding order, the render-measure-fall-back-fail-loud\n * projection ladder, usage normalization, and the protocol identity digest.\n *\n * The cut: the core speaks RAW ROWS and never names a finding type. It knows a\n * prime reply carries an `answer` string plus an array of rows under a named\n * field, and that each row is decoded by a caller-supplied function. Consumers\n * — the CodeTraceBench benchmark runner here, a span-grounded trace analyzer\n * elsewhere — map decoded rows into their own finding shape on the way out. So\n * nothing in this file may import a block type, a finding type, or a trace\n * store, and no consumer needs another copy of the protocol.\n */\n\n// ── Reply contract ───────────────────────────────────────────────────\n\n/**\n * The prime reply grammar is the general analyst reply contract: these aliases\n * keep every prime-protocol consumer compiling against the shared type in\n * ./reply-contract. The exchange below reads the base fields (`rowsField`,\n * contract lines, `decodeRow`, `maxRows`); the strict-envelope knobs serve\n * one-shot JSON arms and are inert here.\n */\nexport type PrimeRowDecoded<TRow> = ReplyRowDecoded<TRow>\n\nexport type PrimeReplyContract<TRow> = ReplyContract<TRow>\n\n// ── Prompt composition ───────────────────────────────────────────────\n\nexport interface PrimePromptSpec {\n  question: string\n  /** Task definition spliced under a `TASK DEFINITION:` heading. Omit when the question is the whole task. */\n  taskDefinition?: string\n  contractLines: readonly string[]\n  /** Line introducing the trajectory, e.g. `TRAJECTORY (trace_id X; 12 assistant step spans; ...):`. */\n  trajectoryHeader: string\n  renderedTrajectory: string\n  /** Material appended after the trajectory, e.g. the final-verification spans. */\n  trailer?: string\n}\n\nexport function buildPrimePrompt(spec: PrimePromptSpec): string {\n  return [\n    `QUESTION: ${spec.question}`,\n    '',\n    ...(spec.taskDefinition === undefined ? [] : ['TASK DEFINITION:', spec.taskDefinition, '']),\n    ...spec.contractLines,\n    '',\n    spec.trajectoryHeader,\n    spec.renderedTrajectory,\n    ...(spec.trailer === undefined ? [] : ['', spec.trailer]),\n  ].join('\\n')\n}\n\nexport interface PrimeRepairPromptSpec {\n  defect: string\n  previousReply: string\n  repairContractLines: readonly string[]\n}\n\n/** Carries the malformed reply and the contract — never the trajectory. */\nexport function buildPrimeRepairPrompt(spec: PrimeRepairPromptSpec): string {\n  return [\n    'Your previous reply to a trace-analysis task was structurally malformed and could not be parsed',\n    `(${spec.defect}). Below is your previous reply verbatim. Re-emit ONLY the corrected JSON — one`,\n    'fenced ```json block, no other text, no tools. The JSON object has exactly two fields:',\n    ...spec.repairContractLines,\n    '',\n    'PREVIOUS REPLY:',\n    spec.previousReply,\n  ].join('\\n')\n}\n\n// ── Reply extraction ─────────────────────────────────────────────────\n\n/**\n * Recover the reply's JSON object.\n *\n * Distinct from `extractJsonPayload` in ../llm-client, which serves a response\n * that DECLARES a JSON root and therefore must not scan onward. A prime reply\n * is prose plus a fenced block, and when the model emits several fences the\n * last one is its answer — so fences are scanned in reverse, and only then is a\n * brace-to-brace slice tried.\n */\nexport function extractPrimeJsonObject(text: string): Record<string, unknown> | null {\n  const direct = parsePrimeJsonObject(text)\n  if (direct) return direct\n  const fenced = [...text.matchAll(/```(?:json)?\\s*\\n?([\\s\\S]*?)```/g)]\n  for (let index = fenced.length - 1; index >= 0; index -= 1) {\n    const candidate = parsePrimeJsonObject(fenced[index]![1]!)\n    if (candidate) return candidate\n  }\n  const start = text.indexOf('{')\n  const end = text.lastIndexOf('}')\n  if (start >= 0 && end > start) {\n    const candidate = parsePrimeJsonObject(text.slice(start, end + 1))\n    if (candidate) return candidate\n  }\n  return null\n}\n\n/** Why the reply cannot be read as a prime answer, or null when it can. */\nexport function primeReplyDefect(\n  parsed: Record<string, unknown> | null,\n  rowsField: string,\n): string | null {\n  if (parsed === null) return 'no parseable JSON object'\n  if (!Array.isArray(parsed[rowsField])) return `JSON has no \"${rowsField}\" array`\n  return null\n}\n\nfunction parsePrimeJsonObject(text: string): Record<string, unknown> | null {\n  try {\n    const value: unknown = JSON.parse(text.trim())\n    return typeof value === 'object' && value !== null && !Array.isArray(value)\n      ? (value as Record<string, unknown>)\n      : null\n  } catch {\n    return null\n  }\n}\n\n// ── Usage ────────────────────────────────────────────────────────────\n\n/**\n * Token accounting exactly as the bridge reported it. Lossless on purpose: a\n * side the bridge did not report stays null rather than becoming a zero, and a\n * side it DID report survives even when its partner is missing.\n */\nexport interface PrimeRawUsage {\n  /**\n   * Model-usage records the bridge observed. NOT a count of bridge round trips:\n   * one prime turn routes several internal model calls, so a single turn\n   * typically reports 3-5.\n   */\n  calls: number | null\n  /** Prompt tokens the bridge reported; null when it reported none. */\n  inputTokens: number | null\n  /** Completion tokens the bridge reported; null when it reported none. */\n  outputTokens: number | null\n  /**\n   * True when the bridge DERIVED the counts (from character lengths) because\n   * the backend reported no usage of its own. Pricing derived counts produces a\n   * guess about a guess, which a reader must be able to tell apart from a\n   * rate-estimated cost over exact tokens.\n   */\n  bridgeEstimated: boolean\n}\n\nexport function emptyPrimeRawUsage(): PrimeRawUsage {\n  return { calls: null, inputTokens: null, outputTokens: null, bridgeEstimated: false }\n}\n\n/** Read the bridge's OpenAI-shaped `usage` object. */\nexport function normalizePrimeUsage(raw: unknown): PrimeRawUsage {\n  if (typeof raw !== 'object' || raw === null) return emptyPrimeRawUsage()\n  const record = raw as Record<string, unknown>\n  return {\n    calls: tokenCountOrNull(record.model_requests),\n    inputTokens: tokenCountOrNull(record.prompt_tokens),\n    outputTokens: tokenCountOrNull(record.completion_tokens),\n    bridgeEstimated: record.estimated === true,\n  }\n}\n\n/**\n * Sum two turns. Each side poisons independently: two turns that both report\n * input and neither report output yield a real input total beside a null\n * output, because discarding a measured count is as wrong as inventing one.\n */\nexport function mergePrimeRawUsage(a: PrimeRawUsage, b: PrimeRawUsage): PrimeRawUsage {\n  return {\n    calls: sumOrNull(a.calls, b.calls),\n    inputTokens: sumOrNull(a.inputTokens, b.inputTokens),\n    outputTokens: sumOrNull(a.outputTokens, b.outputTokens),\n    bridgeEstimated: a.bridgeEstimated || b.bridgeEstimated,\n  }\n}\n\nfunction sumOrNull(a: number | null, b: number | null): number | null {\n  return a !== null && b !== null ? a + b : null\n}\n\nfunction tokenCountOrNull(value: unknown): number | null {\n  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null\n}\n\n/**\n * Bind raw prime usage to agent-eval's typed receipt.\n *\n * `RunTokenUsage.input` and `.output` are non-nullable, so a one-sided count\n * cannot round-trip through `tokens` without writing a zero nobody measured.\n * The complete-accounting field therefore stays null, the reported side is\n * carried verbatim in `partialTokens`, and its price becomes the receipt's\n * `knownCostUsd` lower bound.\n *\n * Only agent-eval calls this; consumers with no pricing table read\n * `PrimeRawUsage` directly.\n */\nexport function analystUsageReceiptFromPrimeUsage(\n  usage: PrimeRawUsage,\n  pricing: CustomTokenPricing,\n): AnalystUsageReceipt {\n  const { calls, inputTokens, outputTokens, bridgeEstimated } = usage\n  const estimatedTokens = bridgeEstimated ? { tokensEstimated: true } : {}\n  if (inputTokens !== null && outputTokens !== null) {\n    return {\n      calls,\n      tokens: { input: inputTokens, output: outputTokens },\n      cost: { kind: 'estimated', usd: priceTokens(inputTokens, outputTokens, pricing) },\n      ...estimatedTokens,\n    }\n  }\n  if (inputTokens === null && outputTokens === null) {\n    return { calls, tokens: null, cost: { kind: 'uncaptured', usd: null }, ...estimatedTokens }\n  }\n  return {\n    calls,\n    tokens: null,\n    partialTokens: { input: inputTokens, output: outputTokens },\n    cost: { kind: 'uncaptured', usd: null },\n    knownCostUsd: priceTokens(inputTokens ?? 0, outputTokens ?? 0, pricing),\n    ...estimatedTokens,\n  }\n}\n\nfunction priceTokens(input: number, output: number, pricing: CustomTokenPricing): number {\n  return (input * pricing.inputUsdPerMillion + output * pricing.outputUsdPerMillion) / 1_000_000\n}\n\n// ── Two-turn exchange ────────────────────────────────────────────────\n\n/**\n * Why an exchange ended without a readable reply. `deadline` and `aborted` are\n * separate members from `transport` on purpose: a model that ran past its\n * deadline, a caller who cancelled, and a bridge that refused the connection\n * demand three different responses, and a record that conflates them cannot be\n * acted on.\n */\nexport type PrimeFailure =\n  | {\n      kind: 'transport' | 'unparseable-json' | 'no-content' | 'deadline' | 'malformed-reply'\n      message: string\n    }\n  | { kind: 'http-status'; message: string; status: number; bodySnippet: string }\n  | { kind: 'aborted'; message: string; cause: unknown }\n\nexport interface PrimeRepairState {\n  attempted: boolean\n  /** Null when no repair turn ran, or when the repair turn never returned a reply. */\n  succeeded: boolean | null\n}\n\n/** One completed bridge turn. A turn that failed produces no record. */\nexport interface PrimeTurnRecord {\n  turn: 'first' | 'repair'\n  usage: PrimeRawUsage\n  /** The reply's `usage` object verbatim; null when the bridge sent none. */\n  rawUsage: unknown\n}\n\nexport interface PrimeRejectedRow {\n  index: number\n  reason: string\n}\n\nexport type PrimeExchangeOutcome<TRow> =\n  | {\n      ok: true\n      /** The reply's `answer` field; null when absent or not a string. */\n      answer: string | null\n      rows: TRow[]\n      rejected: PrimeRejectedRow[]\n      /** Rows the model reported, before decoding or the count cap. */\n      reportedRows: number\n      /** Valid rows dropped by `contract.maxRows`. */\n      overflow: number\n      usage: PrimeRawUsage\n      turns: PrimeTurnRecord[]\n      repair: PrimeRepairState\n      reply: string\n    }\n  | {\n      ok: false\n      failure: PrimeFailure\n      usage: PrimeRawUsage\n      turns: PrimeTurnRecord[]\n      repair: PrimeRepairState\n      /** The last reply received, when one arrived — the diagnostic artifact for a malformed case. */\n      reply?: string\n    }\n\nexport interface PrimeExchangeOptions<TRow> {\n  contract: PrimeReplyContract<TRow>\n  prompt: string\n  transport: PrimeBridgeTransport\n  /** Full endpoint, e.g. `http://localhost:4181/v1/chat/completions`. */\n  url: string\n  model: string\n  /** Deadline for ONE turn. Prime analyses routinely exceed five minutes. */\n  timeoutMs: number\n  /** Whether a structurally malformed reply gets one bounded repair turn. */\n  repair: boolean\n  signal?: AbortSignal\n}\n\n/**\n * Run the protocol: one call, one bounded repair turn on a structurally\n * malformed reply, then decode. Zero valid rows from a well-formed reply is an\n * honest null, not a failure.\n */\nexport async function runPrimeExchange<TRow>(\n  options: PrimeExchangeOptions<TRow>,\n): Promise<PrimeExchangeOutcome<TRow>> {\n  const { contract } = options\n  const turns: PrimeTurnRecord[] = []\n  const repair: PrimeRepairState = { attempted: false, succeeded: null }\n\n  const first = await callPrimeTurn(options, options.prompt)\n  if (!first.ok) {\n    return { ok: false, failure: first.failure, usage: mergeTurns(turns), turns, repair }\n  }\n  turns.push({ turn: 'first', usage: first.usage, rawUsage: first.rawUsage })\n\n  let reply = first.content\n  let parsed = extractPrimeJsonObject(reply)\n  let defect = primeReplyDefect(parsed, contract.rowsField)\n\n  if (defect !== null && options.repair) {\n    repair.attempted = true\n    const second = await callPrimeTurn(\n      options,\n      buildPrimeRepairPrompt({\n        defect,\n        previousReply: reply,\n        repairContractLines: contract.repairContractLines,\n      }),\n    )\n    if (!second.ok) {\n      return { ok: false, failure: second.failure, usage: mergeTurns(turns), turns, repair, reply }\n    }\n    turns.push({ turn: 'repair', usage: second.usage, rawUsage: second.rawUsage })\n    reply = second.content\n    parsed = extractPrimeJsonObject(reply)\n    defect = primeReplyDefect(parsed, contract.rowsField)\n    repair.succeeded = defect === null\n  }\n\n  const usage = mergeTurns(turns)\n  if (defect !== null) {\n    return {\n      ok: false,\n      failure: {\n        kind: 'malformed-reply',\n        message: `${defect} in prime reply${repair.attempted ? ' even after the bounded repair turn' : ''}`,\n      },\n      usage,\n      turns,\n      repair,\n      reply,\n    }\n  }\n\n  const rawRows = parsed![contract.rowsField] as unknown[]\n  const rows: TRow[] = []\n  const rejected: PrimeRejectedRow[] = []\n  let overflow = 0\n  rawRows.forEach((row, index) => {\n    const decoded = contract.decodeRow(row, index)\n    if (!decoded.ok) {\n      rejected.push({ index, reason: decoded.reason })\n      return\n    }\n    // Shape before count: a malformed row must never consume an accepted slot.\n    if (contract.maxRows !== undefined && rows.length >= contract.maxRows) {\n      overflow += 1\n      return\n    }\n    rows.push(decoded.row)\n  })\n  const answer = parsed!.answer\n  return {\n    ok: true,\n    answer: typeof answer === 'string' ? answer : null,\n    rows,\n    rejected,\n    reportedRows: rawRows.length,\n    overflow,\n    usage,\n    turns,\n    repair,\n    reply,\n  }\n}\n\ntype PrimeTurnOutcome =\n  | { ok: true; content: string; usage: PrimeRawUsage; rawUsage: unknown }\n  | { ok: false; failure: PrimeFailure }\n\nasync function callPrimeTurn<TRow>(\n  options: PrimeExchangeOptions<TRow>,\n  content: string,\n): Promise<PrimeTurnOutcome> {\n  const { transport, url, model, timeoutMs, signal } = options\n  const controller = new AbortController()\n  const forwardAbort = () => controller.abort(signal?.reason)\n  if (signal?.aborted) controller.abort(signal.reason)\n  else signal?.addEventListener('abort', forwardAbort, { once: true })\n  const deadline = setTimeout(() => controller.abort(), timeoutMs)\n  let result: PrimeBridgeTransportResult\n  try {\n    result = await transport({\n      url,\n      body: { model, messages: [{ role: 'user', content }] },\n      signal: controller.signal,\n    })\n  } catch (error) {\n    if (signal?.aborted) {\n      return {\n        ok: false,\n        failure: {\n          kind: 'aborted',\n          message: 'prime exchange cancelled by the caller',\n          cause: error,\n        },\n      }\n    }\n    if (controller.signal.aborted) {\n      return {\n        ok: false,\n        failure: { kind: 'deadline', message: `bridge call exceeded ${timeoutMs}ms` },\n      }\n    }\n    return {\n      ok: false,\n      failure: {\n        kind: 'transport',\n        message: `bridge transport failure: ${error instanceof Error ? error.message : String(error)}`,\n      },\n    }\n  } finally {\n    clearTimeout(deadline)\n    signal?.removeEventListener('abort', forwardAbort)\n  }\n\n  if (result.status !== 200) {\n    const bodySnippet = result.text.slice(0, 500)\n    return {\n      ok: false,\n      failure: {\n        kind: 'http-status',\n        message: `bridge HTTP ${result.status}: ${bodySnippet}`,\n        status: result.status,\n        bodySnippet,\n      },\n    }\n  }\n  let response: unknown\n  try {\n    response = JSON.parse(result.text)\n  } catch {\n    return {\n      ok: false,\n      failure: {\n        kind: 'unparseable-json',\n        message: `bridge returned unparseable JSON (${result.text.length} bytes)`,\n      },\n    }\n  }\n  const replyContent = primeReplyContent(response)\n  if (replyContent === null) {\n    return {\n      ok: false,\n      failure: { kind: 'no-content', message: 'bridge reply carries no message content' },\n    }\n  }\n  const rawUsage = primeReplyUsage(response)\n  return { ok: true, content: replyContent, usage: normalizePrimeUsage(rawUsage), rawUsage }\n}\n\n/**\n * Fold from the FIRST turn, never from an empty receipt: an all-null identity\n * would poison every side it merged with and erase counts the bridge reported.\n */\nfunction mergeTurns(turns: readonly PrimeTurnRecord[]): PrimeRawUsage {\n  if (turns.length === 0) return emptyPrimeRawUsage()\n  return turns\n    .slice(1)\n    .reduce<PrimeRawUsage>((total, turn) => mergePrimeRawUsage(total, turn.usage), turns[0]!.usage)\n}\n\nfunction primeReplyContent(response: unknown): string | null {\n  if (typeof response !== 'object' || response === null) return null\n  const choices = (response as { choices?: unknown }).choices\n  if (!Array.isArray(choices) || choices.length === 0) return null\n  const message = (choices[0] as { message?: unknown })?.message\n  if (typeof message !== 'object' || message === null) return null\n  const content = (message as { content?: unknown }).content\n  return typeof content === 'string' && content.length > 0 ? content : null\n}\n\nfunction primeReplyUsage(response: unknown): unknown {\n  if (typeof response !== 'object' || response === null) return null\n  return (response as { usage?: unknown }).usage ?? null\n}\n\n// ── Trajectory projection ────────────────────────────────────────────\n\n/**\n * Where the inlined trajectory comes from. The protocol needs only two moves —\n * fetch it all, or fetch a reduced version — so no store, artifact path, or\n * span type enters the shared signature.\n */\nexport interface PrimeProjectionSource<TItem> {\n  /** The full projection, or null when the source declares itself oversized. */\n  full(): Promise<readonly TItem[] | null>\n  /** A reduced projection of the same material. */\n  capped(): Promise<readonly TItem[]>\n  /** How `capped` reduces, named for the failure message, e.g. `per-attribute cap 1200`. */\n  cappedDescription: string\n}\n\nexport interface PrimeProjectionDelivery {\n  mode: 'inline-json'\n  fetch: 'full' | 'capped'\n  renderedChars: number\n}\n\nexport type PrimeProjectionOutcome<TItem> =\n  | {\n      ok: true\n      items: readonly TItem[]\n      rendered: string\n      delivery: PrimeProjectionDelivery\n    }\n  | { ok: false; reason: string; renderedChars: number }\n\n/**\n * Render, measure, fall back to the capped projection, re-measure, fail loud.\n *\n * Inline is the only delivery prime has, so an oversized trajectory is a\n * refusal rather than a silent truncation: dropping spans would understate the\n * trajectory and the analyst would answer a question about a different run.\n */\nexport async function projectPrimeTrajectory<TItem>(\n  source: PrimeProjectionSource<TItem>,\n  limits: { maxInlineChars: number },\n): Promise<PrimeProjectionOutcome<TItem>> {\n  let fetch: PrimeProjectionDelivery['fetch'] = 'full'\n  let items = await source.full()\n  if (items === null) {\n    fetch = 'capped'\n    items = await source.capped()\n  }\n  let rendered = JSON.stringify(items)\n  if (rendered.length > limits.maxInlineChars && fetch === 'full') {\n    fetch = 'capped'\n    items = await source.capped()\n    rendered = JSON.stringify(items)\n  }\n  if (rendered.length > limits.maxInlineChars) {\n    return {\n      ok: false,\n      reason: `trajectory renders to ${rendered.length} chars even at ${source.cappedDescription}; inline delivery impossible`,\n      renderedChars: rendered.length,\n    }\n  }\n  return {\n    ok: true,\n    items,\n    rendered,\n    delivery: { mode: 'inline-json', fetch, renderedChars: rendered.length },\n  }\n}\n\n// ── Protocol identity ────────────────────────────────────────────────\n\nexport interface PrimeProtocolIdentity {\n  question: string\n  taskDefinition?: string\n  contractLines: readonly string[]\n  repairContractLines: readonly string[]\n  /** Numeric limits the contract states, e.g. row and width caps. */\n  limits: Readonly<Record<string, number>>\n}\n\n/**\n * Digest of everything a consumer can send to the bridge under the prime\n * protocol, recorded per observation so a prime result names the exact contract\n * that produced it.\n *\n * Computed over the ACTUALLY composed contract, so two consumers that both\n * stamp `analyst_id: 'prime'` while asking materially different questions get\n * different digests by construction. That is what makes 'prime' a reproducible\n * claim rather than a label.\n */\nexport function primeProtocolSha256(identity: PrimeProtocolIdentity): string {\n  return createHash('sha256')\n    .update(\n      JSON.stringify({\n        kind: 'prime-analyst-protocol',\n        question: identity.question,\n        taskPrompt: identity.taskDefinition ?? null,\n        outputContract: identity.contractLines,\n        repairContract: buildPrimeRepairPrompt({\n          defect: '<defect>',\n          previousReply: '<previous-reply>',\n          repairContractLines: identity.repairContractLines,\n        }),\n        limits: identity.limits,\n      }),\n    )\n    .digest('hex')\n}\n"],"mappings":"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"}

package/dist/profile-cell.d.ts

@@ -1,2 +1,2 @@
-import { C as verifyAgentProfileCell, S as validateAgentProfileCell, _ as buildAgentInterfaceProfileCell, a as AgentProfileCellSchemaVersion, b as requireAgentProfileCell, c as AgentProfileHarness, d as AgentProfileKind, f as AgentProfileSource, g as assertRunAgentProfileCell, h as agentProfileCellKey, i as AgentProfileCellInput, l as AgentProfileJson, m as agentProfileCellHashMaterial, n as AgentInterfaceProfileLike, o as AgentProfileCellValidationError, p as AgentProfileSourceInput, r as AgentProfileCell, s as AgentProfileDimensionValue, t as AGENT_PROFILE_KINDS, u as AgentProfileJsonObject, v as buildAgentProfileCell, x as toAgentProfileJson, y as groupRunsByAgentProfileCell } from "./agent-profile-cell-Cw0PVwDr.js";
+import { C as verifyAgentProfileCell, S as validateAgentProfileCell, _ as buildAgentInterfaceProfileCell, a as AgentProfileCellSchemaVersion, b as requireAgentProfileCell, c as AgentProfileHarness, d as AgentProfileKind, f as AgentProfileSource, g as assertRunAgentProfileCell, h as agentProfileCellKey, i as AgentProfileCellInput, l as AgentProfileJson, m as agentProfileCellHashMaterial, n as AgentInterfaceProfileLike, o as AgentProfileCellValidationError, p as AgentProfileSourceInput, r as AgentProfileCell, s as AgentProfileDimensionValue, t as AGENT_PROFILE_KINDS, u as AgentProfileJsonObject, v as buildAgentProfileCell, x as toAgentProfileJson, y as groupRunsByAgentProfileCell } from "./agent-profile-cell-BOP-iA9Q.js";
 export { AGENT_PROFILE_KINDS, AgentInterfaceProfileLike, AgentProfileCell, AgentProfileCellInput, AgentProfileCellSchemaVersion, AgentProfileCellValidationError, AgentProfileDimensionValue, AgentProfileHarness, AgentProfileJson, AgentProfileJsonObject, AgentProfileKind, AgentProfileSource, AgentProfileSourceInput, agentProfileCellHashMaterial, agentProfileCellKey, assertRunAgentProfileCell, buildAgentInterfaceProfileCell, buildAgentProfileCell, groupRunsByAgentProfileCell, requireAgentProfileCell, toAgentProfileJson, validateAgentProfileCell, verifyAgentProfileCell };