@arnilo/prism-supervisor 0.0.7 → 0.0.8

package/CHANGELOG.md

@@ -1,4 +1,13 @@
 # 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.

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

package/dist/a2a-server.js

@@ -1,29 +1,31 @@
 import { createA2AAgentCard } from "./a2a-card.js";
+import { bounded, optionalCursor, parseA2AMessage, record, requireId, resolveA2ALimits, validateA2ATask } from "./a2a-parts.js";
 import { A2AError } from "./errors.js";
-const JSON_HEADERS = { "content-type": "application/a2a+json; charset=utf-8" };
-const SSE_HEADERS = { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache, no-transform" };
-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 };
+const JSON_HEADERS = { "content-type": "application/a2a+json; charset=utf-8", "a2a-version": "1.0" };
+const SSE_HEADERS = { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-cache, no-transform", "a2a-version": "1.0" };
 export function createA2AHandler(options) {
     const limits = resolveA2ALimits(options.limits);
     const card = createA2AAgentCard(options.card);
+    if (Boolean(card.capabilities.pushNotifications) !== Boolean(options.push))
+        throw new A2AError("Agent card push capability must match push adapter", 400, "ERR_PRISM_A2A_CONFIG");
     const endpointPath = options.endpointPath ?? new URL(card.supportedInterfaces[0].url).pathname;
     if (!endpointPath.startsWith("/"))
         throw new A2AError("endpointPath must be absolute", 400, "ERR_PRISM_A2A_CONFIG");
     const cardJson = JSON.stringify(card);
-    if (new TextEncoder().encode(cardJson).byteLength > limits.maxCardBytes)
+    if (Buffer.byteLength(cardJson) > limits.maxCardBytes)
         throw new A2AError("Agent card exceeds max bytes", 400, "ERR_PRISM_A2A_CARD");
     let active = 0;
-    let sequence = 0;
     return async (request) => {
-        let acquired = false;
-        let transferred = false;
+        let acquired = false, transferred = false;
         try {
             const path = new URL(request.url).pathname;
             if (request.method === "GET" && path === "/.well-known/agent-card.json")
-                return new Response(cardJson, { status: 200, headers: JSON_HEADERS });
+                return new Response(cardJson, { headers: JSON_HEADERS });
             if (request.method !== "POST" || path !== endpointPath)
                 return errorResponse(404, "Not found", null);
+            const version = request.headers.get("a2a-version");
+            if (version && version !== "1.0")
+                return rpcError(null, -32009, "Unsupported A2A version");
             if (active >= limits.maxConcurrentRequests)
                 return errorResponse(429, "Too many requests", null);
             active += 1;
@@ -33,31 +35,67 @@ export function createA2AHandler(options) {
                 const contentType = request.headers.get("content-type")?.split(";", 1)[0]?.trim();
                 if (contentType !== "application/json" && contentType !== "application/a2a+json")
                     return errorResponse(415, "Unsupported media type", null);
-                const body = await readJson(request, limits.maxRequestBytes, owned.signal);
-                const rpc = parseRpc(body);
-                const authorized = await abortable(Promise.resolve(options.authorize({ request, method: rpc.method, signal: owned.signal })), owned.signal);
-                if (!authorized)
+                const rpc = parseRpc(await readJson(request, limits.maxRequestBytes, owned.signal));
+                const authorization = await abortable(Promise.resolve(options.authorize({ request, method: rpc.method, signal: owned.signal })), owned.signal);
+                if (!authorization)
                     return errorResponse(403, "Forbidden", rpc.id);
                 if (rpc.method === "GetExtendedAgentCard")
-                    return boundedJson({ jsonrpc: "2.0", id: rpc.id, result: card }, limits.maxResponseBytes, options);
-                if (rpc.method !== "SendMessage" && rpc.method !== "SendStreamingMessage")
-                    return boundedJson({ jsonrpc: "2.0", id: rpc.id, error: { code: -32601, message: "Method not found" } }, limits.maxResponseBytes, options);
-                const message = parseMessage(rpc.params?.message, limits.maxRequestBytes);
-                const input = message.parts.map((part) => part.text).join("\n");
-                sequence += 1;
-                const taskId = `task-${crypto.randomUUID()}`;
-                const contextId = message.contextId ?? `context-${sequence}-${crypto.randomUUID()}`;
-                const session = await abortable(Promise.resolve(options.exposure.sessionFactory(authorized)), owned.signal);
-                if (rpc.method === "SendMessage") {
-                    const result = await abortable(session.run(input, { ownership: authorized.ownership, metadata: authorized.metadata, signal: owned.signal, redactor: options.redactor }), owned.signal);
-                    return boundedJson({ jsonrpc: "2.0", id: rpc.id, result: { task: toTask(taskId, contextId, result, options) } }, limits.maxResponseBytes, options);
+                    return card.capabilities.extendedAgentCard ? json(rpc.id, card, limits, options) : rpcError(rpc.id, -32004, "Extended Agent Card unavailable");
+                if (rpc.method === "SendMessage" || rpc.method === "SendStreamingMessage") {
+                    const message = await parseA2AMessage(rpc.params?.message, limits, options.parts);
+                    if (options.tasks) {
+                        const task = await options.tasks.start({ message, authorization, signal: owned.signal, returnImmediately: record(rpc.params?.configuration) && rpc.params.configuration.returnImmediately === true });
+                        await validateA2ATask(task, limits, options.parts);
+                        if (rpc.method === "SendMessage")
+                            return json(rpc.id, { task }, limits, options);
+                        transferred = true;
+                        const events = terminal(task.status.state) ? oneEvent(task) : options.tasks.subscribe({ id: task.id, authorization, signal: owned.signal });
+                        return streamResponse(rpc.id, events, owned, limits, options, () => { active -= 1; });
+                    }
+                    if (message.parts.some((part) => !("text" in part)))
+                        return rpcError(rpc.id, -32004, "Durable task lifecycle required for rich parts");
+                    const input = message.parts.map((part) => part.text).join("\n");
+                    const session = await abortable(Promise.resolve(options.exposure.sessionFactory(authorization)), owned.signal);
+                    const taskId = `task-${crypto.randomUUID()}`, contextId = message.contextId ?? `context-${crypto.randomUUID()}`;
+                    if (rpc.method === "SendMessage")
+                        return json(rpc.id, { task: toTask(taskId, contextId, await abortable(session.run(input, { ownership: authorization.ownership, metadata: authorization.metadata, signal: owned.signal, redactor: options.redactor }), owned.signal), options) }, limits, options);
+                    transferred = true;
+                    const events = runEvents(taskId, contextId, () => session.run(input, { ownership: authorization.ownership, metadata: authorization.metadata, signal: owned.signal, redactor: options.redactor }), options);
+                    return streamResponse(rpc.id, events, owned, limits, options, () => { active -= 1; });
                 }
-                if (rpc.method === "SendStreamingMessage") {
+                if (["GetTask", "ListTasks", "CancelTask", "SubscribeToTask"].includes(rpc.method)) {
+                    if (!options.tasks)
+                        return rpcError(rpc.id, -32004, "Task lifecycle unavailable");
+                    if (rpc.method === "GetTask") {
+                        const task = await options.tasks.get({ id: requireId(rpc.params?.id, limits), historyLength: integer(rpc.params?.historyLength, 0, limits.maxHistory), authorization, signal: owned.signal });
+                        return task ? json(rpc.id, await validateA2ATask(task, limits, options.parts), limits, options) : rpcError(rpc.id, -32001, "Task not found");
+                    }
+                    if (rpc.method === "ListTasks") {
+                        const pageSize = integer(rpc.params?.pageSize, 50, limits.maxPageSize), pageToken = optionalCursor(rpc.params?.pageToken, limits), contextId = rpc.params?.contextId === undefined ? undefined : requireId(rpc.params.contextId, limits, "context id");
+                        const page = await options.tasks.list({ pageSize, pageToken, contextId, authorization, signal: owned.signal });
+                        if (page.tasks.length > pageSize || page.tasks.length > limits.maxPageSize)
+                            throw new A2AError("Task page exceeds limit", 507, "ERR_PRISM_A2A_RESPONSE_LIMIT");
+                        for (const task of page.tasks)
+                            await validateA2ATask(task, limits, options.parts);
+                        optionalCursor(page.nextPageToken, limits);
+                        return json(rpc.id, page, limits, options);
+                    }
+                    if (rpc.method === "CancelTask") {
+                        const task = await options.tasks.cancel({ id: requireId(rpc.params?.id, limits), authorization, signal: owned.signal });
+                        return task ? json(rpc.id, await validateA2ATask(task, limits, options.parts), limits, options) : rpcError(rpc.id, -32001, "Task not found");
+                    }
+                    const taskId = requireId(rpc.params?.id, limits), afterEventId = optionalCursor(rpc.params?.afterEventId, limits);
+                    const current = await options.tasks.get({ id: taskId, historyLength: 0, authorization, signal: owned.signal });
+                    if (!current)
+                        return rpcError(rpc.id, -32001, "Task not found");
+                    if (finalTerminal(current.status.state))
+                        return rpcError(rpc.id, -32004, "Terminal task cannot be subscribed");
                     transferred = true;
-                    const stream = taskStream(rpc.id, taskId, contextId, () => session.run(input, { ownership: authorized.ownership, metadata: authorized.metadata, signal: owned.signal, redactor: options.redactor }), owned, limits, options, () => { active -= 1; });
-                    return new Response(stream, { status: 200, headers: SSE_HEADERS });
+                    return streamResponse(rpc.id, options.tasks.subscribe({ id: taskId, afterEventId, authorization, signal: owned.signal }), owned, limits, options, () => { active -= 1; });
                 }
-                throw new A2AError("Method not found", 400, "ERR_PRISM_A2A_METHOD");
+                if (rpc.method.includes("TaskPushNotificationConfig"))
+                    return await pushOperation(rpc, authorization, owned.signal, limits, options);
+                return rpcError(rpc.id, -32601, "Method not found");
             }
             finally {
                 if (!transferred)
@@ -74,157 +112,140 @@ export function createA2AHandler(options) {
         }
     };
 }
-function taskStream(id, taskId, contextId, run, owned, limits, options, release) {
-    const iterator = (async function* () {
-        yield { jsonrpc: "2.0", id, result: { task: { id: taskId, contextId, status: { state: "TASK_STATE_WORKING", timestamp: new Date().toISOString() } } } };
-        try {
-            const result = await run();
-            yield { jsonrpc: "2.0", id, result: { task: toTask(taskId, contextId, result, options) } };
-        }
-        catch (error) {
-            yield { jsonrpc: "2.0", id, error: { code: -32000, message: safeError(error, options) } };
-        }
-    })()[Symbol.asyncIterator]();
-    let events = 0;
-    let bytes = 0;
-    let released = false;
+async function pushOperation(rpc, authorization, signal, limits, options) {
+    if (!options.push)
+        return rpcError(rpc.id, -32004, "Push notifications unavailable");
+    const taskId = requireId(rpc.params?.taskId, limits), id = rpc.params?.id === undefined ? undefined : requireId(rpc.params.id, limits, "push config id");
+    if (rpc.method === "CreateTaskPushNotificationConfig") {
+        const supplied = record(rpc.params?.config) ? rpc.params.config : rpc.params;
+        if (!record(supplied))
+            throw new A2AError("Invalid push config", 400, "ERR_PRISM_A2A_PUSH");
+        const config = await parsePush({ ...supplied, taskId }, limits, options);
+        return json(rpc.id, publicPush(await options.push.create({ config, authorization, signal })), limits, options);
+    }
+    if (rpc.method === "GetTaskPushNotificationConfig") {
+        const value = await options.push.get({ taskId, id: id, authorization, signal });
+        return value ? json(rpc.id, publicPush(value), limits, options) : rpcError(rpc.id, -32001, "Task or push config not found");
+    }
+    if (rpc.method === "ListTaskPushNotificationConfigs") {
+        const pageSize = integer(rpc.params?.pageSize, limits.maxPushConfigs, limits.maxPushConfigs), pageToken = optionalCursor(rpc.params?.pageToken, limits);
+        const page = await options.push.list({ taskId, pageSize, pageToken, authorization, signal });
+        if (page.configs.length > pageSize)
+            throw new A2AError("Push config page exceeds limit", 507, "ERR_PRISM_A2A_RESPONSE_LIMIT");
+        return json(rpc.id, { configs: page.configs.map(publicPush), nextPageToken: optionalCursor(page.nextPageToken, limits) }, limits, options);
+    }
+    if (rpc.method === "DeleteTaskPushNotificationConfig")
+        return await options.push.delete({ taskId, id: id, authorization, signal }) ? json(rpc.id, {}, limits, options) : rpcError(rpc.id, -32001, "Task or push config not found");
+    return rpcError(rpc.id, -32601, "Method not found");
+}
+async function parsePush(value, limits, options) {
+    const id = requireId(value.id, limits, "push config id"), taskId = requireId(value.taskId, limits);
+    if (typeof value.url !== "string" || !options.parts?.validateUrl)
+        throw new A2AError("Push URL policy required", 403, "ERR_PRISM_A2A_ORIGIN");
+    let url;
+    try {
+        url = new URL(value.url);
+    }
+    catch {
+        throw new A2AError("Invalid push URL", 400, "ERR_PRISM_A2A_PUSH");
+    }
+    if (url.protocol !== "https:" || url.username || url.password || url.hash)
+        throw new A2AError("Push URL requires credential-free HTTPS", 403, "ERR_PRISM_A2A_ORIGIN");
+    await options.parts.validateUrl(url);
+    const authentication = record(value.authentication) && typeof value.authentication.scheme === "string" ? { scheme: value.authentication.scheme.slice(0, 64), credentials: typeof value.authentication.credentials === "string" ? value.authentication.credentials.slice(0, limits.maxPartBytes) : undefined } : undefined;
+    return bounded({ id, taskId, url: url.href, token: typeof value.token === "string" ? value.token.slice(0, limits.maxPartBytes) : undefined, authentication }, limits.maxPartBytes, "Push config");
+}
+function publicPush(value) { return { id: value.id, taskId: value.taskId, url: value.url, authentication: value.authentication ? { scheme: value.authentication.scheme } : undefined }; }
+function streamResponse(id, source, owned, limits, options, release) {
+    const iterator = source[Symbol.asyncIterator]();
+    let events = 0, bytes = 0, released = false, previous = "";
     const finish = () => { if (!released) {
         released = true;
         owned.dispose();
         release();
+        void iterator.return?.();
     } };
-    return new ReadableStream({
-        async pull(controller) {
-            try {
-                const next = await iterator.next();
-                if (next.done) {
-                    finish();
-                    controller.close();
-                    return;
-                }
-                const payload = options.redactor?.redact(next.value) ?? next.value;
-                const chunk = new TextEncoder().encode(`data: ${JSON.stringify(payload)}\n\n`);
-                events += 1;
-                bytes += chunk.byteLength;
-                if (chunk.byteLength > limits.maxEventBytes || events > limits.maxStreamEvents || bytes > limits.maxStreamBytes)
-                    throw new A2AError("A2A stream limit exceeded", 507, "ERR_PRISM_A2A_STREAM_LIMIT");
-                controller.enqueue(chunk);
-            }
-            catch (error) {
+    return new Response(new ReadableStream({
+        async pull(controller) { try {
+            const next = await iterator.next();
+            if (next.done) {
                 finish();
-                controller.error(error);
+                controller.close();
+                return;
             }
-        },
-        cancel(reason) { owned.abort(reason); finish(); void iterator.return?.(); },
-    });
-}
-function toTask(taskId, contextId, result, options) {
-    const state = result.status === "succeeded" ? "TASK_STATE_COMPLETED" : result.status === "aborted" ? "TASK_STATE_CANCELED" : "TASK_STATE_FAILED";
-    const text = options.redactor?.redact(result.text) ?? result.text;
-    return Object.freeze({
-        id: taskId,
-        contextId,
-        status: { state, timestamp: new Date().toISOString() },
-        artifacts: text ? [{ artifactId: `${taskId}-result`, parts: [{ text }] }] : undefined,
-    });
-}
-function parseRpc(value) {
-    if (!isRecord(value) || value.jsonrpc !== "2.0" || !(typeof value.id === "string" || typeof value.id === "number" || value.id === null) || typeof value.method !== "string")
-        throw new A2AError("Invalid JSON-RPC request", 400, "ERR_PRISM_A2A_REQUEST");
-    if (value.params !== undefined && !isRecord(value.params))
-        throw new A2AError("Invalid JSON-RPC params", 400, "ERR_PRISM_A2A_REQUEST");
-    return { jsonrpc: "2.0", id: value.id, method: value.method, params: value.params };
-}
-function parseMessage(value, maxBytes) {
-    if (!isRecord(value) || (value.role !== "user" && value.role !== "ROLE_USER") || typeof value.messageId !== "string" || !value.messageId || !Array.isArray(value.parts) || value.parts.length < 1 || value.parts.length > 32)
-        throw new A2AError("Invalid A2A message", 400, "ERR_PRISM_A2A_MESSAGE");
-    const parts = value.parts.map((part) => {
-        if (!isRecord(part) || typeof part.text !== "string" || Object.keys(part).some((key) => key !== "text" && key !== "metadata"))
-            throw new A2AError("Only text A2A parts are supported", 400, "ERR_PRISM_A2A_MESSAGE");
-        return { text: part.text, metadata: isRecord(part.metadata) ? part.metadata : undefined };
-    });
-    const message = { role: value.role, messageId: value.messageId, parts, contextId: typeof value.contextId === "string" ? value.contextId : undefined };
-    if (encode(message).byteLength > maxBytes)
-        throw new A2AError("A2A message exceeds max bytes", 413, "ERR_PRISM_A2A_MESSAGE_LIMIT");
-    return message;
-}
-function resolveA2ALimits(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;
-}
-async function readJson(request, maxBytes, signal) {
-    if (!request.body)
-        throw new A2AError("Request body is required", 400, "ERR_PRISM_A2A_REQUEST");
-    const reader = request.body.getReader();
-    const chunks = [];
-    let size = 0;
-    try {
-        while (true) {
-            signal.throwIfAborted();
-            const next = await reader.read();
-            if (next.done)
-                break;
-            size += next.value.byteLength;
-            if (size > maxBytes)
-                throw new A2AError("Request exceeds max bytes", 413, "ERR_PRISM_A2A_REQUEST_LIMIT");
-            chunks.push(next.value);
+            if (!optionalCursor(next.value.eventId, limits) || next.value.eventId === previous)
+                throw new A2AError("Duplicate/invalid A2A event id", 500, "ERR_PRISM_A2A_STREAM_LIMIT");
+            await validateTaskEvent(next.value, limits, options);
+            previous = next.value.eventId;
+            const payload = options.redactor?.redact({ jsonrpc: "2.0", id, result: next.value }) ?? { jsonrpc: "2.0", id, result: next.value };
+            const chunk = new TextEncoder().encode(`id: ${next.value.eventId}\ndata: ${JSON.stringify(payload)}\n\n`);
+            events++;
+            bytes += chunk.byteLength;
+            if (events > Math.min(limits.maxStreamEvents, limits.maxReplayEvents) || chunk.byteLength > limits.maxEventBytes || bytes > limits.maxStreamBytes)
+                throw new A2AError("A2A stream limit exceeded", 507, "ERR_PRISM_A2A_STREAM_LIMIT");
+            controller.enqueue(chunk);
         }
+        catch (error) {
+            finish();
+            controller.error(error);
+        } },
+        cancel(reason) { owned.abort(reason); finish(); },
+    }), { headers: SSE_HEADERS });
+}
+async function validateTaskEvent(event, limits, options) {
+    if ("task" in event) {
+        await validateA2ATask(event.task, limits, options.parts);
+        return;
     }
-    finally {
-        reader.releaseLock();
-    }
-    const bytes = new Uint8Array(size);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    try {
-        return JSON.parse(new TextDecoder().decode(bytes));
-    }
-    catch {
-        throw new A2AError("Invalid JSON", 400, "ERR_PRISM_A2A_REQUEST");
+    if ("statusUpdate" in event) {
+        await validateA2ATask({ id: event.statusUpdate.taskId, contextId: event.statusUpdate.contextId, status: event.statusUpdate.status }, limits, options.parts);
+        return;
     }
+    await validateA2ATask({ id: event.artifactUpdate.taskId, contextId: event.artifactUpdate.contextId, status: { state: "TASK_STATE_WORKING", timestamp: new Date().toISOString() }, artifacts: [event.artifactUpdate.artifact] }, limits, options.parts);
 }
-function boundedJson(value, maxBytes, options) {
-    const body = JSON.stringify(options.redactor?.redact(value) ?? value);
-    if (new TextEncoder().encode(body).byteLength > maxBytes)
-        throw new A2AError("Response exceeds max bytes", 507, "ERR_PRISM_A2A_RESPONSE_LIMIT");
-    return new Response(body, { status: 200, headers: JSON_HEADERS });
-}
-function errorResponse(status, message, id) {
-    const body = { jsonrpc: "2.0", id, error: { code: status === 404 ? -32601 : -32000, message } };
-    return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
-}
-function ownedSignal(parent, timeoutMs) {
-    const controller = new AbortController();
-    const abort = () => controller.abort(parent.reason);
-    if (parent.aborted)
-        abort();
-    else
-        parent.addEventListener("abort", abort, { once: true });
-    const timer = setTimeout(() => controller.abort(new DOMException("A2A request timed out", "AbortError")), timeoutMs);
-    return { signal: controller.signal, abort: (reason) => controller.abort(reason), dispose: () => { clearTimeout(timer); parent.removeEventListener("abort", abort); } };
-}
-function abortable(promise, signal) {
-    if (signal.aborted)
-        return Promise.reject(signal.reason);
-    return new Promise((resolve, reject) => {
-        const abort = () => reject(signal.reason);
-        signal.addEventListener("abort", abort, { once: true });
-        promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
-    });
+async function* oneEvent(task) { yield { eventId: `terminal-${task.id}`, task }; }
+async function* runEvents(taskId, contextId, run, options) { yield { eventId: "1", task: { id: taskId, contextId, status: { state: "TASK_STATE_WORKING", timestamp: new Date().toISOString() } } }; yield { eventId: "2", task: toTask(taskId, contextId, await run(), options) }; }
+function toTask(taskId, contextId, result, options) { const state = result.status === "succeeded" ? "TASK_STATE_COMPLETED" : result.status === "aborted" ? "TASK_STATE_CANCELED" : "TASK_STATE_FAILED"; const text = options.redactor?.redact(result.text) ?? result.text; return { id: taskId, contextId, status: { state, timestamp: new Date().toISOString() }, artifacts: text ? [{ artifactId: `${taskId}-result`, parts: [{ text }] }] : undefined }; }
+function parseRpc(value) { if (!record(value) || value.jsonrpc !== "2.0" || !(typeof value.id === "string" || typeof value.id === "number" || value.id === null) || typeof value.method !== "string" || (value.params !== undefined && !record(value.params)))
+    throw new A2AError("Invalid JSON-RPC request", 400, "ERR_PRISM_A2A_REQUEST"); return { jsonrpc: "2.0", id: value.id, method: value.method, params: value.params }; }
+async function readJson(request, maxBytes, signal) { if (!request.body)
+    throw new A2AError("Request body is required", 400, "ERR_PRISM_A2A_REQUEST"); const reader = request.body.getReader(), chunks = []; let size = 0; try {
+    while (true) {
+        signal.throwIfAborted();
+        const n = await reader.read();
+        if (n.done)
+            break;
+        size += n.value.byteLength;
+        if (size > maxBytes)
+            throw new A2AError("Request exceeds max bytes", 413, "ERR_PRISM_A2A_REQUEST_LIMIT");
+        chunks.push(n.value);
+    }
 }
-function encode(value) { return new TextEncoder().encode(JSON.stringify(value)); }
-function isRecord(value) { return !!value && typeof value === "object" && !Array.isArray(value); }
-function safeError(error, options) {
-    const message = (error instanceof Error ? error.message : "A2A request failed").slice(0, 1024);
-    return options.redactor?.redact(message) ?? message;
+finally {
+    reader.releaseLock();
+} const bytes = new Uint8Array(size); let offset = 0; for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+} try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
 }
+catch {
+    throw new A2AError("Invalid JSON", 400, "ERR_PRISM_A2A_REQUEST");
+} }
+function json(id, result, limits, options) { const body = JSON.stringify(options.redactor?.redact({ jsonrpc: "2.0", id, result }) ?? { jsonrpc: "2.0", id, result }); if (Buffer.byteLength(body) > limits.maxResponseBytes)
+    throw new A2AError("Response exceeds max bytes", 507, "ERR_PRISM_A2A_RESPONSE_LIMIT"); return new Response(body, { headers: JSON_HEADERS }); }
+function rpcError(id, code, message) { return new Response(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }), { headers: JSON_HEADERS }); }
+function errorResponse(status, message, id) { const body = { jsonrpc: "2.0", id, error: { code: status === 404 ? -32001 : -32000, message } }; return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS }); }
+function integer(value, fallback, max) { if (value === undefined)
+    return fallback; if (!Number.isSafeInteger(value) || Number(value) < 0 || Number(value) > max)
+    throw new A2AError("Invalid A2A integer limit", 400, "ERR_PRISM_A2A_REQUEST"); return Number(value); }
+function terminal(state) { return finalTerminal(state) || state === "TASK_STATE_INPUT_REQUIRED" || state === "TASK_STATE_AUTH_REQUIRED"; }
+function finalTerminal(state) { return ["TASK_STATE_COMPLETED", "TASK_STATE_FAILED", "TASK_STATE_CANCELED", "TASK_STATE_REJECTED"].includes(state); }
+function ownedSignal(parent, timeoutMs) { const controller = new AbortController(); const abort = () => controller.abort(parent.reason); if (parent.aborted)
+    abort();
+else
+    parent.addEventListener("abort", abort, { once: true }); const timer = setTimeout(() => controller.abort(new DOMException("A2A request timed out", "AbortError")), timeoutMs); return { signal: controller.signal, abort: (reason) => controller.abort(reason), dispose: () => { clearTimeout(timer); parent.removeEventListener("abort", abort); } }; }
+function abortable(promise, signal) { if (signal.aborted)
+    return Promise.reject(signal.reason); return new Promise((resolve, reject) => { const abort = () => reject(signal.reason); signal.addEventListener("abort", abort, { once: true }); promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort)); }); }
+function safeError(error, options) { const message = (error instanceof Error ? error.message : "A2A request failed").slice(0, 1024); return options.redactor?.redact(message) ?? message; }
 //# sourceMappingURL=a2a-server.js.map

package/dist/a2a-types.d.ts

@@ -36,19 +36,51 @@ export interface A2AAgentCard {
     readonly security?: readonly Readonly<Record<string, readonly string[]>>[];
     readonly signatures?: readonly A2AAgentCardSignature[];
 }
-export interface A2ATextPart {
-    readonly text: string;
+interface A2APartBase {
+    readonly mediaType?: string;
+    readonly filename?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
+export type A2APart = (A2APartBase & {
+    readonly text: string;
+    readonly raw?: never;
+    readonly url?: never;
+    readonly data?: never;
+}) | (A2APartBase & {
+    readonly raw: string;
+    readonly text?: never;
+    readonly url?: never;
+    readonly data?: never;
+}) | (A2APartBase & {
+    readonly url: string;
+    readonly text?: never;
+    readonly raw?: never;
+    readonly data?: never;
+}) | (A2APartBase & {
+    readonly data: unknown;
+    readonly text?: never;
+    readonly raw?: never;
+    readonly url?: never;
+});
+export type A2ATextPart = Extract<A2APart, {
+    readonly text: string;
+}>;
 export interface A2AMessage {
     readonly role: "user" | "agent" | "ROLE_USER" | "ROLE_AGENT";
-    readonly parts: readonly A2ATextPart[];
+    readonly parts: readonly A2APart[];
     readonly messageId: string;
     readonly contextId?: string;
     readonly taskId?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
-export type A2ATaskState = "TASK_STATE_SUBMITTED" | "TASK_STATE_WORKING" | "TASK_STATE_COMPLETED" | "TASK_STATE_FAILED" | "TASK_STATE_CANCELED";
+export interface A2AArtifact {
+    readonly artifactId: string;
+    readonly parts: readonly A2APart[];
+    readonly name?: string;
+    readonly description?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export type A2ATaskState = "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";
 export interface A2ATask {
     readonly id: string;
     readonly contextId: string;
@@ -57,16 +89,35 @@ export interface A2ATask {
         readonly timestamp: string;
         readonly message?: A2AMessage;
     };
-    readonly artifacts?: readonly {
-        readonly artifactId: string;
-        readonly parts: readonly A2ATextPart[];
-    }[];
+    readonly artifacts?: readonly A2AArtifact[];
+    readonly history?: readonly A2AMessage[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
 }
+export type A2ATaskEvent = {
+    readonly eventId: string;
+    readonly task: A2ATask;
+} | {
+    readonly eventId: string;
+    readonly statusUpdate: {
+        readonly taskId: string;
+        readonly contextId: string;
+        readonly status: A2ATask["status"];
+    };
+} | {
+    readonly eventId: string;
+    readonly artifactUpdate: {
+        readonly taskId: string;
+        readonly contextId: string;
+        readonly artifact: A2AArtifact;
+        readonly append?: boolean;
+        readonly lastChunk?: boolean;
+    };
+};
 export type A2ARequestId = string | number | null;
 export interface A2AJsonRpcRequest {
     readonly jsonrpc: "2.0";
     readonly id: A2ARequestId;
-    readonly method: "SendMessage" | "SendStreamingMessage" | "GetExtendedAgentCard" | string;
+    readonly method: string;
     readonly params?: Readonly<Record<string, unknown>>;
 }
 export interface A2AJsonRpcResponse {
@@ -91,6 +142,88 @@ export type A2AAuthorizer = (input: {
 export interface A2AAgentExposure {
     readonly sessionFactory: (authorization: A2AAuthorization) => AgentSession | Promise<AgentSession>;
 }
+export interface A2ATaskPage {
+    readonly tasks: readonly A2ATask[];
+    readonly nextPageToken?: string;
+    readonly totalSize?: number;
+}
+export interface A2ATaskLifecycle {
+    start(input: {
+        readonly message: A2AMessage;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+        readonly returnImmediately?: boolean;
+    }): Promise<A2ATask>;
+    get(input: {
+        readonly id: string;
+        readonly historyLength: number;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2ATask | undefined>;
+    list(input: {
+        readonly pageSize: number;
+        readonly pageToken?: string;
+        readonly contextId?: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2ATaskPage>;
+    cancel(input: {
+        readonly id: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2ATask | undefined>;
+    subscribe(input: {
+        readonly id: string;
+        readonly afterEventId?: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): AsyncIterable<A2ATaskEvent>;
+}
+export interface A2APushConfig {
+    readonly id: string;
+    readonly taskId: string;
+    readonly url: string;
+    readonly token?: string;
+    readonly authentication?: {
+        readonly scheme: string;
+        readonly credentials?: string;
+    };
+}
+export interface A2APushProvider {
+    create(input: {
+        readonly config: A2APushConfig;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2APushConfig>;
+    get(input: {
+        readonly taskId: string;
+        readonly id: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2APushConfig | undefined>;
+    list(input: {
+        readonly taskId: string;
+        readonly pageSize: number;
+        readonly pageToken?: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<{
+        readonly configs: readonly A2APushConfig[];
+        readonly nextPageToken?: string;
+    }>;
+    delete(input: {
+        readonly taskId: string;
+        readonly id: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<boolean>;
+}
+export interface A2APartPolicy {
+    readonly allowRaw?: boolean;
+    readonly allowUrl?: boolean;
+    readonly allowData?: boolean;
+    readonly validateUrl?: (url: URL) => void | Promise<void>;
+}
 export interface A2ALimits {
     readonly maxRequestBytes?: number;
     readonly maxResponseBytes?: number;
@@ -100,11 +233,25 @@ export interface A2ALimits {
     readonly maxConcurrentRequests?: number;
     readonly timeoutMs?: number;
     readonly maxCardBytes?: number;
+    readonly maxIdBytes?: number;
+    readonly maxParts?: number;
+    readonly maxPartBytes?: number;
+    readonly maxRawBytes?: number;
+    readonly maxDataBytes?: number;
+    readonly maxArtifacts?: number;
+    readonly maxHistory?: number;
+    readonly maxPageSize?: number;
+    readonly maxCursorBytes?: number;
+    readonly maxReplayEvents?: number;
+    readonly maxPushConfigs?: number;
 }
 export interface CreateA2AHandlerOptions {
     readonly card: A2AAgentCard;
     readonly exposure: A2AAgentExposure;
     readonly authorize: A2AAuthorizer;
+    readonly tasks?: A2ATaskLifecycle;
+    readonly push?: A2APushProvider;
+    readonly parts?: A2APartPolicy;
     readonly endpointPath?: string;
     readonly redactor?: SecretRedactor;
     readonly limits?: A2ALimits;
@@ -121,6 +268,7 @@ export interface A2AClientOptions {
     readonly cardUrl?: string;
     readonly limits?: A2ALimits;
     readonly redactor?: SecretRedactor;
+    readonly parts?: A2APartPolicy;
 }
 export interface A2AClient {
     getCard(options?: {
@@ -129,7 +277,46 @@ export interface A2AClient {
     send(input: string, options?: {
         readonly signal?: AbortSignal;
     }): Promise<AgentRunResult>;
+    sendMessage(message: A2AMessage, options?: {
+        readonly signal?: AbortSignal;
+        readonly returnImmediately?: boolean;
+    }): Promise<A2ATask>;
     stream(input: string, options?: {
         readonly signal?: AbortSignal;
     }): AsyncIterable<string>;
+    getTask(id: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly historyLength?: number;
+    }): Promise<A2ATask>;
+    listTasks(options?: {
+        readonly signal?: AbortSignal;
+        readonly pageSize?: number;
+        readonly pageToken?: string;
+        readonly contextId?: string;
+    }): Promise<A2ATaskPage>;
+    cancelTask(id: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<A2ATask>;
+    subscribeToTask(id: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly afterEventId?: string;
+    }): AsyncIterable<A2ATaskEvent>;
+    createPushConfig(config: A2APushConfig, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<A2APushConfig>;
+    getPushConfig(taskId: string, id: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<A2APushConfig>;
+    listPushConfigs(taskId: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly pageSize?: number;
+        readonly pageToken?: string;
+    }): Promise<{
+        readonly configs: readonly A2APushConfig[];
+        readonly nextPageToken?: string;
+    }>;
+    deletePushConfig(taskId: string, id: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<void>;
 }
+export {};

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./a2a-card.js";
 export * from "./a2a-client.js";
+export * from "./a2a-parts.js";
+export * from "./a2a-push.js";
 export * from "./a2a-server.js";
 export type * from "./a2a-types.js";
 export * from "./errors.js";

package/dist/index.js

@@ -1,5 +1,7 @@
 export * from "./a2a-card.js";
 export * from "./a2a-client.js";
+export * from "./a2a-parts.js";
+export * from "./a2a-push.js";
 export * from "./a2a-server.js";
 export * from "./errors.js";
 export * from "./limits.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arnilo/prism-supervisor",
-  "version": "0.0.7",
-  "description": "Optional bounded local supervisor delegation and A2A 1.0 interoperability.",
+  "version": "0.0.8",
+  "description": "Bounded supervisor delegation and A2A 1.0 durable task, rich-part, reconnect, and push interoperability.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,7 +25,7 @@
     "pack:dry-run": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.0.7"
+    "@arnilo/prism": "0.0.8"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../.."