@mupt-ai/dari-gateway 0.3.1 → 0.3.3

package/src/telemetry/report.ts

@@ -62,7 +62,6 @@ import {
   buildCompletedPrefixHit,
   leaseCountdownForPrefix,
   prefixEntryForIngest,
-  reportPendingLease,
   reportPrefixState,
 } from "./prefix_state.js";
 import { subscriptionUsageLimitFromFailure } from "../providers/subscription_limits.js";
@@ -149,7 +148,6 @@ export class RequestReporter {
   private selectorOutputAccepted = false;
   private decision: RoutingDecision | null = null;
   private nextDecision: RoutingDecision | null = null;
-  private fallbackDecision: RoutingDecision | null = null;
   private providerAttempts: ProviderAttemptReport[] = [];
   private billingProviderAttempts: RoutingBillingProviderAttemptFacts[] = [];
   private decisionDetails: Record<string, unknown> = {};
@@ -202,7 +200,6 @@ export class RequestReporter {
     this.selectorOutputAccepted = true;
     this.decision = run.decision;
     this.nextDecision = run.decision;
-    this.fallbackDecision = run.fallbackDecision ?? null;
   }
 
   attachSpeculativeSelectorRun(run: SelectorRun, servingDecision: RoutingDecision): void {
@@ -211,7 +208,6 @@ export class RequestReporter {
     this.selectorOutputAccepted = true;
     this.decision = servingDecision;
     this.nextDecision = run.decision;
-    this.fallbackDecision = run.fallbackDecision ?? null;
   }
 
   // Speculative execution can begin before a selector run; its serving
@@ -221,10 +217,6 @@ export class RequestReporter {
     this.nextDecision = decision;
   }
 
-  attachFallbackDecision(decision: RoutingDecision | undefined): void {
-    this.fallbackDecision = decision ?? null;
-  }
-
   attachServingDecision(decision: RoutingDecision): void {
     this.decision = decision;
   }
@@ -239,10 +231,10 @@ export class RequestReporter {
     return modelCost(attempt ? [...this.billingProviderAttempts, this.billingFacts(attempt)] : this.billingProviderAttempts);
   }
 
-  private billingFacts({ execution, message, role, attempt, billingOutcome }: ProviderAttemptRecord): RoutingBillingProviderAttemptFacts {
+  private billingFacts({ execution, message, attempt, billingOutcome }: ProviderAttemptRecord): RoutingBillingProviderAttemptFacts {
     return routingBillingProviderAttemptFacts({
       provider: execution.provider, model: execution.model,
-      providerKeySource: execution.providerKeySource, role, attempt, outcome: billingOutcome,
+      providerKeySource: execution.providerKeySource, attempt, outcome: billingOutcome,
       providerMessage: message, usage: isRecord(message.usage) ? message.usage : null,
       providerPricingKnown: this.pricingKnown(execution.model),
     });
@@ -388,18 +380,8 @@ export class RequestReporter {
       const decision = this.decision;
       const selectedModel = outcome.providerExecution?.model ?? decision?.selectedModel ?? null;
       const reasoningBucket = decision?.reasoningEffort ?? null;
-      // A completed fallback attempt means the intended pair failed this
-      // turn: the next-turn recommendation and any lease countdown follow the
-      // pair that actually served instead of re-pinning the failed one.
-      const fallbackServed = this.providerAttempts.some(
-        (attempt) => attempt.role === "fallback" && attempt.outcome === "completed",
-      );
-      const nextModel = fallbackServed
-        ? selectedModel
-        : this.nextDecision?.selectedModel ?? selectedModel;
-      const nextReasoningEffort = fallbackServed
-        ? reasoningBucket
-        : this.nextDecision?.reasoningEffort ?? reasoningBucket;
+      const nextModel = this.nextDecision?.selectedModel ?? selectedModel;
+      const nextReasoningEffort = this.nextDecision?.reasoningEffort ?? reasoningBucket;
       const selectedProvider = outcome.providerExecution?.provider ?? (selectedModel
         ? executionProviderForModel(a.credentials, selectedModel)
         : null);
@@ -470,7 +452,6 @@ export class RequestReporter {
               leaseTurnsRemaining: leaseCountdownForPrefix({
                 served: decision ?? null,
                 next: this.nextDecision,
-                fallbackServed,
               }),
               reason: this.nextDecision?.reason ?? decision?.reason ?? null,
               chain: selectedChain,
@@ -506,21 +487,6 @@ export class RequestReporter {
       // resolves this turn's conversation id and next-model prediction.
       // The full report below re-applies the same state idempotently, so a
       // lost or timed-out fast write only degrades to the old ordering.
-      // An ordinary fallback breaks any lease commitment, prefetched ones
-      // included. A lease-aware fallback transfers the active countdown to
-      // the serving pair, so only clear pending state when no countdown was
-      // transferred. The depth fence orders the clear safely against
-      // in-flight prefetch writes.
-      if (!backgroundRequest && fallbackServed && decision?.leaseTurnsRemaining === undefined) {
-        trackBackgroundTelemetry(
-          reportPendingLease({
-            routerId: a.routerId,
-            conversationId: a.conversationId,
-            decidedAtDepth: a.leaseDepth,
-            lease: null,
-          }),
-        );
-      }
       if (prefixEntry !== null || touchedHash !== null) {
         this.prefixStatePromise = reportPrefixState({
           organization_id: a.credentials.organization_id,
@@ -592,13 +558,6 @@ export class RequestReporter {
           strategy: a.strategy,
           selected_reasoning_effort: reasoningBucket,
           next_reasoning_effort: nextReasoningEffort,
-          ...(this.fallbackDecision
-            ? {
-                fallback_model: this.fallbackDecision.selectedModel,
-                fallback_reasoning_effort:
-                  this.fallbackDecision.reasoningEffort,
-              }
-            : {}),
           ...(this.providerAttempts.length > 0
             ? { provider_attempts: this.providerAttempts }
             : {}),
@@ -662,9 +621,6 @@ export class RequestReporter {
           selected_reasoning_effort: reasoningBucket,
           next_model: nextModel,
           next_reasoning_effort: nextReasoningEffort,
-          fallback_model: this.fallbackDecision?.selectedModel ?? null,
-          fallback_reasoning_effort:
-            this.fallbackDecision?.reasoningEffort ?? null,
           provider_key_source: keySource,
           message_count: observability.messageCount,
           tool_count: observability.metadata.declared_tool_counts.total,

package/src/types.ts

@@ -6,6 +6,7 @@ import type {
   RouterEvalScore,
   RouterModelPrice,
   RouterPrefixHit,
+  RoutingDecision,
   RoutingStrategy,
 } from "@mupt-ai/dari-router/policy-engine";
 // The router resolution contract between the gateway runtime and its
@@ -83,6 +84,10 @@ export type PublicEvalCatalogCard = Omit<RouterEval, "scores"> & {
   scores: PublicEvalCatalogScore[];
 };
 
+// A decision as served: session-pinned decisions say so in response headers
+// and Anthropic routing metadata.
+export type ServedDecision = RoutingDecision & { sessionPinned?: boolean };
+
 export type ClientHarness = "claude_code" | "muse_code";
 
 export type ResolvedRouterModelConfig = {
@@ -122,17 +127,18 @@ export type ResolvedRouter = {
   zdr?: boolean;
   allow_long_context?: boolean;
   speculative_routing?: boolean;
+  // Route each session's (and each subagent's) first turn, then serve that
+  // pair for the rest of the session instead of selecting or leasing.
+  session_pinning?: boolean;
   primary_retries?: number;
   // Serve only the requested `dari/model/<id>` at the requested thinking
-  // level: no selector, lease, fallback, or personal subscription the
-  // platform did not supply through resolveProviderCredential, and an error
-  // for anything else, whatever the client sends.
+  // level: no selector, lease, or personal subscription the platform did not
+  // supply through resolveProviderCredential, and an error for anything
+  // else, whatever the client sends.
   strict?: boolean;
   // On strict routers only, allow requested catalog models of these providers.
-  // Requires dari/model/<provider>/<id>; never enables fallback.
+  // Requires dari/model/<provider>/<id>.
   strict_providers?: string[];
-  model_fallback_enabled?: boolean;
-  fallback_requires_different_provider?: boolean;
   evals?: RouterEval[];
   // When true, fill missing eval scores using thinking-level ratios or an
   // explicitly mapped predecessor model.

package/dist/strategies/fallback_decision.d.ts

@@ -1,8 +0,0 @@
-import { type RoutingCandidate, type RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
-export declare function deriveFallbackDecision(args: {
-    candidates: RoutingCandidate[];
-    selected: RoutingCandidate;
-    enabled?: boolean;
-    requiresDifferentProvider?: boolean;
-    providerForModel?: (model: string) => string;
-}): RoutingDecision | undefined;

package/dist/strategies/fallback_decision.js

@@ -1,17 +0,0 @@
-import { providerForModel, } from "@mupt-ai/dari-router/policy-engine";
-export function deriveFallbackDecision(args) {
-    if (!args.enabled)
-        return undefined;
-    const resolveProvider = args.providerForModel ?? providerForModel;
-    const selectedProvider = resolveProvider(args.selected.model);
-    const fallback = args.candidates.find((candidate) => candidate.model !== args.selected.model &&
-        (!args.requiresDifferentProvider ||
-            resolveProvider(candidate.model) !== selectedProvider));
-    return fallback
-        ? {
-            selectedModel: fallback.model,
-            reasoningEffort: fallback.reasoningEffort,
-            reason: "Runtime-selected fallback for the routed primary decision.",
-        }
-        : undefined;
-}

package/src/strategies/fallback_decision.ts

@@ -1,30 +0,0 @@
-import {
-  providerForModel,
-  type RoutingCandidate,
-  type RoutingDecision,
-} from "@mupt-ai/dari-router/policy-engine";
-
-export function deriveFallbackDecision(args: {
-  candidates: RoutingCandidate[];
-  selected: RoutingCandidate;
-  enabled?: boolean;
-  requiresDifferentProvider?: boolean;
-  providerForModel?: (model: string) => string;
-}): RoutingDecision | undefined {
-  if (!args.enabled) return undefined;
-  const resolveProvider = args.providerForModel ?? providerForModel;
-  const selectedProvider = resolveProvider(args.selected.model);
-  const fallback = args.candidates.find(
-    (candidate) =>
-      candidate.model !== args.selected.model &&
-      (!args.requiresDifferentProvider ||
-        resolveProvider(candidate.model) !== selectedProvider),
-  );
-  return fallback
-    ? {
-        selectedModel: fallback.model,
-        reasoningEffort: fallback.reasoningEffort,
-        reason: "Runtime-selected fallback for the routed primary decision.",
-      }
-    : undefined;
-}