@mupt-ai/dari-gateway 0.3.1 → 0.3.2

package/dist/self_host/config.d.ts

@@ -9,8 +9,8 @@ import { type ReasoningEffort } from "@mupt-ai/dari-router/policy-engine";
  *       - anthropic/claude-sonnet-5-5
  *       - id: openai/gpt-5.5
  *         thinking: [medium, high]
- *     fallback: true        # retry on the next model when a provider fails
  *     subscriptions: true   # serve with connected Claude Code / ChatGPT plans
+ *     sessionPinning: false # route each session and subagent once, then keep its model
  * providers:                # optional: OpenAI-compatible or self-run endpoints
  *   local:
  *     baseUrl: http://localhost:8000/v1
@@ -32,10 +32,9 @@ export type ProviderEndpointConfig = {
 };
 export type RouterConfig = {
     models: RouterModelConfig[];
-    fallback: boolean;
-    fallbackRequiresDifferentProvider: boolean;
     retries: number;
     subscriptions: boolean;
+    sessionPinning: boolean;
     zdr: boolean;
 };
 export type RouterModelConfig = {

package/dist/self_host/config.js

@@ -67,10 +67,9 @@ function parseRouter(id, raw) {
     }
     return {
         models,
-        fallback: optionalBoolean(raw.fallback, `routers.${id}.fallback`) ?? true,
-        fallbackRequiresDifferentProvider: optionalBoolean(raw.fallbackRequiresDifferentProvider, `routers.${id}.fallbackRequiresDifferentProvider`) ?? false,
         retries: optionalRetries(raw.retries, `routers.${id}.retries`) ?? 1,
         subscriptions: optionalBoolean(raw.subscriptions, `routers.${id}.subscriptions`) ?? true,
+        sessionPinning: optionalBoolean(raw.sessionPinning, `routers.${id}.sessionPinning`) ?? false,
         zdr: optionalBoolean(raw.zdr, `routers.${id}.zdr`) ?? false,
     };
 }

package/dist/self_host/main.d.ts

@@ -8,7 +8,8 @@
  *   state (default `dari-gateway.db`). It holds subscription tokens.
  * - `DARI_AUTO_ROUTING_API_KEY`: choose among a router's models with Dari
  *   Auto Routing; without it, `dari/routing` serves the first listed model.
- * - `PORT` (default 8080), and each provider's standard API key variable.
+ * - `PORT` (default 8080), `DARI_GATEWAY_HOST` (default 127.0.0.1; the container
+ *   image sets 0.0.0.0), and each provider's standard API key variable.
  */
 export declare function startSelfHostedGateway(env?: Record<string, string>): Promise<{
     server: import("../http/http2_server.js").Http2RoutingServer | Bun.Server<undefined>;

package/dist/self_host/main.js

@@ -10,8 +10,9 @@ import { createAutoRoutingSelectorBackend } from "../strategies/auto_routing_sel
 import { createPrioritySelectorBackend } from "../strategies/priority_selector.js";
 import { loadGatewayConfig } from "./config.js";
 import { createSelfHostedPlatform } from "./platform.js";
-import { gatewayKeyIndex } from "./resolve.js";
+import { gatewayKeyIndex, providersWithoutCredentials } from "./resolve.js";
 import { PrefixStore } from "./prefix_store.js";
+import { SessionPinStore } from "./session_pin_store.js";
 import { handleSubscriptionRequest, SubscriptionStore } from "./subscriptions/index.js";
 const SUBSCRIPTION_ROUTES = "/v1/organizations/current/credentials";
 /**
@@ -23,7 +24,8 @@ const SUBSCRIPTION_ROUTES = "/v1/organizations/current/credentials";
  *   state (default `dari-gateway.db`). It holds subscription tokens.
  * - `DARI_AUTO_ROUTING_API_KEY`: choose among a router's models with Dari
  *   Auto Routing; without it, `dari/routing` serves the first listed model.
- * - `PORT` (default 8080), and each provider's standard API key variable.
+ * - `PORT` (default 8080), `DARI_GATEWAY_HOST` (default 127.0.0.1; the container
+ *   image sets 0.0.0.0), and each provider's standard API key variable.
  */
 export async function startSelfHostedGateway(env = process.env) {
     const gatewayKeys = (env.DARI_GATEWAY_KEYS ?? "")
@@ -42,20 +44,31 @@ export async function startSelfHostedGateway(env = process.env) {
     db.exec("PRAGMA journal_mode = WAL");
     const subscriptions = new SubscriptionStore(db);
     const prefixes = new PrefixStore(db);
+    const sessionPins = new SessionPinStore(db);
     // Pi's provider auth reads each provider's standard key variable, such as
     // OPENAI_API_KEY, from this environment only.
     const piModels = builtinModels({
         authContext: { env: async (name) => env[name], fileExists: async () => false },
     });
+    const providerApiKey = async (provider) => (await piModels.getAuth(provider))?.auth.apiKey;
     const platform = createSelfHostedPlatform({
         config,
         gatewayKeys,
         subscriptions,
         prefixes,
-        providerApiKey: async (provider) => (await piModels.getAuth(provider))?.auth.apiKey,
+        sessionPins,
+        providerApiKey,
         env,
         fetch,
     });
+    // A model without a credential is dropped at request time, so a missing key
+    // would otherwise surface only as a 424 on the first request.
+    for (const [routerId, router] of Object.entries(config.routers)) {
+        const missing = await providersWithoutCredentials({ config, subscriptions, providerApiKey, env }, router);
+        if (missing.length > 0) {
+            console.warn("dari-gateway router has providers without credentials; their models are not served", JSON.stringify({ router: routerId, providers: missing }));
+        }
+    }
     const autoRoutingKey = env.DARI_AUTO_ROUTING_API_KEY?.trim();
     const selectorBackend = autoRoutingKey
         ? createAutoRoutingSelectorBackend({
@@ -81,8 +94,11 @@ export async function startSelfHostedGateway(env = process.env) {
             ?? errorResponse(new HttpError(404, "Not found", "not_found"));
     };
     const port = Number(env.PORT ?? "8080");
-    const server = startServer(port, handler);
+    // Loopback unless DARI_GATEWAY_HOST says otherwise (see the doc comment).
+    const hostname = (env.DARI_GATEWAY_HOST ?? "").trim() || "127.0.0.1";
+    const server = startServer(port, handler, { hostname });
     console.info("dari-gateway listening", JSON.stringify({
+        hostname,
         port,
         routers: Object.keys(config.routers),
         auto_routing: autoRoutingKey ? "dari" : "priority",

package/dist/self_host/platform.d.ts

@@ -1,13 +1,15 @@
 import type { GatewayPlatform } from "../platform/platform.js";
 import type { PrefixStore } from "./prefix_store.js";
+import type { SessionPinStore } from "./session_pin_store.js";
 import { type SelfHostedResolverDeps } from "./resolve.js";
 import type { SubscriptionStore } from "./subscriptions/index.js";
 /**
- * The self-hosted platform: routers from the config file, subscriptions and
- * prefix-cache state in the gateway's SQLite database, and one content-free
+ * The self-hosted platform: routers from the config file, subscriptions,
+ * prefix-cache state, and session pins in the gateway's SQLite database, and one content-free
  * log line per request.
  */
 export declare function createSelfHostedPlatform(deps: Omit<SelfHostedResolverDeps, "prefixHits"> & {
     prefixes: PrefixStore;
+    sessionPins: SessionPinStore;
     subscriptions: SubscriptionStore;
 }): GatewayPlatform;

package/dist/self_host/platform.js

@@ -1,8 +1,8 @@
 import { errorCode } from "../http/errors.js";
 import { resolveSelfHostedRouter } from "./resolve.js";
 /**
- * The self-hosted platform: routers from the config file, subscriptions and
- * prefix-cache state in the gateway's SQLite database, and one content-free
+ * The self-hosted platform: routers from the config file, subscriptions,
+ * prefix-cache state, and session pins in the gateway's SQLite database, and one content-free
  * log line per request.
  */
 export function createSelfHostedPlatform(deps) {
@@ -18,6 +18,10 @@ export function createSelfHostedPlatform(deps) {
         writePendingLease: async (write) => {
             deps.prefixes.writePendingLease(write, deps.config.routers[write.router_id]?.zdr ?? false);
         },
+        readSessionPin: async (key) => deps.sessionPins.read(key),
+        writeSessionPin: async (write) => {
+            deps.sessionPins.write(write);
+        },
         markSubscriptionUnavailable: async (hold) => hold.credentialId !== undefined &&
             deps.subscriptions.markUnavailable(hold.credentialId, hold.limit.resetsAt, hold.limit.reason),
         async recordUsage() {

package/dist/self_host/resolve.d.ts

@@ -1,7 +1,7 @@
 import { type RouterPrefixHit } from "@mupt-ai/dari-router/policy-engine";
 import type { ResolveRouterRequest } from "../platform/platform.js";
 import type { ResolvedRouter } from "../types.js";
-import type { GatewayConfig } from "./config.js";
+import type { GatewayConfig, RouterConfig } from "./config.js";
 import { type OAuthFetch, type SubscriptionStore } from "./subscriptions/index.js";
 export declare const SELF_HOSTED_ORGANIZATION_ID = "self-hosted";
 export declare const SELF_HOSTED_USER_ID = "self-hosted";
@@ -26,3 +26,10 @@ export type SelfHostedResolverDeps = {
  */
 export declare function resolveSelfHostedRouter(deps: SelfHostedResolverDeps, request: ResolveRouterRequest): Promise<ResolvedRouter>;
 export declare function gatewayKeyIndex(keys: readonly string[], presented: string): number | null;
+/**
+ * Providers a router lists that no credential can serve: no API key and no
+ * connected subscription the router allows. Startup uses this, so it counts a
+ * held subscription as connected (the request-time 424 reports holds) and
+ * checks both harnesses, since startup does not know the client.
+ */
+export declare function providersWithoutCredentials(deps: Pick<SelfHostedResolverDeps, "subscriptions" | "providerApiKey" | "config" | "env">, router: RouterConfig): Promise<string[]>;

package/dist/self_host/resolve.js

@@ -17,7 +17,7 @@ export const SELF_HOSTED_USER_ID = "self-hosted";
 export async function resolveSelfHostedRouter(deps, request) {
     const keyIndex = gatewayKeyIndex(deps.gatewayKeys, request.apiKey);
     if (keyIndex === null) {
-        throw new HttpError(401, "Missing or invalid router/API key.", "routing_key_resolution_failed");
+        throw new HttpError(401, "Missing or invalid gateway key.", "authentication_error");
     }
     const router = deps.config.routers[request.routerId];
     if (router === undefined) {
@@ -48,8 +48,10 @@ export async function resolveSelfHostedRouter(deps, request) {
         credentials.set(provider, apiKey ? { key: apiKey, source: "user" } : null);
     }
     const models = router.models.filter((model) => credentials.get(providerForModel(model.id)) != null);
-    if (models.length === 0)
-        throw unavailableRouterError(request.routerId, exhausted);
+    if (models.length === 0) {
+        const missing = [...credentials].filter(([, credential]) => credential == null).map(([provider]) => provider);
+        throw unavailableRouterError(request.routerId, exhausted, missing);
+    }
     const resolved = {
         router_id: request.routerId,
         organization_id: SELF_HOSTED_ORGANIZATION_ID,
@@ -61,9 +63,8 @@ export async function resolveSelfHostedRouter(deps, request) {
         subscription_credential_ids: {},
         zdr: router.zdr,
         speculative_routing: false,
+        session_pinning: router.sessionPinning,
         primary_retries: router.retries,
-        model_fallback_enabled: router.fallback,
-        fallback_requires_different_provider: router.fallbackRequiresDifferentProvider,
         lease_context_enabled: false,
         routing_strategy: "dari",
         custom_config: null,
@@ -156,12 +157,34 @@ const SUBSCRIPTION_PLAN_NAMES = {
     openai_codex: "ChatGPT",
     meta_muse: "Muse Code",
 };
-function unavailableRouterError(routerId, exhausted) {
+/**
+ * Providers a router lists that no credential can serve: no API key and no
+ * connected subscription the router allows. Startup uses this, so it counts a
+ * held subscription as connected (the request-time 424 reports holds) and
+ * checks both harnesses, since startup does not know the client.
+ */
+export async function providersWithoutCredentials(deps, router) {
+    const missing = [];
+    for (const provider of new Set(router.models.map((model) => providerForModel(model.id)))) {
+        const plans = router.subscriptions
+            ? [subscriptionProviderFor(provider, "claude_code"), subscriptionProviderFor(provider, "muse_code")]
+            : [];
+        const connected = plans.some((plan) => plan !== null && deps.subscriptions.list(plan).length > 0);
+        if (connected)
+            continue;
+        const apiKey = await providerApiKey(deps, provider);
+        if (apiKey === undefined)
+            missing.push(provider);
+    }
+    return missing;
+}
+function unavailableRouterError(routerId, exhausted, missing) {
+    const missingNote = missing.length > 0 ? ` Missing providers: ${missing.join(", ")}.` : "";
     if (exhausted.size > 0) {
         const plans = [...exhausted]
             .map((provider) => SUBSCRIPTION_PLAN_NAMES[provider])
             .join(" and ");
-        return new HttpError(424, `Every connected ${plans} subscription is at its usage limit, and no API key can serve router ${routerId} instead.`, "personal_subscription_unavailable");
+        return new HttpError(424, `Every connected ${plans} subscription is at its usage limit, and no API key can serve router ${routerId} instead.${missingNote}`, "personal_subscription_unavailable");
     }
-    return new HttpError(424, `No credentials can serve router ${routerId}: set a provider API key or connect a subscription.`, "provider_credentials_missing");
+    return new HttpError(424, `No credentials can serve router ${routerId}.${missingNote} Set each provider's API key or connect a subscription that can serve it.`, "provider_credentials_missing");
 }

package/dist/self_host/session_pin_store.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SQLite storage for session pins: the model and thinking level each session
+ * (and each subagent) of a session-pinning router was routed to on its first
+ * turn. Serving a pin refreshes it at most daily; pins unused for longer than
+ * the retention window are no longer served and are deleted.
+ */
+import type { Database } from "bun:sqlite";
+import type { SessionPin, SessionPinKey } from "../platform/platform.js";
+export declare class SessionPinStore {
+    private readonly db;
+    constructor(db: Database);
+    read(key: SessionPinKey, now?: Date): SessionPin | null;
+    write(write: SessionPinKey & SessionPin, now?: Date): void;
+}

package/dist/self_host/session_pin_store.js

@@ -0,0 +1,44 @@
+const RETENTION_MS = 30 * 24 * 60 * 60_000;
+const REFRESH_MS = 24 * 60 * 60_000;
+export class SessionPinStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        db.run(`CREATE TABLE IF NOT EXISTS routing_session_pins (
+      router_id TEXT NOT NULL,
+      pin_key TEXT NOT NULL,
+      model TEXT NOT NULL,
+      reasoning_effort TEXT NOT NULL,
+      updated_at INTEGER NOT NULL,
+      PRIMARY KEY (router_id, pin_key)
+    )`);
+        db.run("CREATE INDEX IF NOT EXISTS ix_routing_session_pins_updated_at ON routing_session_pins (updated_at)");
+    }
+    read(key, now = new Date()) {
+        const row = this.db
+            .query(`SELECT model, reasoning_effort, updated_at FROM routing_session_pins
+          WHERE router_id = ? AND pin_key = ? AND updated_at >= ?`)
+            .get(key.routerId, key.pinKey, now.getTime() - RETENTION_MS);
+        if (row === null)
+            return null;
+        if (row.updated_at < now.getTime() - REFRESH_MS) {
+            this.db
+                .query("UPDATE routing_session_pins SET updated_at = ? WHERE router_id = ? AND pin_key = ?")
+                .run(now.getTime(), key.routerId, key.pinKey);
+        }
+        return { model: row.model, reasoningEffort: row.reasoning_effort };
+    }
+    write(write, now = new Date()) {
+        this.db.transaction(() => {
+            this.db
+                .query(`INSERT INTO routing_session_pins (router_id, pin_key, model, reasoning_effort, updated_at)
+          VALUES (?, ?, ?, ?, ?)
+          ON CONFLICT (router_id, pin_key) DO UPDATE SET
+            model = excluded.model,
+            reasoning_effort = excluded.reasoning_effort,
+            updated_at = excluded.updated_at`)
+                .run(write.routerId, write.pinKey, write.model, write.reasoningEffort, now.getTime());
+            this.db.query("DELETE FROM routing_session_pins WHERE updated_at < ?").run(now.getTime() - RETENTION_MS);
+        })();
+    }
+}

package/dist/strategies/priority_selector.d.ts

@@ -1,7 +1,6 @@
 import type { SelectorBackend } from "./routing.js";
 /**
  * Serve the router's first eligible model/thinking-level pair, in the order
- * the router lists them. Provider failures still fall back to the next pair
- * when the router enables model fallback.
+ * the router lists them.
  */
 export declare function createPrioritySelectorBackend(): SelectorBackend;

package/dist/strategies/priority_selector.js

@@ -4,8 +4,7 @@ const PRIORITY_SELECTOR_MODEL = "dari-gateway/priority";
 const PRIORITY_CONTEXT_WINDOW_CHARS = 1_000_000;
 /**
  * Serve the router's first eligible model/thinking-level pair, in the order
- * the router lists them. Provider failures still fall back to the next pair
- * when the router enables model fallback.
+ * the router lists them.
  */
 export function createPrioritySelectorBackend() {
     return {

package/dist/strategies/route_decision.d.ts

@@ -4,7 +4,6 @@ import type { SelectorImage } from "./selector_projection.js";
 import type { ResolvedRouter } from "../types.js";
 export type RoutedDecision = {
     decision: RoutingDecision;
-    fallbackDecision?: RoutingDecision;
     run?: SelectorRun;
     details?: Record<string, unknown>;
 };

package/dist/strategies/route_decision.js

@@ -42,8 +42,6 @@ export async function routeDecision(args) {
             ? { customRules: custom.rules, defaultTarget: custom.defaultTarget }
             : {}),
         selectorBackend: args.selectorBackend,
-        modelFallbackEnabled: credentials.model_fallback_enabled !== false,
-        fallbackRequiresDifferentProvider: credentials.fallback_requires_different_provider !== false,
         executionProviderForModel: (model) => executionProviderForModel(credentials, model),
         imputeEvalScores: credentials.eval_score_imputation === true,
         leaseHistory: args.leaseHistory,
@@ -58,7 +56,6 @@ export async function routeDecision(args) {
     };
     return {
         decision: run.decision,
-        fallbackDecision: run.fallbackDecision,
         run,
         ...(Object.keys(details).length > 0 ? { details } : {}),
     };

package/dist/strategies/routing.d.ts

@@ -16,7 +16,6 @@ export type SelectorTrace = {
 };
 export type SelectorRun = SelectorTrace & {
     decision: RoutingDecision;
-    fallbackDecision?: RoutingDecision;
 };
 export type SelectModelArgs = {
     allCandidates?: RoutingCandidate[];
@@ -28,8 +27,6 @@ export type SelectModelArgs = {
     customRules?: CustomRouterRule[];
     defaultTarget?: CustomDefaultTarget | null;
     sessionId?: string;
-    modelFallbackEnabled?: boolean;
-    fallbackRequiresDifferentProvider?: boolean;
     executionProviderForModel?: (model: string) => string;
     imputeEvalScores?: boolean;
     imputationReferenceEvals?: RouterEval[];

package/dist/strategies/routing.js

@@ -6,7 +6,6 @@ import { internalChatCompletionsToInteraction } from "../protocol/input/chat_com
 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);
 }
@@ -52,8 +51,6 @@ export async function selectModel(args) {
         contextWindowChars,
         messages: selectorBackend.prepareMessages?.(safeMessages) ?? safeMessages,
         ...(leaseContextEnabled ? { leaseHistory: args.leaseHistory ?? [] } : {}),
-        modelFallbackEnabled: args.modelFallbackEnabled,
-        fallbackRequiresDifferentProvider: args.fallbackRequiresDifferentProvider,
         imputeEvalScores: args.imputeEvalScores,
         imputationReferenceEvals: args.imputationReferenceEvals,
     });
@@ -147,17 +144,7 @@ function validateSelectorRun(run, args) {
     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;
+    return run;
 }
 function requiredSelectorConfig(value, label) {
     const normalized = value.trim();

package/dist/telemetry/billing_finalization.d.ts

@@ -5,7 +5,7 @@ export type RoutingBillingProviderAttemptFacts = {
     provider: string;
     model: string;
     provider_key_source: ProviderKeySource;
-    role: "primary" | "fallback";
+    role: "primary";
     attempt: number;
     outcome: "completed" | "provider_failed" | "customer_canceled";
     provider_request_id: string | null;
@@ -54,7 +54,6 @@ export declare function routingBillingProviderAttemptFacts(args: {
     provider: string;
     model: string;
     providerKeySource: ProviderKeySource;
-    role: "primary" | "fallback";
     attempt: number;
     outcome: "completed" | "provider_failed" | "customer_canceled";
     providerMessage: Record<string, unknown> | null;

package/dist/telemetry/billing_finalization.js

@@ -62,7 +62,7 @@ export function routingBillingProviderAttemptFacts(args) {
         provider: args.provider,
         model: args.model,
         provider_key_source: args.providerKeySource,
-        role: args.role,
+        role: "primary",
         attempt: args.attempt,
         outcome: args.outcome,
         provider_request_id: providerRequestId(args.providerMessage),

package/dist/telemetry/prefix_state.d.ts

@@ -29,7 +29,6 @@ export declare function buildCompletedPrefixHit(args: {
 export declare function leaseCountdownForPrefix(args: {
     served: RoutingDecision | null;
     next: RoutingDecision | null;
-    fallbackServed?: boolean;
 }): number | null;
 export declare function reportPendingLease(args: {
     routerId: string;

package/dist/telemetry/prefix_state.js

@@ -41,12 +41,10 @@ export function buildCompletedPrefixHit(args) {
     };
 }
 export function leaseCountdownForPrefix(args) {
-    const granted = args.fallbackServed === true ? args.served : args.next ?? args.served;
+    const granted = args.next ?? args.served;
     const remaining = granted?.leaseTurnsRemaining;
     if (remaining === undefined || remaining === null)
         return null;
-    if (args.fallbackServed === true)
-        return remaining;
     const servedGrantedPair = args.next === null ||
         (args.served !== null &&
             args.served.selectedModel === args.next.selectedModel &&

package/dist/telemetry/report.d.ts

@@ -20,7 +20,6 @@ export declare class RequestReporter {
     private selectorOutputAccepted;
     private decision;
     private nextDecision;
-    private fallbackDecision;
     private providerAttempts;
     private billingProviderAttempts;
     private decisionDetails;
@@ -62,7 +61,6 @@ export declare class RequestReporter {
     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/telemetry/report.js

@@ -16,7 +16,7 @@ import { routingBillingProviderAttemptFacts, } from "./billing_finalization.js";
 import { estimateBenchmarkReplay } from "./benchmark_replay.js";
 import { extractInteractionObservability } from "./requests/interaction_observability.js";
 import { costString, finiteNumber, isRecord, tokenCount, } from "./ingest_values.js";
-import { buildCompletedPrefixHit, leaseCountdownForPrefix, prefixEntryForIngest, reportPendingLease, reportPrefixState, } from "./prefix_state.js";
+import { buildCompletedPrefixHit, leaseCountdownForPrefix, prefixEntryForIngest, reportPrefixState, } from "./prefix_state.js";
 import { subscriptionUsageLimitFromFailure } from "../providers/subscription_limits.js";
 import { scrubSecrets } from "./scrub.js";
 import { encodeRetainedInteractionRequest } from "./requests/retained_interaction_request.js";
@@ -50,7 +50,6 @@ export class RequestReporter {
     selectorOutputAccepted = false;
     decision = null;
     nextDecision = null;
-    fallbackDecision = null;
     providerAttempts = [];
     billingProviderAttempts = [];
     decisionDetails = {};
@@ -66,7 +65,6 @@ export class RequestReporter {
         this.selectorOutputAccepted = true;
         this.decision = run.decision;
         this.nextDecision = run.decision;
-        this.fallbackDecision = run.fallbackDecision ?? null;
     }
     attachSpeculativeSelectorRun(run, servingDecision) {
         this.selectorRun = run;
@@ -74,7 +72,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
     // decision drives selected-model attribution, prefix entries, and errors.
@@ -82,9 +79,6 @@ export class RequestReporter {
         this.decision = decision;
         this.nextDecision = decision;
     }
-    attachFallbackDecision(decision) {
-        this.fallbackDecision = decision ?? null;
-    }
     attachServingDecision(decision) {
         this.decision = decision;
     }
@@ -96,10 +90,10 @@ export class RequestReporter {
     modelCost(attempt) {
         return modelCost(attempt ? [...this.billingProviderAttempts, this.billingFacts(attempt)] : this.billingProviderAttempts);
     }
-    billingFacts({ execution, message, role, attempt, billingOutcome }) {
+    billingFacts({ execution, message, attempt, billingOutcome }) {
         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),
         });
@@ -224,16 +218,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);
@@ -292,7 +278,6 @@ export class RequestReporter {
                     leaseTurnsRemaining: leaseCountdownForPrefix({
                         served: decision ?? null,
                         next: this.nextDecision,
-                        fallbackServed,
                     }),
                     reason: this.nextDecision?.reason ?? decision?.reason ?? null,
                     chain: selectedChain,
@@ -324,19 +309,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,
@@ -404,12 +376,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 }
                         : {}),
@@ -466,8 +432,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/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { CustomRouterConfig, Provider, ReasoningEffort, RouterEval, RouterEvalScore, RouterModelPrice, RouterPrefixHit, RoutingStrategy } from "@mupt-ai/dari-router/policy-engine";
+import type { CustomRouterConfig, Provider, ReasoningEffort, RouterEval, RouterEvalScore, RouterModelPrice, RouterPrefixHit, RoutingDecision, RoutingStrategy } from "@mupt-ai/dari-router/policy-engine";
 export type ProviderKeySource = "user" | "managed" | "subscription";
 export type BearerProviderAuth = {
     type: "bearer";
@@ -41,6 +41,9 @@ export type PublicEvalCatalogCard = Omit<RouterEval, "scores"> & {
     updated_at: string | null;
     scores: PublicEvalCatalogScore[];
 };
+export type ServedDecision = RoutingDecision & {
+    sessionPinned?: boolean;
+};
 export type ClientHarness = "claude_code" | "muse_code";
 export type ResolvedRouterModelConfig = {
     provider: string;
@@ -74,11 +77,10 @@ export type ResolvedRouter = {
     zdr?: boolean;
     allow_long_context?: boolean;
     speculative_routing?: boolean;
+    session_pinning?: boolean;
     primary_retries?: number;
     strict?: boolean;
     strict_providers?: string[];
-    model_fallback_enabled?: boolean;
-    fallback_requires_different_provider?: boolean;
     evals?: RouterEval[];
     eval_score_imputation?: boolean;
     image_capability_filtering?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mupt-ai/dari-gateway",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Self-hostable LLM gateway for coding agents and APIs: one endpoint for Anthropic Messages, OpenAI Chat Completions, and OpenAI Responses, with subscription pooling, failover, and prompt-cache-aware routing.",
   "license": "Apache-2.0",
   "repository": {
@@ -50,7 +50,7 @@
   "dependencies": {
     "@aws-sdk/client-sts": "3.1063.0",
     "@mupt-ai/dari-router": "0.2.5",
-    "@mupt-ai/pi-ai": "1.4.0-mupt.1"
+    "@mupt-ai/pi-ai": "1.4.0-mupt.2"
   },
   "devDependencies": {
     "@types/bun": "^1.3.4",