@mupt-ai/dari-gateway 0.2.0 → 0.2.1

package/dist/context/interaction_fingerprint_format.js

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import { stableStringify } from "@mupt-ai/dari-router/policy-engine";
+// Bump when canonical fingerprint semantics change so persisted hashes from
+// incompatible contracts remain disjoint.
+const INTERACTION_FINGERPRINT_VERSION = "interaction-v3";
+const OPTION_FINGERPRINT_VERSION = "interaction-options-v1";
+export function interactionFingerprintHeadHash(routerId, request) {
+    const systemItems = [];
+    for (const item of request.items) {
+        if (item.type !== "message"
+            || (item.role !== "system" && item.role !== "developer")) {
+            break;
+        }
+        systemItems.push({
+            actor: item.role,
+            content: systemFingerprintContent(item.content, item.contentShape),
+        });
+    }
+    return sha256(stableStringify({
+        version: INTERACTION_FINGERPRINT_VERSION,
+        routerId,
+        ...(request.agentContext === undefined ? {} : { agentContext: {
+                requestClass: request.agentContext.requestClass,
+                agentId: request.agentContext.agentId ?? null,
+            } }),
+        instructions: request.instructions ?? null,
+        systemItems,
+        tools: request.tools,
+    }));
+}
+function systemFingerprintContent(content, shape) {
+    const normalized = interactionFingerprintContent(content, shape);
+    // Anthropic defines a string system value and one plain text block as
+    // equivalent. Preserve that established head identity without flattening
+    // structured system content such as images or multiple blocks.
+    if (Array.isArray(normalized)
+        && normalized.length === 1
+        && normalized[0]?.type === "text") {
+        return normalized[0].text;
+    }
+    return normalized;
+}
+export function interactionOptionsFingerprints(request) {
+    return {
+        tool_choice_fp: optionFingerprint("tool-choice", request.toolChoice ?? null),
+        response_format_fp: optionFingerprint("response-format", request.responseFormat ?? null),
+    };
+}
+export function canonicalInteractionFingerprintStep(step) {
+    return stableStringify({
+        actor: step.actor,
+        content: step.content,
+        calls: step.calls.length > 0 ? step.calls : null,
+        resultCallId: step.resultCallId,
+        ...(step.itemId ? { itemId: step.itemId } : {}),
+        ...(step.phase ? { phase: step.phase } : {}),
+        ...(step.reasoning ? { reasoning: step.reasoning } : {}),
+    });
+}
+export function interactionFingerprintContent(content, shape) {
+    // Preserve the established identity rule that absent and explicit null
+    // content are equivalent. Structured parts remain distinct from strings.
+    if (shape === "absent" || shape === "null")
+        return null;
+    if (shape === "string") {
+        if (typeof content === "string")
+            return content;
+        if (!Array.isArray(content))
+            return "";
+        return content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("");
+    }
+    if (!Array.isArray(content))
+        return [];
+    return content.map((part) => {
+        if (part.type === "text")
+            return { type: "text", text: part.text };
+        if (part.type === "tool_reference") {
+            return {
+                type: "tool_reference",
+                toolName: part.toolName,
+            };
+        }
+        return {
+            type: "image",
+            url: part.url,
+            ...(part.detail !== undefined ? { detail: part.detail } : {}),
+        };
+    });
+}
+export function normalizedAssistantFingerprintContent(content, shape) {
+    const normalized = interactionFingerprintContent(content, shape);
+    return typeof normalized === "string" && normalized.trim() === ""
+        ? null
+        : normalized;
+}
+export function appendFingerprintContentText(content, text) {
+    if (!text)
+        return content;
+    if (typeof content === "string")
+        return content ? `${content}\n${text}` : text;
+    if (Array.isArray(content))
+        return [...content, { type: "text", text }];
+    return text;
+}
+function optionFingerprint(kind, value) {
+    return sha256(`${OPTION_FINGERPRINT_VERSION}\u0000${kind}\u0000${stableStringify(value)}`);
+}
+function sha256(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}

package/dist/context/interaction_lease_depth.d.ts

@@ -0,0 +1,2 @@
+import type { InteractionRequest } from "../interaction/types.js";
+export declare function interactionLeaseFenceDepth(request: InteractionRequest): number;

package/dist/context/interaction_lease_depth.js

@@ -0,0 +1,110 @@
+// Monotonic, target-independent position used only to fence asynchronous
+// lease writes. It follows canonical Interaction grouping and deliberately
+// does not serialize selector messages or approximate provider cache blocks.
+export function interactionLeaseFenceDepth(request) {
+    const state = {
+        depth: 0,
+        last: null,
+    };
+    const startAssistant = (args) => {
+        const assistant = {
+            kind: "assistant",
+            rawBlocks: args.rawBlocks,
+            hasContent: args.hasContent ?? false,
+            hasReasoning: args.hasReasoning ?? false,
+            hasToolCalls: args.hasToolCalls ?? false,
+            hostedToolCarrier: args.hostedToolCarrier ?? false,
+        };
+        state.depth += groupBlockCount(assistant.rawBlocks);
+        state.last = assistant;
+        return assistant;
+    };
+    const addAssistantBlock = (assistant) => {
+        const before = groupBlockCount(assistant.rawBlocks);
+        assistant.rawBlocks += 1;
+        state.depth += groupBlockCount(assistant.rawBlocks) - before;
+    };
+    const addOther = (blocks) => {
+        state.depth += groupBlockCount(blocks);
+        state.last = { kind: "other" };
+    };
+    for (const item of request.items) {
+        if (item.type === "reasoning") {
+            if (state.last?.kind === "assistant"
+                && !state.last.hasContent
+                && !state.last.hostedToolCarrier) {
+                state.last.hasReasoning = true;
+            }
+            else {
+                startAssistant({ rawBlocks: 0, hasReasoning: true });
+            }
+            continue;
+        }
+        if (item.type === "reasoning_configuration") {
+            continue;
+        }
+        if (item.type === "tool_result") {
+            addOther(1);
+            continue;
+        }
+        if (item.type === "tool_call" || item.type === "hosted_tool_call") {
+            const assistant = state.last?.kind === "assistant"
+                ? state.last
+                : startAssistant({ rawBlocks: 0 });
+            addAssistantBlock(assistant);
+            assistant.hasToolCalls = true;
+            if (item.type === "hosted_tool_call") {
+                assistant.hostedToolCarrier = true;
+            }
+            continue;
+        }
+        if (item.role === "system" || item.role === "developer") {
+            state.last = { kind: "other" };
+            continue;
+        }
+        const blocks = messageContentBlocks(item);
+        const hasContent = blocks > 0;
+        if (item.role === "assistant"
+            && state.last?.kind === "assistant"
+            && state.last.hasReasoning
+            && !state.last.hasContent
+            && !state.last.hasToolCalls) {
+            const before = groupBlockCount(state.last.rawBlocks);
+            state.last.rawBlocks = blocks;
+            state.last.hasContent = hasContent;
+            state.depth += groupBlockCount(state.last.rawBlocks) - before;
+            continue;
+        }
+        if (item.role === "assistant") {
+            startAssistant({ rawBlocks: blocks, hasContent });
+        }
+        else {
+            addOther(blocks);
+        }
+    }
+    return state.depth;
+}
+function messageContentBlocks(message) {
+    if (message.contentShape === "absent" || message.contentShape === "null") {
+        return 0;
+    }
+    if (message.contentShape === "string") {
+        return stringContent(message.content).length > 0 ? 1 : 0;
+    }
+    if (Array.isArray(message.content))
+        return message.content.length;
+    return message.content === null ? 0 : 1;
+}
+function stringContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+}
+function groupBlockCount(rawBlocks) {
+    return Math.max(1, rawBlocks);
+}

package/dist/context/lease_history.d.ts

@@ -0,0 +1,7 @@
+import { type ChatMessage, type RouterPrefixHit, type RoutingCandidate, type SelectorLeaseHistoryEntry } from "@mupt-ai/dari-router/policy-engine";
+export declare function leaseHistoryFromPrefixHits(args: {
+    prefixHits: readonly RouterPrefixHit[];
+    conversationId: string;
+    candidates: readonly RoutingCandidate[];
+    messages: readonly ChatMessage[];
+}): SelectorLeaseHistoryEntry[];

package/dist/context/lease_history.js

@@ -0,0 +1,158 @@
+import { isReasoningEffort, isRecord, routingCandidateKey, } from "@mupt-ai/dari-router/policy-engine";
+const MAX_HISTORY_LEASES = 3;
+const MAX_OBSERVATION_CHARS = 3_000;
+const TEST_COMMAND = /(?:^|\s)(?:bun|npm|pnpm|yarn|uv|pytest|cargo|go|make|npx|bash)\b[^\n]*(?:test|check|lint|typecheck|vet|build)/i;
+export function leaseHistoryFromPrefixHits(args) {
+    const candidateKeys = new Set(args.candidates.map(routingCandidateKey));
+    const hits = deduplicatedHits(args.prefixHits)
+        .filter((hit) => hit.conversation_id === args.conversationId)
+        .sort((left, right) => left.message_depth - right.message_depth);
+    const segments = [];
+    for (const hit of hits) {
+        const remaining = hit.lease_turns_remaining;
+        const effort = hit.next_reasoning_effort;
+        if (typeof remaining !== "number" ||
+            !Number.isInteger(remaining) ||
+            remaining < 0 ||
+            !hit.next_model ||
+            !isReasoningEffort(effort)) {
+            continue;
+        }
+        const candidate = { model: hit.next_model, reasoningEffort: effort };
+        if (!candidateKeys.has(routingCandidateKey(candidate)))
+            continue;
+        const current = segments.at(-1);
+        if (current !== undefined &&
+            routingCandidateKey(current.candidate) === routingCandidateKey(candidate) &&
+            remaining < current.lastRemaining) {
+            current.lastRemaining = remaining;
+            continue;
+        }
+        segments.push({
+            candidate,
+            requestedTurns: remaining + 1,
+            lastRemaining: remaining,
+            rationale: hit.reason ?? "",
+        });
+    }
+    const recent = segments.slice(-MAX_HISTORY_LEASES);
+    const turns = conversationTurns(args.messages);
+    let turnCursor = turns.length;
+    const history = [...recent].reverse().map((segment) => {
+        const completedTurns = Math.max(0, Math.min(segment.requestedTurns, segment.requestedTurns - segment.lastRemaining));
+        const start = Math.max(0, turnCursor - completedTurns);
+        const observation = turns.slice(start, turnCursor);
+        turnCursor = start;
+        return observationForSegment(segment, completedTurns, observation);
+    });
+    return history.reverse();
+}
+function observationForSegment(segment, completedTurns, turns) {
+    const calls = turns.flatMap((turn) => turn.assistant.tool_calls ?? []);
+    const results = turns.flatMap((turn) => turn.toolResults);
+    const lastCall = calls.at(-1);
+    const callId = typeof lastCall?.["id"] === "string" ? lastCall["id"] : null;
+    const lastResult = callId === null
+        ? undefined
+        : [...results].reverse().find((result) => result.tool_call_id === callId);
+    const testCall = [...calls].reverse().find((call) => {
+        const parsed = toolCall(call);
+        return parsed?.name === "bash" && TEST_COMMAND.test(command(parsed.arguments));
+    });
+    const parsedLastCall = lastCall === undefined ? null : toolCall(lastCall);
+    const parsedTestCall = testCall === undefined ? null : toolCall(testCall);
+    const testCallId = typeof testCall?.["id"] === "string" ? testCall["id"] : null;
+    const testResult = testCallId === null
+        ? undefined
+        : [...results].reverse().find((result) => result.tool_call_id === testCallId);
+    const lastAssistant = turns.at(-1)?.assistant;
+    const thought = lastAssistant?.reasoning_content
+        ?? lastAssistant?.reasoning_text
+        ?? lastAssistant?.reasoning
+        ?? null;
+    return {
+        candidate: {
+            model: segment.candidate.model,
+            thinking_level: segment.candidate.reasoningEffort,
+        },
+        requested_turns: segment.requestedTurns,
+        completed_turns: completedTurns,
+        rationale: truncate(segment.rationale),
+        last_agent_thought: thought === null ? null : truncate(thought),
+        last_tool_call: parsedLastCall === null
+            ? null
+            : { name: parsedLastCall.name, arguments: compactJson(parsedLastCall.arguments) },
+        last_tool_result: lastResult === undefined ? null : compactJson(lastResult.content ?? null),
+        // Generic Chat Completions tool results do not carry a portable error bit
+        // or a trustworthy changed-file count.
+        tool_errors: null,
+        files_changed: null,
+        tests: parsedTestCall === null
+            ? null
+            : {
+                command: truncate(command(parsedTestCall.arguments)),
+                status: "unknown",
+                result: testResult === undefined ? null : compactJson(testResult.content ?? null),
+            },
+    };
+}
+function deduplicatedHits(hits) {
+    const byState = new Map();
+    for (const hit of hits) {
+        const key = [
+            hit.conversation_id,
+            hit.message_depth,
+            hit.next_model ?? "",
+            hit.next_reasoning_effort ?? "",
+            hit.lease_turns_remaining ?? "",
+        ].join("\u0000");
+        const existing = byState.get(key);
+        if (existing === undefined || existing.updated_at < hit.updated_at)
+            byState.set(key, hit);
+    }
+    return [...byState.values()];
+}
+function conversationTurns(messages) {
+    const turns = [];
+    let current;
+    for (const message of messages) {
+        if (message.role === "assistant") {
+            current = { assistant: message, toolResults: [] };
+            turns.push(current);
+        }
+        else if (message.role === "tool" && current !== undefined) {
+            current.toolResults.push(message);
+        }
+    }
+    return turns;
+}
+function toolCall(value) {
+    const fn = value["function"];
+    if (!isRecord(fn) || typeof fn.name !== "string")
+        return null;
+    const rawArguments = fn.arguments ?? {};
+    if (typeof rawArguments !== "string") {
+        return { name: fn.name, arguments: compactJson(rawArguments) };
+    }
+    try {
+        return { name: fn.name, arguments: JSON.parse(rawArguments) };
+    }
+    catch {
+        return { name: fn.name, arguments: rawArguments };
+    }
+}
+function command(value) {
+    return isRecord(value) && typeof value.command === "string" ? value.command : "";
+}
+function compactJson(value) {
+    const serialized = JSON.stringify(value) ?? "null";
+    if (serialized.length <= MAX_OBSERVATION_CHARS) {
+        return JSON.parse(serialized);
+    }
+    return `${serialized.slice(0, MAX_OBSERVATION_CHARS)}…`;
+}
+function truncate(value) {
+    return value.length <= MAX_OBSERVATION_CHARS
+        ? value
+        : `${value.slice(0, MAX_OBSERVATION_CHARS)}…`;
+}

package/dist/context/pricing.d.ts

@@ -0,0 +1,4 @@
+import type { ModelPricing, PricingLookup } from "@mupt-ai/dari-router/policy-engine";
+import type { ResolvedRouter } from "../types.js";
+export declare function pricingLookupForRouter(credentials: ResolvedRouter): PricingLookup;
+export declare function modelPricingForRouter(credentials: ResolvedRouter, model: string): ModelPricing | null;

package/dist/context/pricing.js

@@ -0,0 +1,23 @@
+export function pricingLookupForRouter(credentials) {
+    return (model) => modelPricingForRouter(credentials, model);
+}
+export function modelPricingForRouter(credentials, model) {
+    const price = credentials.model_prices?.[model];
+    if (!price || typeof price.input !== "number" || typeof price.output !== "number")
+        return null;
+    // Null cached rates mean the provider publishes none: bill cached prompt
+    // buckets at the input rate, never for free.
+    return {
+        input: price.input,
+        output: price.output,
+        cacheRead: price.cached_input ?? price.input,
+        cacheWrite: price.cache_write ?? price.input,
+        ...(price.tiers?.length ? { tiers: price.tiers.map((tier) => ({
+                inputTokensAbove: tier.input_tokens_above,
+                input: tier.input,
+                output: tier.output,
+                cacheRead: tier.cached_input ?? tier.input,
+                cacheWrite: tier.cache_write ?? tier.input,
+            })) } : {}),
+    };
+}

package/dist/context/provider_prompt_accounting.d.ts

@@ -0,0 +1,14 @@
+import { type CandidatePromptAccounting } from "@mupt-ai/dari-router/policy-engine";
+import type { InteractionRequest, ProviderIdentity } from "../interaction/types.js";
+import type { InteractionPrefixContext } from "./interaction_fingerprint.js";
+type PromptMetrics = {
+    blockDepth: number;
+    serializedChars: number;
+};
+export declare function providerPromptAccounting(args: {
+    request: InteractionRequest;
+    prefix: InteractionPrefixContext;
+    targetsByModel: ReadonlyMap<string, ProviderIdentity>;
+}): CandidatePromptAccounting;
+export declare function promptMetrics(request: InteractionRequest, target: ProviderIdentity): PromptMetrics;
+export {};

package/dist/context/provider_prompt_accounting.js

@@ -0,0 +1,187 @@
+import { isRecord, stableStringify, } from "@mupt-ai/dari-router/policy-engine";
+import { toolsByWireName } from "../interaction/tool_identity.js";
+import { buildContext } from "../providers/pi_context.js";
+import { isOpenAIResponsesApi } from "../providers/model_capabilities.js";
+const ACCOUNTING_IMAGE_URL = "data:image/png;base64,AA==";
+const IMAGE_ESTIMATED_TOKENS = {
+    low: 512,
+    auto: 1024,
+    high: 2048,
+    original: 2048,
+};
+const CHARS_PER_ESTIMATED_TOKEN = 4;
+// Cost and cache-lookback estimates are candidate-specific because compatible
+// continuation state and provider serialization can change what each model
+// sees.
+export function providerPromptAccounting(args) {
+    const fullByModel = new Map();
+    const prefixCharsByModelAndItem = new Map();
+    const targetFor = (model) => {
+        const target = args.targetsByModel.get(model);
+        if (!target) {
+            throw new Error(`missing provider target for ${model}`);
+        }
+        return target;
+    };
+    const fullMetrics = (model) => {
+        const cached = fullByModel.get(model);
+        if (cached)
+            return cached;
+        const target = targetFor(model);
+        const metrics = promptMetrics(args.request, target);
+        fullByModel.set(model, metrics);
+        return metrics;
+    };
+    return {
+        anchorSemantics: "stored_input",
+        providerBlockDepthFor: (model) => fullMetrics(model).blockDepth,
+        promptEstimateFor: (model, anchor) => {
+            const full = fullMetrics(model);
+            if (!anchor) {
+                return {
+                    chars: full.serializedChars,
+                    reusesStoredPromptTokens: false,
+                };
+            }
+            const itemIndex = args.prefix.itemIndexByHashByModel
+                .get(model)
+                ?.get(anchor.hash);
+            if (itemIndex === undefined) {
+                return {
+                    chars: full.serializedChars,
+                    reusesStoredPromptTokens: false,
+                };
+            }
+            const key = `${model}\u0000${itemIndex}`;
+            let prefixChars = prefixCharsByModelAndItem.get(key);
+            if (prefixChars === undefined) {
+                prefixChars = promptMetrics({
+                    ...args.request,
+                    items: args.request.items.slice(0, itemIndex + 1),
+                }, targetFor(model)).serializedChars;
+                prefixCharsByModelAndItem.set(key, prefixChars);
+            }
+            return {
+                chars: Math.max(0, full.serializedChars - prefixChars),
+                reusesStoredPromptTokens: true,
+            };
+        },
+    };
+}
+export function promptMetrics(request, target) {
+    const accountingInput = promptAccountingInput(request);
+    const context = buildContext(accountingInput.request, target);
+    const messages = context.messages.flatMap((message) => {
+        const visible = providerVisibleMessage(message);
+        return visible ? [visible] : [];
+    });
+    const tools = providerVisibleTools(request, context.tools, target);
+    const prompt = {
+        ...(context.systemPrompt !== undefined
+            ? { systemPrompt: context.systemPrompt }
+            : {}),
+        ...(tools.length ? { tools } : {}),
+        messages,
+        ...(request.responseFormat !== undefined
+            ? { responseFormat: request.responseFormat }
+            : {}),
+        ...(request.toolChoice !== undefined
+            ? { toolChoice: request.toolChoice }
+            : {}),
+        ...(request.parallelToolCalls !== undefined
+            ? { parallelToolCalls: request.parallelToolCalls }
+            : {}),
+    };
+    return {
+        blockDepth: messages.reduce((total, message) => total + providerVisibleBlockCount(message), 0),
+        serializedChars: stableStringify(prompt).length + accountingInput.imageEstimatedChars,
+    };
+}
+function providerVisibleMessage(value) {
+    if (!isRecord(value) || typeof value.role !== "string")
+        return null;
+    if (value.role === "assistant") {
+        return {
+            role: value.role,
+            content: sanitizeProviderContent(Array.isArray(value.content) ? value.content : []),
+        };
+    }
+    if (value.role === "toolResult") {
+        return {
+            role: value.role,
+            toolCallId: value.toolCallId ?? null,
+            toolName: value.toolName ?? null,
+            content: sanitizeProviderContent(Array.isArray(value.content) ? value.content : []),
+            isError: value.isError === true,
+        };
+    }
+    return {
+        role: value.role,
+        content: sanitizeProviderContent(value.content ?? ""),
+    };
+}
+function sanitizeProviderContent(value) {
+    if (!Array.isArray(value))
+        return value;
+    return value.map((part) => {
+        if (!isRecord(part))
+            return part;
+        if (part.type === "providerItem" && isRecord(part.item)) {
+            return part.item;
+        }
+        if (part.type === "image"
+            && typeof part.mimeType === "string"
+            && typeof part.data === "string") {
+            return { ...part, data: "<image-data>" };
+        }
+        return part;
+    });
+}
+function providerVisibleBlockCount(message) {
+    if (message.role === "toolResult")
+        return 1;
+    const content = message.content;
+    return Math.max(1, Array.isArray(content) ? content.length : 1);
+}
+function providerVisibleTools(request, contextTools, target) {
+    const definitions = toolsByWireName(request.tools);
+    const tools = (contextTools ?? []).map((tool) => {
+        if (typeof tool.name !== "string")
+            return tool;
+        const definition = definitions.get(tool.name);
+        return definition?.kind !== "function"
+            || definition.strict === undefined
+            ? tool
+            : { ...tool, strict: definition.strict };
+    });
+    if (!isOpenAIResponsesApi(target.api))
+        return tools;
+    return [
+        ...tools,
+        ...request.tools.flatMap((tool) => tool.kind === "hosted" ? [tool.config] : []),
+    ];
+}
+function promptAccountingInput(request) {
+    let imageEstimatedChars = 0;
+    const sanitizeContent = (parts) => parts.map((part) => {
+        if (part.type !== "image")
+            return part;
+        const detail = part.detail ?? "auto";
+        imageEstimatedChars +=
+            IMAGE_ESTIMATED_TOKENS[detail] * CHARS_PER_ESTIMATED_TOKEN;
+        return { ...part, url: ACCOUNTING_IMAGE_URL };
+    });
+    const items = request.items.map((item) => {
+        if (item.type === "message") {
+            return { ...item, content: sanitizeContent(item.content) };
+        }
+        if (item.type === "tool_result" && Array.isArray(item.output)) {
+            return { ...item, output: sanitizeContent(item.output) };
+        }
+        return item;
+    });
+    return {
+        request: { ...request, items },
+        imageEstimatedChars,
+    };
+}

package/dist/context/routing_context.d.ts

@@ -0,0 +1,40 @@
+import { type ActiveLease, type PendingLease, type CandidateCostEstimate, type ChainHits, type PrefixHit, type ChatMessage, type PreviousDecision, type PricingLookup, type SelectorLeaseHistoryEntry, type StrategyCandidateResolution } from "@mupt-ai/dari-router/policy-engine";
+import { type InteractionRequest, type ProviderIdentity } from "../interaction/types.js";
+import { type SelectorImage } from "../strategies/selector_projection.js";
+import type { ResolvedRouter } from "../types.js";
+import { type InteractionPrefixContext } from "./interaction_fingerprint.js";
+export type ImageCapabilityPrunedModel = {
+    model: string;
+    reason: "image_input_unsupported";
+};
+export type RoutingContext = {
+    leaseDepth: number;
+    hits: ChainHits;
+    reportingCostEstimates: CandidateCostEstimate[];
+    previousDecision?: PreviousDecision;
+    activeLease?: ActiveLease;
+    pendingLease?: PendingLease;
+    pricing: PricingLookup;
+    conversationId: string;
+    isNewConversation: boolean;
+    identityMatchDepth: number | null;
+    identityHit?: PrefixHit;
+    zdr: boolean;
+    candidateResolution: StrategyCandidateResolution;
+    imageCapabilityPrunedModels?: ImageCapabilityPrunedModel[];
+    prefix: InteractionPrefixContext;
+    targetsByModel: ReadonlyMap<string, ProviderIdentity>;
+    selectorMessages: ChatMessage[];
+    selectorImages: SelectorImage[];
+    leaseHistory?: SelectorLeaseHistoryEntry[];
+    providerBlockDepthFor: (model: string) => number;
+};
+export declare function derivePrefixLookupHashes(routerId: string, interaction: InteractionRequest): string[];
+export declare function buildRoutingContext(args: {
+    routerId: string;
+    interaction: InteractionRequest;
+    credentials: ResolvedRouter;
+    previousDecision?: PreviousDecision;
+    explicitConversationId?: string;
+    receivedAt?: Date;
+}): Promise<RoutingContext>;