@mupt-ai/dari-gateway 0.2.0 → 0.2.1

package/dist/strategies/routing.js

@@ -0,0 +1,280 @@
+import { CHARS_PER_TOKEN, RouterCoreError, buildSizedSelectorRequest, isRecord, parseSelectorDecision, sameRoutingCandidate, selectorSafeMessages, } from "@mupt-ai/dari-router/policy-engine";
+import { HttpError } from "../http/errors.js";
+import { executionProviderForModel } from "../models/execution_provider.js";
+import { providerLabel } from "../models/provider_defaults.js";
+import { internalChatCompletionsToInteraction } from "../protocol/input/chat_completions.js";
+import { gatewayPlatform } from "../platform/platform.js";
+import { isBedrockApi } from "../providers/model_capabilities.js";
+import { completeInteractionModel, modelContextWindow } from "../providers/pi.js";
+import { deriveFallbackDecision } from "./fallback_decision.js";
+export function resolveRouter(args) {
+    return gatewayPlatform().resolveRouter(args);
+}
+export function createLlmSelectorBackend(config) {
+    const model = requiredSelectorConfig(config.model, "LLM selector model");
+    const apiKey = requiredSelectorConfig(config.apiKey, "LLM selector API key");
+    return {
+        selectorModel: model,
+        contextWindowChars: () => selectorContextWindowChars(model),
+        select: (args) => callLlmSelector(args, apiKey, config.reasoningEffort),
+    };
+}
+export const SELECTOR_OUTPUT_ATTEMPTS = 2;
+// Exported so other selector backends can attach the raw policy completion
+// to failures the same way the LLM selector does. Without this wrapping,
+// selectorTraceFromError() returns null for their failures and the malformed
+// completion is never reported.
+export class SelectorOutputError extends HttpError {
+    selectorTrace;
+    constructor(error, selectorTrace) {
+        super(error.status, error.message, error.code, error.param);
+        this.selectorTrace = selectorTrace;
+    }
+}
+export function selectorTraceFromError(error) {
+    return error instanceof SelectorOutputError ? error.selectorTrace : null;
+}
+export async function selectModel(args) {
+    const { selectorBackend } = args;
+    const selectorModel = selectorBackend.selectorModel;
+    const startedAt = Date.now();
+    const contextWindowChars = await selectorBackend.contextWindowChars();
+    const safeMessages = selectorSafeMessages(args.messages);
+    const leaseContextEnabled = args.leaseContextEnabled !== false;
+    const { selectorInput, selectorRequest } = buildSizedSelectorRequest({
+        candidates: args.candidates,
+        evals: args.evals,
+        previousDecision: args.previousDecision,
+        costEstimates: args.costEstimates,
+        customRules: args.customRules,
+        defaultTarget: args.defaultTarget,
+        selectorModel,
+        contextWindowChars,
+        messages: selectorBackend.prepareMessages?.(safeMessages) ?? safeMessages,
+        ...(leaseContextEnabled ? { leaseHistory: args.leaseHistory ?? [] } : {}),
+        modelFallbackEnabled: args.modelFallbackEnabled,
+        fallbackRequiresDifferentProvider: args.fallbackRequiresDifferentProvider,
+        imputeEvalScores: args.imputeEvalScores,
+        imputationReferenceEvals: args.imputationReferenceEvals,
+    });
+    const runArgs = {
+        ...args,
+        selectorModel,
+        selectorInput,
+        selectorRequest,
+        startedAt,
+    };
+    const run = await selectorBackend.select(runArgs);
+    return validateSelectorRun(run, args);
+}
+async function selectorContextWindowChars(selectorModel) {
+    const contextWindow = modelContextWindow(selectorModel);
+    if (contextWindow === null) {
+        throw new HttpError(500, `No context window is configured for selector model ${selectorModel}.`, "configuration_error");
+    }
+    return contextWindow * CHARS_PER_TOKEN;
+}
+async function callLlmSelector(args, selectorApiKey, reasoningEffort) {
+    const rejectedOutputTexts = [];
+    const usages = [];
+    for (let attempt = 1; attempt <= SELECTOR_OUTPUT_ATTEMPTS; attempt += 1) {
+        let message;
+        try {
+            const completion = await completeInteractionModel({
+                model: args.selectorModel,
+                request: internalChatCompletionsToInteraction(args.selectorRequest),
+                apiKey: selectorApiKey,
+                sessionId: args.sessionId,
+                ...(reasoningEffort ? { selectedReasoningEffort: reasoningEffort } : {}),
+            });
+            message = completion.message;
+        }
+        catch {
+            throw selectorExecutionError(args, rejectedOutputTexts, usages);
+        }
+        if (message.stopReason === "error" || message.stopReason === "aborted") {
+            throw selectorExecutionError(args, rejectedOutputTexts, usages);
+        }
+        const text = assistantText(message);
+        usages.push(isRecord(message.usage) ? message.usage : null);
+        try {
+            // The managed LLM selector never negotiates leases, so drop any
+            // lease_turns_remaining a non-strict provider stamps on the output.
+            const { leaseTurnsRemaining: _leaseTurnsRemaining, ...decision } = parseSelectorDecision(text).decision;
+            return {
+                decision,
+                selectorModel: args.selectorModel,
+                candidates: args.candidates,
+                selectorInput: args.selectorInput,
+                selectorRequest: args.selectorRequest,
+                outputText: text,
+                ...(rejectedOutputTexts.length > 0
+                    ? { rejectedOutputTexts: [...rejectedOutputTexts] }
+                    : {}),
+                usage: aggregateSelectorUsage(usages),
+                latencyMs: Date.now() - args.startedAt,
+            };
+        }
+        catch (error) {
+            const mapped = selectorOutputHttpError(error);
+            if (!mapped || !isMalformedSelectorOutput(mapped))
+                throw error;
+            if (attempt < SELECTOR_OUTPUT_ATTEMPTS) {
+                rejectedOutputTexts.push(text);
+                continue;
+            }
+            throw new SelectorOutputError(mapped, {
+                selectorModel: args.selectorModel,
+                candidates: args.candidates,
+                selectorInput: args.selectorInput,
+                selectorRequest: args.selectorRequest,
+                outputText: text,
+                ...(rejectedOutputTexts.length > 0
+                    ? { rejectedOutputTexts: [...rejectedOutputTexts] }
+                    : {}),
+                usage: aggregateSelectorUsage(usages),
+                latencyMs: Date.now() - args.startedAt,
+            });
+        }
+    }
+    throw new HttpError(502, "Selector request failed.", "selector_execution_failed");
+}
+function validateSelectorRun(run, args) {
+    const selected = {
+        model: run.decision.selectedModel,
+        reasoningEffort: run.decision.reasoningEffort,
+    };
+    if (!args.candidates.some((candidate) => sameRoutingCandidate(candidate, selected))) {
+        throw new SelectorOutputError(new HttpError(502, "Selector returned a model/thinking-level pair outside this router's candidates.", "selector_invalid_candidate"), run);
+    }
+    const { fallbackDecision: _selectorFallback, ...primaryRun } = run;
+    const fallbackDecision = deriveFallbackDecision({
+        candidates: args.candidates,
+        selected,
+        enabled: args.modelFallbackEnabled,
+        requiresDifferentProvider: args.fallbackRequiresDifferentProvider,
+        providerForModel: args.executionProviderForModel,
+    });
+    return fallbackDecision
+        ? { ...primaryRun, fallbackDecision }
+        : primaryRun;
+}
+function requiredSelectorConfig(value, label) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new HttpError(500, `${label} is not configured.`, "configuration_error");
+    }
+    return normalized;
+}
+export function providerAuthForSelectedModel(args) {
+    const provider = executionProviderForModel(args.credentials, args.selectedModel);
+    const config = args.credentials.model_configs?.[args.selectedModel];
+    const structured = args.credentials.provider_auth?.[provider];
+    const key = args.credentials.provider_keys[provider]?.trim();
+    if (structured !== undefined) {
+        if (key
+            || (provider !== "amazon-bedrock" && !isBedrockApi(config?.api))
+            || !(isAwsSigV4ProviderAuth(structured) || isAwsAssumeRoleProviderAuth(structured))) {
+            throw new HttpError(500, `Invalid ${providerLabel(provider)} provider authentication is configured for this router.`, "provider_configuration_error");
+        }
+        return structured;
+    }
+    if (key)
+        return { type: "bearer", apiKey: key };
+    const source = args.credentials.provider_key_sources?.[provider] ?? "user";
+    const prefix = source === "managed" ? "Dari-managed" : "stored";
+    throw new HttpError(401, `No ${prefix} ${providerLabel(provider)} provider credential is configured for this router.`, "missing_provider_key");
+}
+function isAwsAssumeRoleProviderAuth(value) {
+    return (isRecord(value)
+        && value.type === "aws_assume_role"
+        && typeof value.role_arn === "string"
+        && Boolean(value.role_arn.trim())
+        && typeof value.external_id === "string"
+        && Boolean(value.external_id.trim())
+        && typeof value.region === "string"
+        && Boolean(value.region.trim()));
+}
+function isAwsSigV4ProviderAuth(value) {
+    return (isRecord(value)
+        && value.type === "aws_sigv4"
+        && typeof value.access_key_id === "string"
+        && Boolean(value.access_key_id.trim())
+        && typeof value.secret_access_key === "string"
+        && Boolean(value.secret_access_key.trim())
+        && typeof value.region === "string"
+        && Boolean(value.region.trim())
+        && (value.session_token == null
+            || (typeof value.session_token === "string"
+                && Boolean(value.session_token.trim()))));
+}
+function assistantText(message) {
+    const content = message.content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter(isRecord)
+        .filter((item) => item.type === "text" && typeof item.text === "string")
+        .map((item) => String(item.text))
+        .join("");
+}
+function selectorOutputHttpError(error) {
+    if (error instanceof HttpError)
+        return error;
+    if (!(error instanceof RouterCoreError) || error.kind !== "selector_output")
+        return null;
+    return new HttpError(502, error.message, error.code, error.param);
+}
+function isMalformedSelectorOutput(error) {
+    return error.code === "selector_invalid_json" || error.code === "selector_invalid_response";
+}
+function selectorExecutionError(args, rejectedOutputTexts, usages) {
+    const error = new HttpError(502, "Selector request failed.", "selector_execution_failed");
+    const lastOutput = rejectedOutputTexts.at(-1);
+    if (lastOutput === undefined)
+        return error;
+    return new SelectorOutputError(error, {
+        selectorModel: args.selectorModel,
+        candidates: args.candidates,
+        selectorInput: args.selectorInput,
+        selectorRequest: args.selectorRequest,
+        outputText: lastOutput,
+        ...(rejectedOutputTexts.length > 1
+            ? { rejectedOutputTexts: rejectedOutputTexts.slice(0, -1) }
+            : {}),
+        usage: aggregateSelectorUsage(usages),
+        latencyMs: Date.now() - args.startedAt,
+    });
+}
+function aggregateSelectorUsage(usages) {
+    const records = usages.filter((usage) => usage !== null);
+    if (records.length === 0)
+        return null;
+    if (records.length === 1)
+        return records[0];
+    const aggregate = { ...records.at(-1) };
+    for (const key of ["input", "cacheRead", "cacheWrite", "output", "totalTokens"]) {
+        const total = sumFiniteField(records, key);
+        if (total !== null)
+            aggregate[key] = total;
+    }
+    const costs = records.flatMap((usage) => isRecord(usage.cost) ? [usage.cost] : []);
+    if (costs.length > 0) {
+        const aggregateCost = {
+            ...(isRecord(aggregate.cost) ? aggregate.cost : {}),
+        };
+        for (const key of ["input", "cacheRead", "cacheWrite", "output", "total"]) {
+            const total = sumFiniteField(costs, key);
+            if (total !== null)
+                aggregateCost[key] = total;
+        }
+        aggregate.cost = aggregateCost;
+    }
+    return aggregate;
+}
+function sumFiniteField(records, key) {
+    const values = records.flatMap((record) => typeof record[key] === "number" && Number.isFinite(record[key])
+        ? [record[key]]
+        : []);
+    return values.length > 0 ? values.reduce((sum, value) => sum + value, 0) : null;
+}

package/dist/strategies/selector_projection.d.ts

@@ -0,0 +1,15 @@
+import type { ChatMessage } from "@mupt-ai/dari-router/policy-engine";
+import type { InteractionRequest } from "../interaction/types.js";
+export declare const IMAGE_OMITTED = "<image omitted>";
+export declare const SELECTOR_IMAGE_PLACEHOLDERS: RegExp;
+export type SelectorImage = {
+    index: number;
+    url: string;
+};
+export type SelectorProjection = {
+    messages: ChatMessage[];
+    images: SelectorImage[];
+};
+export declare function selectorMessagesForInteraction(interaction: InteractionRequest, options?: {
+    imageInput?: boolean;
+}): SelectorProjection;

package/dist/strategies/selector_projection.js

@@ -0,0 +1,161 @@
+import { toolWireName } from "../interaction/tool_identity.js";
+export const IMAGE_OMITTED = "<image omitted>";
+// Matches every numbered placeholder in a rendered selector prompt.
+export const SELECTOR_IMAGE_PLACEHOLDERS = /<image (\d+)>/g;
+const OPAQUE_REASONING_OMITTED = "<opaque reasoning omitted>";
+// The selector needs readable task history, not provider replay state. This
+// projection intentionally keeps text and tool exchanges while omitting
+// opaque continuation payloads, source item ids, phases, and image bytes.
+// With `imageInput`, image parts become numbered `<image N>` placeholders and
+// the data URLs are returned separately so the policy adapter can attach them
+// as ordered image parts. Without it the projection stays byte-identical to
+// the pre-image-input shape, which the deployed policy was trained on.
+export function selectorMessagesForInteraction(interaction, options = {}) {
+    const messages = [];
+    const images = [];
+    const imagePart = (url, detail) => {
+        let placeholder = IMAGE_OMITTED;
+        if (options.imageInput === true) {
+            images.push({ index: images.length + 1, url });
+            placeholder = `<image ${images.length}>`;
+        }
+        return {
+            type: "image_url",
+            image_url: {
+                url: placeholder,
+                ...(detail !== undefined ? { detail } : {}),
+            },
+        };
+    };
+    // Hosted calls are complete provider output groups. Harness calls can be
+    // persisted before reasoning that belongs to the same assistant turn.
+    const hostedToolCarriers = new WeakSet();
+    if (interaction.instructions) {
+        messages.push({ role: "system", content: interaction.instructions });
+    }
+    for (const item of interaction.items) {
+        if (item.type === "reasoning") {
+            const readable = [...item.summary, ...item.content].join("\n");
+            let assistant = messages.at(-1);
+            if (!assistant
+                || assistant.role !== "assistant"
+                || hasAssistantContent(assistant)
+                || hostedToolCarriers.has(assistant)) {
+                assistant = { role: "assistant", content: null };
+                messages.push(assistant);
+            }
+            const selectorReasoning = readable || OPAQUE_REASONING_OMITTED;
+            assistant.reasoning_content = assistant.reasoning_content
+                ? `${assistant.reasoning_content}\n${selectorReasoning}`
+                : selectorReasoning;
+            continue;
+        }
+        if (item.type === "reasoning_configuration") {
+            continue;
+        }
+        if (item.type === "tool_result") {
+            messages.push({
+                role: "tool",
+                tool_call_id: item.callId,
+                ...selectorContentField(item.output, item.outputShape, imagePart),
+            });
+            continue;
+        }
+        if (item.type === "tool_call") {
+            appendToolCall(messages, item);
+            continue;
+        }
+        if (item.type === "hosted_tool_call") {
+            const assistant = appendToolCall(messages, {
+                type: "tool_call",
+                id: item.id,
+                callId: item.id,
+                kind: "function",
+                name: item.tool,
+                input: item.payload,
+            });
+            hostedToolCarriers.add(assistant);
+            continue;
+        }
+        const content = selectorContentField(item.content, item.contentShape, imagePart);
+        const previous = messages.at(-1);
+        if (item.role === "assistant"
+            && previous?.role === "assistant"
+            && isReasoningOnly(previous)) {
+            if ("content" in content)
+                previous.content = content.content;
+            else
+                delete previous.content;
+            continue;
+        }
+        messages.push({ role: item.role, ...content });
+    }
+    return { messages, images };
+}
+function appendToolCall(messages, item) {
+    let assistant = messages.at(-1);
+    if (!assistant || assistant.role !== "assistant") {
+        assistant = { role: "assistant", content: null };
+        messages.push(assistant);
+    }
+    assistant.tool_calls = [
+        ...(assistant.tool_calls ?? []),
+        {
+            id: item.callId,
+            type: "function",
+            function: {
+                name: toolWireName(item.namespace, item.name),
+                ...(item.input !== undefined
+                    ? {
+                        arguments: item.kind === "custom"
+                            ? JSON.stringify({ input: String(item.input) })
+                            : item.input,
+                    }
+                    : {}),
+            },
+        },
+    ];
+    return assistant;
+}
+function selectorContentField(content, shape, imagePart) {
+    if (shape === "absent")
+        return {};
+    if (shape === "null")
+        return { content: null };
+    if (shape === "string") {
+        const text = Array.isArray(content)
+            ? content
+                .filter((part) => part.type === "text")
+                .map((part) => part.text)
+                .join("")
+            : content;
+        return { content: text ?? "" };
+    }
+    if (!Array.isArray(content)) {
+        return {
+            content: content === null
+                ? []
+                : [{ type: "text", text: content }],
+        };
+    }
+    return {
+        content: content.map((part) => {
+            if (part.type === "text")
+                return { type: "text", text: part.text };
+            if (part.type === "tool_reference") {
+                return { type: "text", text: `Referenced tool: ${part.toolName}` };
+            }
+            return imagePart(part.url, part.detail);
+        }),
+    };
+}
+function hasAssistantContent(message) {
+    if (typeof message.content === "string")
+        return message.content.length > 0;
+    return Array.isArray(message.content) && message.content.length > 0;
+}
+function isReasoningOnly(message) {
+    return !message.tool_calls?.length
+        && !hasAssistantContent(message)
+        && message.reasoning_content !== undefined;
+}

package/dist/telemetry/background.d.ts

@@ -0,0 +1,7 @@
+export declare function trackBackgroundTelemetry(task: Promise<unknown>): void;
+export declare function drainBackgroundTelemetry(): Promise<void>;
+/**
+ * Drain until every tracked task settles or the timeout passes. Tasks tracked
+ * while draining are included. Returns how many tasks were still pending.
+ */
+export declare function drainBackgroundTelemetryFor(timeoutMs: number): Promise<number>;

package/dist/telemetry/background.js

@@ -0,0 +1,33 @@
+const pendingTelemetry = new Set();
+export function trackBackgroundTelemetry(task) {
+    pendingTelemetry.add(task);
+    void task.then(() => pendingTelemetry.delete(task), () => pendingTelemetry.delete(task));
+}
+export async function drainBackgroundTelemetry() {
+    while (pendingTelemetry.size > 0) {
+        await Promise.allSettled([...pendingTelemetry]);
+    }
+}
+/**
+ * Drain until every tracked task settles or the timeout passes. Tasks tracked
+ * while draining are included. Returns how many tasks were still pending.
+ */
+export async function drainBackgroundTelemetryFor(timeoutMs) {
+    let expired = false;
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            expired = true;
+            resolve();
+        }, Math.max(0, timeoutMs));
+    });
+    try {
+        while (pendingTelemetry.size > 0 && !expired) {
+            await Promise.race([Promise.allSettled([...pendingTelemetry]), deadline]);
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    return pendingTelemetry.size;
+}

package/dist/telemetry/benchmark_replay.d.ts

@@ -0,0 +1,37 @@
+import { type PrefixHit, type RouterModelPrice } from "@mupt-ai/dari-router/policy-engine";
+export declare const BENCHMARK_REPLAY_ESTIMATOR_VERSION = "sticky-cache-v2";
+export type BenchmarkReplayPriceSnapshot = {
+    input: number;
+    output: number;
+    cached_input: number | null;
+    cache_write: number | null;
+};
+export type BenchmarkReplayEstimate = {
+    costUsd: number | null;
+    rawCostUsd: number | null;
+    model: string | null;
+    price: BenchmarkReplayPriceSnapshot | null;
+    estimatorVersion: typeof BENCHMARK_REPLAY_ESTIMATOR_VERSION;
+    depth: number;
+};
+/**
+ * Price one turn as if the router had stayed on its most expensive enabled
+ * model for the whole conversation.
+ *
+ * The prior depth comes from synchronized prefix state, so this runs once
+ * while the request is being reported instead of replaying conversation rows
+ * during every Activity read.
+ */
+export declare function estimateBenchmarkReplay(args: {
+    enabledModels: readonly string[];
+    modelPrices: Readonly<Record<string, RouterModelPrice>>;
+    /** Serving provider per canonical model; owner-namespace ids (deepseek-ai/…)
+     * cannot self-identify their provider, so the resolved router supplies it. */
+    executionProvider: (model: string) => string;
+    priorHit?: PrefixHit;
+    receivedAtMs: number;
+    promptTokens: number;
+    outputTokens: number;
+    selectedModel?: string;
+    selectedCostUsd?: number;
+}): BenchmarkReplayEstimate;

package/dist/telemetry/benchmark_replay.js

@@ -0,0 +1,108 @@
+import { PREFIX_WARMTH_WINDOW_MS, providerMinCacheTokens, } from "@mupt-ai/dari-router/policy-engine";
+const TOKENS_PER_MTOK = 1_000_000;
+export const BENCHMARK_REPLAY_ESTIMATOR_VERSION = "sticky-cache-v2";
+/**
+ * Price one turn as if the router had stayed on its most expensive enabled
+ * model for the whole conversation.
+ *
+ * The prior depth comes from synchronized prefix state, so this runs once
+ * while the request is being reported instead of replaying conversation rows
+ * during every Activity read.
+ */
+export function estimateBenchmarkReplay(args) {
+    const promptTokens = nonnegativeInteger(args.promptTokens);
+    const outputTokens = nonnegativeInteger(args.outputTokens);
+    const priorDepth = priorBenchmarkDepth(args.priorHit);
+    const depth = Math.max(priorDepth, promptTokens);
+    const effectivePrices = Object.fromEntries(Object.entries(args.modelPrices).map(([model, base]) => {
+        const tier = base.tiers?.filter((entry) => promptTokens > entry.input_tokens_above)
+            .sort((left, right) => right.input_tokens_above - left.input_tokens_above)[0];
+        return [model, tier ?? base];
+    }));
+    const benchmark = benchmarkPrice(args.enabledModels, effectivePrices);
+    if (benchmark === null) {
+        return {
+            costUsd: null,
+            rawCostUsd: null,
+            model: null,
+            price: null,
+            estimatorVersion: BENCHMARK_REPLAY_ESTIMATOR_VERSION,
+            depth,
+        };
+    }
+    const { model, price } = benchmark;
+    const updatedAtMs = args.priorHit
+        ? Date.parse(args.priorHit.entry.updated_at)
+        : Number.NaN;
+    const isWarm = Number.isFinite(updatedAtMs) &&
+        updatedAtMs >= args.receivedAtMs - PREFIX_WARMTH_WINDOW_MS;
+    const warmTokens = isWarm ? Math.min(priorDepth, promptTokens) : 0;
+    const freshTokens = promptTokens - warmTokens;
+    const cachedRate = validOptionalRate(price.cached_input) ?? price.input;
+    const cacheWriteRate = validOptionalRate(price.cache_write);
+    const freshRate = cacheWriteRate !== null &&
+        cacheWriteRate > 0 &&
+        promptTokens >= providerMinCacheTokens(model, args.executionProvider(model))
+        ? cacheWriteRate
+        : price.input;
+    const replayedCost = (warmTokens * cachedRate +
+        freshTokens * freshRate +
+        outputTokens * price.output) /
+        TOKENS_PER_MTOK;
+    const selectedCost = validOptionalRate(args.selectedCostUsd);
+    return {
+        costUsd: args.selectedModel === model && selectedCost !== null
+            ? Math.min(replayedCost, selectedCost)
+            : replayedCost,
+        rawCostUsd: replayedCost,
+        model,
+        price: {
+            input: price.input,
+            output: price.output,
+            cached_input: validOptionalRate(price.cached_input),
+            cache_write: validOptionalRate(price.cache_write),
+        },
+        estimatorVersion: BENCHMARK_REPLAY_ESTIMATOR_VERSION,
+        depth,
+    };
+}
+function benchmarkPrice(enabledModels, modelPrices) {
+    let benchmark = null;
+    for (const model of enabledModels) {
+        const price = modelPrices[model];
+        if (!validPrice(price))
+            continue;
+        if (benchmark === null ||
+            price.output > benchmark.price.output ||
+            (price.output === benchmark.price.output && price.input > benchmark.price.input) ||
+            (price.output === benchmark.price.output &&
+                price.input === benchmark.price.input &&
+                model > benchmark.model)) {
+            benchmark = { model, price };
+        }
+    }
+    return benchmark;
+}
+function priorBenchmarkDepth(hit) {
+    if (!hit)
+        return 0;
+    const stored = hit.entry.benchmark_replay_depth;
+    if (typeof stored === "number" && Number.isFinite(stored) && stored >= 0) {
+        return Math.trunc(stored);
+    }
+    // Prefix entries written before benchmark depth existed still provide a
+    // safe bootstrap point. The next entry carries the running maximum.
+    return nonnegativeInteger(hit.entry.prompt_tokens);
+}
+function validPrice(price) {
+    return price !== undefined && validRate(price.input) && validRate(price.output);
+}
+function validRate(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function validOptionalRate(value) {
+    return validRate(value) ? value : null;
+}
+function nonnegativeInteger(value) {
+    return Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}