@mupt-ai/dari-gateway 0.3.2 → 0.3.4

package/README.md

@@ -36,27 +36,26 @@ The gateway is the same runtime that serves Dari's hosted routing service. Choos
 
 ## Run
 
-Requires [Bun](https://bun.sh) 1.3 or later.
+Requires [Bun](https://bun.sh) 1.3 or later. Write a `dari-gateway.yaml` (start from [`dari-gateway.example.yaml`](dari-gateway.example.yaml)), then:
 
 ```bash
-cp dari-gateway.example.yaml dari-gateway.yaml   # edit routers and models
 export DARI_GATEWAY_KEYS="$(openssl rand -hex 24)" # keys your clients send
 export ANTHROPIC_API_KEY=... OPENAI_API_KEY=...    # optional with subscriptions
-bun install
-bun run start
+bunx @mupt-ai/dari-gateway
 ```
 
-Or with Docker, from this directory (in the monorepo, run `docker build -t dari-gateway dari-gateway` from the repository root):
+Or with Docker:
 
 ```bash
-docker build -t dari-gateway .
 docker run -p 8080:8080 \
   -e DARI_GATEWAY_KEYS -e ANTHROPIC_API_KEY \
   -v "$PWD/dari-gateway.yaml:/config/dari-gateway.yaml" \
   -v dari-gateway-data:/data \
-  dari-gateway
+  ghcr.io/mupt-ai/dari-gateway
 ```
 
+From a clone, `bun install && bun run start` or `docker build -t dari-gateway .` run the same thing.
+
 | Variable | Meaning |
 | --- | --- |
 | `DARI_GATEWAY_KEYS` | Required. Comma-separated bearer keys clients authenticate with. |
@@ -65,7 +64,7 @@ docker run -p 8080:8080 \
 | `DARI_AUTO_ROUTING_API_KEY` | Optional. Select among a router's models with Dari Auto Routing. |
 | `PORT` | Listen port. Default `8080`. |
 | `DARI_GATEWAY_HOST` | Listen address. Default `127.0.0.1`, so only this machine can connect. The container image sets `0.0.0.0`; set it yourself to expose a process on your network. |
-| Provider keys | Each provider's standard variable, such as `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `META_API_KEY`, or `OPENROUTER_API_KEY`. |
+| Provider keys | Each provider's standard variable, such as `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `META_API_KEY`, or `OPENROUTER_API_KEY`. The gateway checks each key at startup and will not start if a provider rejects one. |
 
 ## Configure
 
@@ -74,7 +73,7 @@ routers:
   default:                 # serves /v1/...
     models:
       - anthropic/claude-sonnet-5-5
-      - id: openai/gpt-5.5
+      - id: openai/gpt-6.1-sol
         thinking: [medium, high]
     subscriptions: true    # prefer connected subscriptions over API keys
     sessionPinning: false  # route each session and subagent once, then keep its model
@@ -121,9 +120,9 @@ The root entry needs no Bun APIs, so any runtime with web-standard `fetch`, `Req
 Platforms can also:
 
 - implement `resolveProviderCredential({ provider, model, routerId, organizationId, apiKey, clientHarness? })` to supply a per-request `{ apiKey, baseUrl?, headers?, subscription? }`, such as a tenant's own key, in place of the router's resolved key. With `subscription` (`"openai_codex"`, `"anthropic_claude_code"`, or `"meta_muse"`), `apiKey` is that plan's access token: Codex's `auth.json` `tokens.access_token`, the token `claude setup-token` prints, or the Model API key a Meta sign-in mints. The platform keeps it fresh. Strict routers serve these supplied plans, but never subscriptions the gateway resolved itself. A plan serves only its own provider's models; a Claude Code plan serves only Claude Code clients, and a Muse Code plan only Muse Code clients (recognized by their `x-client-id`);
-- resolve routers with `strict: true` to serve only the requested `dari/model/<id>` at the requested thinking level, with no selector, lease, or personal subscription. Set `strict_providers: ["openai"]` on the resolved router to permit any bundled-catalog model from that provider without enumerating `enabled_models`. Use `dari/model/openai/gpt-5.5`; bare IDs and unknown models remain refused. This grant is ignored on non-strict routers and does not discover uncatalogued models;
+- resolve routers with `strict: true` to serve only the requested `dari/model/<id>` at the requested thinking level, with no selector, lease, or personal subscription. Set `strict_providers: ["openai"]` on the resolved router to permit any bundled-catalog model from that provider without enumerating `enabled_models`. Use `dari/model/openai/gpt-6.1-sol`; bare IDs and unknown models remain refused. This grant is ignored on non-strict routers and does not discover uncatalogued models;
 - resolve routers with `session_pinning: true` to route each session once and serve that pair for the rest of the session. Each subagent (Claude Code agent id, Codex subagent thread, OpenCode child session) is routed once on its own. Pins are kept through `readSessionPin` and `writeSessionPin`, keyed by router and an opaque pin key; background requests and `dari/model/<id>` requests never use them;
-- read exact usage from `recordRequest`: the summary carries input, output, cache-read, and cache-write tokens and `total_cost_usd`, preferring the provider's billed cost (`cost_source: "provider"`, from OpenRouter and Vercel AI Gateway). Failed and aborted requests are recorded too;
+- read exact usage from `recordRequest`: the summary carries input, output, cache-read, and cache-write tokens and `total_cost_usd`, preferring the provider's billed cost (`cost_source: "provider"`, from OpenRouter and Vercel AI Gateway). Each record also carries the router's non-secret routing settings as `router` (enabled models, thinking levels, and the strict, speculative-routing, and session-pinning flags). Failed and aborted requests are recorded too;
 - attribute cost with `X-Dari-Tags: run=r1,trial=3`, which is parsed into `RequestRecord.tags` and the `recordUsage` payload's `tags`.
 
 ## Development

package/dari-gateway.example.yaml

@@ -7,7 +7,7 @@ routers:
   default:
     models:
       - anthropic/claude-sonnet-5-5
-      - id: openai/gpt-5.5
+      - id: openai/gpt-6.1-sol
         thinking: [medium, high]
     # Serve with connected Claude Code / ChatGPT subscriptions before API
     # keys (default true).

package/dist/context/interaction_fingerprint.js

@@ -59,7 +59,7 @@ export function interactionLooseChain(routerId, request) {
 // transcript step. Growing history and tool changes preserve identity, while
 // unrelated work reusing the same harness session gets a new group.
 export function interactionConversationPrefix(request) {
-    const firstStep = conversationFingerprintSteps(looseFingerprintSteps(request.sourceProtocol, request.items)).at(0);
+    const firstStep = conversationFingerprintSteps(looseFingerprintSteps(request.sourceProtocol, request.items.filter((item) => !isOpenClawRuntimeContext(item)))).at(0);
     return sha256(stableStringify({
         version: CONVERSATION_PREFIX_VERSION,
         firstStep: firstStep === undefined
@@ -67,6 +67,15 @@ export function interactionConversationPrefix(request) {
             : canonicalInteractionFingerprintStep(firstStep),
     }));
 }
+// OpenClaw appends a user message of runtime context (active exec sessions,
+// subagents) to each request and drops it from later history. On a first
+// turn it merges into the first transcript step, so leaving it in would give
+// the first turn a different conversation than the turns after it.
+const OPENCLAW_RUNTIME_CONTEXT = "<<<BEGIN_OPENCLAW_INTERNAL_CONTEXT>>>";
+function isOpenClawRuntimeContext(item) {
+    return item.type === "message" && item.role === "user" && item.content.length > 0 &&
+        item.content.every((part) => part.type === "text" && part.text.trimStart().startsWith(OPENCLAW_RUNTIME_CONTEXT));
+}
 export function interactionPrefixContext(routerId, request, targets) {
     const chainByModel = new Map();
     const itemIndexByHashByModel = new Map();

package/dist/context/interaction_fingerprint_format.d.ts

@@ -6,6 +6,10 @@ export type FingerprintContent = string | Array<{
     type: "image";
     url: string;
     detail?: "auto" | "low" | "high" | "original";
+} | {
+    type: "document";
+    mimeType: "application/pdf";
+    data: string;
 } | {
     type: "tool_reference";
     toolName: string;

package/dist/context/interaction_fingerprint_format.js

@@ -83,6 +83,9 @@ export function interactionFingerprintContent(content, shape) {
                 toolName: part.toolName,
             };
         }
+        if (part.type === "document") {
+            return { type: "document", mimeType: part.mimeType, data: part.data };
+        }
         return {
             type: "image",
             url: part.url,

package/dist/context/provider_prompt_accounting.js

@@ -1,3 +1,4 @@
+import { constants as zlibConstants, inflateSync } from "node:zlib";
 import { isRecord, stableStringify, } from "@mupt-ai/dari-router/policy-engine";
 import { toolsByWireName } from "../interaction/tool_identity.js";
 import { buildContext } from "../providers/pi_context.js";
@@ -10,6 +11,45 @@ const IMAGE_ESTIMATED_TOKENS = {
     original: 2048,
 };
 const CHARS_PER_ESTIMATED_TOKEN = 4;
+// Anthropic bills each PDF page as its text plus a page image: 1,500-3,000
+// tokens. Use the top of that range so a long PDF cannot look like it fits.
+const PDF_ESTIMATED_TOKENS_PER_PAGE = 3000;
+const PDF_PAGE_PATTERN = /\/Type\s*\/Page(?![a-zA-Z])/g;
+const PDF_OBJECT_STREAM_START = /\/Type\s*\/ObjStm[\s\S]*?stream\r?\n/g;
+// Object streams hold small dictionaries. The cap is total inflated bytes per
+// PDF, so a compression bomb in a request costs at most this much memory.
+const PDF_OBJECT_STREAM_INFLATE_BUDGET = 4 * 1024 * 1024;
+function estimatedPdfPages(base64) {
+    const bytes = Buffer.from(base64, "base64");
+    // latin1 maps each byte to one character, so string offsets are byte offsets.
+    const pdf = bytes.toString("latin1");
+    const visible = pdf.match(PDF_PAGE_PATTERN)?.length ?? 0;
+    if (visible > 0)
+        return visible;
+    // PDF 1.5+ may keep every page dictionary in compressed object streams.
+    let hidden = 0;
+    let budget = PDF_OBJECT_STREAM_INFLATE_BUDGET;
+    for (const match of pdf.matchAll(PDF_OBJECT_STREAM_START)) {
+        const start = match.index + match[0].length;
+        const end = pdf.indexOf("endstream", start);
+        if (end === -1 || budget <= 0)
+            break;
+        try {
+            const objects = inflateSync(bytes.subarray(start, end), {
+                finishFlush: zlibConstants.Z_SYNC_FLUSH,
+                maxOutputLength: budget,
+            });
+            budget -= objects.length;
+            hidden += objects.toString("latin1").match(PDF_PAGE_PATTERN)?.length ?? 0;
+        }
+        catch (error) {
+            // Over budget: stop. Another filter or bad data: count what is readable.
+            if (error instanceof RangeError)
+                break;
+        }
+    }
+    return Math.max(1, hidden);
+}
 // Cost and cache-lookback estimates are candidate-specific because compatible
 // continuation state and provider serialization can change what each model
 // sees.
@@ -94,7 +134,7 @@ export function promptMetrics(request, target) {
     };
     return {
         blockDepth: messages.reduce((total, message) => total + providerVisibleBlockCount(message), 0),
-        serializedChars: stableStringify(prompt).length + accountingInput.imageEstimatedChars,
+        serializedChars: stableStringify(prompt).length + accountingInput.attachmentEstimatedChars,
     };
 }
 function providerVisibleMessage(value) {
@@ -162,12 +202,20 @@ function providerVisibleTools(request, contextTools, target) {
     ];
 }
 function promptAccountingInput(request) {
-    let imageEstimatedChars = 0;
+    let attachmentEstimatedChars = 0;
+    // Attachments are estimated rather than serialized: their base64 is not
+    // what the provider bills, and a PDF must not reach the serializer of a
+    // model that cannot carry it.
     const sanitizeContent = (parts) => parts.map((part) => {
+        if (part.type === "document") {
+            attachmentEstimatedChars +=
+                estimatedPdfPages(part.data) * PDF_ESTIMATED_TOKENS_PER_PAGE * CHARS_PER_ESTIMATED_TOKEN;
+            return { type: "text", text: "" };
+        }
         if (part.type !== "image")
             return part;
         const detail = part.detail ?? "auto";
-        imageEstimatedChars +=
+        attachmentEstimatedChars +=
             IMAGE_ESTIMATED_TOKENS[detail] * CHARS_PER_ESTIMATED_TOKEN;
         return { ...part, url: ACCOUNTING_IMAGE_URL };
     });
@@ -182,6 +230,6 @@ function promptAccountingInput(request) {
     });
     return {
         request: { ...request, items },
-        imageEstimatedChars,
+        attachmentEstimatedChars,
     };
 }

package/dist/context/routing_context.d.ts

@@ -1,5 +1,6 @@
-import { type ActiveLease, type PendingLease, type CandidateCostEstimate, type ChainHits, type PrefixHit, type ChatMessage, type PreviousDecision, type PricingLookup, type SelectorLeaseHistoryEntry, type StrategyCandidateResolution } from "@mupt-ai/dari-router/policy-engine";
+import { type ActiveLease, type PendingLease, type CandidateCostEstimate, type ChainHits, type PrefixHit, type ChatMessage, type PreviousDecision, type PricingLookup, type ReasoningEffort, type SelectorLeaseHistoryEntry, type StrategyCandidateResolution } from "@mupt-ai/dari-router/policy-engine";
 import { type InteractionRequest, type ProviderIdentity } from "../interaction/types.js";
+import { modelMetadataLookup } from "../providers/pi.js";
 import { type SelectorImage } from "../strategies/selector_projection.js";
 import type { ResolvedRouter } from "../types.js";
 import { type InteractionPrefixContext } from "./interaction_fingerprint.js";
@@ -38,3 +39,7 @@ export declare function buildRoutingContext(args: {
     explicitConversationId?: string;
     receivedAt?: Date;
 }): Promise<RoutingContext>;
+export declare function clampRequestedEffort(interaction: InteractionRequest, credentials: {
+    strict?: boolean;
+    model_thinking_levels?: Record<string, ReasoningEffort[]>;
+}, metadataLookup: ReturnType<typeof modelMetadataLookup>): InteractionRequest;

package/dist/context/routing_context.js

@@ -1,14 +1,15 @@
-import { prepareCandidates, } from "@mupt-ai/dari-router/policy-engine";
+import { prepareCandidates, isReasoningEffort, } from "@mupt-ai/dari-router/policy-engine";
 import { randomUUID } from "node:crypto";
 import { HttpError } from "../http/errors.js";
 import { effectiveContextWindow } from "../models/context_limits.js";
 import { keySourceForModel } from "../models/execution_provider.js";
-import { requiredCapabilitiesFor } from "../interaction/capabilities.js";
+import { requestHasDocument, requiredCapabilitiesFor } from "../interaction/capabilities.js";
 import { providerIdentityFromModel } from "../interaction/provider_continuation_state.js";
 import { isBackgroundRequest } from "../interaction/types.js";
 import { requireCandidateModels } from "../models/ids.js";
+import { explicitModelId } from "../protocol/input/router_model.js";
 import { modelMetadataLookup } from "../providers/pi.js";
-import { modelSupportsImageInput, modelSupportsHostedWebSearch, modelSupportsReasoningConfigurationUpdate, providerApiCanSerializeResponseFormat, } from "../providers/model_capabilities.js";
+import { modelSupportsDocumentInput, modelSupportsImageInput, modelSupportsHostedWebSearch, modelSupportsReasoningConfigurationUpdate, providerApiCanSerializeResponseFormat, } from "../providers/model_capabilities.js";
 import { selectorMessagesForInteraction, } from "../strategies/selector_projection.js";
 import { interactionPrefixContext, interactionPrefixLookupHashes, } from "./interaction_fingerprint.js";
 import { pricingLookupForRouter } from "./pricing.js";
@@ -64,6 +65,7 @@ export async function buildRoutingContext(args) {
         enabled: args.credentials.image_capability_filtering !== false,
         supportsImageInput: (model) => capabilityLookup(model).supportsImageInput,
     });
+    const documentCapableModels = documentCapableCandidates(imageFilter.candidateModels, requestHasDocument(args.interaction), (model) => modelSupportsDocumentInput(model, metadataLookup(model)));
     const prefix = derivePrefixContext({
         routerId: args.routerId,
         interaction: args.interaction,
@@ -81,7 +83,7 @@ export async function buildRoutingContext(args) {
     const prefixHits = (background ? [] : args.credentials.prefix_hits ?? []).filter((hit) => args.explicitConversationId === undefined
         || hit.conversation_id === args.explicitConversationId);
     const prepared = prepareCandidates({
-        candidateModels: imageFilter.candidateModels,
+        candidateModels: documentCapableModels,
         metadataLookup: capabilityLookup,
         requiredCapabilities: imageFilter.requiredCapabilities,
         requestedReasoningEffort: args.interaction.reasoning?.effort,
@@ -195,6 +197,17 @@ function resolveImageCapableCandidates(args) {
             .map((model) => ({ model, reason: "image_input_unsupported" })),
     };
 }
+// A PDF can only be sent natively, so a conversation carrying one must not
+// route (or hold a lease) to a model that cannot read it.
+function documentCapableCandidates(candidateModels, hasDocument, supportsDocumentInput) {
+    if (!hasDocument)
+        return candidateModels;
+    const capable = candidateModels.filter(supportsDocumentInput);
+    if (capable.length === 0) {
+        throw new HttpError(400, "This conversation contains a PDF document, but no enabled model on this router accepts PDF input.", "no_document_capable_candidates");
+    }
+    return capable;
+}
 function derivePrefixContext(args) {
     try {
         return interactionPrefixContext(args.routerId, args.interaction, args.targetsByModel);
@@ -209,3 +222,26 @@ function derivePrefixContext(args) {
         };
     }
 }
+// An explicit `dari/model/<id>` serves the requested thinking level when the
+// model offers it and otherwise its default level, so the request itself drops
+// an unsupported level before routing and provider validation see it. A strict
+// router never substitutes, so it keeps the level and fails on it.
+export function clampRequestedEffort(interaction, credentials, metadataLookup) {
+    const requested = interaction.reasoning?.effort;
+    const modelId = explicitModelId(interaction.model);
+    if (requested === undefined || modelId === null || credentials.strict === true)
+        return interaction;
+    const supported = metadataLookup(modelId).supportedThinkingLevels.filter(isReasoningEffort);
+    const configured = credentials.model_thinking_levels?.[modelId] ?? supported;
+    if (configured.includes(requested) && supported.includes(requested))
+        return interaction;
+    // The effort implied thinking on and its effort-derived fields (baseEffort,
+    // configuration updates) must not leak into the default. Keep only an explicit
+    // thinking-off and any thinking budget.
+    const { enabled, budgetTokens } = interaction.reasoning;
+    const reasoning = {
+        ...(enabled === false ? { enabled } : {}),
+        ...(budgetTokens === undefined ? {} : { budgetTokens }),
+    };
+    return { ...interaction, reasoning: Object.keys(reasoning).length === 0 ? undefined : reasoning };
+}

package/dist/ingress/anthropic_messages.js

@@ -5,6 +5,7 @@ import { anthropicToken } from "../http/auth.js";
 import { errorResponseHeaders, normalizeError } from "../http/errors.js";
 import { captureRequestError } from "../observability/errors.js";
 import { anthropicMessagesToInteraction } from "../protocol/input/anthropic_messages.js";
+import { explicitModelId } from "../protocol/input/router_model.js";
 import { handleRoutedCompletion } from "../runtime/routed_completion.js";
 import { claudeCodeRequestContext } from "./claude_code/request_context.js";
 import { claudeCodeConversationIdentity, } from "../runtime/harness_identity/index.js";
@@ -24,6 +25,7 @@ export async function handleAnthropicMessages(request, routerId, selectorBackend
         const payload = isClaudeCode
             ? {
                 ...forwarded,
+                reasoning: routedReasoning(forwarded),
                 agentContext: claudeCodeRequestContext(request.headers),
                 // Native tool results may be followed by harness-injected text.
                 // Preserve their structural continuation semantics, not prompt inference.
@@ -58,6 +60,16 @@ export async function handleAnthropicMessages(request, routerId, selectorBackend
         return response;
     }
 }
+// Claude Code sends its session effort on every turn. That preference
+// describes a direct model, not a heterogeneous router, so let Dari select the
+// effort when the router routes; a `dari/model/<id>` keeps the chosen effort.
+function routedReasoning(interaction) {
+    const reasoning = interaction.reasoning;
+    if (reasoning === undefined || explicitModelId(interaction.model) !== null)
+        return reasoning;
+    // Keep only an explicit "thinking off"; effort alone must not force thinking on.
+    return reasoning.enabled === false ? { enabled: false } : undefined;
+}
 function latestMessageHasToolResult(messages) {
     if (!Array.isArray(messages))
         return false;

package/dist/ingress/codex.js

@@ -8,7 +8,7 @@ import { openAIResponsesToInteraction } from "../protocol/input/openai_responses
 import { parseJsonRequest } from "./json.js";
 import { museCodeClientId } from "./muse_code.js";
 import { handleRoutedCompletion } from "../runtime/routed_completion.js";
-import { codexConversationIdentity, codexRequestPurpose, codexRequestContext, } from "../runtime/harness_identity/index.js";
+import { codexConversationIdentity, codexRequestPurpose, codexRequestContext, museCodeConversationIdentity, } from "../runtime/harness_identity/index.js";
 export async function handleResponses(request, routerId, selectorBackend) {
     try {
         const apiKey = bearerToken(request.headers);
@@ -23,14 +23,19 @@ export async function handleResponses(request, routerId, selectorBackend) {
             ...(agentContext === undefined ? {} : { agentContext }),
             ...(museClientId === undefined ? {} : { museCodeClientId: museClientId }),
         };
-        const harnessConversationIdentity = codexConversationIdentity(request.headers, rawPayload);
-        // Codex applies its global model_reasoning_effort setting to custom model
+        const codexIdentity = codexConversationIdentity(request.headers, rawPayload);
+        // Codex and Muse Code apply their session effort to custom model
         // 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 && explicitModelId(payload.model) === null) {
-            payload.reasoning = undefined;
+        // router, so let Dari select the reasoning effort for their routed turns;
+        // a `dari/model/<id>` keeps the chosen effort. Parsing above still
+        // validates malformed Responses reasoning controls.
+        const harness = codexIdentity !== undefined || museClientId !== undefined;
+        if (harness && explicitModelId(payload.model) === null) {
+            // Keep only an explicit thinking-off; a session effort must not force thinking on.
+            payload.reasoning = payload.reasoning?.enabled === false ? { enabled: false } : undefined;
         }
+        const harnessConversationIdentity = codexIdentity
+            ?? (museClientId === undefined ? undefined : museCodeConversationIdentity(request.headers));
         return await handleRoutedCompletion({
             request,
             routerId,

package/dist/interaction/capabilities.d.ts

@@ -1,3 +1,4 @@
 import type { HardCapability } from "@mupt-ai/dari-router/policy-engine";
 import type { InteractionRequest } from "./types.js";
 export declare function requiredCapabilitiesFor(request: Pick<InteractionRequest, "items" | "responseFormat" | "toolChoice" | "tools">): HardCapability[];
+export declare function requestHasDocument(request: Pick<InteractionRequest, "items">): boolean;

package/dist/interaction/capabilities.js

@@ -17,6 +17,12 @@ export function requiredCapabilitiesFor(request) {
 function requiresWebSearch(item) {
     return item.type === "hosted_tool_call" && item.tool === "web_search";
 }
+export function requestHasDocument(request) {
+    return request.items.some((item) => {
+        const parts = item.type === "message" ? item.content : item.type === "tool_result" ? item.output : null;
+        return Array.isArray(parts) && parts.some((part) => part.type === "document");
+    });
+}
 function itemHasImage(item) {
     if (item.type === "message")
         return item.content.some((part) => part.type === "image");

package/dist/interaction/document.d.ts

@@ -0,0 +1,2 @@
+/** The base64 payload of a PDF data URL, or undefined for anything else. */
+export declare function parsePdfDataUrl(url: string): string | undefined;

package/dist/interaction/document.js

@@ -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) {
+    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/dist/interaction/types.d.ts

@@ -32,11 +32,17 @@ export type InteractionImage = {
     url: string;
     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";
     id?: string;

package/dist/observability/errors.js

@@ -1,7 +1,26 @@
+import { HttpError } from "../http/errors.js";
 import { gatewayPlatform, } from "../platform/platform.js";
 export function captureRequestError(error, context) {
+    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, context) {
+    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/dist/platform/platform.d.ts

@@ -110,6 +110,20 @@ export type RequestRecord = {
     zdr: boolean;
     harnessConversationIdentity?: HarnessConversationIdentity;
     tags: RequestTags;
+    router: RequestRecordRouter;
+    candidates: Array<{
+        model: string;
+        reasoningEffort: ReasoningEffort;
+    }>;
+    sessionPinKey?: string;
+};
+export type RequestRecordRouter = {
+    enabledModels: string[];
+    thinkingLevels: Record<string, ReasoningEffort[]>;
+    defaultThinkingLevels: Record<string, ReasoningEffort>;
+    strict: boolean;
+    speculativeRouting: boolean;
+    sessionPinning: boolean;
 };
 export type RequestTags = Record<string, string>;
 export type RequestSummary = {

package/dist/protocol/input/anthropic_messages.js

@@ -102,6 +102,18 @@ function appendAnthropicMessage(items, role, value, messageIndex) {
             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);
@@ -212,6 +224,63 @@ function appendAnthropicMessage(items, role, value, messageIndex) {
     }
     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, param) {
+    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 !== undefined && line.length > 0)
+        .join("\n");
+    const withHeader = (body) => 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 = { 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) => {
+            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, param) {
+    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, param) {
     if (!isRecord(value))
         throw invalidRequest(`${param} must be an object.`, param);
@@ -264,7 +333,7 @@ function anthropicToolResultContent(value, param) {
     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) => {
             const blockParam = `${param}.${index}`;
             if (!isRecord(rawBlock))
                 throw invalidRequest(`${blockParam} must be an object.`, blockParam);
@@ -273,6 +342,10 @@ function anthropicToolResultContent(value, param) {
             }
             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/dist/protocol/input/chat_completions.js

@@ -3,6 +3,7 @@ import { HttpError } from "../../http/errors.js";
 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) {
     validateChatCompletionsRequest(request);
     return internalChatCompletionsToInteraction(request);
@@ -177,6 +178,11 @@ function messageContent(content) {
         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.file_data);
+            return { type: "document", mimeType: "application/pdf", data: parsePdfDataUrl(fileData) };
+        }
         const imageUrl = part.image_url;
         const detail = imageUrl.detail;
         return {

package/dist/protocol/input/chat_completions_validation.js

@@ -3,6 +3,7 @@ import { HttpError } from "../../http/errors.js";
 import { parseDataImageUrl } from "../../interaction/image.js";
 import { CANONICAL_ROUTER_MODEL, explicitModelId, unsupportedModelMessage } from "./router_model.js";
 import { isProtocolToolCallId, TOOL_CALL_ID_MAX_LENGTH, } from "../../interaction/tool_identity.js";
+import { parsePdfDataUrl } from "../../interaction/document.js";
 export function validateChatCompletionsRequest(request) {
     if (request.model !== CANONICAL_ROUTER_MODEL && explicitModelId(request.model) === null) {
         throw new HttpError(400, unsupportedModelMessage(), "unsupported_model", "model");
@@ -103,6 +104,13 @@ function validateMessageContent(content, messageIndex, role) {
             }
             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 : "";