feat(runtime): materialize verified native PDF inputs

packages/core/src/attachments.ts

@@ -58,6 +58,20 @@ export const READ_IMAGE_TOO_LARGE_MESSAGE = `Image exceeds the ${MAX_READ_IMAGE_
 export const MAX_PROVIDER_IMAGE_REQUEST_BYTES = 12 * 1024 * 1024;
 export const PROVIDER_IMAGE_BUDGET_EXCEEDED_MESSAGE = `Image was read, but the per-request image budget (${MAX_PROVIDER_IMAGE_REQUEST_BYTES / 1024 / 1024}MB across all images this turn) was exceeded; earlier images were sent and this one was omitted. Read fewer or smaller images.`;
 
+/**
+ * Native PDF requests are Base64 encoded. Sixteen raw MiB expands to roughly
+ * 21.4 MiB, leaving headroom under Anthropic's 32 MiB whole-request limit for
+ * text, tool schemas, JSON framing, and other content.
+ */
+export const MAX_PROVIDER_PDF_REQUEST_BYTES = 16 * 1024 * 1024;
+
+/**
+ * Shared raw-byte ceiling across image and PDF inputs. Eighteen raw MiB
+ * expands to 24 MiB in Base64, preserving 8 MiB of whole-request headroom on
+ * the strictest verified native PDF route.
+ */
+export const MAX_PROVIDER_BINARY_REQUEST_BYTES = 18 * 1024 * 1024;
+
 const MIME_BY_EXTENSION: Readonly<Record<string, string>> = {
   png: 'image/png',
   jpg: 'image/jpeg',
@@ -88,10 +102,9 @@ export function guessMimeFromName(fileName: string): string {
 
 /**
  * Route a MIME type to an {@link AttachmentRef} kind. The runtime
- * consumption split is image vs. everything-else (images become provider
- * image parts; other kinds are read on demand by the model via Read), so this
- * only needs to single out the kinds that change
- * consumption or display. Unknown / unmapped MIME falls back to `other`.
+ * consumption split singles out images and PDFs (authorized routes can send
+ * them as provider file parts); text-like kinds are read on demand by the
+ * model via Read. Unknown / unmapped MIME falls back to `other`.
  *
  * `fileName` is consulted for kinds whose MIME is unreliable across OSes
  * (Office documents arrive as `application/octet-stream` or a long

packages/runtime-host/src/__tests__/execution-model-composition.test.ts

@@ -237,6 +237,106 @@ test('backend creation does not treat aliased provider metadata as inventory', a
   );
 });
 
+test('Host composition carries verified native PDF input through the provider wire', async () => {
+  const modelId = 'gpt-4o';
+  const provider = await startProvider();
+  let attachmentReads = 0;
+  let backend: Awaited<ReturnType<typeof createHostAiSdkBackend>> | undefined;
+  try {
+    backend = await createHostAiSdkBackend(
+      backendCreationFixture({
+        abortSignal: new AbortController().signal,
+        modelId,
+        resolveExecutionConnection: async () => ({
+          kind: 'ready',
+          connection: {
+            slug: 'backend-creation-connection',
+            providerType: 'openai',
+            baseUrl: provider.baseUrl,
+            enabledModelIds: [modelId],
+            models: [
+              {
+                id: modelId,
+                capabilities: { chat: true, functionCalling: true },
+                modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+                contextWindow: 8_192,
+                maxOutputTokens: 1_024,
+              },
+            ],
+          },
+          networkProxy: { enabled: false },
+          secretMaterial: { connection: { secret: API_KEY } },
+        }),
+        readPricing: async () => ({ revision: 0, overrides: [] }),
+        artifacts: {
+          readDurableAttachmentBinary: async ({
+            artifactId,
+            sessionId,
+          }: {
+            artifactId: string;
+            sessionId: string;
+          }) => {
+            attachmentReads += 1;
+            assert.equal(artifactId, 'brief');
+            assert.equal(sessionId, 'backend-creation-session');
+            return { ok: true, base64: 'JVBERi0=', mimeType: 'application/pdf' };
+          },
+        } as unknown as HostAiSdkBackendInput['artifacts'],
+      }),
+    );
+
+    const events = [];
+    for await (const event of backend.send({
+      invocationId: 'pdf-composition-invocation',
+      runId: 'pdf-composition-run',
+      turnId: 'pdf-composition-turn',
+      text: 'Read the attached PDF.',
+      attachments: [
+        {
+          kind: 'pdf',
+          name: 'brief.pdf',
+          mimeType: 'application/pdf',
+          bytes: 8,
+          ref: {
+            kind: 'session_file',
+            sessionId: 'backend-creation-session',
+            relativePath: 'brief',
+          },
+        },
+      ],
+      context: [],
+      runtimeContext: [],
+    })) {
+      events.push(event);
+    }
+
+    assert.equal(
+      events.find((event) => event.type === 'complete')?.stopReason,
+      'end_turn',
+      JSON.stringify({ events, providerRequests: provider.requests }),
+    );
+    assert.equal(attachmentReads, 1);
+    assert.equal(provider.requests.length, 1);
+    const messages = provider.requests[0]?.body.messages;
+    assert.ok(Array.isArray(messages));
+    const filePart = messages
+      .flatMap((message: { content?: unknown }) =>
+        Array.isArray(message.content) ? message.content : [],
+      )
+      .find((part: { type?: unknown }) => part.type === 'file');
+    assert.deepEqual(filePart, {
+      type: 'file',
+      file: {
+        filename: 'brief.pdf',
+        file_data: 'data:application/pdf;base64,JVBERi0=',
+      },
+    });
+  } finally {
+    await backend?.dispose();
+    await provider.close();
+  }
+});
+
 test('provider dispatch fails closed when the Run Composition commit fails', async () => {
   const provider = await startProvider();
   let commits = 0;
@@ -3180,6 +3280,7 @@ function backendCreationFixture(input: {
   recordModelCallAttempt?: BackendFactoryContext['recordModelCallAttempt'];
   createFetchTransport?: HostAiSdkBackendInput['createFetchTransport'];
   createRunComposer?: HostAiSdkBackendInput['createRunComposer'];
+  artifacts?: HostAiSdkBackendInput['artifacts'];
 }): HostAiSdkBackendInput {
   const runtimePolicy =
     input.runtimePolicy ??
@@ -3252,7 +3353,7 @@ function backendCreationFixture(input: {
     ...(input.oauthCredentials ? { oauthCredentials: input.oauthCredentials } : {}),
     ...(input.claudeDeviceId ? { claudeDeviceId: input.claudeDeviceId } : {}),
     createRunComposer,
-    artifacts: {},
+    artifacts: input.artifacts ?? {},
     executionArtifacts: {
       recordToolArtifacts: async () => undefined,
       toolResultArchive: createToolResultArchiveCapability({

packages/runtime-host/src/server/execution-model-composition.ts

@@ -14,6 +14,7 @@ import { buildLlmHistorySummarizer } from '@maka/runtime/history-compact-summari
 import { buildOpenAiCodexHistoryCompactor } from '@maka/runtime/openai-codex-history-compactor';
 import { buildPricingLookup, recordToolInvocation } from '@maka/runtime/telemetry';
 import { buildProviderOptions, getAIModel } from '@maka/runtime/model-factory';
+import { resolveModelPdfInputContract } from '@maka/runtime/model-runtime';
 import { createProviderRequestCaptureRecorder } from '@maka/runtime/provider-request-telemetry';
 import {
   createProxiedFetchTransport,
@@ -132,6 +133,7 @@ export async function createHostAiSdkBackend(input: HostAiSdkBackendInput): Prom
     input.context.header.thinkingLevel,
   );
   const contextWindow = resolveSelectedModelContextWindow(target.connection, target.model);
+  const pdfInputContract = resolveModelPdfInputContract(target.connection, target.model);
   let modelComposition: HostRunComposer;
   try {
     modelComposition = await readDuringBackendCreation(
@@ -362,6 +364,7 @@ export async function createHostAiSdkBackend(input: HostAiSdkBackendInput): Prom
           target.model,
           relayModelProfile(target.connection, target.model)?.vision,
         ),
+        ...(pdfInputContract ? { pdfInputContract } : {}),
         readAttachmentBytes: createAttachmentByteReader({
           artifactStore: input.artifacts,
           sessionId: input.context.sessionId,