@mupt-ai/dari-gateway 0.3.1 → 0.3.2

package/src/http/auth.ts

@@ -6,7 +6,7 @@ export function bearerToken(headers: Headers): string {
   const value = headers.get("authorization") ?? "";
   const [scheme, token] = value.split(/\s+/, 2);
   if (scheme?.toLowerCase() !== "bearer" || !token) {
-    throw new HttpError(401, "Missing or invalid routing API key.", "authentication_error");
+    throw new HttpError(401, "Missing or invalid API key.", "authentication_error");
   }
   return publicRoutingToken(token);
 }
@@ -16,7 +16,7 @@ export function anthropicToken(headers: Headers): string {
   if (authorization) return bearerToken(headers);
   const apiKey = headers.get("x-api-key");
   if (!apiKey) {
-    throw new HttpError(401, "Missing or invalid routing API key.", "authentication_error");
+    throw new HttpError(401, "Missing or invalid API key.", "authentication_error");
   }
   return publicRoutingToken(apiKey);
 }

package/src/http/http2_server.ts

@@ -23,7 +23,11 @@ const HTTP2_FORBIDDEN_RESPONSE_HEADERS = new Set([
   "upgrade",
 ]);
 
-export function startHttp2Server(port: number, handler: Http2RequestHandler): Http2RoutingServer {
+export function startHttp2Server(
+  port: number,
+  handler: Http2RequestHandler,
+  hostname = "0.0.0.0",
+): Http2RoutingServer {
   const sessions = new Set<ServerHttp2Session>();
   let closePromise: Promise<void> | undefined;
   const server = createServer((request, response) => {
@@ -33,10 +37,10 @@ export function startHttp2Server(port: number, handler: Http2RequestHandler): Ht
     sessions.add(session);
     session.once("close", () => sessions.delete(session));
   });
-  server.listen(port, "0.0.0.0");
+  server.listen(port, hostname);
   const address = server.address();
   if (address === null || typeof address === "string") {
-    throw new Error("HTTP/2 routing server did not bind to a TCP port.");
+    throw new Error("HTTP/2 gateway server did not bind to a TCP port.");
   }
   return {
     port: address.port,

package/src/http/serve.ts

@@ -16,10 +16,10 @@ type StoppableServer = {
 export function startServer(
   listenPort: number,
   handler: (request: Request) => Promise<Response>,
-  options: { http2?: boolean } = {},
+  options: { http2?: boolean; hostname?: string } = {},
 ) {
   if (options.http2) {
-    return startHttp2Server(listenPort, handler);
+    return startHttp2Server(listenPort, handler, options.hostname);
   }
 
   // The selector runs before the first response byte, and routed models can
@@ -27,6 +27,7 @@ export function startServer(
   // clients and infrastructure still bound total request lifetime.
   return Bun.serve({
     port: listenPort,
+    hostname: options.hostname,
     fetch: handler,
     idleTimeout: 0,
   });
@@ -45,7 +46,7 @@ export function installShutdownHandlers(
     if (shuttingDown) return;
     shuttingDown = true;
     const workDeadlineAtMs = performance.now() + SHUTDOWN_WORK_TIMEOUT_MS;
-    console.info("routing server shutting down", JSON.stringify({ signal }));
+    console.info("gateway server shutting down", JSON.stringify({ signal }));
     try {
       await stopServerForShutdown(server);
     } finally {
@@ -54,7 +55,7 @@ export function installShutdownHandlers(
       );
       if (remaining > 0) {
         console.warn(
-          "routing server background drain timed out",
+          "gateway server background drain timed out",
           JSON.stringify({ remaining_task_count: remaining }),
         );
         captureOperationalError(
@@ -112,7 +113,7 @@ function stopWithin(
 
 function reportServerStopFailure(error: unknown): void {
   console.warn(
-    "routing server shutdown failed",
+    "gateway server shutdown failed",
     error instanceof Error ? error.name : "UnknownError",
   );
   captureOperationalError(error, { code: "server_force_stop_failed" });

package/src/ingress/chat_completions.ts

@@ -9,6 +9,7 @@ import type { SelectorBackend } from "../strategies/routing.js";
 import {
   chatCompletionsConversationIdentity,
   openCodeRequestContext,
+  piRequestContext,
 } from "../runtime/harness_identity/index.js";
 import { parseJsonRequest } from "./json.js";
 import { museCodeClientId } from "./muse_code.js";
@@ -22,7 +23,7 @@ export async function handleChatCompletions(
     const apiKey = bearerToken(request.headers);
     const payload = await parseJsonRequest<ChatCompletionRequest>(request);
     const interaction = chatCompletionsToInteraction({ ...payload, source_protocol: "openai_chat" });
-    const agentContext = openCodeRequestContext(request.headers);
+    const agentContext = piRequestContext(request.headers) ?? openCodeRequestContext(request.headers);
     const museClientId = museCodeClientId(request.headers);
     return await handleRoutedCompletion({
       request,

package/src/ingress/codex.ts

@@ -1,3 +1,4 @@
+import { explicitModelId } from "../protocol/input/router_model.js";
 import { bearerToken } from "../http/auth.js";
 import { errorResponse } from "../http/errors.js";
 import { captureRequestError } from "../observability/errors.js";
@@ -40,7 +41,9 @@ export async function handleResponses(
     // providers. That preference describes a direct model, not a heterogeneous
     // router, so let Dari select the reasoning effort for verified Codex turns.
     // Parsing above still validates malformed Responses reasoning controls.
-    if (harnessConversationIdentity !== undefined) payload.reasoning = undefined;
+    if (harnessConversationIdentity !== undefined && explicitModelId(payload.model) === null) {
+      payload.reasoning = undefined;
+    }
     return await handleRoutedCompletion({
       request,
       routerId,

package/src/ingress/codex_models.ts

@@ -32,6 +32,8 @@ type CodexCatalogEntry = {
   contextWindow: number;
   hostedWebSearch: boolean;
   imageInput: boolean;
+  reasoningLevels?: string[];
+  defaultReasoningLevel?: string | null;
 };
 
 function codexCatalogEntry(args: CodexCatalogEntry): Record<string, unknown> {
@@ -39,8 +41,11 @@ function codexCatalogEntry(args: CodexCatalogEntry): Record<string, unknown> {
     slug: args.slug,
     display_name: args.displayName,
     description: args.description,
-    default_reasoning_level: null,
-    supported_reasoning_levels: [],
+    default_reasoning_level: args.defaultReasoningLevel ?? null,
+    supported_reasoning_levels: (args.reasoningLevels ?? []).map((effort) => ({
+      effort,
+      description: `${effort} thinking`,
+    })),
     shell_type: "shell_command",
     visibility: "list",
     supported_in_api: true,
@@ -80,15 +85,17 @@ function codexCatalogEntry(args: CodexCatalogEntry): Record<string, unknown> {
   };
 }
 
-/* `dari/routing` stays first (the Codex launcher patches it); each enabled
-   model follows as `dari/model/<id>` so Codex's /model menu can switch to it. */
+/* `dari/routing` comes first while the router may autoroute (the Codex
+   launcher patches it); each enabled model follows as `dari/model/<id>` so
+   Codex's /model menu can switch to it. The `dari` launchers build every
+   agent's model menu from this list. */
 export function codexModelsResponse(
-  router: Pick<ResolvedRouter, "enabled_models" | "model_configs" | "allow_long_context">,
+  router: Pick<ResolvedRouter, "enabled_models" | "model_configs" | "allow_long_context" | "autorouting_enabled">,
   imageInputFor: (model: string) => boolean
 ): Record<string, unknown> {
   return {
     models: [
-      codexCatalogEntry({
+      ...(router.autorouting_enabled === false ? [] : [codexCatalogEntry({
         slug: CANONICAL_ROUTER_MODEL,
         displayName: "Dari Routing",
         description: "Routes Codex HTTP Responses requests through the configured Dari model router.",
@@ -96,7 +103,7 @@ export function codexModelsResponse(
         contextWindow: codexRouterContextWindow(router),
         hostedWebSearch: codexRouterSupportsHostedWebSearch(router),
         imageInput: router.enabled_models.some(imageInputFor),
-      }),
+      })]),
       ...router.enabled_models.map((model, index) =>
         codexCatalogEntry({
           slug: explicitModelSlug(model),
@@ -106,6 +113,10 @@ export function codexModelsResponse(
           contextWindow: codexRouterContextWindow({ ...router, enabled_models: [model] }),
           hostedWebSearch: codexRouterSupportsHostedWebSearch({ ...router, enabled_models: [model] }),
           imageInput: imageInputFor(model),
+          reasoningLevels: router.model_configs?.[model]?.supported_thinking_levels
+            ?.map((effort) => effort === "off" ? "none" : effort),
+          defaultReasoningLevel: router.model_configs?.[model]?.default_thinking_level === "off"
+            ? "none" : router.model_configs?.[model]?.default_thinking_level,
         })
       ),
     ],

package/src/platform/platform.ts

@@ -45,6 +45,10 @@ export type GatewayPlatform = {
   writePrefixState(write: PrefixStateWrite): Promise<void>;
   /** Set or clear a conversation's prefetched routing lease. */
   writePendingLease(write: PendingLeaseWrite): Promise<void>;
+  /** The pair a session pinned on a session-pinning router, or null. */
+  readSessionPin(request: SessionPinKey): Promise<SessionPin | null>;
+  /** Pin a session to a pair, replacing any earlier pin. */
+  writeSessionPin(write: SessionPinKey & SessionPin): Promise<void>;
   /**
    * Hold an exhausted personal subscription until it resets. Resolves whether
    * another connected subscription for the same provider can serve a retry.
@@ -104,6 +108,17 @@ export type PendingLeaseWrite = {
   } | null;
 };
 
+// A main agent and each of its subagents have their own pin key.
+export type SessionPinKey = {
+  routerId: string;
+  pinKey: string;
+};
+
+export type SessionPin = {
+  model: string;
+  reasoningEffort: ReasoningEffort;
+};
+
 export type SubscriptionHold = {
   userId: string;
   credentialId: string | undefined;
@@ -146,8 +161,6 @@ export type RequestSummary = {
   selected_reasoning_effort: ReasoningEffort | null;
   next_model: string | null;
   next_reasoning_effort: ReasoningEffort | null;
-  fallback_model: string | null;
-  fallback_reasoning_effort: ReasoningEffort | null;
   provider_key_source: ProviderKeySource | null;
   message_count: number;
   tool_count: number;
@@ -184,6 +197,7 @@ export type OperationalErrorCode =
   | "routing_report_assembly_failed"
   | "routing_report_barrier_failed"
   | "server_force_stop_failed"
+  | "session_pin_write_failed"
   | "stream_report_finalization_failed"
   | "subscription_unavailable_ingest_failed";
 

package/src/protocol/input/openai_responses.ts

@@ -572,15 +572,8 @@ function reasoningControls(value: unknown): InteractionRequest["reasoning"] {
   if (value === undefined || value === null) return undefined;
   if (!isRecord(value)) throw new HttpError(400, "reasoning must be an object.", "invalid_request_error", "reasoning");
   const normalizedEffort = normalizedReasoningEffort(value.effort, "reasoning.effort");
-  const summary = value.summary;
-  if (summary !== undefined) {
-    throw new HttpError(
-      400,
-      "reasoning.summary is not supported by this router MVP.",
-      "invalid_request_error",
-      "reasoning.summary"
-    );
-  }
+  // Summaries are display-only: clients such as Muse Code ask for them by
+  // default, and the router serves the turn without them.
   return normalizedEffort === undefined ? undefined : { effort: normalizedEffort };
 }
 

package/src/protocol/output/anthropic_messages_output.ts

@@ -2,7 +2,7 @@ import { parseDataImageUrl } from "../../interaction/image.js";
 import { encodeProviderContinuationState } from "../../interaction/provider_continuation_state.js";
 import { encodePortableReasoningState } from "../../interaction/portable_reasoning_state.js";
 import type { InteractionOutput } from "../../interaction/types.js";
-import type { RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
+import type { ServedDecision } from "../../types.js";
 
 export function anthropicMessageId(requestId: string): string {
   return `msg_${requestId.replace(/[^A-Za-z0-9_-]/g, "_")}`.slice(0, 64);
@@ -99,7 +99,7 @@ export function anthropicUsage(output: Pick<InteractionOutput, "usage">): Record
 }
 
 export function anthropicRouting(
-  decision: RoutingDecision,
+  decision: ServedDecision,
   requestId: string,
   conversationId?: string
 ): Record<string, unknown> {
@@ -113,6 +113,7 @@ export function anthropicRouting(
     ...(decision.leaseTurnsRemaining === undefined
       ? {}
       : { lease_turns_remaining: decision.leaseTurnsRemaining }),
+    ...(decision.sessionPinned === true ? { session_pinned: true } : {}),
   };
 }
 

package/src/protocol/output/openai_responses_stream.ts

@@ -6,7 +6,7 @@ import {
   openAIResponsesTerminal,
   openAIResponsesUsage,
 } from "./openai_responses_output.js";
-import { piMessageToInteractionOutput } from "../../providers/pi_output.js";
+import { piMessageToInteractionOutput, textSignature } from "../../providers/pi_output.js";
 import type {
   InteractionOutput,
   InteractionOutputItem,
@@ -119,6 +119,7 @@ class ResponsesAccumulator {
   private readonly addedIndexes = new Set<number>();
   private readonly completedIndexes = new Set<number>();
   private readonly messageIds = new Map<number, string>();
+  private readonly messagePhases = new Map<number, "commentary" | "final_answer">();
   private readonly reasoningIds = new Map<number, string>();
   private readonly messagePartStarted = new Set<number>();
   private readonly reasoningPartStarted = new Set<number>();
@@ -144,6 +145,7 @@ class ResponsesAccumulator {
       const index = this.indexFor(event);
       this.activate(index, send);
       if (type === "thinking_start") this.ensureReasoning(index, send);
+      if (type === "text_start") this.rememberMessageSignature(event, index);
       return;
     }
     if (type === "text_delta" && typeof event.delta === "string" && event.delta) {
@@ -330,17 +332,29 @@ class ResponsesAccumulator {
     return openAIResponsesUsage(this.finalOutput ?? this.baseOutput());
   }
 
+  // Pi signs a Responses text block with its message id and phase at
+  // text_start, so the item is announced with the phase it ends with.
+  private rememberMessageSignature(event: Record<string, unknown>, index: number): void {
+    const content = isRecord(event.partial) ? event.partial.content : undefined;
+    const block = Array.isArray(content) ? content[event.contentIndex as number] : undefined;
+    const signature = isRecord(block) ? textSignature(block.textSignature) : null;
+    if (signature?.id && !this.messageIds.has(index)) this.messageIds.set(index, signature.id);
+    if (signature?.phase) this.messagePhases.set(index, signature.phase);
+  }
+
   private ensureMessage(index: number, send: Send): Extract<InteractionOutputItem, { type: "message" }> {
     const existing = this.items.get(index);
     if (existing?.type === "message") return existing;
     const id = this.messageIds.get(index) ?? streamedItemId("msg", this.responseId, index);
     this.messageIds.set(index, id);
+    const phase = this.messagePhases.get(index);
     const message: Extract<InteractionOutputItem, { type: "message" }> = {
       type: "message",
       id,
       role: "assistant",
       content: [{ type: "text", text: "" }],
       contentShape: "parts",
+      ...(phase ? { phase } : {}),
       source: this.args.source,
     };
     this.items.set(index, message);
@@ -353,6 +367,7 @@ class ResponsesAccumulator {
         id,
         status: "in_progress",
         content: [],
+        ...(phase ? { phase } : {}),
       },
     });
     this.sendMessagePartAdded(index, id, send);
@@ -420,6 +435,7 @@ class ResponsesAccumulator {
             id: serialized.id,
             status: "in_progress",
             content: [],
+            ...(item.phase ? { phase: item.phase } : {}),
           },
         });
       } else {

package/src/providers/execution.ts

@@ -58,11 +58,8 @@ import {
 export type ProviderChoice = {
   decision: RoutingDecision;
   execution: ProviderExecution;
-  role: "primary" | "fallback";
 };
 
-export type ResolveFallbackChoice = () => Promise<ProviderChoice | null>;
-
 export type PreparedStreamExecution = {
   choice: ProviderChoice;
   started: StartedStream;
@@ -86,7 +83,6 @@ export async function executeNonStreaming(args: {
   interaction: InteractionRequest;
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: ResolveFallbackChoice;
   reporter: RoutedRuntimeReporter;
   protocol: RoutedProtocol;
   startedCompletion?: StartedCompletion;
@@ -111,7 +107,6 @@ export async function completeNonStreaming(args: {
   interaction: InteractionRequest;
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: ResolveFallbackChoice;
   reporter: RoutedRuntimeReporter;
   protocol: RoutedProtocol;
   startedCompletion?: StartedCompletion;
@@ -157,7 +152,7 @@ export async function completeNonStreaming(args: {
       output,
       modelCost: args.reporter.modelCost({
         model: choice.decision.selectedModel, reasoning_effort: choice.decision.reasoningEffort,
-        role: choice.role, attempt: result.attempt, outcome: "completed", billingOutcome: "completed",
+        attempt: result.attempt, outcome: "completed", billingOutcome: "completed",
         execution: reportedExecution(choice.execution), message: completion.message,
       }),
       request: args.interaction,
@@ -231,7 +226,6 @@ async function completeWithRetries(args: {
   interaction: InteractionRequest;
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: ResolveFallbackChoice;
   reporter: RoutedRuntimeReporter;
   startedCompletion?: StartedCompletion;
   clientSignal?: AbortSignal;
@@ -239,7 +233,6 @@ async function completeWithRetries(args: {
   return runProviderAttemptPlan({
     primary: args.primary,
     retries: args.primaryRetries,
-    resolveFallback: args.resolveFallback,
     primaryInitial: args.startedCompletion,
     isCustomerCanceled: () => customerAbortRequested(args.clientSignal),
     canceledFailure: customerCanceledProviderMessage,
@@ -459,7 +452,6 @@ export async function prepareStreamingExecution(args: {
   interaction: InteractionRequest;
   primary: ProviderChoice;
   primaryRetries: number;
-  resolveFallback: ResolveFallbackChoice;
   reporter: RoutedRuntimeReporter;
   startedStream?: StartedStream;
   initialError?: unknown;
@@ -475,7 +467,6 @@ export async function prepareStreamingExecution(args: {
   const result = await runProviderAttemptPlan({
     primary: args.primary,
     retries: args.primaryRetries,
-    resolveFallback: args.resolveFallback,
     primaryInitial,
     isCustomerCanceled: () => customerAbortRequested(args.clientSignal),
     canceledFailure: customerCanceledProviderMessage,
@@ -537,7 +528,7 @@ async function runStreamSetupAttempt(args: {
           clientSignal: args.clientSignal,
         });
     // Prime before committing so connection failures and prompt rejections
-    // stay inside the one shared retry/fallback state machine.
+    // stay inside the one shared retry state machine.
     const primed = await primeProviderStream(
       started.providerStream.events,
       started.customerAbort,
@@ -611,7 +602,6 @@ export async function executeStreaming(args: {
     protocol: args.protocol,
     providerLatencyMs: () =>
       args.failedSetupLatencyMs + Date.now() - started.providerStartedMs,
-    role: args.choice.role,
     attempt: args.attempt,
     reportBarrier: args.reportBarrier,
     delivered: observed.delivered,
@@ -630,7 +620,7 @@ export async function executeStreaming(args: {
       clientSignal: args.clientSignal,
       modelCost: (message, failed) => args.reporter.modelCost({
         model: args.choice.decision.selectedModel, reasoning_effort: args.choice.decision.reasoningEffort,
-        role: args.choice.role, attempt: args.attempt,
+        attempt: args.attempt,
         outcome: failed ? "terminal_error" : "completed",
         billingOutcome: failed ? "provider_failed" : "completed",
         execution: reportedExecution(execution), message,
@@ -673,7 +663,6 @@ function recordProviderAttempt(
   reporter.recordProviderAttempt({
     model: choice.decision.selectedModel,
     reasoning_effort: choice.decision.reasoningEffort,
-    role: choice.role,
     attempt,
     outcome,
     execution: reportedExecution(choice.execution),
@@ -720,7 +709,8 @@ async function providerFailedAttempt(
   }
   // Retrying an exhausted plan cannot succeed. The platform learns about it
   // before this request returns so the next resolve already serves the
-  // user's next subscription, or the router's subscription fallback model.
+  // user's next subscription, or the model's API credential when the router
+  // allows subscription API fallback for it.
   const switched = execution.subscriptionUserId !== undefined
     && await holdSubscription({
       userId: execution.subscriptionUserId,

package/src/providers/pi_output.ts

@@ -411,7 +411,7 @@ function reasoningText(value: unknown, type: "summary_text" | "reasoning_text"):
   );
 }
 
-function textSignature(value: unknown): { id?: string; phase?: "commentary" | "final_answer" } | null {
+export function textSignature(value: unknown): { id?: string; phase?: "commentary" | "final_answer" } | null {
   if (typeof value !== "string" || !value) return null;
   try {
     const parsed: unknown = JSON.parse(value);

package/src/providers/provider_attempt_runner.ts

@@ -31,7 +31,6 @@ export type ProviderAttemptPlanResult<TChoice, TValue> = {
 type RunProviderAttemptPlanArgs<TChoice, TValue, TInitial> = {
   primary: TChoice;
   retries: number;
-  resolveFallback: () => Promise<TChoice | null>;
   primaryInitial?: TInitial;
   isCustomerCanceled: (choice: TChoice) => boolean;
   canceledFailure: () => Record<string, unknown>;
@@ -51,8 +50,8 @@ type ChoiceResult<TChoice, TValue> = ProviderAttemptPlanResult<TChoice, TValue>;
 
 /**
  * Owns the order-sensitive provider plan shared by completion and stream setup:
- * retries within one choice, cancellation fences around asynchronous fallback
- * resolution, and one contiguous attempt record for every failed dispatch.
+ * retries within the choice, cancellation fences between attempts, and one
+ * contiguous attempt record for every failed dispatch.
  */
 export async function runProviderAttemptPlan<TChoice, TValue, TInitial>(
   args: RunProviderAttemptPlanArgs<TChoice, TValue, TInitial>,
@@ -62,29 +61,19 @@ export async function runProviderAttemptPlan<TChoice, TValue, TInitial>(
   }
   const primary = await runChoice(args, args.primary, args.primaryInitial);
   if (primary.kind !== "provider_failed") return primary;
-  // The user's next subscription serves a retry of this same choice, which
-  // beats a fallback model billed elsewhere.
+  // The user's next subscription serves the client's retry of this choice, so
+  // the failure stands even if the client has already gone.
   if (subscriptionUsageLimitFromFailure(primary.failure)?.switched === true) return primary;
-  // A disconnect before or during fallback resolution stays attributed to the
-  // primary: it is the only choice that was dispatched, and a resolved but
-  // undispatched fallback must not appear as the serving model.
-  const canceledAfterPrimary = () =>
-    syntheticCancellation(args, {
+  // A client that disconnected while the plan settled is a cancellation,
+  // attributed to the only choice that was dispatched.
+  if (args.isCustomerCanceled(args.primary)) {
+    return syntheticCancellation(args, {
       choice: args.primary,
       attempt: primary.attempt + 1,
       latencyMs: primary.latencyMs,
     });
-  if (args.isCustomerCanceled(args.primary)) return canceledAfterPrimary();
-
-  const fallback = await args.resolveFallback();
-  if (args.isCustomerCanceled(args.primary)) return canceledAfterPrimary();
-  if (fallback === null) return primary;
-
-  const fallbackResult = await runChoice(args, fallback, undefined);
-  return {
-    ...fallbackResult,
-    latencyMs: primary.latencyMs + fallbackResult.latencyMs,
-  };
+  }
+  return primary;
 }
 
 async function runChoice<TChoice, TValue, TInitial>(

package/src/providers/provider_call.ts

@@ -33,6 +33,7 @@ import type {
   ProviderKeySource,
   ResolvedRouter,
   ResolvedRouterModelConfig,
+  ServedDecision,
 } from "../types.js";
 import { awsRoleCredentials } from "./aws_assume_role.js";
 import {
@@ -97,7 +98,7 @@ export type StartedStream = {
 };
 
 export function prepareProviderExecution(args: {
-  decision: RoutingDecision;
+  decision: ServedDecision;
   credentials: ResolvedRouter;
   billable: boolean;
   routerId: string;
@@ -174,6 +175,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/src/providers/stream_finalization.ts

@@ -50,7 +50,6 @@ type CreateStreamFinalizerArgs = {
   reporter: RoutedRuntimeReporter;
   protocol: RoutedProtocol;
   providerLatencyMs: () => number;
-  role: "primary" | "fallback";
   attempt: number;
   reportBarrier?: Promise<unknown>;
   delivered: () => DeliveredOutput;
@@ -171,7 +170,6 @@ function buildStreamTerminalReport(
   const attemptBase = {
     model: args.decision.selectedModel,
     reasoning_effort: args.decision.reasoningEffort,
-    role: args.role,
     attempt: args.attempt,
     execution,
   } as const;

package/src/providers/subscription_limits.ts

@@ -11,7 +11,7 @@ export type SubscriptionUsageLimit = {
   resetsAt: Date;
   reason: string;
   // The platform made the user's next subscription active, so a retry
-  // succeeds without any fallback.
+  // succeeds on it.
   switched?: boolean;
 };
 

package/src/runtime/claude_code/auxiliary_routing.ts

@@ -9,7 +9,6 @@ import { isBackgroundRequest } from "../../interaction/types.js";
 import { HttpError } from "../../http/errors.js";
 import { assertCreditAvailableBeforeRouting } from "../../telemetry/usage.js";
 import type { PreparedRoutedCompletion } from "../prepare_routed_completion.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.
@@ -30,13 +29,7 @@ export function auxiliaryDecision(
     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

package/src/runtime/explicit_model.ts

@@ -6,7 +6,7 @@ import type { RoutedDecision } from "../strategies/route_decision.js";
 import type { PreparedRoutedCompletion } from "./prepare_routed_completion.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(

package/src/runtime/harness_identity/conversation.ts

@@ -46,6 +46,17 @@ export function scopedHarnessSessionId(args: {
   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: {
+  identity: HarnessConversationIdentity;
+  sourceProtocol: SourceProtocol;
+  scope: HarnessConversationScope;
+}): string {
+  return scopedHarnessId(args);
+}
+
 export function scopedHarnessConversationId(args: {
   identity: HarnessConversationIdentity;
   sourceProtocol: SourceProtocol;