@mupt-ai/dari-gateway 0.3.3 → 0.3.5

package/src/context/provider_prompt_accounting.ts

@@ -1,3 +1,5 @@
+import { constants as zlibConstants, inflateSync } from "node:zlib";
+
 import {
   isRecord,
   stableStringify,
@@ -27,6 +29,42 @@ const IMAGE_ESTIMATED_TOKENS = {
   original: 2048,
 } as const;
 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: string): number {
+  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
@@ -130,7 +168,7 @@ export function promptMetrics(
       0,
     ),
     serializedChars:
-      stableStringify(prompt).length + accountingInput.imageEstimatedChars,
+      stableStringify(prompt).length + accountingInput.attachmentEstimatedChars,
   };
 }
 
@@ -214,14 +252,22 @@ function providerVisibleTools(
 
 function promptAccountingInput(request: InteractionRequest): {
   request: InteractionRequest;
-  imageEstimatedChars: number;
+  attachmentEstimatedChars: number;
 } {
-  let imageEstimatedChars = 0;
-  const sanitizeContent = (parts: InteractionContent[]) =>
+  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: InteractionContent[]): InteractionContent[] =>
     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 };
     });
@@ -236,6 +282,6 @@ function promptAccountingInput(request: InteractionRequest): {
   });
   return {
     request: { ...request, items },
-    imageEstimatedChars,
+    attachmentEstimatedChars,
   };
 }

package/src/context/routing_context.ts

@@ -10,6 +10,8 @@ import {
   type HardCapability,
   type PreviousDecision,
   type PricingLookup,
+  isReasoningEffort,
+  type ReasoningEffort,
   type SelectorLeaseHistoryEntry,
   type StrategyCandidateResolution,
 } from "@mupt-ai/dari-router/policy-engine";
@@ -18,12 +20,14 @@ 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, type InteractionRequest, type ProviderIdentity } 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 {
+  modelSupportsDocumentInput,
   modelSupportsImageInput,
   modelSupportsHostedWebSearch,
   modelSupportsReasoningConfigurationUpdate,
@@ -152,6 +156,11 @@ 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,
@@ -171,7 +180,7 @@ export async function buildRoutingContext(args: {
       || hit.conversation_id === args.explicitConversationId,
   );
   const prepared = prepareCandidates({
-    candidateModels: imageFilter.candidateModels,
+    candidateModels: documentCapableModels,
     metadataLookup: capabilityLookup,
     requiredCapabilities: imageFilter.requiredCapabilities,
     requestedReasoningEffort: args.interaction.reasoning?.effort,
@@ -308,6 +317,25 @@ function resolveImageCapableCandidates(args: {
   };
 }
 
+// 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: string[],
+  hasDocument: boolean,
+  supportsDocumentInput: (model: string) => boolean,
+): string[] {
+  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: {
   routerId: string;
   interaction: InteractionRequest;
@@ -335,3 +363,29 @@ 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: InteractionRequest,
+  credentials: { strict?: boolean; model_thinking_levels?: Record<string, ReasoningEffort[]> },
+  metadataLookup: ReturnType<typeof modelMetadataLookup>,
+): InteractionRequest {
+  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/src/ingress/anthropic_messages.ts

@@ -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 type { SelectorBackend } from "../strategies/routing.js";
 import { claudeCodeRequestContext } from "./claude_code/request_context.js";
@@ -12,7 +13,7 @@ import {
   claudeCodeConversationIdentity,
 } from "../runtime/harness_identity/index.js";
 import { parseJsonRequest } from "./json.js";
-import type { AnthropicSafeguards } from "../interaction/types.js";
+import type { AnthropicSafeguards, ReasoningControls } from "../interaction/types.js";
 
 type AnthropicErrorType =
   | "authentication_error"
@@ -42,6 +43,7 @@ export async function handleAnthropicMessages(
     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.
@@ -79,6 +81,18 @@ export async function handleAnthropicMessages(
   }
 }
 
+// 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: ReturnType<typeof anthropicMessagesToInteraction>,
+): ReasoningControls | undefined {
+  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: unknown): boolean {
   if (!Array.isArray(messages)) return false;
   const message = messages.at(-1);

package/src/ingress/codex.ts

@@ -35,12 +35,15 @@ export async function handleResponses(
       ...(museClientId === undefined ? {} : { museCodeClientId: museClientId }),
     };
     const codexIdentity = codexConversationIdentity(request.headers, rawPayload);
-    // Codex applies its global model_reasoning_effort setting to custom model
+    // 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 (codexIdentity !== 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));

package/src/interaction/capabilities.ts

@@ -24,6 +24,13 @@ function requiresWebSearch(item: InteractionItem): boolean {
   return item.type === "hosted_tool_call" && item.tool === "web_search";
 }
 
+export function requestHasDocument(request: Pick<InteractionRequest, "items">): boolean {
+  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: InteractionItem): boolean {
   if (item.type === "message") return item.content.some((part) => part.type === "image");
   return item.type === "tool_result" && Array.isArray(item.output) && item.output.some((part) => part.type === "image");

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/models/canonical.ts

@@ -0,0 +1,4 @@
+import canonicalIds from "./canonical_model_ids.json" with { type: "json" };
+
+/** The canonical model ids Dari serves, from the monorepo's router catalog. */
+export const CANONICAL_MODEL_IDS: readonly string[] = canonicalIds;

package/src/models/canonical_model_ids.json

@@ -0,0 +1,33 @@
+[
+  "openai/gpt-6-astra",
+  "openai/gpt-6.1-terra",
+  "openai/gpt-6.1-sol",
+  "openai/gpt-6-sol",
+  "openai/gpt-6-luna",
+  "openai/gpt-5.6-sol",
+  "openai/gpt-5.6-terra",
+  "openai/gpt-5.6-luna",
+  "anthropic/claude-opus-5-5",
+  "anthropic/claude-opus-5",
+  "anthropic/claude-sonnet-5-5",
+  "anthropic/claude-sonnet-5",
+  "anthropic/claude-fable-5-2",
+  "anthropic/claude-fable-5-1",
+  "anthropic/claude-fable-5",
+  "anthropic/claude-haiku-5-5",
+  "anthropic/claude-haiku-4-5",
+  "meta/muse-wonder-1.0",
+  "meta/muse-spark-1.3",
+  "meta/muse-ember",
+  "meta/muse-spark-1.2",
+  "moonshotai/Kimi-K3",
+  "zai-org/GLM-5.3",
+  "zai-org/GLM-5.3-Flash",
+  "deepseek-ai/DeepSeek-V4-Pro-0813",
+  "zai-org/GLM-5.2",
+  "deepseek-ai/DeepSeek-V4-Flash-0731",
+  "deepseek-ai/DeepSeek-V4.1-Flash-1017",
+  "deepseek-ai/DeepSeek-V4.1-Flash",
+  "xai/grok-4.6",
+  "xai/grok-4.7"
+]

package/src/models/runtime_overrides.ts

@@ -29,6 +29,10 @@ const MODEL_COMPAT_OVERRIDES: Record<string, Record<string, unknown>> = {
     forceAdaptiveThinking: true,
     supportsTemperature: false,
   },
+  "anthropic/claude-fable-5-2": {
+    forceAdaptiveThinking: true,
+    supportsTemperature: false,
+  },
   "anthropic/claude-opus-5-5": {
     forceAdaptiveThinking: true,
     supportsTemperature: false,
@@ -68,6 +72,14 @@ const MODEL_COMPAT_OVERRIDES: Record<string, Record<string, unknown>> = {
     supportsExplicitPromptCacheMode: true,
     supportsReasoningConfigurationUpdate: true,
   },
+  "openai/gpt-6.1-terra": {
+    supportsStrictMode: true,
+    supportsOpenAIGrammarTools: true,
+    supportsAdditionalTools: true,
+    supportsToolSearch: true,
+    supportsExplicitPromptCacheMode: true,
+    supportsReasoningConfigurationUpdate: true,
+  },
   "openai/gpt-6-sol": {
     supportsStrictMode: true,
     supportsOpenAIGrammarTools: true,
@@ -144,7 +156,9 @@ const NATIVE_REASONING_COMPAT_KEYS: ReadonlySet<string> = new Set([
 const MODEL_INPUT_OVERRIDES: Record<string, string[]> = {
   "anthropic/claude-haiku-5-5": ["text", "image"],
   "anthropic/claude-sonnet-5-5": ["text", "image"],
+  "meta/muse-ember": ["text", "image"],
   "openai/gpt-6.1-sol": ["text", "image"],
+  "openai/gpt-6.1-terra": ["text", "image"],
   "openai/gpt-6-sol": ["text", "image"],
   "openai/gpt-6-luna": ["text", "image"],
   "openai/gpt-5.6-luna": ["text", "image"],

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({