@mupt-ai/dari-gateway 0.1.0 → 0.2.1

package/src/providers/pi_output.ts

@@ -1,9 +1,9 @@
 import { isRecord } from "@mupt-ai/dari-router/policy-engine";
 
-import { HttpError } from "../http/errors";
-import { providerToolCallIdentity, toolsByWireName } from "../interaction/tool_identity";
-import { isAnthropicEffort } from "../interaction/provider_continuation_state";
-import { isBedrockApi, isOpenAIResponsesApi } from "./model_capabilities";
+import { HttpError } from "../http/errors.js";
+import { providerToolCallIdentity, toolsByWireName } from "../interaction/tool_identity.js";
+import { isAnthropicEffort } from "../interaction/provider_continuation_state.js";
+import { isBedrockApi, isOpenAIResponsesApi } from "./model_capabilities.js";
 import type {
   InteractionItem,
   InteractionOutput,
@@ -13,7 +13,7 @@ import type {
   ProviderContinuationState,
   ProviderIdentity,
   ToolKind,
-} from "../interaction/types";
+} from "../interaction/types.js";
 
 export function piMessageToInteractionOutput(
   message: Record<string, unknown>,
@@ -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_attempt_runner.ts

@@ -1,4 +1,4 @@
-import { subscriptionUsageLimitFromFailure } from "./subscription_limits";
+import { subscriptionUsageLimitFromFailure } from "./subscription_limits.js";
 
 export type ProviderAttemptFailure =
   | {

package/src/providers/provider_call.ts

@@ -8,44 +8,46 @@ import {
   type RoutingDecision,
 } from "@mupt-ai/dari-router/policy-engine";
 
-import { executionProviderForModel, keySourceForModel } from "../models/execution_provider";
-import { HttpError } from "../http/errors";
-import type { InteractionRequest, ProviderIdentity } from "../interaction/types";
+import { executionProviderForModel, keySourceForModel } from "../models/execution_provider.js";
+import { HttpError } from "../http/errors.js";
+import type { RequestTags } from "../platform/platform.js";
+import type { InteractionRequest, ProviderIdentity } from "../interaction/types.js";
 import {
   CustomerDisconnectedError,
   createProviderAttemptAbort,
   type ProviderAttemptAbort,
-} from "../runtime/customer_disconnect";
+} from "../runtime/customer_disconnect.js";
 import {
   isProviderFailureMessage,
   providerFailureFromCaught,
   providerFailureFromEvent,
-} from "../runtime/provider_stream_outcome";
-import { providerAuthForSelectedModel } from "../strategies/routing";
-import { scrubSecretValues } from "../telemetry/scrub";
+} from "../runtime/provider_stream_outcome.js";
+import { providerAuthForSelectedModel } from "../strategies/routing.js";
+import { scrubSecretValues } from "../telemetry/scrub.js";
 import {
   usageContextFor,
   type RoutingUsageContext,
-} from "../telemetry/usage";
+} from "../telemetry/usage.js";
 import type {
   ProviderAuth,
   ProviderKeySource,
   ResolvedRouter,
   ResolvedRouterModelConfig,
-} from "../types";
-import { awsRoleCredentials } from "./aws_assume_role";
+} from "../types.js";
+import { awsRoleCredentials } from "./aws_assume_role.js";
 import {
   attachProviderResponseCapture,
   createProviderResponseCapture,
   type ProviderFetch,
   type ProviderResponseCapture,
-} from "./response_capture";
+} from "./response_capture.js";
 import {
   completeInteractionModel,
   streamInteractionModel,
+  type ProviderEndpoint,
   type ProviderEventStream,
-} from "./pi";
-import { promptTokenEstimateFor, type PromptTokenEstimate } from "./cancel_estimate";
+} from "./pi.js";
+import { promptTokenEstimateFor, type PromptTokenEstimate } from "./cancel_estimate.js";
 
 type ProviderCallConfig = {
   model: string;
@@ -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.js";
+import { providerFailureFromCaught } from "../runtime/provider_stream_outcome.js";
+import type { ProviderFetch } from "./response_capture.js";
+
+// Gateways bill per call and say what they billed: OpenRouter as `usage.cost`
+// on the final chunk, Vercel AI Gateway as `providerMetadata.gateway.cost`.
+// 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/reasoning.ts

@@ -1,6 +1,6 @@
 import type { ReasoningEffort } from "@mupt-ai/dari-router/policy-engine";
-import { HttpError } from "../http/errors";
-import type { InteractionRequest } from "../interaction/types";
+import { HttpError } from "../http/errors.js";
+import type { InteractionRequest } from "../interaction/types.js";
 
 type ReasoningRequest = Pick<InteractionRequest, "reasoning">;
 

package/src/providers/stream_finalization.ts

@@ -3,32 +3,32 @@ import type {
   RoutingDecision,
 } from "@mupt-ai/dari-router/policy-engine";
 
-import type { InteractionRequest, ProviderIdentity } from "../interaction/types";
+import type { InteractionRequest, ProviderIdentity } from "../interaction/types.js";
 import {
   captureOperationalError,
   type OperationalErrorCode,
-} from "../observability/errors";
-import type { ProviderStreamOutcome } from "../runtime/provider_stream_outcome";
-import type { RoutedProtocol } from "../runtime/routed_protocol";
+} from "../observability/errors.js";
+import type { ProviderStreamOutcome } from "../runtime/provider_stream_outcome.js";
+import type { RoutedProtocol } from "../runtime/routed_protocol.js";
 import {
   reportedExecution,
   type FrozenProviderTerminal,
   type ProviderAttemptRecord,
   type ReportableProviderOutcome,
   type RoutedRuntimeReporter,
-} from "../runtime/runtime_reporter";
-import type { ProviderKeySource } from "../types";
+} from "../runtime/runtime_reporter.js";
+import type { ProviderKeySource } from "../types.js";
 import {
   reportRoutingUsage,
   type RoutingUsageContext,
-} from "../telemetry/usage";
-import { customerCanceledProviderMessage } from "../runtime/customer_disconnect";
+} from "../telemetry/usage.js";
+import { customerCanceledProviderMessage } from "../runtime/customer_disconnect.js";
 import {
   estimatedCancelUsage,
   partialInteractionOutput,
   type DeliveredOutput,
   type PromptTokenEstimate,
-} from "./cancel_estimate";
+} from "./cancel_estimate.js";
 
 // Structurally a subset of ProviderExecution. The narrowing is deliberate: it
 // keeps apiKey and auth out of the finalizer.
@@ -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/providers/subscription_limits.ts

@@ -1,8 +1,8 @@
 import { isRecord } from "@mupt-ai/dari-router/policy-engine";
 
-import { providerFailureMessage } from "../runtime/provider_stream_outcome";
-import type { ProviderKeySource } from "../types";
-import type { CapturedProviderResponse } from "./response_capture";
+import { providerFailureMessage } from "../runtime/provider_stream_outcome.js";
+import type { ProviderKeySource } from "../types.js";
+import type { CapturedProviderResponse } from "./response_capture.js";
 
 export type SubscriptionOAuthProvider = "anthropic_claude_code" | "openai_codex";
 

package/src/runtime/claude_code/auxiliary_routing.ts

@@ -4,11 +4,11 @@ import {
   type RoutingDecision,
 } from "@mupt-ai/dari-router/policy-engine";
 
-import type { RoutedDecision } from "../../strategies/route_decision";
-import { isBackgroundRequest } from "../../interaction/types";
-import { HttpError } from "../../http/errors";
-import { assertCreditAvailableBeforeRouting } from "../../telemetry/usage";
-import type { PreparedRoutedCompletion } from "../prepare_routed_completion";
+import type { RoutedDecision } from "../../strategies/route_decision.js";
+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.

package/src/runtime/customer_disconnect.ts

@@ -1,4 +1,4 @@
-import { HttpError } from "../http/errors";
+import { HttpError } from "../http/errors.js";
 
 const CUSTOMER_DISCONNECTED_MESSAGE = "Client disconnected.";
 

package/src/runtime/explicit_model.ts

@@ -1,9 +1,9 @@
 import type { RoutingCandidate, RoutingDecision } from "@mupt-ai/dari-router/policy-engine";
 
-import { HttpError } from "../http/errors";
-import { explicitModelId } from "../protocol/input/router_model";
-import type { RoutedDecision } from "../strategies/route_decision";
-import type { PreparedRoutedCompletion } from "./prepare_routed_completion";
+import { HttpError } from "../http/errors.js";
+import { explicitModelId } from "../protocol/input/router_model.js";
+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
@@ -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/harness_identity/conversation.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 
-import type { SourceProtocol } from "../../interaction/types";
+import type { SourceProtocol } from "../../interaction/types.js";
 
 export type HarnessConversationIdentity =
   | {

package/src/runtime/harness_identity/extract.ts

@@ -1,12 +1,12 @@
 import { isRecord } from "@mupt-ai/dari-router/policy-engine";
 
-import { HttpError } from "../../http/errors";
+import { HttpError } from "../../http/errors.js";
 import type {
   AgentRequestClass,
   AgentRequestContext,
   InteractionRequestPurpose,
-} from "../../interaction/types";
-import type { HarnessConversationIdentity } from "./conversation";
+} from "../../interaction/types.js";
+import type { HarnessConversationIdentity } from "./conversation.js";
 
 const MAX_ID_CHARS = 200;
 

package/src/runtime/harness_identity/index.ts

@@ -3,7 +3,7 @@ export {
   scopedHarnessSessionId,
   type HarnessConversationIdentity,
   type HarnessConversationScope,
-} from "./conversation";
+} from "./conversation.js";
 export {
   chatCompletionsConversationIdentity,
   claudeCodeConversationIdentity,
@@ -11,4 +11,4 @@ export {
   codexRequestPurpose,
   codexRequestContext,
   openCodeRequestContext,
-} from "./extract";
+} from "./extract.js";

package/src/runtime/prepare_routed_completion.ts

@@ -1,24 +1,27 @@
 import type { CandidatePruningAudit } from "@mupt-ai/dari-router/policy-engine";
 
-import { interactionConversationPrefix } from "../context/interaction_fingerprint";
+import { interactionConversationPrefix } from "../context/interaction_fingerprint.js";
 import {
   buildRoutingContext,
   derivePrefixLookupHashes,
   type ImageCapabilityPrunedModel,
   type RoutingContext,
-} from "../context/routing_context";
-import { isBackgroundRequest, type InteractionRequest } from "../interaction/types";
-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 { RoutedRuntimeReporter } from "./runtime_reporter";
-import type { RoutedProtocol } from "./routed_protocol";
+} from "../context/routing_context.js";
+import { isBackgroundRequest, type InteractionRequest } from "../interaction/types.js";
+import { executionProviderForModel } from "../models/execution_provider.js";
+import { gatewayPlatform, type RequestTags } from "../platform/platform.js";
+import { resolveRouter } from "../strategies/routing.js";
+import { RequestReporter, type ReportedCandidatePruning } from "../telemetry/report.js";
+import { RoutingBillingFinalization } from "../telemetry/billing_finalization.js";
+import type { ClientHarness, ProviderCredential, ResolvedRouter } from "../types.js";
+import { requestTags } from "./request_tags.js";
+import type { RoutedRuntimeReporter } from "./runtime_reporter.js";
+import type { RoutedProtocol } from "./routed_protocol.js";
 import {
   scopedHarnessConversationId,
   scopedHarnessSessionId,
   type HarnessConversationIdentity,
-} from "./harness_identity";
+} from "./harness_identity/index.js";
 
 export type PreparedRoutedCompletion = {
   requestId: string;
@@ -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/provider_stream_lifecycle.ts

@@ -1,4 +1,4 @@
-import type { ProviderStreamOutcome } from "./provider_stream_outcome";
+import type { ProviderStreamOutcome } from "./provider_stream_outcome.js";
 
 type LifecycleArgs = {
   partialResponse: () => Record<string, unknown>;

package/src/runtime/provider_stream_outcome.ts

@@ -1,6 +1,6 @@
 import { isRecord } from "@mupt-ai/dari-router/policy-engine";
-import type { InteractionOutput } from "../interaction/types";
-import { scrubSecrets } from "../telemetry/scrub";
+import type { InteractionOutput } from "../interaction/types.js";
+import { scrubSecrets } from "../telemetry/scrub.js";
 
 export type ProviderStreamOutcome =
   | {

package/src/runtime/request_tags.ts

@@ -0,0 +1,34 @@
+import { HttpError } from "../http/errors.js";
+import type { RequestTags } from "../platform/platform.js";
+
+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");
+}