@mupt-ai/dari-gateway 0.3.3 → 0.3.4

package/src/interaction/document.ts

@@ -0,0 +1,8 @@
+const PDF_DATA_URL_PREFIX = "data:application/pdf;base64,";
+
+/** The base64 payload of a PDF data URL, or undefined for anything else. */
+export function parsePdfDataUrl(url: string): string | undefined {
+  if (!url.startsWith(PDF_DATA_URL_PREFIX)) return undefined;
+  const data = url.slice(PDF_DATA_URL_PREFIX.length);
+  return data.length > 0 ? data : undefined;
+}

package/src/interaction/types.ts

@@ -53,12 +53,19 @@ export type InteractionImage = {
   detail?: "auto" | "low" | "high" | "original";
 };
 
+/** A base64-encoded PDF. Only Anthropic Messages targets accept documents. */
+export type InteractionDocument = {
+  type: "document";
+  mimeType: "application/pdf";
+  data: string;
+};
+
 export type InteractionToolReference = {
   type: "tool_reference";
   toolName: string;
 };
 
-export type InteractionContent = InteractionText | InteractionImage | InteractionToolReference;
+export type InteractionContent = InteractionText | InteractionImage | InteractionDocument | InteractionToolReference;
 
 export type InteractionMessage = {
   type: "message";

package/src/observability/errors.ts

@@ -1,3 +1,4 @@
+import { HttpError } from "../http/errors.js";
 import {
   gatewayPlatform,
   type OperationalErrorContext,
@@ -10,9 +11,29 @@ export function captureRequestError(
   error: unknown,
   context: RequestErrorContext,
 ): void {
+  logUnsupportedInput(error, context);
   gatewayPlatform().captureRequestError(error, context);
 }
 
+/* Platforms report only 5xx, so a client sending a block the gateway cannot
+   carry would otherwise be invisible. Log the code and parameter path, never
+   request content. */
+function logUnsupportedInput(error: unknown, context: RequestErrorContext): void {
+  if (!(error instanceof HttpError) || error.status >= 500) return;
+  if (!error.code.startsWith("unsupported_") && !error.code.startsWith("no_")) return;
+  console.warn(
+    "routing request unsupported input",
+    JSON.stringify({
+      router_id: context.routerId,
+      request_id: context.requestId ?? null,
+      source_protocol: context.sourceProtocol,
+      error_code: error.code,
+      param: error.param ?? null,
+      message: error.message,
+    }),
+  );
+}
+
 /**
  * Report failures deliberately caught outside the ingress exception path,
  * including work after a response has started and process shutdown.

package/src/platform/platform.ts

@@ -138,6 +138,28 @@ export type RequestRecord = {
   harnessConversationIdentity?: HarnessConversationIdentity;
   // Parsed from the request's X-Dari-Tags header; empty when absent.
   tags: RequestTags;
+  // The router's non-secret routing settings, for embedders that compare or
+  // replay routing decisions.
+  router: RequestRecordRouter;
+  // The model and reasoning pairs this request could be routed to, after
+  // capability, custom-rule, and cost pruning.
+  candidates: Array<{ model: string; reasoningEffort: ReasoningEffort }>;
+  // The session pin key this request routed under, when the router pins
+  // sessions and the request was pinnable (not strict, explicit, or
+  // background). Each harness subagent has its own key.
+  sessionPinKey?: string;
+};
+
+export type RequestRecordRouter = {
+  enabledModels: string[];
+  // Each enabled model's selectable reasoning levels: the router's
+  // configured levels, else the model's supported levels.
+  thinkingLevels: Record<string, ReasoningEffort[]>;
+  // The level a requested dari/model/<id> uses when the request sets none.
+  defaultThinkingLevels: Record<string, ReasoningEffort>;
+  strict: boolean;
+  speculativeRouting: boolean;
+  sessionPinning: boolean;
 };
 
 // Caller-supplied attribution labels (run, trial, setting), opaque to the

package/src/protocol/input/anthropic_messages.ts

@@ -9,6 +9,7 @@ import { explicitModelId, isAnthropicRouterModel, unsupportedModelMessage } from
 import type {
   ClientTool,
   InteractionContent,
+  InteractionDocument,
   InteractionItem,
   InteractionRequest,
   InteractionResponseFormat,
@@ -134,6 +135,16 @@ function appendAnthropicMessage(
       buffered.push(anthropicImage(rawBlock.source, `${param}.source`));
       continue;
     }
+    if (type === "document") {
+      if (role !== "user") throw invalidRequest("Anthropic document blocks are only supported on user messages.", param);
+      buffered.push(...anthropicDocument(rawBlock, param));
+      continue;
+    }
+    if (type === "search_result") {
+      if (role !== "user") throw invalidRequest("Anthropic search_result blocks are only supported on user messages.", param);
+      buffered.push(anthropicSearchResult(rawBlock, param));
+      continue;
+    }
     if (type === "thinking" || type === "redacted_thinking") {
       if (role !== "assistant") throw invalidRequest(`${type} blocks require the assistant role.`, param);
       flushMessage();
@@ -240,6 +251,63 @@ function appendAnthropicMessage(
   flushMessage();
 }
 
+/* PDFs stay native documents; they route only to models that read PDFs.
+   Text and content documents become ordinary parts so every model can read
+   them. Title and context travel as a leading text part. Citations are not
+   requested from the provider, so the citations setting is dropped. */
+function anthropicDocument(block: Record<string, unknown>, param: string): InteractionContent[] {
+  const source = block.source;
+  const sourceParam = `${param}.source`;
+  if (!isRecord(source)) throw invalidRequest(`${sourceParam} must be an object.`, sourceParam);
+  const header = [optionalString(block.title, `${param}.title`), optionalString(block.context, `${param}.context`)]
+    .filter((line): line is string => line !== undefined && line.length > 0)
+    .join("\n");
+  const withHeader = (body: InteractionContent[]): InteractionContent[] =>
+    header ? [{ type: "text", text: `Document: ${header}` }, ...body] : body;
+  const type = requiredString(source.type, `${sourceParam}.type`);
+  if (type === "base64") {
+    const mediaType = requiredString(source.media_type, `${sourceParam}.media_type`);
+    if (mediaType !== "application/pdf") {
+      throw new HttpError(400, "Base64 document sources must be application/pdf.", "unsupported_document_source", `${sourceParam}.media_type`);
+    }
+    const document: InteractionDocument = { type: "document", mimeType: "application/pdf", data: requiredString(source.data, `${sourceParam}.data`) };
+    return withHeader([document]);
+  }
+  if (type === "text") {
+    return withHeader([{ type: "text", text: requiredStringAllowEmpty(source.data, `${sourceParam}.data`) }]);
+  }
+  if (type === "content") {
+    if (typeof source.content === "string") return withHeader([{ type: "text", text: source.content }]);
+    if (!Array.isArray(source.content)) throw invalidRequest(`${sourceParam}.content must be a string or an array.`, `${sourceParam}.content`);
+    return withHeader(source.content.map((part, index): InteractionContent => {
+      const partParam = `${sourceParam}.content.${index}`;
+      if (!isRecord(part)) throw invalidRequest(`${partParam} must be an object.`, partParam);
+      if (part.type === "text") return { type: "text", text: requiredStringAllowEmpty(part.text, `${partParam}.text`) };
+      if (part.type === "image") return anthropicImage(part.source, `${partParam}.source`);
+      throw new HttpError(400, `Document content block type '${String(part.type ?? "unknown")}' is not supported.`, "unsupported_content_block", partParam);
+    }));
+  }
+  throw new HttpError(
+    400,
+    `Anthropic document source type '${type}' is not supported; use a base64 PDF, text, or content source.`,
+    "unsupported_document_source",
+    `${sourceParam}.type`
+  );
+}
+
+// Search results are text with provenance; they reach every model as text.
+function anthropicSearchResult(block: Record<string, unknown>, param: string): InteractionContent {
+  const title = requiredStringAllowEmpty(block.title, `${param}.title`);
+  const source = requiredStringAllowEmpty(block.source, `${param}.source`);
+  if (!Array.isArray(block.content)) throw invalidRequest(`${param}.content must be an array.`, `${param}.content`);
+  const body = block.content.map((part, index) => {
+    const partParam = `${param}.content.${index}`;
+    if (!isRecord(part) || part.type !== "text") throw invalidRequest(`${partParam} must be a text block.`, partParam);
+    return requiredStringAllowEmpty(part.text, `${partParam}.text`);
+  });
+  return { type: "text", text: [`Search result: ${title}`, `Source: ${source}`, "", ...body].join("\n") };
+}
+
 function anthropicImage(value: unknown, param: string): InteractionContent {
   if (!isRecord(value)) throw invalidRequest(`${param} must be an object.`, param);
   const type = requiredString(value.type, `${param}.type`);
@@ -306,13 +374,15 @@ function anthropicToolResultContent(
   if (typeof value === "string") return { output: value, shape: "string" };
   if (!Array.isArray(value)) throw invalidRequest(`${param} must be a string or an array.`, param);
   return {
-    output: value.map((rawBlock, index) => {
+    output: value.flatMap((rawBlock, index): InteractionContent | InteractionContent[] => {
       const blockParam = `${param}.${index}`;
       if (!isRecord(rawBlock)) throw invalidRequest(`${blockParam} must be an object.`, blockParam);
       if (rawBlock.type === "text") {
         return { type: "text", text: requiredStringAllowEmpty(rawBlock.text, `${blockParam}.text`) };
       }
       if (rawBlock.type === "image") return anthropicImage(rawBlock.source, `${blockParam}.source`);
+      if (rawBlock.type === "document") return anthropicDocument(rawBlock, blockParam);
+      if (rawBlock.type === "search_result") return [anthropicSearchResult(rawBlock, blockParam)];
       if (rawBlock.type === "tool_reference") {
         return {
           type: "tool_reference",

package/src/protocol/input/chat_completions.ts

@@ -18,6 +18,7 @@ import type {
 import { toolsByWireName } from "../../interaction/tool_identity.js";
 import { decodeUntrustedProviderContinuationState } from "../../interaction/provider_continuation_state.js";
 import { validateChatCompletionsRequest } from "./chat_completions_validation.js";
+import { parsePdfDataUrl } from "../../interaction/document.js";
 
 export function chatCompletionsToInteraction(request: ChatCompletionRequest): InteractionRequest {
   validateChatCompletionsRequest(request);
@@ -220,6 +221,11 @@ function messageContent(content: ChatMessage["content"]): InteractionContent[] {
     if (part.type === "tool_reference") {
       return { type: "text", text: `Referenced tool: ${String(part.tool_name)}` };
     }
+    if (part.type === "file") {
+      // Validation guarantees a base64 PDF data URL.
+      const fileData = String((part.file as Record<string, unknown>).file_data);
+      return { type: "document", mimeType: "application/pdf", data: parsePdfDataUrl(fileData)! };
+    }
     const imageUrl = part.image_url as Record<string, unknown>;
     const detail = imageUrl.detail;
     return {

package/src/protocol/input/chat_completions_validation.ts

@@ -7,6 +7,7 @@ import {
   isProtocolToolCallId,
   TOOL_CALL_ID_MAX_LENGTH,
 } from "../../interaction/tool_identity.js";
+import { parsePdfDataUrl } from "../../interaction/document.js";
 
 export function validateChatCompletionsRequest(request: ChatCompletionRequest): void {
   if (request.model !== CANONICAL_ROUTER_MODEL && explicitModelId(request.model) === null) {
@@ -124,6 +125,13 @@ function validateMessageContent(content: unknown, messageIndex: number, role: st
       }
       return;
     }
+    if (part.type === "file") {
+      const fileData = isRecord(part.file) ? part.file.file_data : undefined;
+      if (typeof fileData !== "string" || parsePdfDataUrl(fileData) === undefined) {
+        throw new HttpError(400, `Unsupported file at messages[${messageIndex}].content[${partIndex}]; use a base64 PDF data URL in file.file_data.`, "unsupported_file_source", `messages.${messageIndex}.content.${partIndex}.file`);
+      }
+      return;
+    }
     if (part.type === "image_url") {
       const imageUrl = part.image_url;
       const url = isRecord(imageUrl) && typeof imageUrl.url === "string" ? imageUrl.url : "";

package/src/protocol/input/openai_responses.ts

@@ -21,6 +21,7 @@ import type {
   InteractionToolChoice,
   ToolKind,
 } from "../../interaction/types.js";
+import { parsePdfDataUrl } from "../../interaction/document.js";
 
 const UNSUPPORTED_INPUT_ITEM_TYPES = new Set([
   "additional_tools",
@@ -470,6 +471,18 @@ function responseContent(value: unknown, param: string): InteractionContent[] {
         ...(detail !== undefined ? { detail } : {}),
       };
     }
+    if (part.type === "input_file") {
+      const data = typeof part.file_data === "string" ? parsePdfDataUrl(part.file_data) : undefined;
+      if (data === undefined) {
+        throw new HttpError(
+          400,
+          "Responses input_file parts must carry a base64 PDF data URL in file_data; file_id and file_url are not supported.",
+          "unsupported_file_source",
+          `${param}.${index}`
+        );
+      }
+      return { type: "document", mimeType: "application/pdf", data };
+    }
     throw new HttpError(400, `Responses content part type '${String(part.type ?? "unknown")}' is not supported.`, "unsupported_response_content", `${param}.${index}.type`);
   });
 }

package/src/protocol/output/anthropic_messages_output.ts

@@ -54,6 +54,13 @@ export function anthropicContent(output: InteractionOutput): Array<Record<string
         content.push({ type: "text", text: `Referenced tool: ${part.toolName}` });
         continue;
       }
+      if (part.type === "document") {
+        content.push({
+          type: "document",
+          source: { type: "base64", media_type: part.mimeType, data: part.data },
+        });
+        continue;
+      }
       const image = parseDataImageUrl(part.url);
       if (!image) throw new Error("Anthropic output images must use base64 data URLs.");
       content.push({

package/src/providers/key_check.ts

@@ -0,0 +1,76 @@
+import { getBuiltinModels } from "@mupt-ai/pi-ai/providers/all";
+
+const CHECK_TIMEOUT_MS = 10_000;
+
+/**
+ * - `valid`: the provider accepted the key.
+ * - `rejected`: the provider refused it (401 or 403).
+ * - `unchecked`: no answer either way, such as a network error, an outage, or
+ *   a provider without a known check. Callers treat this as not rejected so a
+ *   provider outage never blocks a key.
+ */
+export type ProviderKeyCheckResult =
+  | { result: "valid" }
+  | { result: "rejected"; status: number }
+  | { result: "unchecked" };
+
+// A provider endpoint outside the model catalog, such as a self-run server.
+export type ProviderKeyEndpoint = { api: string; baseUrl: string };
+
+/**
+ * Ask a provider whether an API key works, with the cheapest authenticated
+ * request its wire API offers: list models, or, where listing models needs
+ * no key, an endpoint that does. The self-hosted gateway runs this at startup
+ * and the hosted control plane before it saves a key.
+ */
+export async function checkProviderKey(args: {
+  provider: string;
+  key: string;
+  endpoint?: ProviderKeyEndpoint;
+  fetch: typeof fetch;
+}): Promise<ProviderKeyCheckResult> {
+  const check = keyCheckRequest(args.provider, args.key, args.endpoint);
+  if (check === null) return { result: "unchecked" };
+  try {
+    const response = await args.fetch(check.url, {
+      headers: check.headers,
+      signal: AbortSignal.timeout(CHECK_TIMEOUT_MS),
+    });
+    await response.body?.cancel();
+    if (response.status === 401 || response.status === 403) {
+      return { result: "rejected", status: response.status };
+    }
+    return response.ok ? { result: "valid" } : { result: "unchecked" };
+  } catch {
+    return { result: "unchecked" };
+  }
+}
+
+function keyCheckRequest(
+  provider: string,
+  key: string,
+  endpoint: ProviderKeyEndpoint | undefined,
+): { url: string; headers: Record<string, string> } | null {
+  const bearer = { authorization: `Bearer ${key}` };
+  if (endpoint === undefined) {
+    if (provider === "openrouter") return { url: "https://openrouter.ai/api/v1/key", headers: bearer };
+    if (provider === "vercel-ai-gateway") return { url: "https://ai-gateway.vercel.sh/v1/credits", headers: bearer };
+  }
+  const target = endpoint
+    ?? (getBuiltinModels(provider as never) as unknown as ProviderKeyEndpoint[] | undefined)?.[0];
+  if (target === undefined || !URL.canParse(target.baseUrl)) return null;
+  const base = target.baseUrl.replace(/\/+$/, "");
+  switch (target.api) {
+    case "anthropic-messages":
+      return { url: `${base}/v1/models`, headers: { "x-api-key": key, "anthropic-version": "2023-06-01" } };
+    case "google-generative-ai":
+      return { url: `${base}/models`, headers: { "x-goog-api-key": key } };
+    case "mistral-conversations":
+      return { url: `${base}/v1/models`, headers: bearer };
+    case "openai-completions":
+    case "openai-responses":
+      return { url: `${base}/models`, headers: bearer };
+    default:
+      return null;
+  }
+}

package/src/providers/model_capabilities.ts

@@ -14,6 +14,24 @@ export function modelSupportsImageInput(metadata: ModelCapabilityMetadata): bool
   return Array.isArray(metadata.model.input) && metadata.model.input.includes("image");
 }
 
+/* PDFs are sent natively only where the model owner documents PDF input on
+   that API. The same API can serve other owners (xAI and Meta on Responses,
+   GPT on Bedrock) whose PDF support is unverified, so both must match. */
+const DOCUMENT_INPUT_APIS_BY_OWNER: Readonly<Record<string, ReadonlySet<string>>> = {
+  anthropic: new Set(["anthropic-messages", "bedrock-converse-stream"]),
+  openai: new Set(["openai-responses", "azure-openai-responses", "openai-codex-responses"]),
+};
+
+export function apiSupportsDocumentInput(api: string): boolean {
+  return Object.values(DOCUMENT_INPUT_APIS_BY_OWNER).some((apis) => apis.has(api));
+}
+
+export function modelSupportsDocumentInput(modelId: string, metadata: ModelCapabilityMetadata): boolean {
+  const owner = modelId.split("/", 1)[0] ?? "";
+  const api = metadata.model.api;
+  return typeof api === "string" && DOCUMENT_INPUT_APIS_BY_OWNER[owner]?.has(api) === true;
+}
+
 export function providerApiCanSerializeResponseFormat(metadata: ModelCapabilityMetadata): boolean {
   return (
     metadata.model.api === "openai-responses" ||

package/src/providers/pi_context.ts

@@ -17,6 +17,7 @@ import {
   sameProviderIdentity,
 } from "../interaction/provider_continuation_state.js";
 import { isOpenAIResponsesApi } from "./model_capabilities.js";
+import { apiSupportsDocumentInput } from "./model_capabilities.js";
 
 const UNKNOWN_SOURCE: ProviderIdentity = {
   provider: "dari",
@@ -104,7 +105,7 @@ export function buildContext(
     sawConversationItem = true;
     if (item.type === "message" && item.role === "user") {
       flushAssistant();
-      appendUserMessage(messages, userContent(item.content, item.contentShape), timestamp);
+      appendUserMessage(messages, userContent(item.content, item.contentShape, target), timestamp);
       continue;
     }
     if (item.type === "tool_result") {
@@ -297,10 +298,11 @@ function thinkingContent(
 
 function userContent(
   content: InteractionContent[],
-  shape: "string" | "parts" | "null" | "absent"
+  shape: "string" | "parts" | "null" | "absent",
+  target: ProviderIdentity,
 ): string | Array<Record<string, unknown>> {
   if (shape !== "parts") return content.filter((part) => part.type === "text").map((part) => part.text).join("");
-  return content.map(contentToPi);
+  return content.map((part) => contentToPi(part, target));
 }
 
 function appendPositionalNote(
@@ -347,12 +349,19 @@ function toolResultContent(
   const filtered = target.api === "anthropic-messages"
     ? content.filter((part) => part.type !== "tool_reference")
     : content;
-  return filtered.map(contentToPi);
+  return filtered.map((part) => contentToPi(part, target));
 }
 
-function contentToPi(content: InteractionContent): Record<string, unknown> {
+function contentToPi(content: InteractionContent, target: ProviderIdentity): Record<string, unknown> {
   if (content.type === "text") return { type: "text", text: content.text };
   if (content.type === "tool_reference") return { type: "text", text: `Referenced tool: ${content.toolName}` };
+  if (content.type === "document") {
+    // Routing keeps PDFs on document-capable models; this guards direct callers.
+    if (!apiSupportsDocumentInput(target.api)) {
+      throw new HttpError(400, `PDF document input is not supported by the ${target.api} API.`, "unsupported_input_modality", "input.document");
+    }
+    return { type: "document", mimeType: content.mimeType, data: content.data };
+  }
   const image = parseDataImageUrl(content.url);
   if (!image) {
     throw new HttpError(400, "Only base64 data URLs are supported for routed image input.", "invalid_request_error", "input.image_url");

package/src/runtime/prepare_routed_completion.ts

@@ -1,6 +1,8 @@
 import type { CandidatePruningAudit } from "@mupt-ai/dari-router/policy-engine";
 
 import { interactionConversationPrefix } from "../context/interaction_fingerprint.js";
+import { clampRequestedEffort } from "../context/routing_context.js";
+import { modelMetadataLookup } from "../providers/pi.js";
 import {
   buildRoutingContext,
   derivePrefixLookupHashes,
@@ -134,7 +136,14 @@ export async function prepareRoutedCompletion(args: {
   }
   const access = strictProviderAccess(credentials, args.interaction);
   credentials = access.credentials;
-  args = { ...args, interaction: access.interaction };
+  args = {
+    ...args,
+    interaction: clampRequestedEffort(
+      access.interaction,
+      credentials,
+      modelMetadataLookup(credentials.model_configs),
+    ),
+  };
   credentials = await withProviderCredentials(credentials, args.apiKey, args.clientHarness);
   const billable = true;
   const routing = await buildRoutingContext({
@@ -190,6 +199,8 @@ export async function prepareRoutedCompletion(args: {
     identityHit: routing.identityHit,
     hits: routing.hits,
     costEstimates: routing.reportingCostEstimates,
+    candidates: candidateResolution.candidates,
+    sessionPinKey: sessionPin?.key,
     pruning: reportedPruning(
       candidateResolution.pruning,
       routing.imageCapabilityPrunedModels,

package/src/self_host/config.ts

@@ -12,7 +12,7 @@ import {
  *   default:
  *     models:
  *       - anthropic/claude-sonnet-5-5
- *       - id: openai/gpt-5.5
+ *       - id: openai/gpt-6.1-sol
  *         thinking: [medium, high]
  *     subscriptions: true   # serve with connected Claude Code / ChatGPT plans
  *     sessionPinning: false # route each session and subagent once, then keep its model

package/src/self_host/main.ts

@@ -10,9 +10,11 @@ import { installShutdownHandlers, startServer } from "../http/serve.js";
 import { createAutoRoutingSelectorBackend } from "../strategies/auto_routing_selector.js";
 import { createPrioritySelectorBackend } from "../strategies/priority_selector.js";
 import type { SelectorBackend } from "../strategies/routing.js";
-import { loadGatewayConfig } from "./config.js";
 import { createSelfHostedPlatform } from "./platform.js";
-import { gatewayKeyIndex, providersWithoutCredentials } from "./resolve.js";
+import { providerForModel } from "@mupt-ai/dari-router/policy-engine";
+import { checkProviderKey } from "../providers/key_check.js";
+import { loadGatewayConfig, type GatewayConfig } from "./config.js";
+import { configuredProviderApiKey, 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";
@@ -76,6 +78,8 @@ export async function startSelfHostedGateway(env: Record<string, string> = proce
       );
     }
   }
+  await checkConfiguredProviderKeys(config, (provider) =>
+    configuredProviderApiKey({ config, providerApiKey, env }, provider));
   const autoRoutingKey = env.DARI_AUTO_ROUTING_API_KEY?.trim();
   const selectorBackend: SelectorBackend = autoRoutingKey
     ? createAutoRoutingSelectorBackend({
@@ -109,7 +113,8 @@ export async function startSelfHostedGateway(env: Record<string, string> = proce
     "dari-gateway listening",
     JSON.stringify({
       hostname,
-      port,
+      // The bound port, so PORT=0 reports the port the OS assigned.
+      port: server.port,
       routers: Object.keys(config.routers),
       auto_routing: autoRoutingKey ? "dari" : "priority",
     }),
@@ -117,6 +122,37 @@ export async function startSelfHostedGateway(env: Record<string, string> = proce
   return { server, close: () => db.close() };
 }
 
+/**
+ * Check each provider API key the routers use before serving: a key its
+ * provider rejects fails startup, and one no check could answer is reported.
+ */
+async function checkConfiguredProviderKeys(
+  config: GatewayConfig,
+  providerApiKey: (provider: string) => Promise<string | undefined>,
+): Promise<void> {
+  const providers = new Set(
+    Object.values(config.routers).flatMap((router) => router.models.map((model) => providerForModel(model.id))),
+  );
+  const checks = await Promise.all([...providers].map(async (provider) => {
+    const endpoint = config.providers[provider];
+    // Endpoints configured without a key variable take no key.
+    if (endpoint !== undefined && endpoint.apiKeyEnv === undefined) return null;
+    const key = await providerApiKey(provider);
+    if (key === undefined) return null;
+    return { provider, ...(await checkProviderKey({ provider, key, ...(endpoint ? { endpoint } : {}), fetch })) };
+  }));
+  const rejected = checks.flatMap((check) => check?.result === "rejected" ? [`${check.provider} (${check.status})`] : []);
+  if (rejected.length > 0) {
+    throw new Error(
+      `Provider API keys were rejected: ${rejected.join(", ")}. Fix or unset each key before starting the gateway.`,
+    );
+  }
+  const unchecked = checks.flatMap((check) => check?.result === "unchecked" ? [check.provider] : []);
+  if (unchecked.length > 0) {
+    console.warn("dari-gateway could not check these provider API keys", JSON.stringify({ providers: unchecked }));
+  }
+}
+
 if (import.meta.main) {
   // Startup errors are configuration mistakes: print the message, not a stack.
   const started = await startSelfHostedGateway().catch((error: unknown) => {

package/src/self_host/resolve.ts

@@ -86,7 +86,7 @@ export async function resolveSelfHostedRouter(
     if (subscription !== null && deps.subscriptions.list(subscription).length > 0) {
       exhausted.add(subscription);
     }
-    const apiKey = await providerApiKey(deps, provider);
+    const apiKey = await configuredProviderApiKey(deps, provider);
     credentials.set(provider, apiKey ? { key: apiKey, source: "user" } : null);
   }
 
@@ -154,7 +154,7 @@ 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.
-async function providerApiKey(
+export async function configuredProviderApiKey(
   deps: Pick<SelfHostedResolverDeps, "config" | "providerApiKey" | "env">,
   provider: string,
 ): Promise<string | undefined> {
@@ -226,7 +226,7 @@ export async function providersWithoutCredentials(
       : [];
     const connected = plans.some((plan) => plan !== null && deps.subscriptions.list(plan).length > 0);
     if (connected) continue;
-    const apiKey = await providerApiKey(deps, provider);
+    const apiKey = await configuredProviderApiKey(deps, provider);
     if (apiKey === undefined) missing.push(provider);
   }
   return missing;

package/src/strategies/selector_projection.ts

@@ -190,6 +190,8 @@ function selectorContentField(
       if (part.type === "tool_reference") {
         return { type: "text", text: `Referenced tool: ${part.toolName}` };
       }
+      // The selector model is text-only; it sees a marker, not the document bytes.
+      if (part.type === "document") return { type: "text", text: "(PDF document omitted from selector input)" };
       return imagePart(part.url, part.detail);
     }),
   };

package/src/telemetry/report.ts

@@ -11,6 +11,7 @@ import {
   type ChainHits,
   type PrefixHit,
   type PricingLookup,
+  type RoutingCandidate,
   type RoutingDecision,
   type RoutingStrategy,
 } from "@mupt-ai/dari-router/policy-engine";
@@ -25,7 +26,7 @@ import {
   type ProviderIdentity,
 } from "../interaction/types.js";
 import { captureOperationalError } from "../observability/errors.js";
-import { gatewayPlatform, type RequestTags } from "../platform/platform.js";
+import { gatewayPlatform, type RequestRecordRouter, type RequestTags } from "../platform/platform.js";
 import type {
   ProviderAttemptRecord,
   ProviderAttemptReport,
@@ -179,6 +180,10 @@ export class RequestReporter {
       identityHit?: PrefixHit;
       hits: ChainHits;
       costEstimates: CandidateCostEstimate[];
+      // The model and reasoning pairs this request could be routed to.
+      candidates: readonly RoutingCandidate[];
+      // The session pin this request routed under, when the router pins.
+      sessionPinKey?: string;
       // Cache-aware selector-candidate pruning outcome, plus any pre-strategy
       // capability exclusions. Null when custom routing configuration cannot
       // produce candidates.
@@ -603,6 +608,9 @@ export class RequestReporter {
       };
 
       gatewayPlatform().recordRequest({
+        router: requestRecordRouter(a.credentials),
+        candidates: a.candidates.map(({ model, reasoningEffort }) => ({ model, reasoningEffort })),
+        ...(a.sessionPinKey === undefined ? {} : { sessionPinKey: a.sessionPinKey }),
         row: ingestPayload,
         summary: {
           request_id: a.requestId,
@@ -786,3 +794,28 @@ function usageIngest(
     pricing_known: pricingKnown,
   };
 }
+
+function requestRecordRouter(router: ResolvedRouter): RequestRecordRouter {
+  return {
+    enabledModels: [...router.enabled_models],
+    thinkingLevels: Object.fromEntries(
+      router.enabled_models.map((model) => [
+        model,
+        [
+          ...(router.model_thinking_levels?.[model]
+            ?? router.model_configs?.[model]?.supported_thinking_levels
+            ?? []),
+        ],
+      ]),
+    ),
+    defaultThinkingLevels: Object.fromEntries(
+      router.enabled_models.flatMap((model) => {
+        const level = router.model_configs?.[model]?.default_thinking_level;
+        return level ? [[model, level]] : [];
+      }),
+    ),
+    strict: router.strict === true,
+    speculativeRouting: router.speculative_routing === true,
+    sessionPinning: router.session_pinning === true,
+  };
+}