@mupt-ai/dari-gateway 0.1.0 → 0.2.0

package/src/providers/pi_output.ts

@@ -465,6 +465,7 @@ function interactionUsage(value: unknown, source: ProviderIdentity): Interaction
         ? calculatedTotalCost
         : finiteNumber(cost.total) ?? calculatedTotalCost,
     },
+    ...(usage.costSource === "provider" ? { costSource: "provider" as const } : {}),
   };
 }
 

package/src/providers/provider_call.ts

@@ -10,6 +10,7 @@ import {
 
 import { executionProviderForModel, keySourceForModel } from "../models/execution_provider";
 import { HttpError } from "../http/errors";
+import type { RequestTags } from "../platform/platform";
 import type { InteractionRequest, ProviderIdentity } from "../interaction/types";
 import {
   CustomerDisconnectedError,
@@ -43,6 +44,7 @@ import {
 import {
   completeInteractionModel,
   streamInteractionModel,
+  type ProviderEndpoint,
   type ProviderEventStream,
 } from "./pi";
 import { promptTokenEstimateFor, type PromptTokenEstimate } from "./cancel_estimate";
@@ -57,6 +59,8 @@ type ProviderCallConfig = {
   sessionId: string;
   reasoningEffort: ReasoningEffort;
   promptEstimate: PromptTokenEstimate | undefined;
+  // A platform-supplied endpoint replacing the model's configured one.
+  endpoint?: ProviderEndpoint;
 };
 
 export type ProviderExecution = ProviderCallConfig & {
@@ -101,6 +105,7 @@ export function prepareProviderExecution(args: {
   conversationId: string;
   promptCacheKey?: string;
   costEstimates?: readonly CandidateCostEstimate[];
+  tags?: RequestTags;
 }): ProviderExecution {
   const model = args.decision.selectedModel;
   const promptEstimate = promptTokenEstimateFor(args.costEstimates, model, args.decision.reasoningEffort);
@@ -109,11 +114,19 @@ export function prepareProviderExecution(args: {
     throw new HttpError(400, "The prompt exceeds this model's standard-price context range. Shorten or compact the conversation.", "context_length_exceeded");
   }
   const provider = executionProviderForModel(args.credentials, model);
-  const providerKeySource = keySourceForModel(args.credentials, model);
-  const auth = providerAuthForSelectedModel({
-    selectedModel: model,
-    credentials: args.credentials,
-  });
+  const supplied = args.credentials.provider_credentials?.[model];
+  const providerKeySource = supplied ? "user" : keySourceForModel(args.credentials, model);
+  if (args.credentials.strict === true && providerKeySource === "subscription") {
+    throw new HttpError(
+      400,
+      `Strict routers do not serve '${model}' from a personal subscription.`,
+      "strict_subscription_refused",
+      "model",
+    );
+  }
+  const auth: ProviderAuth = supplied
+    ? { type: "bearer", apiKey: supplied.apiKey.trim() }
+    : providerAuthForSelectedModel({ selectedModel: model, credentials: args.credentials });
   return {
     model,
     apiKey: auth.type === "bearer" ? auth.apiKey : "",
@@ -130,6 +143,9 @@ export function prepareProviderExecution(args: {
       : args.conversationId,
     reasoningEffort: args.decision.reasoningEffort,
     promptEstimate,
+    ...(supplied?.baseUrl || supplied?.headers
+      ? { endpoint: { baseUrl: supplied.baseUrl, headers: supplied.headers } }
+      : {}),
     provider,
     providerKeySource,
     ...(providerKeySource === "subscription" && args.credentials.attributed_user_id
@@ -144,6 +160,7 @@ export function prepareProviderExecution(args: {
       routerId: args.routerId,
       selectedModel: model,
       keySource: providerKeySource,
+      tags: args.tags ?? {},
     }),
     headers: {
       "X-Dari-Selected-Model": model,
@@ -212,6 +229,7 @@ export async function startProviderStream(args: {
       config: args.execution.config,
       sessionId: args.execution.sessionId,
       selectedReasoningEffort: args.execution.reasoningEffort,
+      endpoint: args.execution.endpoint,
       signal: customerAbort.signal,
       fetch: responseCapture?.fetch,
     });
@@ -306,6 +324,7 @@ async function completeProvider(args: {
     config: args.execution.config,
     sessionId: args.execution.sessionId,
     selectedReasoningEffort: args.execution.reasoningEffort,
+    endpoint: args.execution.endpoint,
     signal: args.signal,
     fetch: args.fetch,
   });

package/src/providers/provider_reported_cost.ts

@@ -0,0 +1,138 @@
+import { isRecord } from "@mupt-ai/dari-router/policy-engine";
+
+import { gatewayFor } from "../models/gateways";
+import { providerFailureFromCaught } from "../runtime/provider_stream_outcome";
+import type { ProviderFetch } from "./response_capture";
+
+// Gateways bill per call and say what they billed: OpenRouter as `usage.cost`
+// on the final chunk, 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: Record<string, unknown>): boolean {
+  return gatewayFor(model.provider) !== undefined;
+}
+
+export type ProviderReportedCostTap = {
+  fetch: ProviderFetch;
+  cost: () => number | undefined;
+};
+
+export function providerReportedCostTap(
+  fetch: ProviderFetch = globalThis.fetch,
+): ProviderReportedCostTap {
+  let cost: number | undefined;
+  return {
+    cost: () => cost,
+    fetch: async (input, init) => {
+      const response = await fetch(input, init);
+      if (!response.ok || response.body === null) return response;
+      cost = undefined;
+      return new Response(
+        response.body.pipeThrough(costScanner((value) => {
+          cost = value;
+        })),
+        { status: response.status, statusText: response.statusText, headers: response.headers },
+      );
+    },
+  };
+}
+
+export function messageWithProviderReportedCost(
+  message: Record<string, unknown>,
+  cost: number | undefined,
+): Record<string, unknown> {
+  if (cost === undefined) return message;
+  // A thrown error (or other record without a stop reason) becomes a failure
+  // message first: spreading an Error drops its non-enumerable `message`, and
+  // failure handling keeps usage only on messages that stopped in error.
+  const base = message.stopReason === undefined
+    ? { ...providerFailureFromCaught(message), ...(isRecord(message.usage) ? { usage: message.usage } : {}) }
+    : message;
+  const usage = isRecord(base.usage) ? base.usage : {};
+  return {
+    ...base,
+    usage: {
+      ...usage,
+      cost: { ...(isRecord(usage.cost) ? usage.cost : {}), total: cost },
+      costSource: "provider",
+    },
+  };
+}
+
+// Aborted and failed calls end in an error event carrying the partial
+// message; it keeps whatever cost the provider reported before the end.
+export async function* eventsWithProviderReportedCost(
+  events: AsyncIterable<Record<string, unknown>>,
+  tap: ProviderReportedCostTap,
+): AsyncIterable<Record<string, unknown>> {
+  for await (const event of events) {
+    if (event.type === "done" && isRecord(event.message)) {
+      yield { ...event, message: messageWithProviderReportedCost(event.message, tap.cost()) };
+      continue;
+    }
+    if (event.type === "error" && isRecord(event.error)) {
+      yield { ...event, error: messageWithProviderReportedCost(event.error, tap.cost()) };
+      continue;
+    }
+    yield event;
+  }
+}
+
+export function reportedCost(body: unknown): number | undefined {
+  if (!isRecord(body)) return undefined;
+  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);
+}
+
+function usd(value: unknown): number | undefined {
+  const amount = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  return typeof amount === "number" && Number.isFinite(amount) && amount >= 0 ? amount : undefined;
+}
+
+// Reads SSE `data:` lines and plain JSON bodies alike; the last reported
+// amount wins.
+function costScanner(onCost: (cost: number) => void): TransformStream<Uint8Array, Uint8Array> {
+  const decoder = new TextDecoder();
+  let pending = "";
+  let body = "";
+  let sse = false;
+  const scan = (line: string) => {
+    if (!line.startsWith("data:") || !line.includes("cost")) return;
+    try {
+      const cost = reportedCost(JSON.parse(line.slice("data:".length)));
+      if (cost !== undefined) onCost(cost);
+    } catch {
+      // Not JSON: [DONE] or a keep-alive.
+    }
+  };
+  return new TransformStream({
+    transform(chunk, controller) {
+      controller.enqueue(chunk);
+      const text = decoder.decode(chunk, { stream: true });
+      pending += text;
+      const lines = pending.split("\n");
+      pending = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trimEnd();
+        if (trimmed.startsWith("data:")) sse = true;
+        scan(trimmed);
+      }
+      if (!sse && body.length < 1024 * 1024) body += text;
+    },
+    flush() {
+      const tail = decoder.decode();
+      scan((pending + tail).trimEnd());
+      body += tail;
+      if (sse || !body.includes("cost")) return;
+      try {
+        const cost = reportedCost(JSON.parse(body));
+        if (cost !== undefined) onCost(cost);
+      } catch {
+        // Not a JSON body.
+      }
+    },
+  });
+}

package/src/providers/stream_finalization.ts

@@ -138,7 +138,7 @@ async function reportTerminalOnce(
       ? args.reportBarrier
       : Promise.race([
           args.reportBarrier,
-          Bun.sleep(args.cancelBarrierCapMs ?? CANCEL_REPORT_BARRIER_CAP_MS),
+          new Promise((resolve) => setTimeout(resolve, args.cancelBarrierCapMs ?? CANCEL_REPORT_BARRIER_CAP_MS)),
         ]));
   } catch (error) {
     capture(error, "routing_report_barrier_failed");

package/src/runtime/explicit_model.ts

@@ -57,3 +57,30 @@ function pickCandidate(
   }
   return candidates[0]!;
 }
+
+/* A strict router serves only the pinned `dari/model/<id>` at exactly the
+   requested thinking level (the model's default when none is sent), and
+   refuses everything else instead of substituting. */
+export function strictModelDecision(prepared: PreparedRoutedCompletion): RoutedDecision {
+  const modelId = explicitModelId(prepared.interaction.model);
+  if (modelId === null) {
+    throw new HttpError(
+      400,
+      "This router is strict: request a pinned model as 'dari/model/<id>'.",
+      "strict_model_required",
+      "model",
+    );
+  }
+  const { decision } = explicitModelDecision(prepared)!;
+  const requested = prepared.interaction.reasoning?.effort
+    ?? prepared.credentials.model_configs?.[modelId]?.default_thinking_level;
+  if (requested !== undefined && requested !== null && decision.reasoningEffort !== requested) {
+    throw new HttpError(
+      400,
+      `Model '${modelId}' cannot serve thinking level '${requested}' on this router.`,
+      "thinking_level_unavailable",
+      "reasoning_effort",
+    );
+  }
+  return { decision };
+}

package/src/runtime/prepare_routed_completion.ts

@@ -8,10 +8,13 @@ import {
   type RoutingContext,
 } from "../context/routing_context";
 import { isBackgroundRequest, type InteractionRequest } from "../interaction/types";
+import { executionProviderForModel } from "../models/execution_provider";
+import { gatewayPlatform, type RequestTags } from "../platform/platform";
 import { resolveRouter } from "../strategies/routing";
 import { RequestReporter, type ReportedCandidatePruning } from "../telemetry/report";
 import { RoutingBillingFinalization } from "../telemetry/billing_finalization";
-import type { ClientHarness, ResolvedRouter } from "../types";
+import type { ClientHarness, ProviderCredential, ResolvedRouter } from "../types";
+import { requestTags } from "./request_tags";
 import type { RoutedRuntimeReporter } from "./runtime_reporter";
 import type { RoutedProtocol } from "./routed_protocol";
 import {
@@ -28,6 +31,7 @@ export type PreparedRoutedCompletion = {
   protocol: RoutedProtocol;
   credentials: ResolvedRouter;
   billable: boolean;
+  tags: RequestTags;
   harnessConversationIdentity?: HarnessConversationIdentity;
   routing: RoutingContext;
   reporter: RoutedRuntimeReporter;
@@ -42,9 +46,11 @@ export async function prepareRoutedCompletion(args: {
   startedMs: number;
   requestId: string;
   clientRequestId: string | null;
+  tagsHeader: string | null;
   clientHarness?: ClientHarness;
   harnessConversationIdentity?: HarnessConversationIdentity;
 }): Promise<PreparedRoutedCompletion> {
+  const tags = requestTags(args.tagsHeader);
   // Eval relevance draws from the public catalog, which resolve only returns
   // on request.
   const resolveRequest = {
@@ -119,6 +125,7 @@ export async function prepareRoutedCompletion(args: {
     }
     credentials = conversationCredentials;
   }
+  credentials = await withProviderCredentials(credentials, args.apiKey);
   const billable = true;
   const routing = await buildRoutingContext({
     routerId: prefixFingerprintRouterId,
@@ -131,6 +138,7 @@ export async function prepareRoutedCompletion(args: {
   const reporter = new RequestReporter({
     requestId: args.requestId,
     clientRequestId: args.clientRequestId,
+    tags,
     credentials,
     routerId: canonicalRouterId,
     interaction: args.interaction,
@@ -168,12 +176,40 @@ export async function prepareRoutedCompletion(args: {
     protocol: args.protocol,
     credentials,
     billable,
+    tags,
     harnessConversationIdentity: args.harnessConversationIdentity,
     routing,
     reporter,
   };
 }
 
+// Ask the platform for each enabled model's credential up front, so provider
+// execution and fallback stay synchronous.
+async function withProviderCredentials(
+  credentials: ResolvedRouter,
+  apiKey: string,
+): Promise<ResolvedRouter> {
+  const platform = gatewayPlatform();
+  if (platform.resolveProviderCredential === undefined) return credentials;
+  const resolved = await Promise.all(
+    credentials.enabled_models.map(async (model) => [
+      model,
+      await platform.resolveProviderCredential!({
+        provider: executionProviderForModel(credentials, model),
+        model,
+        routerId: credentials.router_id,
+        organizationId: credentials.organization_id,
+        apiKey,
+      }),
+    ] as const),
+  );
+  const provider_credentials: Record<string, ProviderCredential> = {};
+  for (const [model, credential] of resolved) {
+    if (credential?.apiKey.trim()) provider_credentials[model] = credential;
+  }
+  return { ...credentials, provider_credentials };
+}
+
 // Core's cache-aware pruning audit, extended with the context layer's image
 // capability exclusions. The exclusions survive on their own when custom
 // routing produced no core audit (missing config), so the error path keeps

package/src/runtime/request_tags.ts

@@ -0,0 +1,34 @@
+import { HttpError } from "../http/errors";
+import type { RequestTags } from "../platform/platform";
+
+const TAGS_MAX_CHARS = 2048;
+const TAGS_MAX_COUNT = 32;
+const TAG_KEY = /^[A-Za-z0-9_.:-]{1,64}$/;
+const TAG_VALUE_MAX_CHARS = 256;
+
+/**
+ * Parse `X-Dari-Tags: run=r1,trial=3,setting=low` into attribution labels for
+ * the platform's request and usage records. Malformed or oversized headers
+ * are refused rather than silently dropped, so cost is never misattributed.
+ */
+export function requestTags(header: string | null): RequestTags {
+  const tags: RequestTags = {};
+  if (header === null || header.trim() === "") return tags;
+  if (header.length > TAGS_MAX_CHARS) throw invalidTags(`X-Dari-Tags exceeds ${TAGS_MAX_CHARS} characters.`);
+  const pairs = header.split(",");
+  if (pairs.length > TAGS_MAX_COUNT) throw invalidTags(`X-Dari-Tags has more than ${TAGS_MAX_COUNT} tags.`);
+  for (const pair of pairs) {
+    const separator = pair.indexOf("=");
+    const key = pair.slice(0, separator).trim();
+    const value = pair.slice(separator + 1).trim();
+    if (separator < 0 || !TAG_KEY.test(key) || value.length > TAG_VALUE_MAX_CHARS) {
+      throw invalidTags("X-Dari-Tags must be comma-separated key=value pairs.");
+    }
+    tags[key] = value;
+  }
+  return tags;
+}
+
+function invalidTags(message: string): HttpError {
+  return new HttpError(400, message, "invalid_tags");
+}

package/src/runtime/routed_completion.ts

@@ -37,6 +37,7 @@ export async function handleRoutedCompletion(args: {
     startedMs,
     requestId,
     clientRequestId,
+    tagsHeader: args.request.headers.get("x-dari-tags"),
     clientHarness: args.clientHarness,
     harnessConversationIdentity: args.harnessConversationIdentity,
   }).catch((error: unknown) => ({ error }));
@@ -56,6 +57,7 @@ export async function handleRoutedCompletion(args: {
     // Only auto-selection needs the plan: an explicitly requested model and
     // background work are served without the selector.
     const selects =
+      prepared.credentials.strict !== true &&
       explicitModelId(prepared.interaction.model) === null &&
       !isBackgroundRequest(prepared.interaction) &&
       routerSelectsModels(prepared.credentials);

package/src/runtime/routed_runtime.ts

@@ -36,7 +36,7 @@ import { scrubSecrets } from "../telemetry/scrub";
 import type { ResolvedRouter } from "../types";
 import type { PreparedRoutedCompletion } from "./prepare_routed_completion";
 import { auxiliaryDecision } from "./claude_code/auxiliary_routing.js";
-import { explicitModelDecision } from "./explicit_model.js";
+import { explicitModelDecision, strictModelDecision } from "./explicit_model.js";
 import {
   clearPendingLease,
   committedLeaseDecision,
@@ -238,6 +238,7 @@ async function prepareExplicitRoutedCompletion(
     protocol: inProcessProtocol,
     credentials: args.credentials,
     billable: args.billable ?? false,
+    tags: {},
     harnessConversationIdentity: undefined,
     routing,
     reporter: args.reporter ?? createExperimentRoutedRuntimeReporter(),
@@ -252,6 +253,21 @@ async function prepareRuntimeExecution(args: {
 }): Promise<RuntimeExecutionPlan> {
   const { prepared } = args;
 
+  // A strict router never selects, leases, or falls back: the pinned pair or
+  // an error.
+  if (prepared.credentials.strict === true) {
+    const pinned = strictModelDecision(prepared);
+    prepared.reporter.attachServingDecision(pinned.decision);
+    prepared.reporter.attachDecisionDetails({
+      decision_source: "strict_model",
+      explicit_model: {
+        model: pinned.decision.selectedModel,
+        reasoning_effort: pinned.decision.reasoningEffort,
+      },
+    });
+    return selectedExecutionPlan(prepared, pinned);
+  }
+
   // A requested `dari/model/<id>` is served as chosen, before any lease.
   const explicit = args.requireSelectorDecision ? null : explicitModelDecision(prepared);
   if (explicit) {
@@ -621,6 +637,7 @@ function providerExecution(
     conversationId: prepared.routing.conversationId,
     costEstimates: prepared.routing.reportingCostEstimates,
     promptCacheKey: prepared.interaction.promptCacheKey,
+    tags: prepared.tags,
   });
 }
 

package/src/self_host/main.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { chmodSync, existsSync } from "node:fs";
 import { Database } from "bun:sqlite";
-import { getEnvApiKey } from "@mupt-ai/pi-ai/compat";
+import { builtinModels } from "@mupt-ai/pi-ai/providers/all";
 
 import { bearerToken } from "../http/auth";
 import { errorResponse, HttpError } from "../http/errors";
@@ -45,13 +45,18 @@ export async function startSelfHostedGateway(env: Record<string, string> = proce
   db.exec("PRAGMA journal_mode = WAL");
   const subscriptions = new SubscriptionStore(db);
   const prefixes = new PrefixStore(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 platform = createSelfHostedPlatform({
     config,
     gatewayKeys,
     subscriptions,
     prefixes,
-    providerApiKey: (provider) => getEnvApiKey(provider, env),
+    providerApiKey: async (provider) => (await piModels.getAuth(provider))?.auth.apiKey,
     env,
     fetch,
   });

package/src/self_host/resolve.ts

@@ -41,7 +41,7 @@ export type SelfHostedResolverDeps = {
     conversationId?: string;
   }) => RouterPrefixHit[];
   // The provider's API key from its standard environment variable.
-  providerApiKey: (provider: string) => string | undefined;
+  providerApiKey: (provider: string) => Promise<string | undefined>;
   env: Record<string, string | undefined>;
   fetch: OAuthFetch;
 };
@@ -92,7 +92,7 @@ export async function resolveSelfHostedRouter(
     if (subscription !== null && deps.subscriptions.list(subscription).length > 0) {
       exhausted.add(subscription);
     }
-    const apiKey = providerApiKey(deps, provider);
+    const apiKey = await providerApiKey(deps, provider);
     credentials.set(provider, apiKey ? { key: apiKey, source: "user" } : null);
   }
 
@@ -137,7 +137,7 @@ export async function resolveSelfHostedRouter(
     }
   }
   for (const model of models) {
-    const price = await registeredModelPrice(model.id);
+    const price = registeredModelPrice(model.id);
     if (price !== null) resolved.model_prices![model.id] = price;
     const provider = providerForModel(model.id);
     const endpoint = deps.config.providers[provider];
@@ -158,9 +158,9 @@ export async function resolveSelfHostedRouter(
 
 // Configured endpoints read their own key variable, or send a placeholder
 // when they take none; known providers use their standard variable.
-function providerApiKey(deps: SelfHostedResolverDeps, provider: string): string | undefined {
+async function providerApiKey(deps: SelfHostedResolverDeps, provider: string): Promise<string | undefined> {
   const endpoint = deps.config.providers[provider];
-  if (endpoint === undefined) return deps.providerApiKey(provider)?.trim() || undefined;
+  if (endpoint === undefined) return (await deps.providerApiKey(provider))?.trim() || undefined;
   if (endpoint.apiKeyEnv === undefined) return "no-key";
   return deps.env[endpoint.apiKeyEnv]?.trim() || undefined;
 }

package/src/strategies/routing.ts

@@ -188,7 +188,7 @@ export async function selectModel(
 }
 
 async function selectorContextWindowChars(selectorModel: string): Promise<number> {
-  const contextWindow = await modelContextWindow(selectorModel);
+  const contextWindow = modelContextWindow(selectorModel);
   if (contextWindow === null) {
     throw new HttpError(
       500,

package/src/telemetry/report.ts

@@ -25,7 +25,7 @@ import {
   type ProviderIdentity,
 } from "../interaction/types";
 import { captureOperationalError } from "../observability/errors";
-import { gatewayPlatform } from "../platform/platform";
+import { gatewayPlatform, type RequestTags } from "../platform/platform";
 import type {
   ProviderAttemptRecord,
   ProviderAttemptReport,
@@ -161,6 +161,7 @@ export class RequestReporter {
     private readonly args: {
       requestId: string;
       clientRequestId: string | null;
+      tags: RequestTags;
       credentials: ResolvedRouter;
       routerId: string;
       interaction: InteractionRequest;
@@ -428,6 +429,9 @@ export class RequestReporter {
           : null
       );
       const pricingKnown = selectedModel ? this.pricingKnown(selectedModel) : null;
+      const costSource = usage?.costSource === "provider"
+        ? "provider"
+        : pricingKnown === true ? "pricing" : null;
       const observability = extractInteractionObservability(a.interaction);
       const inputTokens = tokenCount(usage?.input) ?? 0;
       const retainedClientRequest = encodeRetainedInteractionRequest(
@@ -676,10 +680,10 @@ export class RequestReporter {
           cache_write_tokens: tokenCount(usage?.cacheWrite),
           output_tokens: tokenCount(usage?.output),
           total_tokens: tokenCount(usage?.totalTokens),
-          total_cost_usd:
-            pricingKnown === true && isRecord(usage?.cost)
-              ? finiteNumber(usage.cost.total)
-              : null,
+          total_cost_usd: costSource === null || !isRecord(usage?.cost)
+            ? null
+            : finiteNumber(usage.cost.total),
+          cost_source: costSource,
           pricing_known: pricingKnown,
         },
         distinctId:
@@ -690,6 +694,7 @@ export class RequestReporter {
         isNewConversation: a.isNewConversation,
         zdr: a.zdr,
         harnessConversationIdentity: a.harnessConversationIdentity,
+        tags: a.tags,
       });
     } catch (error) {
       console.error("routing report assembly failed", error);

package/src/telemetry/usage.ts

@@ -4,7 +4,7 @@ import { randomUUID } from "node:crypto";
 import { HttpError } from "../http/errors";
 import { executionProviderForModel, keySourceForModel } from "../models/execution_provider";
 import { captureOperationalError } from "../observability/errors";
-import { gatewayPlatform } from "../platform/platform";
+import { gatewayPlatform, type RequestTags } from "../platform/platform";
 import type { ProviderKeySource, ResolvedRouter } from "../types";
 
 export type RoutingUsageContext = {
@@ -12,6 +12,7 @@ export type RoutingUsageContext = {
   routerId: string;
   provider: Provider;
   model: string;
+  tags: RequestTags;
   startedAt: Date;
 };
 
@@ -75,6 +76,7 @@ export function usageContextFor(args: {
   routerId: string;
   selectedModel: string;
   keySource: ProviderKeySource;
+  tags: RequestTags;
 }): RoutingUsageContext | undefined {
   if (!args.billable || args.keySource !== "managed") return undefined;
   if (args.credentials.credit_exhausted) throw creditExhaustedError();
@@ -83,6 +85,7 @@ export function usageContextFor(args: {
     routerId: args.routerId,
     provider: executionProviderForModel(args.credentials, args.selectedModel),
     model: args.selectedModel,
+    tags: args.tags,
     startedAt: new Date(),
   };
 }
@@ -143,6 +146,7 @@ function usagePayload(context: RoutingUsageContext, message: Record<string, unkn
     total_cost_usd: usd(cost.total) ?? "0",
     started_at: context.startedAt.toISOString(),
     ended_at: new Date().toISOString(),
+    tags: context.tags,
   };
 }
 

package/src/types.ts

@@ -42,6 +42,14 @@ export type AwsAssumeRoleProviderAuth = {
 // Authentication a provider call can use directly.
 export type ResolvedProviderAuth = BearerProviderAuth | AwsSigV4ProviderAuth;
 
+// A bearer credential an embedding platform supplies for one request through
+// GatewayPlatform.resolveProviderCredential, optionally with its own endpoint.
+export type ProviderCredential = {
+  apiKey: string;
+  baseUrl?: string;
+  headers?: Record<string, string>;
+};
+
 export type ProviderAuth = ResolvedProviderAuth | AwsAssumeRoleProviderAuth;
 
 export type AwsProviderAuth = AwsSigV4ProviderAuth | AwsAssumeRoleProviderAuth;
@@ -93,12 +101,19 @@ export type ResolvedRouter = {
   provider_keys: Partial<Record<Provider, string>>;
   provider_auth?: Partial<Record<Provider, AwsProviderAuth>>;
   provider_key_sources?: Partial<Record<Provider, ProviderKeySource>>;
+  // Model -> the platform-supplied credential that replaces the provider key
+  // above for this request. Filled from resolveProviderCredential.
+  provider_credentials?: Record<string, ProviderCredential>;
   // Execution provider -> the user's subscription credential serving it.
   subscription_credential_ids?: Partial<Record<Provider, string>>;
   zdr?: boolean;
   allow_long_context?: boolean;
   speculative_routing?: boolean;
   primary_retries?: number;
+  // Serve only the requested `dari/model/<id>` at the requested thinking
+  // level: no selector, lease, fallback, or personal subscription, and an
+  // error for anything else, whatever the client sends.
+  strict?: boolean;
   model_fallback_enabled?: boolean;
   fallback_requires_different_provider?: boolean;
   evals?: RouterEval[];