modelrig 0.11.0 → 0.12.0

package/dist/run/messages.js

@@ -0,0 +1,430 @@
+"use strict";
+/**
+ * The messages-native lane — ARC-β (agent-archetypes spec §4, builder-prompt-02
+ * §1.1). A provider-neutral conversation HISTORY that every adapter maps to its
+ * native shape (adapters/history-mapping.ts), so a chat turn or a tool loop can
+ * be routed, captured and replayed on a cheaper model.
+ *
+ * Design rules (binding):
+ *  - NO `system` role in history. The system prompt stays
+ *    `AdapterRequest.systemPrompt`, rendered by the route template exactly as
+ *    today. A `system` message in caller input is rejected with a teaching error.
+ *  - Tool calls reuse the existing normalized {@link ToolCall} (OpenAI
+ *    `tool_calls` shape) — there is no second tool-call vocabulary.
+ *  - `history` absent ⇒ every adapter takes today's code path, byte-identical
+ *    (pinned by adapters/one-turn-parity.test.ts).
+ *
+ * NAMING NOTE: the spec calls the type `ChatMessage`, but `ChatMessage` is
+ * already a public export (the gateway's OpenAI wire message,
+ * gateway/http-protocol.ts). To keep that export stable the lane's type is
+ * exported as {@link HistoryMessage} (it is what `AdapterRequest.history` holds).
+ *
+ * Pure module: types, validation, canonicalization and the capture codec. No I/O.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HISTORY_INCOMPATIBLE_PREFIX = exports.HISTORY_SKIPPED_TAG = exports.MESSAGES_CAPTURE_KIND = exports.MessagesInputError = exports.MESSAGES_DOCS_ANCHOR = void 0;
+exports.historyProblems = historyProblems;
+exports.assertValidHistory = assertValidHistory;
+exports.contentText = contentText;
+exports.historyChars = historyChars;
+exports.canonicalize = canonicalize;
+exports.renderForCapture = renderForCapture;
+exports.parseCaptureInput = parseCaptureInput;
+exports.captureInputFor = captureInputFor;
+exports.routedHistory = routedHistory;
+exports.withSkipTag = withSkipTag;
+exports.messagesUserTurn = messagesUserTurn;
+exports.historyIncompatibility = historyIncompatibility;
+exports.isGemini3Model = isGemini3Model;
+exports.historyIncompatibilityCode = historyIncompatibilityCode;
+exports.rawHistory = rawHistory;
+exports.userSideForHash = userSideForHash;
+const loader_1 = require("../routes/loader");
+const failures_1 = require("../types/failures");
+const input_loader_1 = require("../routes/input-loader");
+const template_1 = require("../routes/template");
+/** Where every messages-lane teaching message points. */
+exports.MESSAGES_DOCS_ANCHOR = "messages-lane.md";
+/** A caller-contract breach in a `messages` input. Subclasses RouteConfigError
+ * so every surface that already maps config errors (the gateway's 422, the CLI)
+ * treats it the same way: thrown pre-dispatch, nothing billed, no telemetry. */
+class MessagesInputError extends loader_1.RouteConfigError {
+    constructor(problems) {
+        super("invalid messages", { problems });
+        this.name = "MessagesInputError";
+    }
+}
+exports.MessagesInputError = MessagesInputError;
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function contentProblems(content, at, problems) {
+    if (typeof content === "string")
+        return;
+    if (!Array.isArray(content)) {
+        problems.push(`${at}.content must be a string or an array of {type: "text", text} parts`);
+        return;
+    }
+    content.forEach((p, j) => {
+        if (!isRecord(p) || p.type !== "text" || typeof p.text !== "string") {
+            const kind = isRecord(p) && typeof p.type === "string" ? `"${p.type}" ` : "";
+            problems.push(`${at}.content[${j}] ${kind}is not a text part — only {type: "text", text: string} parts are supported ` +
+                "(image parts arrive with the image-input lane)");
+        }
+    });
+}
+function isJsonObjectString(s) {
+    try {
+        return isRecord(JSON.parse(s));
+    }
+    catch {
+        return false;
+    }
+}
+function toolCallProblems(calls, at, problems) {
+    if (!Array.isArray(calls)) {
+        problems.push(`${at}.toolCalls must be an array of tool calls (the shape meta.toolCalls returned)`);
+        return [];
+    }
+    const ids = [];
+    calls.forEach((c, j) => {
+        const fn = isRecord(c) ? c.function : undefined;
+        if (!isRecord(c) ||
+            typeof c.id !== "string" ||
+            c.id === "" ||
+            c.type !== "function" ||
+            !isRecord(fn) ||
+            typeof fn.name !== "string" ||
+            typeof fn.arguments !== "string") {
+            problems.push(`${at}.toolCalls[${j}] must be {id, type: "function", function: {name, arguments: <JSON string>}}`);
+            return;
+        }
+        if (!isJsonObjectString(fn.arguments)) {
+            problems.push(`${at}.toolCalls[${j}].function.arguments must be a JSON object string (e.g. "{\\"q\\":\\"acme\\"}")`);
+            return;
+        }
+        ids.push(c.id);
+    });
+    return ids;
+}
+/**
+ * Validate a caller-supplied history. Returns the list of teaching problems
+ * (empty ⇒ valid). Rules: a non-empty array; roles user | assistant | tool only
+ * (a `system` message is rejected, pointing at the route template /
+ * `systemPrompt`); `toolCalls` only on assistant messages; every tool message
+ * answers a PRIOR assistant tool call by id; the last message is `user` or
+ * `tool` (the model answers it).
+ */
+function historyProblems(messages) {
+    const problems = [];
+    if (!Array.isArray(messages))
+        return ["messages must be an array of {role, content} messages"];
+    if (messages.length === 0) {
+        return ["messages is empty — a conversation needs at least one user message for the model to answer"];
+    }
+    // Tool-call PAIRING (QA M2 — every provider enforces it): the tool messages that
+    // immediately follow an assistant turn with toolCalls answer EXACTLY that turn's
+    // ids — none missing, none extra, none twice — before any other turn. Ids are
+    // scoped to ONE assistant turn and its results (R2-3): hosts that emit `call_0`
+    // on every turn are valid. One problem per real fault (no overlapping echoes).
+    const everIssued = new Set();
+    const reportedUnanswered = new Set();
+    let windowAnswered = new Set();
+    let pending = null;
+    const closePending = (before) => {
+        if (pending !== null && pending.ids.size > 0) {
+            problems.push(`${pending.at} issued tool call(s) ${[...pending.ids].map((id) => `"${id}"`).join(", ")} that are not answered ` +
+                `before ${before} — every tool call needs its tool result immediately after the assistant turn`);
+            for (const id of pending.ids)
+                reportedUnanswered.add(id);
+        }
+        pending = null;
+    };
+    messages.forEach((m, i) => {
+        const at = `messages[${i}]`;
+        if (!isRecord(m)) {
+            problems.push(`${at} must be an object {role, content}`);
+            return;
+        }
+        if (m.role === "system") {
+            problems.push(`send your system prompt via the route template, not as a system message — ${at} has role "system". ` +
+                "With rig.run it belongs in the route's system template; with runRaw pass it as `systemPrompt`; " +
+                "history holds only user, assistant and tool turns");
+            return;
+        }
+        if (m.role === "user" || m.role === "assistant") {
+            closePending(at);
+            contentProblems(m.content, at, problems);
+            if (m.toolCalls !== undefined) {
+                if (m.role === "user") {
+                    problems.push(`${at}.toolCalls is only allowed on an assistant message`);
+                }
+                else {
+                    const ids = new Set();
+                    for (const id of toolCallProblems(m.toolCalls, at, problems)) {
+                        if (ids.has(id))
+                            problems.push(`${at} issues tool call id "${id}" more than once in the same turn`);
+                        ids.add(id);
+                        everIssued.add(id);
+                        reportedUnanswered.delete(id);
+                    }
+                    windowAnswered = new Set();
+                    if (ids.size > 0)
+                        pending = { at, ids };
+                }
+            }
+            return;
+        }
+        if (m.role === "tool") {
+            if (typeof m.content !== "string")
+                problems.push(`${at}.content must be a string (the tool's result)`);
+            const id = m.toolCallId;
+            if (typeof id !== "string" || id === "") {
+                problems.push(`${at}.toolCallId must name the tool call this result answers`);
+            }
+            else if (pending !== null && pending.ids.has(id)) {
+                pending.ids.delete(id);
+                windowAnswered.add(id);
+            }
+            else if (windowAnswered.has(id)) {
+                problems.push(`${at} answers tool call "${id}" a second time — each tool call takes exactly one tool result`);
+            }
+            else if (reportedUnanswered.has(id)) {
+                // already reported once, as the unanswered call — no second message
+            }
+            else if (everIssued.has(id)) {
+                problems.push(`${at} answers tool call "${id}" out of place — a tool result must immediately follow the assistant turn ` +
+                    "that issued it (no user or assistant turn in between)");
+            }
+            else {
+                problems.push(`${at} answers tool call "${id}", but no earlier assistant message issued it — ` +
+                    "include the assistant turn with its toolCalls before the tool result");
+            }
+            return;
+        }
+        problems.push(`${at}.role ${JSON.stringify(m.role)} is not one of user | assistant | tool`);
+    });
+    closePending("the end of the conversation");
+    const last = messages[messages.length - 1];
+    if (isRecord(last) && last.role !== "user" && last.role !== "tool" && last.role !== "system") {
+        problems.push(`the last message is "${String(last.role)}" — a conversation must end with a user or tool message for the model to answer`);
+    }
+    return problems;
+}
+/** Throw a {@link MessagesInputError} when `messages` is not a valid history;
+ * otherwise return it typed. */
+function assertValidHistory(messages) {
+    const problems = historyProblems(messages);
+    if (problems.length > 0)
+        throw new MessagesInputError(problems);
+    return messages;
+}
+/** The text of a content value (parts concatenated in order, no separator —
+ * the same joining OpenAI applies to multi-part text content). */
+function contentText(content) {
+    return typeof content === "string" ? content : content.map((p) => p.text).join("");
+}
+/** Total characters across every message's text and tool-call arguments — the
+ * history's contribution to the envelope's pre-dispatch input estimate. */
+function historyChars(history) {
+    if (history === undefined)
+        return 0;
+    let n = 0;
+    for (const m of history) {
+        n += m.role === "tool" ? m.content.length : contentText(m.content).length;
+        if (m.role === "assistant")
+            for (const c of m.toolCalls ?? [])
+                n += c.function.name.length + c.function.arguments.length;
+    }
+    return n;
+}
+/** Deterministic JSON (keys sorted, arrays in order). */
+function stable(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "null";
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(",")}]`;
+    const rec = value;
+    return `{${Object.keys(rec)
+        .filter((k) => rec[k] !== undefined)
+        .sort()
+        .map((k) => `${JSON.stringify(k)}:${stable(rec[k])}`)
+        .join(",")}}`;
+}
+/**
+ * Canonical text of a history, for hashing and cache-prefix reasoning: one
+ * sorted-key JSON line per message. PREFIX-STABLE by construction —
+ * `canonicalize(h.slice(0, n))` is a string prefix of `canonicalize(h)` — so a
+ * conversation that grows by appending turns keeps every earlier turn's bytes
+ * (the property provider prefix caches key on).
+ */
+function canonicalize(history) {
+    return history.map((m) => `${stable(m)}\n`).join("");
+}
+// ── Capture codec (spec §4: one JSON capture per turn) ───────────────────────
+/** The marker that tells a capture row's `variablesJson` holds a messages call. */
+exports.MESSAGES_CAPTURE_KIND = "modelrig.messages";
+/** Render a messages call's replay input for the capture row (JSON). */
+function renderForCapture(history, variables = {}, tools = {}) {
+    const capture = {
+        kind: exports.MESSAGES_CAPTURE_KIND,
+        v: 1,
+        variables,
+        history,
+        ...(tools.tools !== undefined ? { tools: tools.tools } : {}),
+        ...(tools.toolChoice !== undefined ? { toolChoice: tools.toolChoice } : {}),
+    };
+    return JSON.stringify(capture);
+}
+function parseCaptureInput(variablesJson) {
+    const parsed = JSON.parse(variablesJson);
+    if (isRecord(parsed) && parsed.kind === exports.MESSAGES_CAPTURE_KIND && Array.isArray(parsed.history)) {
+        const variables = isRecord(parsed.variables) ? parsed.variables : {};
+        return {
+            input: variables,
+            messages: assertValidHistory(parsed.history),
+            ...(Array.isArray(parsed.tools) ? { tools: parsed.tools } : {}),
+            ...(parsed.toolChoice !== undefined ? { toolChoice: parsed.toolChoice } : {}),
+        };
+    }
+    return { input: parsed };
+}
+/** The capture-row input for a run: the variables alone (legacy, byte-identical)
+ * or the messages envelope. Returned as a value for `JSON.stringify` by the
+ * capture writer. */
+function captureInputFor(input, messages, tools = {}) {
+    return messages === undefined ? input : JSON.parse(renderForCapture(messages, input, tools));
+}
+function routedHistory(route, opts) {
+    if (route.inputKind !== "messages") {
+        if (opts.messages === undefined)
+            return { history: undefined, route, skipTag: {} };
+        throw new loader_1.RouteConfigError(`route "${route.route}" does not accept messages — declare \`input: { kind: messages }\` in its bundle to ` +
+            `serve a conversation, or pass the content as \`input\` variables (see ${exports.MESSAGES_DOCS_ANCHOR})`);
+    }
+    const conflict = (0, input_loader_1.messagesGuardConflict)({
+        maskDeclared: route.mask !== undefined,
+        screenDeclared: route.screen !== undefined,
+        repairDeclared: route.repair !== undefined || (route.variants ?? []).some((v) => v.repair !== undefined),
+    });
+    if (conflict !== null)
+        throw new loader_1.RouteConfigError(`route "${route.route}": ${conflict}`);
+    if (opts.messages === undefined) {
+        throw new MessagesInputError([
+            `route "${route.route}" declares input: messages — pass the conversation as \`messages\` (the system prompt still comes from the route template)`,
+        ]);
+    }
+    const history = assertValidHistory(opts.messages);
+    return { history, ...compatibleCandidates(route, history, opts.tools) };
+}
+/** The `history_skipped` tag key (the precedent is `zdr_enforced`). */
+exports.HISTORY_SKIPPED_TAG = "history_skipped";
+/** Merge the skip tag onto the run's tags; the SAME object when there is none. */
+function withSkipTag(tags, skipTag) {
+    return Object.keys(skipTag).length === 0 ? tags : { ...tags, ...skipTag };
+}
+/**
+ * Ruling R2-2: a candidate that cannot take this history natively is SKIPPED
+ * before the ladder (no dispatch, no row), and the run proceeds on the
+ * compatible candidates in their declared order. The skips ride every row of
+ * the call as the `history_skipped` tag. Only when NO candidate is compatible
+ * does the run fail closed — the terminal `invariant_violation`, listing each
+ * candidate's reason (no new FailureClass).
+ */
+function compatibleCandidates(route, history, tools) {
+    const skipped = [];
+    const kept = route.candidates.filter((c) => {
+        const why = historyIncompatibilityCode(c.provider, c.model, history, tools);
+        if (why !== null)
+            skipped.push({ c, why });
+        return why === null;
+    });
+    if (skipped.length === 0)
+        return { route, skipTag: {} };
+    if (kept.length === 0) {
+        const only = route.candidates.length === 1 ? route.candidates[0] : undefined;
+        throw new failures_1.RigFailureError({
+            class: "invariant_violation",
+            message: `${exports.HISTORY_INCOMPATIBLE_PREFIX}: no candidate of route "${route.route}" can take this conversation natively — ` +
+                skipped.map((s) => s.why.message.slice(exports.HISTORY_INCOMPATIBLE_PREFIX.length + 2)).join("; "),
+            fixHint: "add a candidate that accepts tool-loop history (and pass the loop's `tools` on every turn)",
+            ...(only !== undefined ? { provider: only.provider, model: only.model } : {}),
+        });
+    }
+    return {
+        route: Object.freeze({ ...route, candidates: Object.freeze(kept) }),
+        skipTag: { [exports.HISTORY_SKIPPED_TAG]: skipped.map((s) => `${s.c.provider}/${s.c.model}=${s.why.code}`).join(",") },
+    };
+}
+/** A messages route's final user instruction: its rendered `prompt.user` when
+ * declared, else nothing (the history's last turn IS the prompt — the fixed
+ * single-turn trigger is never appended to a conversation). */
+function messagesUserTurn(route, ctx) {
+    return route.userTemplate === undefined ? "" : (0, template_1.renderTemplate)(route.userTemplate, ctx);
+}
+// ── Provider acceptance (architect ruling M3(b), 2026-10-24) ─────────────────
+/** Prefix of every "this provider cannot take this history natively" refusal —
+ * the stable marker turn replay keys on to mark a case INCOMPARABLE for a
+ * candidate (bakeoff/turn-replay.ts) rather than score it as a failure. */
+exports.HISTORY_INCOMPATIBLE_PREFIX = "history not accepted natively";
+const hasToolBlocks = (h) => h.some((m) => m.role === "tool" || (m.role === "assistant" && (m.toolCalls ?? []).length > 0));
+/**
+ * Why `provider/model` cannot be sent this history natively, or null. Fail-closed
+ * PRE-DISPATCH (no provider call) on two documented provider rules:
+ *  - Anthropic rejects `tool_use` / `tool_result` blocks unless the request
+ *    declares `tools`;
+ *  - Gemini 3 models require thought signatures on earlier `functionCall` parts,
+ *    which ModelRig neither captures nor invents (no placeholder signatures).
+ * Every other provider/model proceeds.
+ */
+function historyIncompatibility(provider, model, history, declaredTools) {
+    return historyIncompatibilityCode(provider, model, history, declaredTools)?.message ?? null;
+}
+/** R2-4: `models/gemini-3…` and case variants normalize to `gemini-3…`. An
+ * unregistered alias (e.g. `gemini-pro-latest`) does not match and falls
+ * through to the provider's own 400 — documented, never guessed. */
+function isGemini3Model(model) {
+    return /^gemini-3/.test(model.trim().toLowerCase().replace(/^models\//, ""));
+}
+function historyIncompatibilityCode(provider, model, history, declaredTools) {
+    if (history === undefined || !hasToolBlocks(history))
+        return null;
+    if (provider === "anthropic" && (declaredTools === undefined || declaredTools.length === 0)) {
+        return {
+            code: "tools_required",
+            message: `${exports.HISTORY_INCOMPATIBLE_PREFIX}: anthropic/${model} rejects tool_use / tool_result blocks in the history unless ` +
+                "the request declares `tools`, and this request declared none — pass the same `tools` on every turn of the tool loop",
+        };
+    }
+    if (provider === "gemini" && isGemini3Model(model) && history.some((m) => m.role === "assistant" && (m.toolCalls ?? []).length > 0)) {
+        return {
+            code: "thought_signatures",
+            message: `${exports.HISTORY_INCOMPATIBLE_PREFIX}: gemini/${model} requires thought signatures on the function calls in the history, ` +
+                "which ModelRig does not capture or invent — serve tool-loop turns with a non-Gemini-3 model (Gemini 2.x and other providers accept them)",
+        };
+    }
+    return null;
+}
+/** The raw lane's history (runRaw / runRawStream), or `undefined` for the
+ * single-turn call. `userPrompt` is optional only when `messages` is given;
+ * neither is a teaching error. A history the target provider cannot take
+ * natively is refused here, pre-dispatch (no provider call, no telemetry row). */
+function rawHistory(input) {
+    if (input.messages === undefined) {
+        if (input.userPrompt === undefined) {
+            throw new MessagesInputError(["runRaw needs a `userPrompt` or a `messages` conversation — neither was given"]);
+        }
+        return undefined;
+    }
+    const history = assertValidHistory(input.messages);
+    const incompatible = historyIncompatibility(input.provider, input.model, history, input.tools);
+    if (incompatible !== null)
+        throw new MessagesInputError([incompatible]);
+    return history;
+}
+/** The user side of the rendered request for the attempt envelope's
+ * input_hash / size (WI-1): the canonical history followed by the final user
+ * instruction; exactly `userPrompt` when there is no history (byte-identical). */
+function userSideForHash(userPrompt, history) {
+    return history === undefined ? userPrompt : `${canonicalize(history)}${userPrompt}`;
+}

package/dist/run/raw-finalize.d.ts

@@ -9,7 +9,7 @@
  * recorder — NO route/registry/capability-gate dependency.
  */
 import { type ActiveRunContext } from "../artifacts/run-context";
-import type { AdapterResult, AdapterUsage, ProviderId, ServiceTier } from "../types/provider";
+import type { AdapterResult, AdapterUsage, ProviderId, ServiceTier, ToolCall } from "../types/provider";
 import type { RunResult, RunTags } from "../types/route";
 import type { AttemptMetaV1 } from "../telemetry/attempt-meta";
 import type { TelemetryRow, TelemetryStore } from "../types/telemetry";
@@ -80,7 +80,10 @@ export declare function prepareRawStep(deps: Pick<RawRunDeps, "manifest">, input
  * ground-truth step — parity with the routed lane's record-attempt. No-op when
  * no run context was captured at entry. Fail-open is handled inside
  * `emitGroundTruthStep` (buffer errors are swallowed). */
-export declare function emitRawStep(step: RawStepContext | null, task: string, inferenceId: string, failureClass: string | null): void;
+export declare function emitRawStep(step: RawStepContext | null, task: string, inferenceId: string, failureClass: string | null, limitInputs?: {
+    readonly costUsd?: number;
+    readonly toolCalls?: readonly ToolCall[];
+}): void;
 /**
  * Turn an `AdapterResult` into a RunResult, recording exactly one telemetry row.
  * Shared by the buffered and streaming paths so cost/telemetry are byte-identical.

package/dist/run/raw-finalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raw-finalize.d.ts","sourceRoot":"","sources":["../../src/run/raw-finalize.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"raw-finalize.d.ts","sourceRoot":"","sources":["../../src/run/raw-finalize.ts"],"names":[],"mappings":"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"}

package/dist/run/raw-finalize.js

@@ -15,6 +15,7 @@ exports.recordRawRow = recordRawRow;
 exports.prepareRawStep = prepareRawStep;
 exports.emitRawStep = emitRawStep;
 exports.finalizeRaw = finalizeRaw;
+const messages_1 = require("./messages");
 const node_crypto_1 = require("node:crypto");
 const cost_1 = require("./cost");
 const raw_defaults_1 = require("./raw-defaults");
@@ -112,7 +113,7 @@ function prepareRawStep(deps, input) {
  * ground-truth step — parity with the routed lane's record-attempt. No-op when
  * no run context was captured at entry. Fail-open is handled inside
  * `emitGroundTruthStep` (buffer errors are swallowed). */
-function emitRawStep(step, task, inferenceId, failureClass) {
+function emitRawStep(step, task, inferenceId, failureClass, limitInputs) {
     if (step === null)
         return;
     step.runCtx.emitGroundTruthStep({
@@ -122,6 +123,8 @@ function emitRawStep(step, task, inferenceId, failureClass) {
         startedAt: step.startedAtIso,
         endedAt: new Date().toISOString(),
         failureClass,
+        ...(limitInputs?.costUsd !== undefined ? { costUsd: limitInputs.costUsd } : {}),
+        ...(limitInputs?.toolCalls !== undefined ? { toolCalls: limitInputs.toolCalls.map((t) => ({ name: t.function.name, arguments: t.function.arguments })) } : {}),
     });
 }
 /**
@@ -171,7 +174,7 @@ function finalizeRaw(deps, input, result, latencyMs, step) {
     const declaredToolNames = input.tools?.map((t) => t.function.name);
     const rawMeta = (usage) => (0, attempt_meta_1.summarizeAttemptMeta)({
         ...(result.meta !== undefined ? { adapterMeta: result.meta } : {}),
-        renderedRequest: (0, attempt_meta_1.renderRequestForHash)({ system: input.systemPrompt, user: input.userPrompt, schema }),
+        renderedRequest: (0, attempt_meta_1.renderRequestForHash)({ system: input.systemPrompt, user: (0, messages_1.userSideForHash)(input.userPrompt ?? "", input.messages), schema }),
         outputText: result.ok ? result.text : null,
         ...(declaredToolNames !== undefined ? { declaredToolNames } : {}),
         ...(schemaSha !== undefined ? { schemaSha } : {}),
@@ -182,7 +185,7 @@ function finalizeRaw(deps, input, result, latencyMs, step) {
     // G1: mirror this raw inference into a ground-truth step (parity with the
     // routed lane's record-attempt). task = tags.step ?? provider/model (spec F1).
     // Fail-open is handled inside emitGroundTruthStep (buffer errors are swallowed).
-    const emitStep = (inferenceId, failureClass) => emitRawStep(step, input.tags?.step ?? rawModelId, inferenceId, failureClass);
+    const emitStep = (inferenceId, failureClass, limitInputs) => emitRawStep(step, input.tags?.step ?? rawModelId, inferenceId, failureClass, limitInputs);
     if (!result.ok) {
         let costUsd = 0;
         let pricingMissing = false;
@@ -208,7 +211,7 @@ function finalizeRaw(deps, input, result, latencyMs, step) {
             meta: rawMeta(result.usage),
             ...(input.cache !== undefined ? { cacheKey: input.cache.key } : {}),
         });
-        emitStep(failId, result.failure.class);
+        emitStep(failId, result.failure.class, { costUsd });
         // R1: a raw-lane timeout is the #245 footgun — attach the tier-aware teaching
         // hint (the customer is looking at THIS error). Any other failure surfaces
         // unchanged. Overrides any adapter-set hint: the tier + budget is the fix.
@@ -245,7 +248,7 @@ function finalizeRaw(deps, input, result, latencyMs, step) {
         meta: rawMeta(result.usage),
         ...(input.cache !== undefined ? { cacheKey: input.cache.key } : {}),
     });
-    emitStep(id, schemaOutcome.ok ? null : "content_invalid");
+    emitStep(id, schemaOutcome.ok ? null : "content_invalid", { costUsd, toolCalls: toolCalls ?? [] });
     if (!schemaOutcome.ok)
         throw new failures_1.RigFailureError((0, raw_schema_1.rawSchemaMismatchFailure)(input, schemaOutcome.errors));
     // NWS N3: a NATIVE-grounded success writes one extra, legible `rung:"search"`

package/dist/run/raw-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raw-request.d.ts","sourceRoot":"","sources":["../../src/run/raw-request.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAEzC;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAE9D;AAED,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,GAAG,cAAc,CA0C3F"}
+{"version":3,"file":"raw-request.d.ts","sourceRoot":"","sources":["../../src/run/raw-request.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAEzC;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAE9D;AAED,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,GAAG,cAAc,CA2C3F"}

package/dist/run/raw-request.js

@@ -39,7 +39,8 @@ function buildRawRequest(candidate, input) {
     return {
         candidate,
         systemPrompt: input.systemPrompt,
-        userPrompt: input.userPrompt,
+        userPrompt: input.userPrompt ?? "", // ARC-β: optional only alongside `messages` (rawHistory guards)
+        ...(input.messages !== undefined ? { history: input.messages } : {}), // ARC-β; absent ⇒ no key
         // R2 (issue #6): a declared `responseSchema` rides the adapters' existing
         // NATIVE schema path (outputSchema) — gemini responseJsonSchema, openai/grok
         // strict json_schema, anthropic forced tool. Absent ⇒ null, byte-identical:

package/dist/run/raw.d.ts

@@ -16,9 +16,9 @@
  * touches an adapter or the brand.
  *
  * KNOWN LIMITATIONS (flagged for the architect, not hidden):
- *  - The adapter contract is single `systemPrompt` + `userPrompt`, not a
- *    `messages[]` array, so a multi-turn transcript is flattened by the caller
- *    (see `modelrig-server`'s `deriveRawPrompts`).
+ *  - ARC-β: a multi-turn transcript rides `messages` (→ `AdapterRequest.history`,
+ *    mapped per provider); the single-turn `systemPrompt` + `userPrompt` path is
+ *    unchanged (byte-identical, adapters/one-turn-parity.test.ts).
  *  - CE-6: the raw lane now forwards `temperature`/`topP` (via
  *    `AdapterRequest.sampling`) when the caller supplies them; absent, they are
  *    still dropped and the dispatch is byte-identical to pre-CE-6. `max_tokens`
@@ -52,6 +52,7 @@ import type { ProviderId, ReasoningParams, ServiceTier, ToolChoice, ToolDefiniti
 import type { RunResult, RunTags } from "../types/route";
 import type { RunStreamHandle } from "./stream";
 import type { TelemetryStore } from "../types/telemetry";
+import type { HistoryMessage } from "./messages";
 export { assertRawKnobsSupported } from "./raw-knobs";
 export { buildRawRequest } from "./raw-request";
 /** Raw-lane request. `systemPrompt`/`userPrompt` are already flattened from the
@@ -65,7 +66,12 @@ export interface RawRunInput {
      * in memory for this one call, then dropped (never logged, never stored). */
     readonly apiKey: string;
     readonly systemPrompt: string;
-    readonly userPrompt: string;
+    /** The single-turn user prompt. ARC-β: optional when `messages` is given (then a
+     * non-empty value is appended as a final user message); one of them is required. */
+    readonly userPrompt?: string;
+    /** ARC-β messages lane — the conversation (user / assistant+toolCalls / tool);
+     * `systemPrompt` stays the system prompt. Absent ⇒ byte-identical single turn. */
+    readonly messages?: readonly HistoryMessage[];
     readonly tags?: RunTags;
     /** G1 (spec §3): names the ground-truth step this raw call records inside an
      * active `run.start` context — the SAME field the routed lane exposes, so a

package/dist/run/raw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raw.d.ts","sourceRoot":"","sources":["../../src/run/raw.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAgBH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAIV,UAAU,EACV,eAAe,EACf,WAAW,EACX,UAAU,EACV,cAAc,EACf,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,KAAK,EAAkB,eAAe,EAAE,MAAM,UAAU,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD;;;sCAGsC;AACtC,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;iFAC6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;iFAK6E;IAC7E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;6EAGyE;IACzE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC;;;;;;;0BAOsB;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxE;;;;;;;iDAO6C;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC;IACjD;;;;mFAI+E;IAC/E,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC;;;;qFAIiF;IACjF,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC;IACrC;;;;;;;;sEAQkE;IAClE,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC;IACxC;;;;;;;;;;;;;4DAawD;IACxD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC;;+EAE2E;IAC3E,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IACzC;;sEAEkE;IAClE,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CACxC;AAsCD;wDACwD;AACxD,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAYrF;AAcD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,GAAG,eAAe,CAiDlF"}
+{"version":3,"file":"raw.d.ts","sourceRoot":"","sources":["../../src/run/raw.ts"],"names":[],"mappings":"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"}

package/dist/run/raw.js

@@ -17,9 +17,9 @@
  * touches an adapter or the brand.
  *
  * KNOWN LIMITATIONS (flagged for the architect, not hidden):
- *  - The adapter contract is single `systemPrompt` + `userPrompt`, not a
- *    `messages[]` array, so a multi-turn transcript is flattened by the caller
- *    (see `modelrig-server`'s `deriveRawPrompts`).
+ *  - ARC-β: a multi-turn transcript rides `messages` (→ `AdapterRequest.history`,
+ *    mapped per provider); the single-turn `systemPrompt` + `userPrompt` path is
+ *    unchanged (byte-identical, adapters/one-turn-parity.test.ts).
  *  - CE-6: the raw lane now forwards `temperature`/`topP` (via
  *    `AdapterRequest.sampling`) when the caller supplies them; absent, they are
  *    still dropped and the dispatch is byte-identical to pre-CE-6. `max_tokens`
@@ -66,6 +66,8 @@ const resolve_1 = require("./resolve");
 const raw_knobs_1 = require("./raw-knobs");
 const raw_request_1 = require("./raw-request");
 const raw_finalize_1 = require("./raw-finalize");
+const run_context_1 = require("../artifacts/run-context"); // ARC-5
+const messages_1 = require("./messages");
 var raw_knobs_2 = require("./raw-knobs");
 Object.defineProperty(exports, "assertRawKnobsSupported", { enumerable: true, get: function () { return raw_knobs_2.assertRawKnobsSupported; } });
 var raw_request_2 = require("./raw-request");
@@ -110,9 +112,11 @@ async function runRaw(deps, input) {
     // CE-2 F1/F3: fail closed on an unsupported declared directive BEFORE building
     // an adapter — no meter, no provider call, no telemetry row.
     (0, raw_knobs_1.assertRawKnobsSupported)(input);
+    (0, messages_1.rawHistory)(input); // ARC-β: validate messages / require a prompt, pre-dispatch
     // G1: bind the ambient run context at ENTRY (ALS boundary) so a raw call inside
     // a run.start records a ground-truth step (spec §4). Null ⇒ uninstrumented.
     const step = (0, raw_finalize_1.prepareRawStep)(deps, input);
+    (0, run_context_1.enforceRunLimits)(); // ARC-5: pre-dispatch run-limit check (throws RunLimitExceeded; no-op without limits)
     const adapter = buildRawAdapter(input.provider, input.apiKey);
     const candidate = (0, resolve_1.mintRawCandidate)(input.provider, input.model);
     const started = Date.now();
@@ -143,6 +147,7 @@ function runRawStream(deps, input) {
     // boundary — NOT inside the async generator below (which defers to drain time,
     // possibly on a different async context, where getActiveRunContext would miss).
     const step = (0, raw_finalize_1.prepareRawStep)(deps, input);
+    const limitRefusal = (0, run_context_1.runLimitRefusal)(); // ARC-5: checked at the ALS entry, thrown through the handle below
     let settle;
     let fail;
     const result = new Promise((res, rej) => {
@@ -158,6 +163,9 @@ function runRawStream(deps, input) {
             // adapter/dispatch — surfaced through the handle (result rejects, the
             // events iterator throws), so no meter, no provider call, no telemetry row.
             (0, raw_knobs_1.assertRawKnobsSupported)(input);
+            (0, messages_1.rawHistory)(input); // ARC-β: validate messages / require a prompt, pre-dispatch
+            if (limitRefusal !== null)
+                throw limitRefusal; // ARC-5
             const adapter = buildRawAdapter(input.provider, input.apiKey);
             const candidate = (0, resolve_1.mintRawCandidate)(input.provider, input.model);
             const req = (0, raw_request_1.buildRawRequest)(candidate, input);