@arnilo/prism-supervisor 0.0.6 → 0.0.8

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## Unreleased
+
+## [0.0.8] - 2026-07-20
+
+- Added host-owned durable A2A task start/get/list/cancel/subscribe with bounded cursor replay, interrupted states, ordered rich task events, and non-disclosing task errors.
+- Added opt-in bounded text/raw/URL/data parts; URL policy validates without dereferencing.
+- Added capability-gated push config CRUD/client APIs and explicit bounded `deliverA2APushEvent()` retry/timeout/idempotency-key wrapper; webhook transport/credentials remain host-owned and secrets are omitted from responses.
+
+## [0.0.7] - 2026-07-19
+
+- Released with the exact 0.0.7 first-party package graph.
+
 ## [0.0.6] - 2026-07-19
 
 - Fixed A2A streaming UTF-8 corruption across chunk boundaries with one fatal streaming decoder and incremental LF/CRLF/multiline SSE parsing; truncated or post-terminal streams fail without changing existing limits.

package/README.md

@@ -26,6 +26,6 @@ const supervisor = createSupervisor({
 console.log((await supervisor.delegate({ childId: "research", input: "Check sources" })).text);
 ```
 
-Also exports A2A 1.0 `createA2AAgentCard`, `signA2AAgentCard`, `verifyA2AAgentCard`, `createA2AHandler`, and `createA2AClient`. Streaming uses one fatal UTF-8 decoder, accepts LF/CRLF/mixed SSE separators and multiline `data:`, rejects truncated/post-terminal frames, and retains existing finite byte/event/time limits. Only text parts and JSON-RPC `SendMessage`, `SendStreamingMessage`, and `GetExtendedAgentCard` are supported. Hosts own authentication, TLS, endpoint allow-lists, child credential resolution, and memory construction from package-derived resource/thread IDs.
+Also exports bounded A2A 1.0 cards, handler/client, rich one-of parts, host-owned `A2ATaskLifecycle`, reconnect subscriptions, and push-config CRUD. Direct text invocation remains compatible; durable get/list/cancel/subscribe and rich raw/data/URL parts require explicit adapters/policy. URL parts are validated but never fetched. Push persistence/network/credentials and exact-owner checks remain host-owned; explicit `deliverA2APushEvent()` only bounds attempts/time and forwards stable event IDs for host idempotency. Returned configs omit secrets. JSON-RPC/HTTPS is the only binding.
 
 See [Supervisors](../../docs/supervisors.md) and [A2A interoperability](../../docs/a2a.md).

package/dist/a2a-card.js

@@ -60,6 +60,15 @@ function canonicalCard(card) {
     return canonicalJson(unsigned);
 }
 function validateCard(card) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(card);
+    }
+    catch {
+        throw new A2AError("Agent card must be JSON", 400, "ERR_PRISM_A2A_CARD");
+    }
+    if (Buffer.byteLength(serialized) > 1024 * 1024 || card.supportedInterfaces.length > 16 || card.skills.length > 256)
+        throw new A2AError("Agent card exceeds collection/byte limits", 400, "ERR_PRISM_A2A_CARD");
     if (!card.name?.trim() || !card.description?.trim() || !card.version?.trim())
         throw new A2AError("Agent card identity is incomplete", 400, "ERR_PRISM_A2A_CARD");
     if (!card.supportedInterfaces.length || !card.supportedInterfaces.every((item) => item.protocolBinding === "JSONRPC" && item.protocolVersion === "1.0" && isHttpsUrl(item.url)))
@@ -68,7 +77,7 @@ function validateCard(card) {
         throw new A2AError("Agent card must support text/plain", 400, "ERR_PRISM_A2A_CARD");
     const ids = new Set();
     for (const skill of card.skills) {
-        if (!skill.id.trim() || !skill.name.trim() || !skill.description.trim() || ids.has(skill.id))
+        if (!skill.id.trim() || !skill.name.trim() || !skill.description.trim() || ids.has(skill.id) || skill.tags.length > 64 || [skill.id, skill.name, skill.description, ...skill.tags].some((value) => Buffer.byteLength(value) > 16 * 1024))
             throw new A2AError("Agent card skill is invalid", 400, "ERR_PRISM_A2A_CARD");
         ids.add(skill.id);
     }

package/dist/a2a-client.js

@@ -1,13 +1,12 @@
 import { createA2AAgentCard } from "./a2a-card.js";
+import { resolveA2ALimits } from "./a2a-parts.js";
 import { A2AError } from "./errors.js";
 import { A2A_PROTOCOL_VERSION } from "./a2a-types.js";
-const DEFAULTS = { maxRequestBytes: 64 * 1024, maxResponseBytes: 1024 * 1024, maxEventBytes: 64 * 1024, maxStreamBytes: 10 * 1024 * 1024, maxStreamEvents: 10_000, maxConcurrentRequests: 16, timeoutMs: 120_000, maxCardBytes: 64 * 1024 };
-const HARD = { maxRequestBytes: 1024 * 1024, maxResponseBytes: 8 * 1024 * 1024, maxEventBytes: 1024 * 1024, maxStreamBytes: 64 * 1024 * 1024, maxStreamEvents: 100_000, maxConcurrentRequests: 256, timeoutMs: 30 * 60_000, maxCardBytes: 1024 * 1024 };
 export function createA2AClient(options) {
     const endpoint = requireAllowedHttpsUrl(options.endpoint, options.allowedOrigins);
     const cardUrl = requireAllowedHttpsUrl(options.cardUrl ?? `${endpoint.origin}/.well-known/agent-card.json`, options.allowedOrigins);
     const fetcher = options.fetch ?? globalThis.fetch;
-    const limits = clientLimits(options.limits);
+    const limits = resolveA2ALimits(options.limits);
     let active = 0;
     let requestId = 0;
     async function withRequest(signal, operation) {
@@ -46,7 +45,7 @@ export function createA2AClient(options) {
             if (new TextEncoder().encode(body).byteLength > limits.maxRequestBytes)
                 throw new A2AError("A2A request exceeds max bytes", 413, "ERR_PRISM_A2A_REQUEST_LIMIT");
             const authHeaders = await abortable(Promise.resolve(options.authorize?.({ endpoint: endpoint.href, signal }) ?? {}), signal);
-            const response = await fetcher(endpoint, { method: "POST", signal, redirect: "error", headers: { ...headersObject(authHeaders), "content-type": "application/a2a+json", accept: "application/a2a+json" }, body });
+            const response = await fetcher(endpoint, { method: "POST", signal, redirect: "error", headers: { ...headersObject(authHeaders), "content-type": "application/a2a+json", accept: "application/a2a+json", "a2a-version": "1.0" }, body });
             if (!response.ok)
                 throw new A2AError("A2A remote request failed", response.status, "ERR_PRISM_A2A_REMOTE");
             const rpc = parseRpcResponse(await readBoundedJson(response, limits.maxResponseBytes, signal), id);
@@ -69,7 +68,7 @@ export function createA2AClient(options) {
             if (new TextEncoder().encode(body).byteLength > limits.maxRequestBytes)
                 throw new A2AError("A2A request exceeds max bytes", 413, "ERR_PRISM_A2A_REQUEST_LIMIT");
             const authHeaders = await abortable(Promise.resolve(options.authorize?.({ endpoint: endpoint.href, signal: owned.signal }) ?? {}), owned.signal);
-            const response = await fetcher(endpoint, { method: "POST", signal: owned.signal, redirect: "error", headers: { ...headersObject(authHeaders), "content-type": "application/a2a+json", accept: "text/event-stream" }, body });
+            const response = await fetcher(endpoint, { method: "POST", signal: owned.signal, redirect: "error", headers: { ...headersObject(authHeaders), "content-type": "application/a2a+json", accept: "text/event-stream", "a2a-version": "1.0" }, body });
             if (!response.ok || !response.body || !response.headers.get("content-type")?.startsWith("text/event-stream"))
                 throw new A2AError("A2A stream request failed", response.status, "ERR_PRISM_A2A_REMOTE");
             reader = response.body.getReader();
@@ -90,13 +89,16 @@ export function createA2AClient(options) {
                 if (rpc.error)
                     throw new A2AError(safeRemote(rpc.error.message, options), 502, "ERR_PRISM_A2A_REMOTE");
                 const task = parseTaskResult(rpc.result);
-                if (task.status.state === "TASK_STATE_FAILED" || task.status.state === "TASK_STATE_CANCELED")
+                if (task.status.state === "TASK_STATE_FAILED" || task.status.state === "TASK_STATE_CANCELED" || task.status.state === "TASK_STATE_REJECTED")
                     throw new A2AError("Remote A2A stream task failed", 502, "ERR_PRISM_A2A_REMOTE");
+                if (task.status.state === "TASK_STATE_INPUT_REQUIRED" || task.status.state === "TASK_STATE_AUTH_REQUIRED")
+                    throw new A2AError(`Remote A2A task interrupted: ${task.status.state}`, 409, "ERR_PRISM_A2A_INTERRUPTED");
                 if (task.status.state === "TASK_STATE_COMPLETED")
                     terminal = true;
                 for (const artifact of task.artifacts ?? [])
                     for (const part of artifact.parts)
-                        yield options.redactor?.redact(part.text) ?? part.text;
+                        if (typeof part.text === "string")
+                            yield options.redactor?.redact(part.text) ?? part.text;
             }
             if (!terminal)
                 throw new A2AError("A2A stream ended before terminal task state", 502, "ERR_PRISM_A2A_REMOTE");
@@ -118,7 +120,74 @@ export function createA2AClient(options) {
             await abortable(Promise.resolve(options.verifyCard(card)), signal);
         return card;
     }
-    return { getCard, send, stream };
+    async function invoke(method, params, signal) {
+        return withRequest(signal, async (owned) => {
+            await getCardWithin(owned);
+            const id = ++requestId;
+            const body = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+            if (Buffer.byteLength(body) > limits.maxRequestBytes)
+                throw new A2AError("A2A request exceeds max bytes", 413, "ERR_PRISM_A2A_REQUEST_LIMIT");
+            const authHeaders = await abortable(Promise.resolve(options.authorize?.({ endpoint: endpoint.href, signal: owned }) ?? {}), owned);
+            const response = await fetcher(endpoint, { method: "POST", signal: owned, redirect: "error", headers: { ...headersObject(authHeaders), "content-type": "application/a2a+json", accept: "application/a2a+json", "a2a-version": "1.0" }, body });
+            if (!response.ok)
+                throw new A2AError("A2A remote request failed", response.status, "ERR_PRISM_A2A_REMOTE");
+            const rpc = parseRpcResponse(await readBoundedJson(response, limits.maxResponseBytes, owned), id);
+            if (rpc.error)
+                throw remoteProtocolError(rpc.error.code, rpc.error.message, options);
+            return rpc.result;
+        });
+    }
+    async function sendMessage(message, call = {}) {
+        return parseTaskResult(await invoke("SendMessage", { message, configuration: { returnImmediately: call.returnImmediately ?? false } }, call.signal));
+    }
+    async function getTask(id, call = {}) { return parseTaskResult(await invoke("GetTask", { id, historyLength: call.historyLength ?? 0 }, call.signal)); }
+    async function listTasks(call = {}) {
+        const value = await invoke("ListTasks", { pageSize: call.pageSize ?? 50, pageToken: call.pageToken, contextId: call.contextId }, call.signal);
+        if (!isRecord(value) || !Array.isArray(value.tasks) || value.tasks.length > limits.maxPageSize)
+            throw new A2AError("Malformed A2A task page", 502, "ERR_PRISM_A2A_REMOTE");
+        return { tasks: value.tasks.map((task) => parseTaskResult(task)), nextPageToken: typeof value.nextPageToken === "string" ? value.nextPageToken : undefined, totalSize: typeof value.totalSize === "number" ? value.totalSize : undefined };
+    }
+    async function cancelTask(id, call = {}) { return parseTaskResult(await invoke("CancelTask", { id }, call.signal)); }
+    async function* subscribeToTask(id, call = {}) {
+        if (active >= limits.maxConcurrentRequests)
+            throw new A2AError("A2A client concurrency exceeded", 429, "ERR_PRISM_A2A_CONCURRENCY");
+        active += 1;
+        const owned = ownedSignal(call.signal, limits.timeoutMs);
+        let reader;
+        try {
+            await getCardWithin(owned.signal);
+            const request = ++requestId;
+            const authHeaders = await abortable(Promise.resolve(options.authorize?.({ endpoint: endpoint.href, signal: owned.signal }) ?? {}), owned.signal);
+            const response = await fetcher(endpoint, { method: "POST", signal: owned.signal, redirect: "error", headers: { ...headersObject(authHeaders), "content-type": "application/a2a+json", accept: "text/event-stream", "a2a-version": "1.0" }, body: JSON.stringify({ jsonrpc: "2.0", id: request, method: "SubscribeToTask", params: { id, afterEventId: call.afterEventId } }) });
+            if (!response.ok || !response.body || !response.headers.get("content-type")?.startsWith("text/event-stream"))
+                throw new A2AError("A2A subscribe request failed", response.status, "ERR_PRISM_A2A_REMOTE");
+            reader = response.body.getReader();
+            let previous = "", count = 0;
+            for await (const data of readA2AStreamData(reader, limits, owned.signal)) {
+                const rpc = parseRpcResponse(JSON.parse(data), request);
+                if (rpc.error)
+                    throw remoteProtocolError(rpc.error.code, rpc.error.message, options);
+                const event = parseTaskEvent(rpc.result);
+                if (event.eventId === previous)
+                    continue;
+                previous = event.eventId;
+                if (++count > limits.maxReplayEvents)
+                    throw new A2AError("A2A replay exceeds event limit", 507, "ERR_PRISM_A2A_STREAM_LIMIT");
+                yield event;
+            }
+        }
+        finally {
+            await reader?.cancel().catch(() => undefined);
+            owned.dispose();
+            active -= 1;
+        }
+    }
+    async function createPushConfig(config, call = {}) { return parsePushConfig(await invoke("CreateTaskPushNotificationConfig", { ...config }, call.signal)); }
+    async function getPushConfig(taskId, id, call = {}) { return parsePushConfig(await invoke("GetTaskPushNotificationConfig", { taskId, id }, call.signal)); }
+    async function listPushConfigs(taskId, call = {}) { const value = await invoke("ListTaskPushNotificationConfigs", { taskId, pageSize: call.pageSize, pageToken: call.pageToken }, call.signal); if (!isRecord(value) || !Array.isArray(value.configs))
+        throw new A2AError("Malformed A2A push config page", 502, "ERR_PRISM_A2A_REMOTE"); return { configs: value.configs.map(parsePushConfig), nextPageToken: typeof value.nextPageToken === "string" ? value.nextPageToken : undefined }; }
+    async function deletePushConfig(taskId, id, call = {}) { await invoke("DeleteTaskPushNotificationConfig", { taskId, id }, call.signal); }
+    return { getCard, send, sendMessage, stream, getTask, listTasks, cancelTask, subscribeToTask, createPushConfig, getPushConfig, listPushConfigs, deletePushConfig };
 }
 async function* readA2AStreamData(reader, limits, signal) {
     const decoder = new TextDecoder("utf-8", { fatal: true });
@@ -224,7 +293,9 @@ function requestBody(id, method, input) {
 function taskResult(task, options) {
     if (task.status.state === "TASK_STATE_SUBMITTED" || task.status.state === "TASK_STATE_WORKING")
         throw new A2AError("A2A response task is not terminal", 502, "ERR_PRISM_A2A_REMOTE");
-    const text = (task.artifacts ?? []).flatMap((artifact) => artifact.parts.map((part) => part.text)).join("");
+    if (task.status.state === "TASK_STATE_INPUT_REQUIRED" || task.status.state === "TASK_STATE_AUTH_REQUIRED")
+        throw new A2AError(`Remote A2A task interrupted: ${task.status.state}`, 409, "ERR_PRISM_A2A_INTERRUPTED");
+    const text = (task.artifacts ?? []).flatMap((artifact) => artifact.parts.flatMap((part) => "text" in part ? [part.text] : [])).join("");
     const safeText = options.redactor?.redact(text) ?? text;
     const status = task.status.state === "TASK_STATE_COMPLETED" ? "succeeded" : task.status.state === "TASK_STATE_CANCELED" ? "aborted" : "failed";
     const content = safeText ? [{ type: "text", text: safeText }] : [];
@@ -232,16 +303,17 @@ function taskResult(task, options) {
     return Object.freeze({ sessionId: task.contextId, runId: task.id, status, text: safeText, content, message, error: status === "failed" ? { message: "Remote A2A task failed" } : undefined, abortReason: status === "aborted" ? "Remote A2A task canceled" : undefined });
 }
 function parseTaskResult(value) {
-    if (!isRecord(value) || !isRecord(value.task))
+    if (!isRecord(value))
         throw new A2AError("Malformed A2A task result", 502, "ERR_PRISM_A2A_REMOTE");
-    const task = value.task;
+    const task = isRecord(value.task) ? value.task : value;
     if (typeof task.id !== "string" || typeof task.contextId !== "string" || !isRecord(task.status) || typeof task.status.state !== "string")
         throw new A2AError("Malformed A2A task", 502, "ERR_PRISM_A2A_REMOTE");
-    const states = new Set(["TASK_STATE_SUBMITTED", "TASK_STATE_WORKING", "TASK_STATE_COMPLETED", "TASK_STATE_FAILED", "TASK_STATE_CANCELED"]);
+    const states = new Set(["TASK_STATE_SUBMITTED", "TASK_STATE_WORKING", "TASK_STATE_COMPLETED", "TASK_STATE_FAILED", "TASK_STATE_CANCELED", "TASK_STATE_INPUT_REQUIRED", "TASK_STATE_REJECTED", "TASK_STATE_AUTH_REQUIRED"]);
     if (!states.has(task.status.state))
         throw new A2AError("Unknown A2A task state", 502, "ERR_PRISM_A2A_REMOTE");
     const artifacts = task.artifacts === undefined ? undefined : parseArtifacts(task.artifacts);
-    return { id: task.id, contextId: task.contextId, status: { state: task.status.state, timestamp: typeof task.status.timestamp === "string" ? task.status.timestamp : new Date(0).toISOString() }, artifacts };
+    const history = task.history === undefined ? undefined : Array.isArray(task.history) ? task.history.map(parseRemoteMessage) : (() => { throw new A2AError("Malformed A2A task history", 502, "ERR_PRISM_A2A_REMOTE"); })();
+    return { id: task.id, contextId: task.contextId, status: { state: task.status.state, timestamp: typeof task.status.timestamp === "string" ? task.status.timestamp : new Date(0).toISOString() }, artifacts, history };
 }
 function parseArtifacts(value) {
     if (!Array.isArray(value) || value.length > 32)
@@ -249,13 +321,49 @@ function parseArtifacts(value) {
     return value.map((artifact) => {
         if (!isRecord(artifact) || typeof artifact.artifactId !== "string" || !Array.isArray(artifact.parts) || artifact.parts.length > 32)
             throw new A2AError("Malformed A2A artifact", 502, "ERR_PRISM_A2A_REMOTE");
-        return { artifactId: artifact.artifactId, parts: artifact.parts.map((part) => {
-                if (!isRecord(part) || typeof part.text !== "string")
-                    throw new A2AError("Unsupported A2A artifact part", 502, "ERR_PRISM_A2A_REMOTE");
-                return { text: part.text };
-            }) };
+        return { artifactId: artifact.artifactId, parts: artifact.parts.map(parseRemotePart) };
     });
 }
+function parseRemotePart(value) {
+    if (!isRecord(value))
+        throw new A2AError("Malformed A2A part", 502, "ERR_PRISM_A2A_REMOTE");
+    const keys = ["text", "raw", "url", "data"].filter((key) => Object.hasOwn(value, key));
+    if (keys.length !== 1)
+        throw new A2AError("Malformed A2A part union", 502, "ERR_PRISM_A2A_REMOTE");
+    const base = { mediaType: typeof value.mediaType === "string" ? value.mediaType : undefined, filename: typeof value.filename === "string" ? value.filename : undefined };
+    if (keys[0] === "text" && typeof value.text === "string")
+        return { ...base, text: value.text };
+    if (keys[0] === "raw" && typeof value.raw === "string" && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value.raw))
+        return { ...base, raw: value.raw };
+    if (keys[0] === "url" && typeof value.url === "string") {
+        const url = new URL(value.url);
+        if (url.protocol !== "https:" || url.username || url.password || url.hash)
+            throw new A2AError("Unsafe remote A2A URL part", 502, "ERR_PRISM_A2A_REMOTE");
+        return { ...base, url: url.href };
+    }
+    if (keys[0] === "data")
+        return { ...base, data: structuredClone(value.data) };
+    throw new A2AError("Malformed A2A part", 502, "ERR_PRISM_A2A_REMOTE");
+}
+function parseRemoteMessage(value) { if (!isRecord(value) || typeof value.messageId !== "string" || !Array.isArray(value.parts) || (value.role !== "ROLE_USER" && value.role !== "ROLE_AGENT" && value.role !== "user" && value.role !== "agent"))
+    throw new A2AError("Malformed A2A message", 502, "ERR_PRISM_A2A_REMOTE"); return { role: value.role, messageId: value.messageId, parts: value.parts.map(parseRemotePart), contextId: typeof value.contextId === "string" ? value.contextId : undefined, taskId: typeof value.taskId === "string" ? value.taskId : undefined }; }
+function parseTaskEvent(value) {
+    if (!isRecord(value) || typeof value.eventId !== "string" || !value.eventId)
+        throw new A2AError("Malformed A2A task event", 502, "ERR_PRISM_A2A_REMOTE");
+    if (isRecord(value.task))
+        return { eventId: value.eventId, task: parseTaskResult(value.task) };
+    if (isRecord(value.statusUpdate) && typeof value.statusUpdate.taskId === "string" && typeof value.statusUpdate.contextId === "string" && isRecord(value.statusUpdate.status)) {
+        const parsed = parseTaskResult({ id: value.statusUpdate.taskId, contextId: value.statusUpdate.contextId, status: value.statusUpdate.status });
+        return { eventId: value.eventId, statusUpdate: { taskId: parsed.id, contextId: parsed.contextId, status: parsed.status } };
+    }
+    if (isRecord(value.artifactUpdate) && typeof value.artifactUpdate.taskId === "string" && typeof value.artifactUpdate.contextId === "string" && isRecord(value.artifactUpdate.artifact))
+        return { eventId: value.eventId, artifactUpdate: { taskId: value.artifactUpdate.taskId, contextId: value.artifactUpdate.contextId, artifact: parseArtifacts([value.artifactUpdate.artifact])[0], append: value.artifactUpdate.append === true, lastChunk: value.artifactUpdate.lastChunk === true } };
+    throw new A2AError("Malformed A2A task event", 502, "ERR_PRISM_A2A_REMOTE");
+}
+function parsePushConfig(value) { if (!isRecord(value) || typeof value.id !== "string" || typeof value.taskId !== "string" || typeof value.url !== "string")
+    throw new A2AError("Malformed A2A push config", 502, "ERR_PRISM_A2A_REMOTE"); const url = new URL(value.url); if (url.protocol !== "https:" || url.username || url.password || url.hash)
+    throw new A2AError("Unsafe A2A push URL", 502, "ERR_PRISM_A2A_REMOTE"); return { id: value.id, taskId: value.taskId, url: url.href, token: typeof value.token === "string" ? value.token : undefined, authentication: isRecord(value.authentication) && typeof value.authentication.scheme === "string" ? { scheme: value.authentication.scheme, credentials: typeof value.authentication.credentials === "string" ? value.authentication.credentials : undefined } : undefined }; }
+function remoteProtocolError(code, message, options) { return new A2AError(safeRemote(message, options), code === -32001 ? 404 : code === -32004 ? 501 : 502, code === -32001 ? "ERR_PRISM_A2A_TASK_NOT_FOUND" : code === -32004 ? "ERR_PRISM_A2A_UNSUPPORTED" : "ERR_PRISM_A2A_REMOTE"); }
 function parseRpcResponse(value, id) {
     if (!isRecord(value) || value.jsonrpc !== "2.0" || value.id !== id)
         throw new A2AError("Malformed A2A JSON-RPC response", 502, "ERR_PRISM_A2A_REMOTE");
@@ -339,16 +447,6 @@ function requireAllowedHttpsUrl(value, origins) {
         throw new A2AError("A2A endpoint origin is not allow-listed HTTPS", 403, "ERR_PRISM_A2A_ORIGIN");
     return url;
 }
-function clientLimits(input = {}) {
-    const output = {};
-    for (const key of Object.keys(DEFAULTS)) {
-        const value = input[key] ?? DEFAULTS[key];
-        if (!Number.isSafeInteger(value) || value < 1 || value > HARD[key])
-            throw new A2AError(`${key} is invalid`, 400, "ERR_PRISM_A2A_CONFIG");
-        output[key] = value;
-    }
-    return output;
-}
 function ownedSignal(parent, timeoutMs) {
     const controller = new AbortController();
     const abort = () => controller.abort(parent?.reason);

package/dist/a2a-parts.d.ts

@@ -0,0 +1,54 @@
+import type { A2ALimits, A2AMessage, A2APart, A2APartPolicy, A2ATask } from "./a2a-types.js";
+export declare const A2A_DEFAULT_LIMITS: {
+    readonly maxRequestBytes: number;
+    readonly maxResponseBytes: number;
+    readonly maxEventBytes: number;
+    readonly maxStreamBytes: number;
+    readonly maxStreamEvents: 10000;
+    readonly maxConcurrentRequests: 16;
+    readonly timeoutMs: 120000;
+    readonly maxCardBytes: number;
+    readonly maxIdBytes: 256;
+    readonly maxParts: 32;
+    readonly maxPartBytes: number;
+    readonly maxRawBytes: number;
+    readonly maxDataBytes: number;
+    readonly maxArtifacts: 32;
+    readonly maxHistory: 100;
+    readonly maxPageSize: 100;
+    readonly maxCursorBytes: 4096;
+    readonly maxReplayEvents: 1000;
+    readonly maxPushConfigs: 10;
+};
+export declare const A2A_HARD_LIMITS: {
+    readonly maxRequestBytes: number;
+    readonly maxResponseBytes: number;
+    readonly maxEventBytes: number;
+    readonly maxStreamBytes: number;
+    readonly maxStreamEvents: 100000;
+    readonly maxConcurrentRequests: 256;
+    readonly timeoutMs: number;
+    readonly maxCardBytes: number;
+    readonly maxIdBytes: 4096;
+    readonly maxParts: 256;
+    readonly maxPartBytes: number;
+    readonly maxRawBytes: number;
+    readonly maxDataBytes: number;
+    readonly maxArtifacts: 256;
+    readonly maxHistory: 1000;
+    readonly maxPageSize: 1000;
+    readonly maxCursorBytes: number;
+    readonly maxReplayEvents: 10000;
+    readonly maxPushConfigs: 100;
+};
+export type ResolvedA2ALimits = {
+    readonly [K in keyof typeof A2A_DEFAULT_LIMITS]: number;
+};
+export declare function resolveA2ALimits(input?: A2ALimits): ResolvedA2ALimits;
+export declare function parseA2AMessage(value: unknown, limits: ResolvedA2ALimits, policy?: A2APartPolicy): Promise<A2AMessage>;
+export declare function parseA2APart(value: unknown, limits: ResolvedA2ALimits, policy?: A2APartPolicy): Promise<A2APart>;
+export declare function validateA2ATask(task: A2ATask, limits: ResolvedA2ALimits, policy?: A2APartPolicy): Promise<A2ATask>;
+export declare function requireId(value: unknown, limits: ResolvedA2ALimits, label?: string): string;
+export declare function optionalCursor(value: unknown, limits: ResolvedA2ALimits): string | undefined;
+export declare function bounded<T>(value: T, maxBytes: number, label: string): T;
+export declare function record(value: unknown): value is Record<string, unknown>;

package/dist/a2a-parts.js

@@ -0,0 +1,121 @@
+import { A2AError } from "./errors.js";
+export const A2A_DEFAULT_LIMITS = { maxRequestBytes: 64 * 1024, maxResponseBytes: 1024 * 1024, maxEventBytes: 64 * 1024, maxStreamBytes: 10 * 1024 * 1024, maxStreamEvents: 10_000, maxConcurrentRequests: 16, timeoutMs: 120_000, maxCardBytes: 64 * 1024, maxIdBytes: 256, maxParts: 32, maxPartBytes: 1024 * 1024, maxRawBytes: 1024 * 1024, maxDataBytes: 256 * 1024, maxArtifacts: 32, maxHistory: 100, maxPageSize: 100, maxCursorBytes: 4096, maxReplayEvents: 1000, maxPushConfigs: 10 };
+export const A2A_HARD_LIMITS = { maxRequestBytes: 1024 * 1024, maxResponseBytes: 8 * 1024 * 1024, maxEventBytes: 1024 * 1024, maxStreamBytes: 64 * 1024 * 1024, maxStreamEvents: 100_000, maxConcurrentRequests: 256, timeoutMs: 30 * 60_000, maxCardBytes: 1024 * 1024, maxIdBytes: 4096, maxParts: 256, maxPartBytes: 8 * 1024 * 1024, maxRawBytes: 8 * 1024 * 1024, maxDataBytes: 4 * 1024 * 1024, maxArtifacts: 256, maxHistory: 1000, maxPageSize: 1000, maxCursorBytes: 16 * 1024, maxReplayEvents: 10_000, maxPushConfigs: 100 };
+export function resolveA2ALimits(input = {}) {
+    const output = {};
+    for (const key of Object.keys(A2A_DEFAULT_LIMITS)) {
+        const value = input[key] ?? A2A_DEFAULT_LIMITS[key];
+        if (!Number.isSafeInteger(value) || value < 1 || value > A2A_HARD_LIMITS[key])
+            throw new A2AError(`${key} is invalid`, 400, "ERR_PRISM_A2A_CONFIG");
+        output[key] = value;
+    }
+    return output;
+}
+export async function parseA2AMessage(value, limits, policy = {}) {
+    if (!record(value) || (value.role !== "user" && value.role !== "ROLE_USER" && value.role !== "agent" && value.role !== "ROLE_AGENT") || !id(value.messageId, limits) || !Array.isArray(value.parts) || value.parts.length < 1 || value.parts.length > limits.maxParts)
+        throw new A2AError("Invalid A2A message", 400, "ERR_PRISM_A2A_MESSAGE");
+    const parts = [];
+    for (const part of value.parts)
+        parts.push(await parseA2APart(part, limits, policy));
+    const message = { role: value.role, messageId: value.messageId, parts, contextId: optionalId(value.contextId, limits), taskId: optionalId(value.taskId, limits), metadata: record(value.metadata) ? value.metadata : undefined };
+    bounded(message, limits.maxRequestBytes, "A2A message");
+    return message;
+}
+export async function parseA2APart(value, limits, policy = {}) {
+    if (!record(value))
+        throw new A2AError("Invalid A2A part", 400, "ERR_PRISM_A2A_PART");
+    const variants = ["text", "raw", "url", "data"].filter((key) => Object.hasOwn(value, key));
+    if (Object.keys(value).some((key) => !["text", "raw", "url", "data", "mediaType", "filename", "metadata"].includes(key)))
+        throw new A2AError("Unknown A2A part field", 400, "ERR_PRISM_A2A_PART");
+    if (variants.length !== 1)
+        throw new A2AError("A2A part requires exactly one content field", 400, "ERR_PRISM_A2A_PART");
+    const base = { mediaType: optionalString(value.mediaType, 256), filename: optionalString(value.filename, 1024), metadata: record(value.metadata) ? value.metadata : undefined };
+    let part;
+    if (variants[0] === "text" && typeof value.text === "string")
+        part = { ...base, text: value.text };
+    else if (variants[0] === "raw" && policy.allowRaw && typeof value.raw === "string" && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value.raw) && Buffer.from(value.raw, "base64").byteLength <= limits.maxRawBytes)
+        part = { ...base, raw: value.raw };
+    else if (variants[0] === "url" && policy.allowUrl && policy.validateUrl && typeof value.url === "string") {
+        let url;
+        try {
+            url = new URL(value.url);
+        }
+        catch {
+            throw new A2AError("Invalid A2A file URL", 400, "ERR_PRISM_A2A_PART");
+        }
+        if (url.protocol !== "https:" || url.username || url.password || url.hash)
+            throw new A2AError("A2A file URL requires credential-free HTTPS", 403, "ERR_PRISM_A2A_ORIGIN");
+        await policy.validateUrl?.(url); // Validation only; never dereference.
+        part = { ...base, url: url.href };
+    }
+    else if (variants[0] === "data" && policy.allowData) {
+        bounded(value.data, limits.maxDataBytes, "A2A data part");
+        part = { ...base, data: structuredClone(value.data) };
+    }
+    else
+        throw new A2AError("Unsupported A2A part", 400, "ERR_PRISM_A2A_PART");
+    bounded(part, limits.maxPartBytes, "A2A part");
+    return part;
+}
+export async function validateA2ATask(task, limits, policy = { allowRaw: true, allowUrl: true, allowData: true }) {
+    if (!id(task.id, limits) || !id(task.contextId, limits) || !task.status || !TASK_STATES.has(task.status.state) || !Number.isFinite(Date.parse(task.status.timestamp)))
+        throw new A2AError("Invalid A2A task", 500, "ERR_PRISM_A2A_TASK");
+    if ((task.artifacts?.length ?? 0) > limits.maxArtifacts || (task.history?.length ?? 0) > limits.maxHistory)
+        throw new A2AError("A2A task collection limit exceeded", 507, "ERR_PRISM_A2A_RESPONSE_LIMIT");
+    for (const artifact of task.artifacts ?? [])
+        await validateArtifact(artifact, limits, policy);
+    for (const message of task.history ?? [])
+        await parseA2AMessage(message, limits, policy);
+    bounded(task, limits.maxResponseBytes, "A2A task");
+    return task;
+}
+async function validateArtifact(value, limits, policy) {
+    if (!id(value.artifactId, limits) || !value.parts.length || value.parts.length > limits.maxParts)
+        throw new A2AError("Invalid A2A artifact", 500, "ERR_PRISM_A2A_TASK");
+    for (const part of value.parts)
+        await parseA2APart(part, limits, policy);
+}
+export function requireId(value, limits, label = "task id") { if (!id(value, limits))
+    throw new A2AError(`Invalid A2A ${label}`, 400, "ERR_PRISM_A2A_REQUEST"); return value; }
+export function optionalCursor(value, limits) { if (value === undefined || value === "")
+    return undefined; if (typeof value !== "string" || Buffer.byteLength(value) > limits.maxCursorBytes)
+    throw new A2AError("Invalid A2A page/event cursor", 400, "ERR_PRISM_A2A_REQUEST"); return value; }
+export function bounded(value, maxBytes, label) {
+    let properties = 0;
+    const stack = [{ value, depth: 0 }];
+    const seen = new Set();
+    while (stack.length) {
+        const item = stack.pop();
+        if (typeof item.value === "number" && !Number.isFinite(item.value))
+            throw new A2AError(`${label} contains non-finite number`, 400, "ERR_PRISM_A2A_REQUEST");
+        if (!item.value || typeof item.value !== "object")
+            continue;
+        if (item.depth > 64 || seen.has(item.value))
+            throw new A2AError(`${label} exceeds JSON depth or is cyclic`, 400, "ERR_PRISM_A2A_REQUEST");
+        seen.add(item.value);
+        const values = Array.isArray(item.value) ? item.value : Object.values(item.value);
+        properties += values.length;
+        if (properties > 10_000)
+            throw new A2AError(`${label} exceeds JSON property limit`, 400, "ERR_PRISM_A2A_REQUEST");
+        for (const child of values)
+            stack.push({ value: child, depth: item.depth + 1 });
+    }
+    let json;
+    try {
+        json = JSON.stringify(value);
+    }
+    catch {
+        throw new A2AError(`${label} is not JSON`, 400, "ERR_PRISM_A2A_REQUEST");
+    }
+    if (Buffer.byteLength(json) > maxBytes)
+        throw new A2AError(`${label} exceeds max bytes`, 507, "ERR_PRISM_A2A_RESPONSE_LIMIT");
+    return value;
+}
+export function record(value) { return !!value && typeof value === "object" && !Array.isArray(value); }
+function id(value, limits) { return typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= limits.maxIdBytes; }
+function optionalId(value, limits) { return value === undefined ? undefined : requireId(value, limits); }
+function optionalString(value, max) { if (value === undefined)
+    return undefined; if (typeof value !== "string" || Buffer.byteLength(value) > max)
+    throw new A2AError("Invalid A2A part metadata", 400, "ERR_PRISM_A2A_PART"); return value; }
+const TASK_STATES = new Set(["TASK_STATE_SUBMITTED", "TASK_STATE_WORKING", "TASK_STATE_COMPLETED", "TASK_STATE_FAILED", "TASK_STATE_CANCELED", "TASK_STATE_INPUT_REQUIRED", "TASK_STATE_REJECTED", "TASK_STATE_AUTH_REQUIRED"]);
+//# sourceMappingURL=a2a-parts.js.map

package/dist/a2a-push.d.ts

@@ -0,0 +1,20 @@
+import type { A2ALimits, A2APushConfig, A2ATaskEvent } from "./a2a-types.js";
+export interface A2APushDelivery {
+    deliver(input: {
+        readonly config: A2APushConfig;
+        readonly event: A2ATaskEvent;
+        readonly idempotencyKey: string;
+        readonly attempt: number;
+        readonly signal: AbortSignal;
+    }): Promise<void>;
+}
+export interface DeliverA2APushEventOptions {
+    readonly signal?: AbortSignal;
+    readonly maxAttempts?: number;
+    readonly timeoutMs?: number;
+    readonly limits?: A2ALimits;
+}
+/** Explicit host call; stores no timer/config/event and performs no network I/O itself. */
+export declare function deliverA2APushEvent(delivery: A2APushDelivery, config: A2APushConfig, event: A2ATaskEvent, options?: DeliverA2APushEventOptions): Promise<{
+    readonly attempts: number;
+}>;

package/dist/a2a-push.js

@@ -0,0 +1,38 @@
+import { bounded, resolveA2ALimits } from "./a2a-parts.js";
+import { A2AError } from "./errors.js";
+/** Explicit host call; stores no timer/config/event and performs no network I/O itself. */
+export async function deliverA2APushEvent(delivery, config, event, options = {}) {
+    const limits = resolveA2ALimits(options.limits);
+    const maxAttempts = options.maxAttempts ?? 1, timeoutMs = options.timeoutMs ?? 10_000;
+    if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 3 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60_000)
+        throw new A2AError("Invalid A2A push delivery limits", 400, "ERR_PRISM_A2A_CONFIG");
+    bounded(event, limits.maxEventBytes, "A2A push event");
+    if (!event.eventId || Buffer.byteLength(event.eventId) > limits.maxCursorBytes)
+        throw new A2AError("Invalid A2A push event id", 400, "ERR_PRISM_A2A_PUSH");
+    let last;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const controller = new AbortController();
+        const abort = () => controller.abort(options.signal?.reason);
+        if (options.signal?.aborted)
+            abort();
+        else
+            options.signal?.addEventListener("abort", abort, { once: true });
+        const timer = setTimeout(() => controller.abort(new DOMException("A2A push delivery timed out", "AbortError")), timeoutMs);
+        try {
+            controller.signal.throwIfAborted();
+            await Promise.race([delivery.deliver({ config, event, idempotencyKey: event.eventId, attempt, signal: controller.signal }), new Promise((_resolve, reject) => controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true }))]);
+            return { attempts: attempt };
+        }
+        catch (error) {
+            last = error;
+            if (controller.signal.aborted || attempt === maxAttempts)
+                break;
+        }
+        finally {
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abort);
+        }
+    }
+    throw new A2AError(last instanceof DOMException && last.name === "AbortError" ? "A2A push delivery timed out" : "A2A push delivery failed", 502, "ERR_PRISM_A2A_PUSH");
+}
+//# sourceMappingURL=a2a-push.js.map