@arnilo/prism-supervisor 0.0.96 → 0.1.0

package/dist/a2a-event-source.js

@@ -0,0 +1,40 @@
+import { A2AError } from "./errors.js";
+/** Host-selected durable task stream over AgentEventSource; owns no task database or worker. */
+export function createA2AAgentEventSource(options) {
+    return {
+        subscribe(input) {
+            return {
+                async *[Symbol.asyncIterator]() {
+                    input.signal.throwIfAborted();
+                    const resolved = await options.resolveTask(input);
+                    if (!resolved?.run.sessionId || resolved.task.id !== input.id) {
+                        throw new A2AError("Task unavailable", 404, "ERR_PRISM_A2A_TASK");
+                    }
+                    let first = true;
+                    for await (const item of options.source.subscribe({
+                        ownership: input.authorization.ownership,
+                        sessionId: resolved.run.sessionId,
+                        runId: resolved.run.runId,
+                        after: input.afterEventId,
+                        signal: input.signal,
+                    })) {
+                        if (!item.record.redacted)
+                            throw new A2AError("Task event unavailable", 500, "ERR_PRISM_A2A_TASK");
+                        const payload = await options.map({ record: item.record, task: resolved.task, authorization: input.authorization });
+                        if (!payload)
+                            continue;
+                        if (first && input.afterEventId === undefined && !("task" in payload)) {
+                            throw new A2AError("Initial task event required", 500, "ERR_PRISM_A2A_TASK");
+                        }
+                        first = false;
+                        yield { eventId: item.cursor, ...payload };
+                    }
+                    if (first && input.afterEventId === undefined) {
+                        throw new A2AError("Initial task event required", 500, "ERR_PRISM_A2A_TASK");
+                    }
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=a2a-event-source.js.map

package/dist/a2a-parts.js

@@ -1,6 +1,46 @@
 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 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)) {
@@ -12,12 +52,24 @@ export function resolveA2ALimits(input = {}) {
     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)
+    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 };
+    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;
 }
@@ -29,11 +81,19 @@ export async function parseA2APart(value, limits, policy = {}) {
         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 };
+    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)
+    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;
@@ -58,7 +118,11 @@ export async function parseA2APart(value, limits, policy = {}) {
     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)))
+    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");
@@ -75,11 +139,18 @@ async function validateArtifact(value, limits, policy) {
     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 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 }];
@@ -111,11 +182,30 @@ export function bounded(value, maxBytes, label) {
         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"]);
+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.js

@@ -4,7 +4,12 @@ import { A2AError } from "./errors.js";
 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)
+    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)
@@ -20,7 +25,10 @@ export async function deliverA2APushEvent(delivery, config, event, options = {})
         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 }))]);
+            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) {

package/dist/a2a-server.js

@@ -1,5 +1,6 @@
+import { assertIdentityActive, assertIdentityMatchesOwnership } from "@arnilo/prism";
 import { createA2AAgentCard } from "./a2a-card.js";
-import { bounded, optionalCursor, parseA2AMessage, record, requireId, resolveA2ALimits, validateA2ATask } from "./a2a-parts.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", "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" };
@@ -39,36 +40,72 @@ export function createA2AHandler(options) {
                 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 (authorization.identity) {
+                    try {
+                        assertIdentityActive(authorization.identity);
+                        assertIdentityMatchesOwnership(authorization.identity, authorization.ownership);
+                    }
+                    catch {
+                        return errorResponse(403, "Forbidden", rpc.id);
+                    }
+                }
                 if (rpc.method === "GetExtendedAgentCard")
-                    return card.capabilities.extendedAgentCard ? json(rpc.id, card, limits, options) : rpcError(rpc.id, -32004, "Extended Agent Card unavailable");
+                    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 });
+                        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; });
+                        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()}`;
+                    const runOptions = {
+                        ownership: authorization.ownership,
+                        identity: authorization.identity,
+                        metadata: authorization.metadata,
+                        signal: owned.signal,
+                        redactor: options.redactor,
+                    };
                     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);
+                        return json(rpc.id, { task: toTask(taskId, contextId, await abortable(session.run(input, runOptions), 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; });
+                    const events = runEvents(taskId, contextId, () => session.run(input, runOptions), options);
+                    return streamResponse(rpc.id, events, owned, limits, options, () => {
+                        active -= 1;
+                    });
                 }
                 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");
+                        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");
@@ -82,7 +119,9 @@ export function createA2AHandler(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");
+                        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 });
@@ -91,7 +130,9 @@ export function createA2AHandler(options) {
                     if (finalTerminal(current.status.state))
                         return rpcError(rpc.id, -32004, "Terminal task cannot be subscribed");
                     transferred = true;
-                    return streamResponse(rpc.id, options.tasks.subscribe({ id: taskId, afterEventId, authorization, signal: owned.signal }), owned, limits, options, () => { active -= 1; });
+                    return streamResponse(rpc.id, options.tasks.subscribe({ id: taskId, afterEventId, authorization, signal: owned.signal }), owned, limits, options, () => {
+                        active -= 1;
+                    });
                 }
                 if (rpc.method.includes("TaskPushNotificationConfig"))
                     return await pushOperation(rpc, authorization, owned.signal, limits, options);
@@ -135,7 +176,9 @@ async function pushOperation(rpc, authorization, signal, limits, options) {
         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 (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) {
@@ -152,44 +195,77 @@ async function parsePush(value, limits, options) {
     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");
+    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 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?.();
-    } };
+    const finish = () => {
+        if (!released) {
+            released = true;
+            owned.dispose();
+            release();
+            void iterator.return?.();
+        }
+    };
     return new Response(new ReadableStream({
-        async pull(controller) { try {
-            const next = await iterator.next();
-            if (next.done) {
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    finish();
+                    controller.close();
+                    return;
+                }
+                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.close();
-                return;
+                controller.error(error);
             }
-            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) {
+        },
+        cancel(reason) {
+            owned.abort(reason);
             finish();
-            controller.error(error);
-        } },
-        cancel(reason) { owned.abort(reason); finish(); },
+        },
     }), { headers: SSE_HEADERS });
 }
 async function validateTaskEvent(event, limits, options) {
@@ -201,51 +277,126 @@ async function validateTaskEvent(event, limits, options) {
         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);
-}
-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);
+    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);
+}
+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);
+        }
+    }
+    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;
 }
-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