modelrig 0.11.0 → 0.12.0

package/dist/run/limits.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * ARC-5 — run limits: an inline loop and budget guard, per run, in-process.
+ *
+ *   run.start({ pipeline, limits: { maxUsd, maxCalls, maxWallMs, maxRepeatToolCall } })
+ *   rig.conversation(id, { agent, limits })
+ *
+ * Every call inside an ambient run passes through the SDK, so the SDK can refuse
+ * the NEXT dispatch once a limit is reached — something an observability tool
+ * structurally cannot. On breach the dispatch throws a typed
+ * {@link RunLimitExceeded} (`failureClass: "limit_exceeded"`, terminal), the
+ * run's `RunMeta.failure_reason` becomes `limit:<which>`, and the run ends
+ * `failed`. A run that stopped at a limit keeps refusing on that async path.
+ *
+ * `recordCall` cannot prevent a call it did not dispatch: it ACCUMULATES (cost,
+ * call count) and the next `run`/`runRaw` throws. Distinct from envelopes (org /
+ * route money budgets, server-side, monthly): limits are per run and immediate.
+ *
+ * `maxRepeatToolCall: n` trips when the SAME tool name + argument hash is
+ * requested n times IN A ROW (a stuck agent loop). Only a SHA-256 of the
+ * canonical JSON arguments is kept — never the argument content.
+ *
+ * Everything here is PURE (state in, state out); run-context.ts holds the state.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunLimitExceeded = void 0;
+exports.initialLimitState = initialLimitState;
+exports.toolCallSignature = toolCallSignature;
+exports.accumulate = accumulate;
+exports.checkRunLimits = checkRunLimits;
+exports.limitFailureReason = limitFailureReason;
+exports.validateRunLimits = validateRunLimits;
+exports.limitsForMeta = limitsForMeta;
+const node_crypto_1 = require("node:crypto");
+const failures_1 = require("../types/failures");
+const failures_teaching_1 = require("../types/failures-teaching");
+function initialLimitState(startedAtMs) {
+    return { costUsd: 0, calls: 0, startedAtMs, lastToolSig: null, repeatCount: 0 };
+}
+/** Canonical JSON (sorted keys) so `{a:1,b:2}` and `{b:2,a:1}` hash alike. A
+ * non-JSON argument string hashes as the raw string. */
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const obj = value;
+        return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${canonical(obj[k])}`).join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+/** `<name>:<sha256(canonical JSON args)>` — the ONLY form a tool call is kept in. */
+function toolCallSignature(name, argsJson) {
+    let body;
+    try {
+        body = canonical(JSON.parse(argsJson));
+    }
+    catch {
+        body = argsJson;
+    }
+    return `${name}:${(0, node_crypto_1.createHash)("sha256").update(body, "utf8").digest("hex")}`;
+}
+/** Fold one recorded call into the state (pure). */
+function accumulate(state, call) {
+    if (call.notDispatched === true)
+        return state;
+    let { lastToolSig, repeatCount } = state;
+    if (call.toolCalls !== undefined) {
+        if (call.toolCalls.length === 0) {
+            lastToolSig = null;
+            repeatCount = 0;
+        }
+        for (const tc of call.toolCalls) {
+            const sig = toolCallSignature(tc.name, tc.arguments);
+            if (sig === lastToolSig)
+                repeatCount += 1;
+            else {
+                lastToolSig = sig;
+                repeatCount = 1;
+            }
+        }
+    }
+    const cost = typeof call.costUsd === "number" && Number.isFinite(call.costUsd) && call.costUsd > 0 ? call.costUsd : 0;
+    return { ...state, costUsd: state.costUsd + cost, calls: state.calls + 1, lastToolSig, repeatCount };
+}
+/** PURE pre-dispatch check: the first limit already reached, or null. Order:
+ * money, calls, wall clock, repeat loop. */
+function checkRunLimits(state, limits, nowMs) {
+    if (limits.maxUsd !== undefined && state.costUsd >= limits.maxUsd) {
+        return { which: "max_usd", limit: limits.maxUsd, observed: state.costUsd };
+    }
+    if (limits.maxCalls !== undefined && state.calls >= limits.maxCalls) {
+        return { which: "max_calls", limit: limits.maxCalls, observed: state.calls };
+    }
+    const elapsed = nowMs - state.startedAtMs;
+    if (limits.maxWallMs !== undefined && elapsed >= limits.maxWallMs) {
+        return { which: "max_wall_ms", limit: limits.maxWallMs, observed: elapsed };
+    }
+    if (limits.maxRepeatToolCall !== undefined && state.repeatCount >= limits.maxRepeatToolCall) {
+        return { which: "max_repeat_tool_call", limit: limits.maxRepeatToolCall, observed: state.repeatCount };
+    }
+    return null;
+}
+/** `limit:<which>` — the RunMeta.failure_reason a breach writes. */
+function limitFailureReason(which) {
+    return `limit:${which}`;
+}
+/** Validate caller limits (a caller bug throws with the fix). Returns null for
+ * an empty / absent object — no limits, no state, byte-identical runs. */
+function validateRunLimits(limits) {
+    if (limits === undefined)
+        return null;
+    const out = {};
+    const check = (key, integer) => {
+        const v = limits[key];
+        if (v === undefined)
+            return;
+        if (typeof v !== "number" || !Number.isFinite(v) || v <= 0 || (integer && !Number.isInteger(v))) {
+            throw new Error(`run limits: ${key} must be a positive ${integer ? "integer" : "number"}, got ${String(v)} — ` +
+                "omit the field to leave that limit off");
+        }
+        out[key] = v;
+    };
+    check("maxUsd", false);
+    check("maxCalls", true);
+    check("maxWallMs", false);
+    check("maxRepeatToolCall", true);
+    return Object.keys(out).length > 0 ? out : null;
+}
+/** The snake_case copy recorded on `RunMeta.limits` (metadata-safe numbers). */
+function limitsForMeta(limits) {
+    return {
+        ...(limits.maxUsd !== undefined ? { max_usd: limits.maxUsd } : {}),
+        ...(limits.maxCalls !== undefined ? { max_calls: limits.maxCalls } : {}),
+        ...(limits.maxWallMs !== undefined ? { max_wall_ms: limits.maxWallMs } : {}),
+        ...(limits.maxRepeatToolCall !== undefined ? { max_repeat_tool_call: limits.maxRepeatToolCall } : {}),
+    };
+}
+/** The typed error a refused dispatch throws. A `RigFailureError` (class
+ * `limit_exceeded`, terminal) carrying which limit, its value and the observed one. */
+class RunLimitExceeded extends failures_1.RigFailureError {
+    constructor(breach, runId) {
+        super({
+            class: "limit_exceeded",
+            message: `run ${runId} stopped at its ${breach.which} limit (limit ${breach.limit}, observed ` +
+                `${Number.isInteger(breach.observed) ? breach.observed : breach.observed.toFixed(6)}) — the next call was not dispatched`,
+            fixHint: failures_teaching_1.FAILURE_TEACHING.limit_exceeded.fixHint,
+        });
+        this.name = "RunLimitExceeded";
+        this.which = breach.which;
+        this.limit = breach.limit;
+        this.observed = breach.observed;
+        this.runId = runId;
+    }
+}
+exports.RunLimitExceeded = RunLimitExceeded;

package/dist/run/messages.d.ts

@@ -0,0 +1,199 @@
+/**
+ * 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.
+ */
+import type { ToolCall, ToolChoice, ToolDefinition } from "../types/provider";
+import type { RouteBundle, RunOptions } from "../types/route";
+import type { CapabilityFlag } from "../types/provider";
+import { RouteConfigError } from "../routes/loader";
+/** A text part of a message's content. */
+export interface HistoryTextPart {
+    readonly type: "text";
+    readonly text: string;
+}
+/** A content part. TEXT ONLY in ARC-β — image parts are UC-3 M1's job and join
+ * this union there (EXTENSION POINT: add `| HistoryImagePart` and teach each
+ * mapper in adapters/history-mapping.ts; validation below rejects any other
+ * `type` with a teaching problem until then). */
+export type HistoryPart = HistoryTextPart;
+export type HistoryContent = string | readonly HistoryPart[];
+export interface HistoryUserMessage {
+    readonly role: "user";
+    readonly content: HistoryContent;
+}
+export interface HistoryAssistantMessage {
+    readonly role: "assistant";
+    readonly content: HistoryContent;
+    /** The tool calls this assistant turn emitted (exactly what `meta.toolCalls`
+     * returned on that turn). Only assistant messages carry them. */
+    readonly toolCalls?: readonly ToolCall[];
+}
+export interface HistoryToolMessage {
+    readonly role: "tool";
+    /** The `ToolCall.id` this message answers — must match a PRIOR assistant
+     * message's tool call. */
+    readonly toolCallId: string;
+    readonly content: string;
+}
+/** One turn of a conversation (spec's `ChatMessage`; see the naming note). */
+export type HistoryMessage = HistoryUserMessage | HistoryAssistantMessage | HistoryToolMessage;
+/** Where every messages-lane teaching message points. */
+export declare const 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. */
+export declare class MessagesInputError extends RouteConfigError {
+    constructor(problems: readonly string[]);
+}
+/**
+ * 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).
+ */
+export declare function historyProblems(messages: unknown): string[];
+/** Throw a {@link MessagesInputError} when `messages` is not a valid history;
+ * otherwise return it typed. */
+export declare function assertValidHistory(messages: unknown): readonly HistoryMessage[];
+/** The text of a content value (parts concatenated in order, no separator —
+ * the same joining OpenAI applies to multi-part text content). */
+export declare function contentText(content: HistoryContent): string;
+/** Total characters across every message's text and tool-call arguments — the
+ * history's contribution to the envelope's pre-dispatch input estimate. */
+export declare function historyChars(history: readonly HistoryMessage[] | undefined): number;
+/**
+ * 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).
+ */
+export declare function canonicalize(history: readonly HistoryMessage[]): string;
+/** The marker that tells a capture row's `variablesJson` holds a messages call. */
+export declare const MESSAGES_CAPTURE_KIND = "modelrig.messages";
+export interface MessagesCapture {
+    readonly kind: typeof MESSAGES_CAPTURE_KIND;
+    readonly v: 1;
+    /** The route's template variables (`RunOptions.input`). */
+    readonly variables: Record<string, unknown>;
+    /** The history the model answered — up to and including the turn's final
+     * user/tool message. The captured output is the reference assistant reply. */
+    readonly history: readonly HistoryMessage[];
+    /** The tool definitions the live call declared (R2-1) — present ONLY when it
+     * declared them, so a capture without tools is byte-identical to before. */
+    readonly tools?: readonly ToolDefinition[];
+    readonly toolChoice?: ToolChoice;
+}
+/** The live call's tool surface, recorded on the capture so turn replay answers
+ * the final turn with the SAME tool definitions. */
+export interface CapturedTools {
+    readonly tools?: readonly ToolDefinition[];
+    readonly toolChoice?: ToolChoice;
+}
+/** Render a messages call's replay input for the capture row (JSON). */
+export declare function renderForCapture(history: readonly HistoryMessage[], variables?: Record<string, unknown>, tools?: CapturedTools): string;
+/** The replay input a capture row encodes: the route variables, plus the
+ * history when the row came from a messages call. A legacy (variables-only)
+ * row parses exactly as before. */
+export interface CaptureReplayInput {
+    readonly input: Record<string, unknown>;
+    readonly messages?: readonly HistoryMessage[];
+    /** The live call's tools (R2-1), when it declared any — replayed verbatim. */
+    readonly tools?: readonly ToolDefinition[];
+    readonly toolChoice?: ToolChoice;
+}
+export declare function parseCaptureInput(variablesJson: string): CaptureReplayInput;
+/** 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. */
+export declare function captureInputFor(input: Record<string, unknown>, messages: readonly HistoryMessage[] | undefined, tools?: CapturedTools): unknown;
+/**
+ * The routed lane's history for one run (rig.run / runStream / runBundle), or
+ * `undefined` for a variables route — BYTE-IDENTICAL then. Throws pre-dispatch
+ * (nothing billed, no telemetry — a config error, like every RouteConfigError):
+ * `messages` on a route that does not declare `input: messages`; a messages
+ * route called without `messages`; a messages route that also declares
+ * mask/screen (mirror bundles skip the loader, so the pairing is re-checked);
+ * an invalid history.
+ */
+export interface RoutedHistory<R> {
+    readonly history: readonly HistoryMessage[] | undefined;
+    /** The route the ladder runs on: the SAME object unless candidates were
+     * skipped for this history (ruling R2-2). */
+    readonly route: R;
+    /** Telemetry tag for the skipped candidates (`provider/model=code,…`), or {}. */
+    readonly skipTag: Record<string, string>;
+}
+export declare function routedHistory<R extends Pick<RouteBundle, "route" | "inputKind" | "mask" | "screen" | "repair" | "variants" | "candidates">>(route: R, opts: Pick<RunOptions, "messages" | "tools">): RoutedHistory<R>;
+/** The `history_skipped` tag key (the precedent is `zdr_enforced`). */
+export declare const HISTORY_SKIPPED_TAG = "history_skipped";
+/** Merge the skip tag onto the run's tags; the SAME object when there is none. */
+export declare function withSkipTag<T extends RunOptions["tags"]>(tags: T, skipTag: Record<string, string>): T;
+/** 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). */
+export declare function messagesUserTurn(route: Pick<RouteBundle, "userTemplate">, ctx: {
+    readonly variables: Record<string, unknown>;
+    readonly capabilities: ReadonlySet<CapabilityFlag>;
+    readonly variableTrust?: Readonly<Record<string, "untrusted">>;
+}): string;
+/** 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. */
+export declare const HISTORY_INCOMPATIBLE_PREFIX = "history not accepted natively";
+/**
+ * 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.
+ */
+export declare function historyIncompatibility(provider: string, model: string, history: readonly HistoryMessage[] | undefined, declaredTools: readonly unknown[] | undefined): string | null;
+/** Short reason code (telemetry tag value) + the teaching message. */
+export interface HistoryIncompatibility {
+    readonly code: "tools_required" | "thought_signatures";
+    readonly message: string;
+}
+/** 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. */
+export declare function isGemini3Model(model: string): boolean;
+export declare function historyIncompatibilityCode(provider: string, model: string, history: readonly HistoryMessage[] | undefined, declaredTools: readonly unknown[] | undefined): HistoryIncompatibility | 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). */
+export declare function rawHistory(input: {
+    readonly provider: string;
+    readonly model: string;
+    readonly userPrompt?: string;
+    readonly messages?: unknown;
+    readonly tools?: readonly unknown[];
+}): readonly HistoryMessage[] | undefined;
+/** 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). */
+export declare function userSideForHash(userPrompt: string, history: readonly HistoryMessage[] | undefined): string;
+//# sourceMappingURL=messages.d.ts.map

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

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