@mupt-ai/dari-gateway 0.3.0 → 0.3.2

package/dist/providers/provider_call.d.ts

@@ -1,9 +1,9 @@
-import { type CandidateCostEstimate, type ModelPricing, type PricingLookup, type Provider, type ReasoningEffort, type RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+import { type CandidateCostEstimate, type ModelPricing, type PricingLookup, type Provider, type ReasoningEffort } from "@mupt-ai/dari-router/policy-engine";
 import type { RequestTags } from "../platform/platform.js";
 import type { InteractionRequest, ProviderIdentity } from "../interaction/types.js";
 import { type ProviderAttemptAbort } from "../runtime/customer_disconnect.js";
 import { type RoutingUsageContext } from "../telemetry/usage.js";
-import type { ProviderAuth, ProviderKeySource, ResolvedRouter, ResolvedRouterModelConfig } from "../types.js";
+import type { ProviderAuth, ProviderKeySource, ResolvedRouter, ResolvedRouterModelConfig, ServedDecision } from "../types.js";
 import { type ProviderResponseCapture } from "./response_capture.js";
 import { type ProviderEndpoint, type ProviderEventStream } from "./pi.js";
 import { type PromptTokenEstimate } from "./cancel_estimate.js";
@@ -45,7 +45,7 @@ export type StartedStream = {
     responseCapture?: ProviderResponseCapture;
 };
 export declare function prepareProviderExecution(args: {
-    decision: RoutingDecision;
+    decision: ServedDecision;
     credentials: ResolvedRouter;
     billable: boolean;
     routerId: string;

package/dist/providers/provider_call.js

@@ -73,6 +73,7 @@ export function prepareProviderExecution(args) {
             ...(args.decision.leaseTurnsRemaining === undefined
                 ? {}
                 : { "X-Dari-Lease-Turns-Remaining": String(args.decision.leaseTurnsRemaining) }),
+            ...(args.decision.sessionPinned === true ? { "X-Dari-Session-Pinned": "true" } : {}),
         },
     };
 }

package/dist/providers/provider_reported_cost.js

@@ -2,7 +2,8 @@ import { isRecord } from "@mupt-ai/dari-router/policy-engine";
 import { gatewayFor } from "../models/gateways.js";
 import { providerFailureFromCaught } from "../runtime/provider_stream_outcome.js";
 // Gateways bill per call and say what they billed: OpenRouter as `usage.cost`
-// on the final chunk, Vercel AI Gateway as `providerMetadata.gateway.cost`.
+// on the final chunk (plus the provider's charge on a BYOK call), Vercel AI
+// Gateway as `providerMetadata.gateway.cost`.
 // Pi prices usage from model rates and drops both, so the amount is read off
 // the raw response bytes and replaces the priced total.
 export function reportsProviderCost(model) {
@@ -63,7 +64,21 @@ export function reportedCost(body) {
     const gateway = isRecord(body.providerMetadata) && isRecord(body.providerMetadata.gateway)
         ? body.providerMetadata.gateway
         : undefined;
-    return usd(isRecord(body.usage) ? body.usage.cost : undefined) ?? usd(gateway?.cost);
+    return openRouterCost(body.usage) ?? usd(gateway?.cost);
+}
+// On a BYOK call OpenRouter bills the provider's charge to the org's own key:
+// `usage.cost` is only its fee (often 0), and the charge is in
+// `cost_details.upstream_inference_cost`.
+function openRouterCost(usage) {
+    if (!isRecord(usage))
+        return undefined;
+    const cost = usd(usage.cost);
+    if (cost === undefined || usage.is_byok !== true)
+        return cost;
+    const upstream = isRecord(usage.cost_details)
+        ? usd(usage.cost_details.upstream_inference_cost)
+        : undefined;
+    return cost + (upstream ?? 0);
 }
 function usd(value) {
     const amount = typeof value === "string" && value.trim() !== "" ? Number(value) : value;

package/dist/providers/stream_finalization.d.ts

@@ -23,7 +23,6 @@ type CreateStreamFinalizerArgs = {
     reporter: RoutedRuntimeReporter;
     protocol: RoutedProtocol;
     providerLatencyMs: () => number;
-    role: "primary" | "fallback";
     attempt: number;
     reportBarrier?: Promise<unknown>;
     delivered: () => DeliveredOutput;

package/dist/providers/stream_finalization.js

@@ -74,7 +74,6 @@ function buildStreamTerminalReport(args, outcome) {
     const attemptBase = {
         model: args.decision.selectedModel,
         reasoning_effort: args.decision.reasoningEffort,
-        role: args.role,
         attempt: args.attempt,
         execution,
     };

package/dist/runtime/claude_code/auxiliary_routing.js

@@ -2,7 +2,6 @@ import { routingCandidateKey, } from "@mupt-ai/dari-router/policy-engine";
 import { isBackgroundRequest } from "../../interaction/types.js";
 import { HttpError } from "../../http/errors.js";
 import { assertCreditAvailableBeforeRouting } from "../../telemetry/usage.js";
-import { leaseFallbackDecision } from "../routing_lease.js";
 // Explicit background classes bypass the selector and every lease path.
 // Keep the existing deterministic cheapest-input-cost serving policy.
 export function auxiliaryDecision(prepared) {
@@ -19,14 +18,7 @@ export function auxiliaryDecision(prepared) {
         reasoningEffort: cheapest.reasoning_effort,
         reason: `${requestClass} request served by the cheapest routable model without selection.`,
     };
-    const fallbackDecision = leaseFallbackDecision({
-        candidates: prepared.routing.candidateResolution.candidates,
-        decision,
-        credentials: prepared.credentials,
-    });
-    if (fallbackDecision)
-        prepared.reporter.attachFallbackDecision(fallbackDecision);
-    return fallbackDecision ? { decision, fallbackDecision } : { decision };
+    return { decision };
 }
 /* Ranked on estimated input cost: these requests carry a whole transcript in
    and a sentence out, so the prompt dominates. Estimates cover the configured

package/dist/runtime/explicit_model.js

@@ -1,7 +1,7 @@
 import { HttpError } from "../http/errors.js";
 import { explicitModelId } from "../protocol/input/router_model.js";
 /* A request for `dari/model/<id>` is served by exactly that enabled model,
-   with no selector, lease, or fallback: the user chose it, like picking a
+   with no selector or lease: the user chose it, like picking a
    model in their agent's /model menu. The client's thinking level is kept
    when the model supports it; otherwise the model's default level is used. */
 export function explicitModelDecision(prepared) {

package/dist/runtime/harness_identity/conversation.d.ts

@@ -25,6 +25,11 @@ export declare function scopedHarnessSessionId(args: {
     sourceProtocol: SourceProtocol;
     scope: HarnessConversationScope;
 }): string;
+export declare function scopedHarnessAgentId(args: {
+    identity: HarnessConversationIdentity;
+    sourceProtocol: SourceProtocol;
+    scope: HarnessConversationScope;
+}): string;
 export declare function scopedHarnessConversationId(args: {
     identity: HarnessConversationIdentity;
     sourceProtocol: SourceProtocol;

package/dist/runtime/harness_identity/conversation.js

@@ -11,6 +11,12 @@ export function scopedHarnessSessionId(args) {
         : args.identity;
     return scopedHarnessId({ ...args, identity });
 }
+// One agent of a session: the main agent on the bare session, each subagent
+// on its own qualifier or thread. Unlike the conversation id, it survives
+// compaction.
+export function scopedHarnessAgentId(args) {
+    return scopedHarnessId(args);
+}
 export function scopedHarnessConversationId(args) {
     return scopedHarnessId(args, args.conversationPrefix);
 }

package/dist/runtime/harness_identity/extract.d.ts

@@ -1,6 +1,7 @@
 import type { AgentRequestContext, InteractionRequestPurpose } from "../../interaction/types.js";
 import type { HarnessConversationIdentity } from "./conversation.js";
 export declare function chatCompletionsConversationIdentity(headers: Headers, promptCacheKey?: string): HarnessConversationIdentity | undefined;
+export declare function piRequestContext(headers: Headers): AgentRequestContext | undefined;
 export declare function openCodeRequestContext(headers: Headers): AgentRequestContext | undefined;
 export declare function codexConversationIdentity(headers: Headers, payload: Record<string, unknown>): HarnessConversationIdentity | undefined;
 export declare function codexRequestPurpose(headers: Headers, payload: Record<string, unknown>): InteractionRequestPurpose | undefined;

package/dist/runtime/harness_identity/extract.js

@@ -2,11 +2,10 @@ import { isRecord } from "@mupt-ai/dari-router/policy-engine";
 import { HttpError } from "../../http/errors.js";
 const MAX_ID_CHARS = 200;
 export function chatCompletionsConversationIdentity(headers, promptCacheKey) {
-    // x-session-affinity is the authoritative Chat Completions identity.
-    // Fall back to prompt_cache_key from the request body for callers that
-    // send a stable cache key without the affinity header, so append-only
-    // sessions (growing message history) stay grouped under one conversation.
-    const sessionId = boundedIdentity(headers.get("x-session-affinity"), "x-session-affinity") ?? boundedIdentity(promptCacheKey, "prompt_cache_key");
+    // Pi summaries use fresh cache/affinity IDs. Its explicit session header
+    // groups them with the main turns without changing provider cache affinity.
+    // Other callers use x-session-affinity, falling back to prompt_cache_key.
+    const sessionId = boundedIdentity(headers.get("x-pi-session-id"), "x-pi-session-id") ?? boundedIdentity(headers.get("x-session-affinity"), "x-session-affinity") ?? boundedIdentity(promptCacheKey, "prompt_cache_key");
     if (sessionId === undefined)
         return undefined;
     // OpenCode sends a subagent's parent session as its affinity, so subagents
@@ -19,6 +18,15 @@ export function chatCompletionsConversationIdentity(headers, promptCacheKey) {
         ...(subagentId === undefined ? {} : { qualifiers: [subagentId] }),
     };
 }
+export function piRequestContext(headers) {
+    if (boundedIdentity(headers.get("x-pi-session-id"), "x-pi-session-id") === undefined) {
+        return undefined;
+    }
+    const kind = headers.get("x-pi-request-kind")?.trim();
+    return {
+        requestClass: kind === "turn" ? "main" : kind === "compaction" ? "compaction" : "unknown",
+    };
+}
 // OpenCode names the session behind every request, and a subagent's parent
 // session too. The `dari opencode` plugin adds the request kind and agent,
 // which OpenCode does not send itself. Like Claude Code's headers, these are

package/dist/runtime/harness_identity/index.d.ts

@@ -1,2 +1,2 @@
-export { scopedHarnessConversationId, scopedHarnessSessionId, type HarnessConversationIdentity, type HarnessConversationScope, } from "./conversation.js";
-export { chatCompletionsConversationIdentity, claudeCodeConversationIdentity, codexConversationIdentity, codexRequestPurpose, codexRequestContext, openCodeRequestContext, } from "./extract.js";
+export { scopedHarnessAgentId, scopedHarnessConversationId, scopedHarnessSessionId, type HarnessConversationIdentity, type HarnessConversationScope, } from "./conversation.js";
+export { chatCompletionsConversationIdentity, claudeCodeConversationIdentity, codexConversationIdentity, codexRequestPurpose, codexRequestContext, openCodeRequestContext, piRequestContext, } from "./extract.js";

package/dist/runtime/harness_identity/index.js

@@ -1,2 +1,2 @@
-export { scopedHarnessConversationId, scopedHarnessSessionId, } from "./conversation.js";
-export { chatCompletionsConversationIdentity, claudeCodeConversationIdentity, codexConversationIdentity, codexRequestPurpose, codexRequestContext, openCodeRequestContext, } from "./extract.js";
+export { scopedHarnessAgentId, scopedHarnessConversationId, scopedHarnessSessionId, } from "./conversation.js";
+export { chatCompletionsConversationIdentity, claudeCodeConversationIdentity, codexConversationIdentity, codexRequestPurpose, codexRequestContext, openCodeRequestContext, piRequestContext, } from "./extract.js";

package/dist/runtime/prepare_routed_completion.d.ts

@@ -1,6 +1,6 @@
 import { type RoutingContext } from "../context/routing_context.js";
 import { type InteractionRequest } from "../interaction/types.js";
-import { type RequestTags } from "../platform/platform.js";
+import { type RequestTags, type SessionPin } from "../platform/platform.js";
 import type { ClientHarness, ResolvedRouter } from "../types.js";
 import type { RoutedRuntimeReporter } from "./runtime_reporter.js";
 import type { RoutedProtocol } from "./routed_protocol.js";
@@ -16,6 +16,10 @@ export type PreparedRoutedCompletion = {
     tags: RequestTags;
     harnessConversationIdentity?: HarnessConversationIdentity;
     routing: RoutingContext;
+    sessionPin?: {
+        key: string;
+        pin: SessionPin | null;
+    };
     reporter: RoutedRuntimeReporter;
 };
 export declare function prepareRoutedCompletion(args: {

package/dist/runtime/prepare_routed_completion.js

@@ -3,13 +3,14 @@ import { buildRoutingContext, derivePrefixLookupHashes, } from "../context/routi
 import { isBackgroundRequest } from "../interaction/types.js";
 import { executionProviderForModel } from "../models/execution_provider.js";
 import { codexModelConfig, subscriptionServes } from "../models/subscriptions.js";
+import { explicitModelId } from "../protocol/input/router_model.js";
 import { gatewayPlatform } from "../platform/platform.js";
 import { resolveRouter } from "../strategies/routing.js";
 import { RequestReporter } from "../telemetry/report.js";
 import { RoutingBillingFinalization } from "../telemetry/billing_finalization.js";
 import { requestTags } from "./request_tags.js";
 import { strictProviderAccess } from "./strict_provider_access.js";
-import { scopedHarnessConversationId, scopedHarnessSessionId, } from "./harness_identity/index.js";
+import { scopedHarnessAgentId, scopedHarnessConversationId, scopedHarnessSessionId, } from "./harness_identity/index.js";
 export async function prepareRoutedCompletion(args) {
     const tags = requestTags(args.tagsHeader);
     // Eval relevance draws from the public catalog, which resolve only returns
@@ -94,6 +95,28 @@ export async function prepareRoutedCompletion(args) {
         receivedAt: args.receivedAt,
     });
     const candidateResolution = routing.candidateResolution;
+    let sessionPin;
+    if (credentials.session_pinning === true &&
+        credentials.strict !== true &&
+        !background &&
+        explicitModelId(args.interaction.model) === null) {
+        // Harness identity keys the main agent and each subagent separately and
+        // survives compaction. Claude Code names its subagents only with gateway
+        // hint headers; without them, and for callers with no harness identity,
+        // each conversation is pinned on its own.
+        const identity = args.harnessConversationIdentity;
+        const unclassifiedClaudeCode = identity?.kind === "claude_code_session"
+            && args.interaction.agentContext?.requestClass === "unknown";
+        const key = identity === undefined || unclassifiedClaudeCode
+            ? routing.conversationId
+            : scopedHarnessAgentId({
+                identity,
+                sourceProtocol: args.interaction.sourceProtocol,
+                scope: harnessScope,
+            });
+        const pin = await gatewayPlatform().readSessionPin({ routerId: canonicalRouterId, pinKey: key });
+        sessionPin = { key, pin };
+    }
     const reporter = new RequestReporter({
         requestId: args.requestId,
         clientRequestId: args.clientRequestId,
@@ -134,11 +157,12 @@ export async function prepareRoutedCompletion(args) {
         tags,
         harnessConversationIdentity: args.harnessConversationIdentity,
         routing,
+        ...(sessionPin === undefined ? {} : { sessionPin }),
         reporter,
     };
 }
 // Ask the platform for each enabled model's credential up front, so provider
-// execution and fallback stay synchronous.
+// execution stays synchronous.
 async function withProviderCredentials(credentials, apiKey, clientHarness) {
     const platform = gatewayPlatform();
     if (platform.resolveProviderCredential === undefined)

package/dist/runtime/routed_runtime.js

@@ -11,7 +11,8 @@ import { buildCompletedPrefixHit } from "../telemetry/prefix_state.js";
 import { scrubSecrets } from "../telemetry/scrub.js";
 import { auxiliaryDecision } from "./claude_code/auxiliary_routing.js";
 import { explicitModelDecision, strictModelDecision } from "./explicit_model.js";
-import { clearPendingLease, committedLeaseDecision, leaseHoldDecision, leasePrefetchDue, leasedDecision, pendingLeaseDecision, prefetchNextLease, selectorNegotiatesLeases, } from "./routing_lease.js";
+import { clearPendingLease, leaseHoldDecision, leasePrefetchDue, leasedDecision, pendingLeaseDecision, prefetchNextLease, selectorNegotiatesLeases, } from "./routing_lease.js";
+import { pinSession, sessionPinHoldDecision, sessionPinnedSelection } from "./session_pin.js";
 import { createExperimentRoutedRuntimeReporter, } from "./runtime_reporter.js";
 import { HttpError } from "../http/errors.js";
 export class RoutedRuntimeProviderSettledError extends Error {
@@ -38,7 +39,6 @@ export async function runPreparedRoutedCompletion(args) {
             interaction: prepared.interaction,
             primary: plan.primary,
             primaryRetries: plan.primaryRetries,
-            resolveFallback: plan.resolveFallback,
             reporter: prepared.reporter,
             protocol: prepared.protocol,
             startedCompletion: plan.startedCompletion,
@@ -51,7 +51,6 @@ export async function runPreparedRoutedCompletion(args) {
         interaction: prepared.interaction,
         primary: plan.primary,
         primaryRetries: plan.primaryRetries,
-        resolveFallback: plan.resolveFallback,
         reporter: prepared.reporter,
         startedStream: plan.startedStream,
         initialError: plan.initialStreamError,
@@ -84,7 +83,6 @@ export async function runPreparedRoutedInteraction(args) {
         interaction: args.prepared.interaction,
         primary: plan.primary,
         primaryRetries: plan.primaryRetries,
-        resolveFallback: plan.resolveFallback,
         reporter: args.prepared.reporter,
         protocol: args.prepared.protocol,
         startedCompletion: plan.startedCompletion,
@@ -129,8 +127,7 @@ async function prepareExplicitRoutedCompletion(args) {
 }
 async function prepareRuntimeExecution(args) {
     const { prepared } = args;
-    // A strict router never selects, leases, or falls back: the pinned pair or
-    // an error.
+    // A strict router never selects or leases: the pinned pair or an error.
     if (prepared.credentials.strict === true) {
         const pinned = strictModelDecision(prepared);
         prepared.reporter.attachServingDecision(pinned.decision);
@@ -171,14 +168,16 @@ async function prepareRuntimeExecution(args) {
         });
         return selectedExecutionPlan(prepared, auxiliary);
     }
+    // A session-pinning router serves the session's pin, or selects once and
+    // pins the result. Leases and speculation never apply to a pinned session.
+    if (prepared.sessionPin !== undefined && !args.requireSelectorDecision) {
+        return selectedExecutionPlan(prepared, await sessionPinnedDecision(prepared, args.selectorBackend));
+    }
     // Persisted policy leases (negotiated {action, turns}) take precedence.
     // Explicit in-process runs are selector experiments: they must observe the
     // selector and must not consume or prefetch live conversations' leases.
     const held = args.requireSelectorDecision ? null : leaseHoldDecision(prepared);
     if (held) {
-        // Serving-only attach: nextDecision stays unset so if a fallback serves
-        // this turn, execution's attachServingDecision moves both the prefix's
-        // next_model and inherited countdown onto the healthy serving pair.
         prepared.reporter.attachServingDecision(held);
         prepared.reporter.attachDecisionDetails({
             decision_source: "lease_hold",
@@ -197,7 +196,7 @@ async function prepareRuntimeExecution(args) {
         if (leasePrefetchDue(prepared)) {
             trackBackgroundTelemetry(prefetchNextLease(prepared, args.selectorBackend));
         }
-        return selectedExecutionPlan(prepared, committedLeaseDecision(prepared, held));
+        return selectedExecutionPlan(prepared, { decision: held });
     }
     const adopted = args.requireSelectorDecision ? null : pendingLeaseDecision(prepared);
     if (adopted) {
@@ -222,7 +221,7 @@ async function prepareRuntimeExecution(args) {
         // wait elapses, the next lease's own prefetch overwrites the stale rows
         // before its expiry (the menu's shortest lease exceeds the lag).
         await clearPendingLease(prepared);
-        return selectedExecutionPlan(prepared, committedLeaseDecision(prepared, adopted));
+        return selectedExecutionPlan(prepared, { decision: adopted });
     }
     // The stateless ten-turn hold covers per-turn policies. A lease-negotiating
     // backend must reach the selector at expiry — the modulo hold would mask it
@@ -250,27 +249,15 @@ async function prepareRuntimeExecution(args) {
     const primary = {
         decision: speculative.decision,
         execution: speculative.execution,
-        role: "primary",
     };
     const selectionPromise = selectDecision(prepared, speculative.decision, args.selectorBackend, args.requireSelectorDecision === true);
     // The execution layer awaits selection as its report barrier only after the
     // provider settles, which can be long after a rejection. Mark the promise
-    // handled now; fallback still consumes the original and its rejection.
+    // handled now; the report barrier still observes the original rejection.
     selectionPromise.catch(() => undefined);
-    let fallbackPromise = null;
-    const resolveFallback = () => {
-        fallbackPromise ??= selectionPromise.then((selected) => {
-            const decision = fallbackForPrimary(prepared, primary.decision, selected);
-            if (decision)
-                prepared.reporter.attachFallbackDecision(decision);
-            return decision ? providerChoice(prepared, decision, "fallback") : null;
-        });
-        return fallbackPromise;
-    };
     return {
         primary,
         primaryRetries: configuredPrimaryRetries(prepared.credentials.primary_retries),
-        resolveFallback,
         reportBarrier: selectionPromise,
         startedCompletion: speculative.transport === "completion" ? speculative.started : undefined,
         startedStream: speculative.transport === "stream" ? speculative.started : undefined,
@@ -281,19 +268,8 @@ async function prepareRuntimeExecution(args) {
 }
 function selectedExecutionPlan(prepared, selected) {
     return {
-        primary: providerChoice(prepared, selected.decision, "primary"),
+        primary: providerChoice(prepared, selected.decision),
         primaryRetries: configuredPrimaryRetries(prepared.credentials.primary_retries),
-        resolveFallback: async () => {
-            if (!selected.fallbackDecision)
-                return null;
-            const fallbackDecision = selected.decision.leaseTurnsRemaining === undefined
-                ? selected.fallbackDecision
-                : {
-                    ...selected.fallbackDecision,
-                    leaseTurnsRemaining: selected.decision.leaseTurnsRemaining,
-                };
-            return providerChoice(prepared, fallbackDecision, "fallback");
-        },
     };
 }
 async function startSpeculativeExecution(prepared, selectorBackend, clientSignal) {
@@ -349,10 +325,28 @@ async function startSpeculativeExecution(prepared, selectorBackend, clientSignal
         return null;
     }
 }
+async function sessionPinnedDecision(prepared, selectorBackend) {
+    const held = sessionPinHoldDecision(prepared);
+    if (held) {
+        prepared.reporter.attachDecision(held);
+        prepared.reporter.attachDecisionDetails({
+            decision_source: "session_pin",
+            session_pin: { model: held.selectedModel, reasoning_effort: held.reasoningEffort },
+        });
+        return { decision: held };
+    }
+    const selected = await selectDecision(prepared, null, selectorBackend);
+    prepared.reporter.attachDecisionDetails({
+        decision_source: "selector",
+        session_pin_established: true,
+    });
+    await pinSession(prepared, selected.decision);
+    return selected;
+}
 async function selectDecision(prepared, servingDecision, selectorBackend, requireSelectorDecision = false) {
     const { credentials, reporter, routing } = prepared;
     try {
-        const routed = await routeDecision({
+        const selected = await routeDecision({
             selectorMessages: routing.selectorMessages,
             selectorImages: routing.selectorImages,
             resolution: routing.candidateResolution,
@@ -362,6 +356,7 @@ async function selectDecision(prepared, servingDecision, selectorBackend, requir
             selectorBackend,
             leaseHistory: routing.leaseHistory,
         });
+        const routed = prepared.sessionPin === undefined ? selected : sessionPinnedSelection(selected);
         if (routed.details)
             reporter.attachDecisionDetails(routed.details);
         if (servingDecision) {
@@ -387,7 +382,6 @@ async function selectDecision(prepared, servingDecision, selectorBackend, requir
         }
         else {
             reporter.attachDecision(routed.decision);
-            reporter.attachFallbackDecision(routed.fallbackDecision);
         }
         return routed;
     }
@@ -430,24 +424,10 @@ function configuredPrimaryRetries(value) {
     const retries = value ?? 1;
     return Number.isInteger(retries) && retries >= 0 && retries <= 5 ? retries : 1;
 }
-function fallbackForPrimary(prepared, primary, selected) {
-    if (prepared.credentials.model_fallback_enabled === false)
-        return undefined;
-    const fallback = [selected.fallbackDecision, selected.decision].find((candidate) => candidate !== undefined &&
-        candidate.selectedModel !== primary.selectedModel);
-    if (!fallback || selected.decision.leaseTurnsRemaining === undefined) {
-        return fallback;
-    }
-    return {
-        ...fallback,
-        leaseTurnsRemaining: selected.decision.leaseTurnsRemaining,
-    };
-}
-function providerChoice(prepared, decision, role) {
+function providerChoice(prepared, decision) {
     return {
         decision,
         execution: providerExecution(prepared, decision),
-        role,
     };
 }
 function providerExecution(prepared, decision) {

package/dist/runtime/routing_lease.d.ts

@@ -12,15 +12,13 @@ export declare function leasedRoutingDecision(args: {
     previousDecision?: PreviousDecision;
 }): RoutingLeaseDecision | null;
 export declare function leasedDecision(prepared: PreparedRoutedCompletion): RoutedDecision | null;
-export declare function committedLeaseDecision(prepared: PreparedRoutedCompletion, decision: RoutingDecision): RoutedDecision;
-export declare function leaseFallbackDecision(args: {
-    candidates: PreparedRoutedCompletion["routing"]["candidateResolution"]["candidates"];
-    decision: RoutingDecision;
-    credentials: PreparedRoutedCompletion["credentials"];
-}): RoutingDecision | undefined;
 export declare function selectorNegotiatesLeases(backend: SelectorBackend): Promise<boolean>;
 export declare function prefetchNextLease(prepared: PreparedRoutedCompletion, selectorBackend: SelectorBackend): Promise<void>;
 export declare function leasePrefetchDue(prepared: PreparedRoutedCompletion): boolean;
 export declare function clearPendingLease(prepared: PreparedRoutedCompletion): Promise<void>;
+export declare function canServeCommittedPair(prepared: PreparedRoutedCompletion, pair: {
+    model: string;
+    reasoningEffort: string;
+}): boolean;
 export declare function pendingLeaseDecision(prepared: PreparedRoutedCompletion): RoutingDecision | null;
 export declare function leaseHoldDecision(prepared: PreparedRoutedCompletion): RoutingDecision | null;

package/dist/runtime/routing_lease.js

@@ -1,6 +1,4 @@
 import { FIXED_TURN_COST_COMPARISON_TURNS, LEASE_DECISION_TURN_LAG, } from "@mupt-ai/dari-router/policy-engine";
-import { deriveFallbackDecision } from "../strategies/fallback_decision.js";
-import { executionProviderForModel } from "../models/execution_provider.js";
 import { routeDecision, } from "../strategies/route_decision.js";
 import { reportPendingLease } from "../telemetry/prefix_state.js";
 import { scrubSecrets } from "../telemetry/scrub.js";
@@ -42,17 +40,7 @@ export function leasedDecision(prepared) {
     // incumbent cannot hide an available user-owned key behind the lease.
     if (prepared.billable && prepared.credentials.credit_exhausted)
         return null;
-    const fallbackDecision = leaseFallbackDecision({
-        candidates: prepared.routing.candidateResolution.candidates,
-        decision: lease.decision,
-        credentials: prepared.credentials,
-    });
-    // Use attachServingDecision rather than attachDecision so next_model
-    // follows the model that actually serves. When fallback handles a primary
-    // failure, it inherits this countdown and subsequent held turns continue
-    // on the healthy serving pair instead of retrying the failed primary.
     prepared.reporter.attachServingDecision(lease.decision);
-    prepared.reporter.attachFallbackDecision(fallbackDecision);
     prepared.reporter.attachDecisionDetails({
         decision_source: "lease_hold",
         routing_lease: {
@@ -61,40 +49,7 @@ export function leasedDecision(prepared) {
             turn_in_lease: lease.turnInLease,
         },
     });
-    return { decision: lease.decision, fallbackDecision };
-}
-// Wraps a lease-held (or adopted) decision with a runtime-derived fallback so
-// a mid-lease provider failure degrades like any other turn instead of
-// erroring the request. The fallback inherits the remaining commitment so the
-// completed prefix follows the healthy serving pair for the rest of the lease.
-export function committedLeaseDecision(prepared, decision) {
-    const fallbackDecision = leaseFallbackDecision({
-        candidates: prepared.routing.candidateResolution.candidates,
-        decision,
-        credentials: prepared.credentials,
-    });
-    if (fallbackDecision)
-        prepared.reporter.attachFallbackDecision(fallbackDecision);
-    return fallbackDecision ? { decision, fallbackDecision } : { decision };
-}
-export function leaseFallbackDecision(args) {
-    const fallback = deriveFallbackDecision({
-        candidates: args.candidates,
-        selected: {
-            model: args.decision.selectedModel,
-            reasoningEffort: args.decision.reasoningEffort,
-        },
-        enabled: args.credentials.model_fallback_enabled !== false,
-        requiresDifferentProvider: args.credentials.fallback_requires_different_provider !== false,
-        providerForModel: (model) => executionProviderForModel(args.credentials, model),
-    });
-    if (!fallback || args.decision.leaseTurnsRemaining === undefined) {
-        return fallback;
-    }
-    return {
-        ...fallback,
-        leaseTurnsRemaining: args.decision.leaseTurnsRemaining,
-    };
+    return { decision: lease.decision };
 }
 export async function selectorNegotiatesLeases(backend) {
     if (backend.negotiatedLeaseTurns === undefined)
@@ -164,7 +119,7 @@ export async function clearPendingLease(prepared) {
         lease: null,
     }), PENDING_LEASE_CLEAR_WAIT_MS);
 }
-function canServeCommittedPair(prepared, pair) {
+export function canServeCommittedPair(prepared, pair) {
     if (prepared.billable && prepared.credentials.credit_exhausted)
         return false;
     return prepared.routing.candidateResolution.candidates.some((candidate) => candidate.model === pair.model &&

package/dist/runtime/runtime_reporter.d.ts

@@ -31,7 +31,6 @@ export type ReportableProviderOutcome = {
 export type ProviderAttemptReport = {
     model: string;
     reasoning_effort: string;
-    role: "primary" | "fallback";
     attempt: number;
     outcome: "completed" | "error" | "terminal_error" | "canceled";
 };
@@ -47,7 +46,6 @@ export type RoutedRuntimeReporter = {
     attachSelectorRun(run: SelectorRun): void;
     attachSpeculativeSelectorRun(run: SelectorRun, servingDecision: RoutingDecision): void;
     attachDecision(decision: RoutingDecision): void;
-    attachFallbackDecision(decision: RoutingDecision | undefined): void;
     attachServingDecision(decision: RoutingDecision): void;
     recordProviderAttempt(attempt: ProviderAttemptRecord): void;
     modelCost(attempt?: ProviderAttemptRecord): number | null;

package/dist/runtime/runtime_reporter.js

@@ -14,7 +14,6 @@ export function createExperimentRoutedRuntimeReporter() {
         attachSelectorRun() { },
         attachSpeculativeSelectorRun() { },
         attachDecision() { },
-        attachFallbackDecision() { },
         attachServingDecision() { },
         recordProviderAttempt() { },
         modelCost() { return null; },

package/dist/runtime/session_pin.d.ts

@@ -0,0 +1,7 @@
+import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+import type { RoutedDecision } from "../strategies/route_decision.js";
+import type { ServedDecision } from "../types.js";
+import type { PreparedRoutedCompletion } from "./prepare_routed_completion.js";
+export declare function sessionPinHoldDecision(prepared: PreparedRoutedCompletion): ServedDecision | null;
+export declare function sessionPinnedSelection(routed: RoutedDecision): RoutedDecision;
+export declare function pinSession(prepared: PreparedRoutedCompletion, decision: RoutingDecision): Promise<void>;