melchizedek-agents 1.13.0 → 1.14.0

package/.env.example

@@ -295,7 +295,10 @@ PUBLIC_URL=
 # OpenAPI tools: the exact environment variables an `auth:` may name. Unset, any
 # variable but the framework's own settings (this file's) is allowed.
 # OPENAPI_CREDENTIAL_ENVS=WEATHER_API_KEY,CRM_TOKEN
-# A2A_BODY_LIMIT=1mb
+# Inline files in one message, decoded bytes; 0 refuses file parts. A file by URL is always refused.
+# A2A_MAX_FILE_BYTES=10485760
+# Set by default to hold A2A_MAX_FILE_BYTES as base64.
+# A2A_BODY_LIMIT=15mb
 # How long SIGTERM waits for running tasks before canceling them.
 # A2A_SHUTDOWN_GRACE_MS=25000
 # Of that, how long /readyz fails while requests are still served, so a load

package/CHANGELOG.md

@@ -4,6 +4,24 @@ Consumers of the package read this file; it records changes to the
 **published API surface** (the exports map in `package.json`, the bins,
 the starter pack and the templates), not the repo's full history.
 
+## 1.14.0 — 2026-11-01
+
+**Files in a message.** The A2A server takes inline file parts (`raw`, or 0.3's
+`file.bytes`): images and documents the agent's model reads go to it as blobs,
+text types as a text part, and anything else ends `rejected` naming what it
+does read. `A2A_MAX_FILE_BYTES` (default 10 MiB) caps one message's files, and
+0 restores the old refusal; `A2A_BODY_LIMIT` now defaults to what holds that
+limit as base64. A file by URL is still refused. The agent card's
+`defaultInputModes` lists the types.
+
+**`attachmentSupport(model)`** (from the barrel) says which file types a
+model's path takes and how large, for a caller that converts a file first.
+
+**Claude reads PDFs.** A `application/pdf` blob is a `document` block; it was
+dropped. The chat-completions adapters no longer label a non-image blob as an
+image, which failed the whole request; it is left out with a warning. A failed
+call's recorded request keeps a file's size, not its bytes.
+
 ## 1.13.0 — 2026-10-24
 
 **A Prompt Writer template.** `templates/prompt_writer.yaml` writes

package/DOCUMENTATION.md

@@ -1056,7 +1056,7 @@ running". The lock is in-process by default and a Postgres advisory lock
 with `DATABASE_URL`, so it holds across instances. `tasks/cancel` stops a running task, including the model call
 in flight, and the task ends `canceled`. Final states: `completed`,
 `failed` (the message names the stage and the provider's reason),
-`canceled`, `rejected` (a file part, an empty message, or the server at
+`canceled`, `rejected` (a file its model does not read, a file by URL, an empty message, or the server at
 capacity). Message parts may be `text` or `data` (sent to the model as
 JSON); `file` parts are refused.
 

package/dist/lib/a2a/app.d.ts

@@ -309,8 +309,10 @@ export interface A2AAppOptions {
     };
     /** Express `trust proxy` setting (hop count, boolean, or subnet list). */
     trustProxy?: number | boolean | string;
-    /** JSON body size limit, e.g. "1mb". */
+    /** JSON body size limit, e.g. "1mb". An inline file is base64 in this body: leave room for `maxFileBytes`. */
     bodyLimit?: string;
+    /** Largest total of inline files in one message, decoded bytes. Undefined or 0 refuses file parts. */
+    maxFileBytes?: number;
     /**
      * Allowlist of agent ids reachable at /:agentId/*. Undefined = any id with
      * a file in the deployment's own agents directory. Ids listed here may also
@@ -386,6 +388,8 @@ export declare function compileAgentCard(config: SyndicateYamlConfig, opts: {
     identity?: IdentityScheme;
     version: string;
     byok?: boolean;
+    /** The server takes file parts: the card names what this agent's model reads. */
+    files?: boolean;
 }): AgentCard;
 /**
  * The app name a syndicate's sessions and memory are stored under: its

package/dist/lib/a2a/app.js

@@ -73,6 +73,7 @@ import { setCredentialHosts } from '../tools/credentialHosts.js';
 import { syndicateCredentialHostProblems } from '../tools/credentialUses.js';
 import { syndicateOAuthHostProblems } from '../tools/oauthTools.js';
 import { credentialValue } from '../models/credentialSource.js';
+import { attachmentSupport } from '../models/attachments.js';
 const SURFACE_HEADERS = [
     ['x-surface', 'name'],
     ['x-surface-guild', 'guild'],
@@ -183,6 +184,7 @@ const scopeUserBuilder = async () => {
  */
 export function compileAgentCard(config, opts) {
     const base = `${opts.baseUrl.replace(/\/$/, '')}${opts.routePrefix ?? ''}`;
+    const fileSupport = opts.files ? attachmentSupport(config.orchestrator?.model) : undefined;
     const securitySchemes = {};
     if (opts.byok) {
         securitySchemes.apiKey = {
@@ -242,7 +244,7 @@ export function compileAgentCard(config, opts) {
         },
         securitySchemes,
         securityRequirements: Object.keys(requirement).length ? [{ schemes: requirement }] : [],
-        defaultInputModes: ['text/plain', 'application/json'],
+        defaultInputModes: ['text/plain', 'application/json', ...(fileSupport ? [...fileSupport.images, ...fileSupport.documents, ...fileSupport.media] : [])],
         defaultOutputModes: ['text/plain'],
         skills: (config.subagents ?? []).map((sub) => ({
             id: sub.name,
@@ -541,6 +543,7 @@ export async function createA2AApp(options) {
             memoryService: services.memoryService,
             compileFor,
             taskTimeoutMs: options.taskTimeoutMs,
+            maxFileBytes: options.maxFileBytes,
             streamText: options.streamText,
             turnLock,
             turnLockWaitMs: options.turnLockWaitMs,
@@ -556,6 +559,7 @@ export async function createA2AApp(options) {
         });
         const version = executor.configHashFor().slice(0, 12);
         const cardFor = (base) => compileAgentCard(cfg, {
+            files: !!options.maxFileBytes,
             baseUrl: base,
             routePrefix,
             bearer: !!options.serverSecret,

package/dist/lib/a2a/executor.d.ts

@@ -26,6 +26,7 @@ import type { TaskRecord } from '../observability/metrics.ts';
 import type { AuditSink } from '../observability/audit.ts';
 import type { Policy } from './policy.ts';
 import type { Metadata } from '../observability/metadata.ts';
+import type { AttachmentSupport } from '../models/attachments.ts';
 /** Per-request caller context, set by the server's identity middleware. */
 export interface A2AContext {
     /** The caller's provider key in BYOK mode (or from resolveRequest); '' otherwise. */
@@ -108,17 +109,24 @@ export declare function describeTurnError(error: {
 }): string;
 /** The failed task's message for a turn result. */
 export declare function describeFailedTurn(result: SyndicateTurnResult): string;
+/** What this server takes as a file part: the bytes it allows and what the agent's model reads. */
+export interface FilePartPolicy {
+    /** Largest total of files in one message, decoded bytes. */
+    maxBytes: number;
+    support: AttachmentSupport;
+}
 /**
  * A2A message parts → model parts. Text passes through; a `data` part
  * becomes its JSON as text (callers inject structured payloads this way).
- * File parts (`url` or `raw` content) are refused with a clear error rather
- * than silently blanked: a file URL fetched server-side is an SSRF surface,
- * and inline bytes need a size policy this server does not yet have.
+ * An inline file (`raw` content, or 0.3's `file.bytes`) becomes a blob part
+ * the agent's model reads, or text when it is text, within `files`; anything
+ * else is refused with a clear error rather than silently blanked. A file by
+ * URL is always refused: fetching one server-side is an SSRF surface.
  *
  * Accepts A2A 1.0 parts (`content.$case`) and, for callers that hand in
  * plain objects, the 0.3 shapes (`kind: 'text' | 'data' | 'file'`).
  */
-export declare function a2aPartsToMessage(rawParts: unknown[]): {
+export declare function a2aPartsToMessage(rawParts: unknown[], files?: FilePartPolicy): {
     parts: MessagePart[];
     refused?: string;
 };
@@ -132,6 +140,8 @@ export interface ExecutorOptions {
     compileFor: (ctx: A2AContext) => CompileOptions;
     /** Wall-clock budget per task in ms; 0 or undefined = none. */
     taskTimeoutMs?: number;
+    /** Largest total of inline files in one message, decoded bytes; 0 or undefined refuses file parts. */
+    maxFileBytes?: number;
     /** Shared across every executor on the server. */
     limiter: TaskLimiter;
     /** The agent id this executor serves ('' for the default syndicate). */

package/dist/lib/a2a/executor.js

@@ -27,6 +27,7 @@ import { isWorkflowSyndicate } from '../workflow.js';
 import { describeInput } from '../runtime/syndicateTurn.js';
 import { describeConsent } from '../runtime/credentials.js';
 import { MAX_META_KEYS, metaAttributes, requestMetadata } from '../observability/metadata.js';
+import { attachmentSupport, takesBlob } from '../models/attachments.js';
 export const requestContextStorage = new AsyncLocalStorage();
 /** The app name every A2A session and memory silo is stored under. */
 export const A2A_APP_NAME = 'melchizedek-a2a';
@@ -143,19 +144,62 @@ export function describeFailedTurn(result) {
     }
     return `Error: [${error.code}] The agent run failed — ${describeTurnError(error)}`;
 }
+/** Types read as text whatever the model: they go to it as a text part. */
+const TEXT_FILE = /^(text\/[\w.+-]+|application\/(json|xml|yaml|x-yaml|x-ndjson|csv))$/;
+/** A file's name as the model reads it: printable and short, since the caller chose it. */
+const fileLabel = (name) => (typeof name === 'string' ? name : '').replace(/[^\p{L}\p{N} ._()-]/gu, '_').slice(0, 120) || 'file';
+/** One inline file as model parts, or why it is refused. */
+function filePart(bytes, declared, name, policy) {
+    const type = String(declared ?? '').split(';')[0].trim().toLowerCase();
+    const shown = type.replace(/[^\x20-\x7e]/g, '?').slice(0, 64) || 'a file with no type';
+    if (TEXT_FILE.test(type)) {
+        let text;
+        try {
+            text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        }
+        catch {
+            return `The file part declared as ${shown} is not UTF-8 text.`;
+        }
+        return { text: `<attached_file name="${fileLabel(name)}" type="${shown}">\n${text}\n</attached_file>` };
+    }
+    if (!takesBlob(policy.support, type))
+        return `This agent's model does not read ${shown}. It reads ${[...policy.support.images, ...policy.support.documents, ...policy.support.media].join(', ')} and text.`;
+    const limit = policy.support.images.includes(type) ? policy.support.maxImageBytes : policy.support.maxFileBytes;
+    if (bytes.length > limit)
+        return `A ${shown} file may be at most ${limit} bytes for this agent's model; this one is ${bytes.length}.`;
+    return { inlineData: { mimeType: type, data: bytes.toString('base64') } };
+}
 /**
  * A2A message parts → model parts. Text passes through; a `data` part
  * becomes its JSON as text (callers inject structured payloads this way).
- * File parts (`url` or `raw` content) are refused with a clear error rather
- * than silently blanked: a file URL fetched server-side is an SSRF surface,
- * and inline bytes need a size policy this server does not yet have.
+ * An inline file (`raw` content, or 0.3's `file.bytes`) becomes a blob part
+ * the agent's model reads, or text when it is text, within `files`; anything
+ * else is refused with a clear error rather than silently blanked. A file by
+ * URL is always refused: fetching one server-side is an SSRF surface.
  *
  * Accepts A2A 1.0 parts (`content.$case`) and, for callers that hand in
  * plain objects, the 0.3 shapes (`kind: 'text' | 'data' | 'file'`).
  */
-export function a2aPartsToMessage(rawParts) {
+export function a2aPartsToMessage(rawParts, files) {
     const parts = [];
-    const refusal = 'File parts are not supported by this server; send text or data parts.';
+    const refusal = files ? 'A file part given by URL is not fetched by this server; send its bytes.' : 'File parts are not supported by this server; send text or data parts.';
+    let total = 0;
+    /** Adds one inline file; a string is why the message is refused. */
+    const addFile = (value, declared, name) => {
+        if (!files)
+            return refusal;
+        const bytes = typeof value === 'string' ? Buffer.from(value, 'base64') : value instanceof Uint8Array ? Buffer.from(value) : null;
+        if (!bytes || bytes.length === 0)
+            return 'A file part has no bytes.';
+        total += bytes.length;
+        if (total > files.maxBytes)
+            return `The files in one message may total at most ${files.maxBytes} bytes on this server.`;
+        const part = filePart(bytes, declared, name, files);
+        if (typeof part === 'string')
+            return part;
+        parts.push(part);
+        return undefined;
+    };
     for (const raw of rawParts) {
         if (typeof raw === 'string') {
             parts.push({ text: raw });
@@ -168,8 +212,13 @@ export function a2aPartsToMessage(rawParts) {
                 parts.push({ text: content.value });
             else if (content.$case === 'data')
                 parts.push({ text: JSON.stringify(content.value) });
-            else if (content.$case === 'url' || content.$case === 'raw')
+            else if (content.$case === 'url')
                 return { parts, refused: refusal };
+            else if (content.$case === 'raw') {
+                const refused = addFile(content.value, p.mediaType, p.filename);
+                if (refused)
+                    return { parts, refused };
+            }
             continue;
         }
         const kind = p.kind ?? (p.text !== undefined ? 'text' : p.data !== undefined ? 'data' : p.file !== undefined ? 'file' : undefined);
@@ -181,7 +230,11 @@ export function a2aPartsToMessage(rawParts) {
             parts.push({ text: JSON.stringify(p.data) });
         }
         else if (kind === 'file') {
-            return { parts, refused: refusal };
+            if (p.file?.bytes === undefined)
+                return { parts, refused: refusal };
+            const refused = addFile(p.file.bytes, p.file.mimeType, p.file.name);
+            if (refused)
+                return { parts, refused };
         }
     }
     return { parts };
@@ -606,7 +659,7 @@ export class SyndicateExecutor {
                 throw new Error('No authentication context available.');
             ctxForReport = ctx;
             const rawParts = message?.parts ?? message?.content ?? [];
-            const mapped = a2aPartsToMessage(rawParts);
+            const mapped = a2aPartsToMessage(rawParts, this.opts.maxFileBytes ? { maxBytes: this.opts.maxFileBytes, support: attachmentSupport(this.opts.config.orchestrator?.model, { callerKey: !!ctx.apiKey }) } : undefined);
             const refused = mapped.refused;
             let parts = mapped.parts;
             if (refused) {

package/dist/lib/index.d.ts

@@ -68,6 +68,8 @@ export type { MemoryStore } from './memory/store.ts';
 export { validateSyndicateConfig, syndicateJsonSchema, SyndicateValidationError } from './syndicateSchema.ts';
 export { PROVIDERS, providerForModel, providerKeyPresent, providerStatuses, logProviderStatuses, resolveModel, describeCapabilities, capabilitySummary, planTransport, gatewayConfig, gatewayProblem, gatewayUsable, GATEWAYS, } from './models/registry.ts';
 export { loadEnv } from './loadEnv.ts';
+export { attachmentSupport, takesBlob } from './models/attachments.ts';
+export type { AttachmentSupport } from './models/attachments.ts';
 export { setCredentialSource, credentialValue } from './models/credentialSource.ts';
 export type { CredentialSource } from './models/credentialSource.ts';
 export { PROJECT_MANIFEST, projectManifestSchema, ProjectManifestError, findProject, findProjectRoot, loadProject, parseProjectManifest, resolveAgentsDir, listProjectSyndicates, checkProject, type Project, type ProjectManifest, type ProjectCheck, } from './project.ts';

package/dist/lib/index.js

@@ -54,6 +54,8 @@ export { PROVIDERS, providerForModel, providerKeyPresent, providerStatuses, logP
 // subpath until 0.16.0.
 describeCapabilities, capabilitySummary, planTransport, gatewayConfig, gatewayProblem, gatewayUsable, GATEWAYS, } from './models/registry.js';
 export { loadEnv } from './loadEnv.js';
+// Which files a model's path takes in a user message, and how large.
+export { attachmentSupport, takesBlob } from './models/attachments.js';
 // Where credentials are read, by environment variable name (ADR 0133).
 export { setCredentialSource, credentialValue } from './models/credentialSource.js';
 // Project manifest, melchizedek.json (ADR 0138).

package/dist/lib/models/attachments.d.ts

@@ -0,0 +1,42 @@
+/**
+ * lib/models/attachments.ts — which files a model's path takes in a user
+ * message, and how large.
+ *
+ * WHY this file exists:
+ *   A file reaches a model as a blob part, and what an adapter can send
+ *   differs by provider: Gemini takes audio and video, the Messages API and
+ *   the Responses API take PDFs, a chat-completions path takes images only. A
+ *   caller that converts or shrinks a file first (the desktop app), and the
+ *   A2A server that refuses one, read the same table, so neither learns of a
+ *   mismatch from a provider's 400.
+ *
+ * Limits are the provider's published ones, set a little under where the
+ * base64 a request carries is what is counted. `maxRequestBytes` is decoded
+ * bytes across a whole request, and a conversation's earlier files are in it.
+ */
+export interface AttachmentSupport {
+    /** Image types sent as images. */
+    images: readonly string[];
+    /** Document types sent as documents; anything else must arrive as text. */
+    documents: readonly string[];
+    /** Audio and video types sent as they are. */
+    media: readonly string[];
+    /** The longest image edge worth sending, in pixels: past it the provider shrinks the image or refuses it. */
+    maxImageEdge: number;
+    /** Largest image, decoded bytes. */
+    maxImageBytes: number;
+    /** Largest document or media file, decoded bytes. */
+    maxFileBytes: number;
+    /** Largest total of files in one request, decoded bytes. */
+    maxRequestBytes: number;
+}
+/**
+ * What `model` takes on the path it will actually run on. A gateway speaks
+ * chat completions whichever provider is behind it, so a direct-only type is
+ * not offered there. An id no path serves reads as the plain table.
+ */
+export declare function attachmentSupport(model: unknown, opts?: {
+    callerKey?: boolean;
+}): AttachmentSupport;
+/** Whether a media type is sent as a blob on this path (not whether it fits). */
+export declare function takesBlob(support: AttachmentSupport, mediaType: string): boolean;

package/dist/lib/models/attachments.js

@@ -0,0 +1,80 @@
+/**
+ * lib/models/attachments.ts — which files a model's path takes in a user
+ * message, and how large.
+ *
+ * WHY this file exists:
+ *   A file reaches a model as a blob part, and what an adapter can send
+ *   differs by provider: Gemini takes audio and video, the Messages API and
+ *   the Responses API take PDFs, a chat-completions path takes images only. A
+ *   caller that converts or shrinks a file first (the desktop app), and the
+ *   A2A server that refuses one, read the same table, so neither learns of a
+ *   mismatch from a provider's 400.
+ *
+ * Limits are the provider's published ones, set a little under where the
+ * base64 a request carries is what is counted. `maxRequestBytes` is decoded
+ * bytes across a whole request, and a conversation's earlier files are in it.
+ */
+import { planTransport } from './gateway.js';
+const MB = 1024 * 1024;
+/** Any path that takes a data URI: the chat-completions adapters, Ollama and the gateways. */
+const PLAIN = {
+    images: ['image/jpeg', 'image/png'],
+    documents: [],
+    media: [],
+    maxImageEdge: 1568,
+    maxImageBytes: 8 * MB,
+    maxFileBytes: 0,
+    maxRequestBytes: 14 * MB,
+};
+const DIRECT = {
+    anthropic: {
+        images: ['image/jpeg', 'image/png', 'image/gif', 'image/webp'],
+        documents: ['application/pdf'],
+        media: [],
+        maxImageEdge: 1568,
+        maxImageBytes: 3.75 * MB,
+        maxFileBytes: 22 * MB,
+        maxRequestBytes: 22 * MB,
+    },
+    openai: {
+        images: ['image/jpeg', 'image/png', 'image/gif', 'image/webp'],
+        documents: ['application/pdf'],
+        media: [],
+        maxImageEdge: 2048,
+        maxImageBytes: 20 * MB,
+        maxFileBytes: 32 * MB,
+        maxRequestBytes: 36 * MB,
+    },
+    gemini: {
+        images: ['image/jpeg', 'image/png', 'image/webp', 'image/heic', 'image/heif'],
+        documents: ['application/pdf'],
+        media: [
+            'audio/wav', 'audio/mp3', 'audio/mpeg', 'audio/aiff', 'audio/aac', 'audio/ogg', 'audio/flac',
+            'video/mp4', 'video/mpeg', 'video/quicktime', 'video/webm',
+        ],
+        maxImageEdge: 3072,
+        maxImageBytes: 14 * MB,
+        maxFileBytes: 14 * MB,
+        maxRequestBytes: 14 * MB,
+    },
+};
+/**
+ * What `model` takes on the path it will actually run on. A gateway speaks
+ * chat completions whichever provider is behind it, so a direct-only type is
+ * not offered there. An id no path serves reads as the plain table.
+ */
+export function attachmentSupport(model, opts = {}) {
+    if (typeof model !== 'string' || !model)
+        return PLAIN;
+    try {
+        const plan = planTransport(model, opts);
+        return (plan.transport === 'direct' && DIRECT[plan.provider]) || PLAIN;
+    }
+    catch {
+        return PLAIN;
+    }
+}
+/** Whether a media type is sent as a blob on this path (not whether it fits). */
+export function takesBlob(support, mediaType) {
+    return support.images.includes(mediaType) || support.documents.includes(mediaType) || support.media.includes(mediaType);
+}

package/dist/lib/models/chatCompletionsAdapter.js

@@ -837,7 +837,12 @@ export class ChatCompletionsAdapter {
                         else if (part.data) {
                             // Inline only: a data URI for vision models. A URL blob is not
                             // sent (Moonshot takes no public image URLs).
-                            images.push({ type: 'image_url', image_url: { url: `data:${part.mimeType || 'image/png'};base64,${part.data}` } });
+                            const type = !part.mimeType || part.mimeType === 'application/octet-stream' ? 'image/png' : part.mimeType;
+                            // This wire has images only; a PDF labelled as one would fail the whole request.
+                            if (type.startsWith('image/'))
+                                images.push({ type: 'image_url', image_url: { url: `data:${type};base64,${part.data}` } });
+                            else
+                                console.warn(`⚠ A file part (${type.replace(/[^\x20-\x7e]/g, '?').slice(0, 64)}) is not sent: this path takes images only.`);
                         }
                     }
                     const text = texts.join('\n');

package/dist/lib/models/claudeAdapter.js

@@ -105,6 +105,16 @@ function imageBlockFor(part, urlImages) {
     const named = (type) => type.replace(/[^\x20-\x7e]/g, '?').slice(0, 64);
     const declared = String(part.mimeType ?? '').toLowerCase();
     const untyped = UNTYPED.has(declared);
+    if (declared === 'application/pdf') {
+        if (part.data !== undefined)
+            return part.data ? { type: 'document', source: { type: 'base64', media_type: 'application/pdf', data: part.data } } : undefined;
+        const uri = String(part.url ?? '');
+        if (!uri)
+            return undefined;
+        if (!/^https:\/\//i.test(uri))
+            return `non-https URL (${/^[a-z][a-z0-9+.-]*:/i.exec(uri)?.[0] ?? 'no scheme'})`;
+        return urlImages ? { type: 'document', source: { type: 'url', url: uri } } : URL_SOURCE;
+    }
     if (part.data !== undefined) {
         if (!part.data)
             return undefined;

package/dist/lib/observability/tracer.js

@@ -628,7 +628,7 @@ function safePayloadJson(value) {
 /** What `llm.payload.request` records for a failed call: the ModelRequest less its signal, else the older `llmRequest`. */
 function payloadRequest(meta) {
     if (meta.request === undefined)
-        return meta.llmRequest;
+        return withoutFileBytes(meta.llmRequest);
     let request;
     try {
         request = typeof meta.request === 'function' ? meta.request() : meta.request;
@@ -637,7 +637,18 @@ function payloadRequest(meta) {
         return undefined;
     }
     const { signal: _signal, ...recorded } = request;
-    return recorded;
+    return withoutFileBytes(recorded);
+}
+/** A copy with each file's bytes replaced by their count: a request's base64 would fill the payload's cap and say nothing a reader can use. */
+function withoutFileBytes(value) {
+    if (Array.isArray(value))
+        return value.map(withoutFileBytes);
+    if (!value || typeof value !== 'object')
+        return value;
+    const v = value;
+    if (typeof v.mimeType === 'string' && typeof v.data === 'string')
+        return { ...v, data: `[${Math.floor((v.data.length * 3) / 4)} bytes not recorded]` };
+    return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, withoutFileBytes(x)]));
 }
 /**
  * Providers throw errors whose message IS the API's JSON error body

package/dist/scripts/a2a_server.js

@@ -46,7 +46,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
  *   A2A_AUTH_FAILURE_MAX      failed authentications per window per IP (30)
  *   A2A_TRUST_PROXY           Express trust-proxy: hop count, true/false, or subnets
  *                             (false; required with PUBLIC_URL)
- *   A2A_BODY_LIMIT            JSON body limit ("1mb")
+ *   A2A_MAX_FILE_BYTES        inline files in one message, decoded bytes (10485760; 0 refuses file parts)
+ *   A2A_BODY_LIMIT            JSON body limit ("1mb", or "15mb" with file parts on)
  *   A2A_KEY_MODE              server (default): models run on the server's keys;
  *                             byok: the caller's X-API-Key pays. Under A2A_AUTH=secret
  *                             the mode also scopes data: X-User-Id in server mode,
@@ -479,7 +480,9 @@ export async function startServer(syndicateName = 'syndicate.yaml', extensions =
             authFailureLimit: { windowMs: 15 * 60 * 1000, max: envInt('A2A_AUTH_FAILURE_MAX', 30) },
             trustProxy: envTrustProxy(),
             ...(limitStore ? { limitStore } : {}),
-            bodyLimit: process.env.A2A_BODY_LIMIT?.trim() || '1mb',
+            maxFileBytes: envInt('A2A_MAX_FILE_BYTES', 10 * 1024 * 1024),
+            // Base64 is 4/3 of the bytes; the body must hold what the file limit allows.
+            bodyLimit: process.env.A2A_BODY_LIMIT?.trim() || `${Math.max(1, Math.ceil((envInt('A2A_MAX_FILE_BYTES', 10 * 1024 * 1024) * 4) / 3 / (1024 * 1024)) + 1)}mb`,
             servedAgents,
             registryAgents,
             keyMode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melchizedek-agents",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "A multi-model, multi-agent orchestration framework — YAML-defined syndicates on the engine's own agent loop, Supabase or Postgres session persistence, pgvector long-term memory. Companion repo to the lyceumagents.com curriculum.",
   "type": "module",
   "license": "MIT",