@nylorun/runtime 0.36.1-beta → 0.38.0-beta

package/dist/api/a2a/list.js

@@ -0,0 +1,169 @@
+import { encodeCursor } from "../../record/index.js";
+import { historyCursor, readCursor } from "../../reads/cursor.js";
+import { ENDED_TURN_STATUSES } from "../../store/postgres/turns.js";
+import { loadSession } from "../../tenant/context.js";
+import { HttpError } from "../../tenant/http.js";
+import { readHistory } from "../../tenant/session-streams.js";
+import { a2aFail, parseHistoryLength } from "./protocol.js";
+import { contextSessionId } from "./tasks.js";
+/** `ListTasks`' page size when the request names none, and the most it may ask. */
+export const LIST_PAGE_DEFAULT = 50;
+export const LIST_PAGE_MAX = 100;
+/**
+ * The turn index states each A2A state is (profile v2 §1): a paused turn by what its first open
+ * interaction asks for. `SUBMITTED` (a queued message), `REJECTED` and anything else: none.
+ */
+const TURN_STATES = {
+    TASK_STATE_WORKING: [{ status: "running" }],
+    TASK_STATE_INPUT_REQUIRED: [{ status: "paused", waitingFor: ["question"] }],
+    TASK_STATE_AUTH_REQUIRED: [{ status: "paused", waitingFor: ["approval", "connection"] }],
+    TASK_STATE_COMPLETED: [{ status: "completed" }],
+    TASK_STATE_FAILED: [{ status: "failed" }],
+    TASK_STATE_CANCELED: [{ status: "cancelled" }],
+};
+const TASK_STATES = [
+    "TASK_STATE_SUBMITTED",
+    "TASK_STATE_WORKING",
+    "TASK_STATE_INPUT_REQUIRED",
+    "TASK_STATE_AUTH_REQUIRED",
+    "TASK_STATE_COMPLETED",
+    "TASK_STATE_FAILED",
+    "TASK_STATE_CANCELED",
+    "TASK_STATE_REJECTED",
+];
+const VISIBLE = /^[\x21-\x7e]{1,200}$/;
+const present = (value) => value !== undefined && value !== null && value !== "";
+/** `ListTasks` params (A2A 1.0 §3.1.4), checked in the order a client can fix them. */
+export function parseListParams(params) {
+    const { contextId, status, statusTimestampAfter, pageSize, pageToken, includeArtifacts } = params;
+    if (present(contextId) && (typeof contextId !== "string" || !VISIBLE.test(contextId)))
+        a2aFail("invalidParams", "contextId must be 1 to 200 visible ASCII characters", {}, "contextId");
+    if (present(status) &&
+        status !== "TASK_STATE_UNSPECIFIED" &&
+        !TASK_STATES.includes(status))
+        a2aFail("invalidParams", "status must be a TaskState", {}, "status");
+    let since;
+    if (present(statusTimestampAfter)) {
+        const time = typeof statusTimestampAfter === "string" &&
+            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/.test(statusTimestampAfter)
+            ? new Date(statusTimestampAfter)
+            : undefined;
+        if (!time || Number.isNaN(time.getTime()))
+            a2aFail("invalidParams", "statusTimestampAfter must be an ISO 8601 timestamp", {}, "statusTimestampAfter");
+        since = time.toISOString();
+    }
+    if (present(pageSize) &&
+        (typeof pageSize !== "number" ||
+            !Number.isInteger(pageSize) ||
+            pageSize < 1 ||
+            pageSize > LIST_PAGE_MAX))
+        a2aFail("invalidParams", `pageSize must be an integer from 1 to ${LIST_PAGE_MAX}`, {}, "pageSize");
+    if (present(pageToken) && typeof pageToken !== "string")
+        a2aFail("invalidParams", "pageToken must be a string", {}, "pageToken");
+    if (includeArtifacts !== undefined && includeArtifacts !== null && typeof includeArtifacts !== "boolean")
+        a2aFail("invalidParams", "includeArtifacts must be a boolean", {}, "includeArtifacts");
+    const historyLength = parseHistoryLength(params.historyLength, "historyLength");
+    return {
+        ...(present(contextId) ? { contextId: contextId } : {}),
+        ...(present(status) && status !== "TASK_STATE_UNSPECIFIED" ? { status: status } : {}),
+        ...(since !== undefined ? { statusTimestampAfter: since } : {}),
+        pageSize: present(pageSize) ? pageSize : LIST_PAGE_DEFAULT,
+        ...(present(pageToken) ? { pageToken: pageToken } : {}),
+        ...(historyLength !== undefined ? { historyLength } : {}),
+        includeArtifacts: includeArtifacts === true,
+    };
+}
+/**
+ * One turn's events, in stream order, read from its first lifecycle event: up to its last one
+ * when it has ended, else to the stream's tail. Never the session's whole history.
+ */
+export async function indexedTurnEvents(ctx, row) {
+    const after = row.firstSeq > 0 ? encodeCursor(row.sessionId, row.firstSeq - 1) : undefined;
+    const { items } = ENDED_TURN_STATUSES.has(row.status)
+        ? await readHistory(ctx, row.sessionId, after === undefined
+            ? undefined
+            : historyCursor(ctx.config.tenantId, row.sessionId).encode(after), undefined, row.lastSeq - row.firstSeq + 1)
+        : await readHistory(ctx, row.sessionId, after, undefined);
+    return items.filter((event) => event.turnId === row.turnId);
+}
+/** The events of a session's turn, from the turn index; none when the session never had it. */
+export async function turnEventsOf(ctx, sessionId, turnId) {
+    const row = await ctx.store.tx((t) => t.turn(sessionId, turnId));
+    return row ? indexedTurnEvents(ctx, row) : [];
+}
+/** `ListTasks`: the caller's tasks with this Agent, from the turn index. */
+export async function listTasks(caller, params, build) {
+    const { ctx, access, agentId } = caller;
+    const owner = access.owner;
+    const token = readCursor(ctx.config.tenantId, "a2a-tasks", {
+        owner,
+        agentId,
+        contextId: params.contextId ?? null,
+        status: params.status ?? null,
+        statusTimestampAfter: params.statusTimestampAfter ?? null,
+    });
+    let key;
+    try {
+        key = token.decode(params.pageToken);
+    }
+    catch (error) {
+        if (!(error instanceof HttpError))
+            throw error;
+        return a2aFail("invalidParams", "pageToken is not one this request returned", {}, "pageToken");
+    }
+    if (key && (key.length !== 3 || key.some((part) => typeof part !== "string")))
+        a2aFail("invalidParams", "pageToken is not one this request returned", {}, "pageToken");
+    const states = params.status === undefined ? undefined : (TURN_STATES[params.status] ?? []);
+    const { turns, total } = await ctx.store.tx((t) => t.listTurns({
+        ownerUserId: owner,
+        agentId,
+        a2a: true,
+        ...(params.contextId === undefined
+            ? {}
+            : { sessionId: contextSessionId(owner, agentId, params.contextId) }),
+        ...(states === undefined ? {} : { states }),
+        ...(params.statusTimestampAfter === undefined ? {} : { changedSince: params.statusTimestampAfter }),
+        ...(key ? { after: { changedAt: key[0], sessionId: key[1], turnId: key[2] } } : {}),
+        limit: params.pageSize + 1,
+    }));
+    const page = turns.slice(0, params.pageSize);
+    const last = page.at(-1);
+    const tasks = [];
+    const sessions = new Map();
+    for (const row of page) {
+        // Only a context the A2A server opened for this caller: its session id is the context's.
+        if (contextSessionId(owner, agentId, row.a2aContextId) !== row.sessionId)
+            continue;
+        if (!sessions.has(row.sessionId))
+            sessions.set(row.sessionId, await sessionOf(caller, row.sessionId));
+        const session = sessions.get(row.sessionId);
+        const built = session ? await build(row, session, params.historyLength ?? 0) : undefined;
+        if (!built)
+            continue;
+        const { artifacts, ...task } = built;
+        tasks.push({
+            ...task,
+            status: { ...task.status, timestamp: row.changedAt },
+            ...(params.includeArtifacts && artifacts ? { artifacts } : {}),
+        });
+    }
+    return {
+        tasks,
+        nextPageToken: turns.length > params.pageSize && last
+            ? token.encode([last.changedAt, last.sessionId, last.turnId])
+            : "",
+        pageSize: params.pageSize,
+        totalSize: total,
+    };
+}
+/** The caller's session for a listed task, or undefined when it is gone. */
+async function sessionOf(caller, sessionId) {
+    try {
+        return await loadSession(caller.ctx, sessionId, caller.access);
+    }
+    catch (error) {
+        if (error instanceof HttpError && error.status === 404)
+            return undefined;
+        throw error;
+    }
+}

package/dist/api/a2a/protocol.d.ts

@@ -1,9 +1,3 @@
-/**
- * A2A 1.0 over JSON-RPC: the wire types the Runtime answers with, the envelope, the error
- * codes and the parameter checks (Host feature `a2a-endpoint`). Only what v1 serves is typed:
- * text, data and file parts, tasks, the card. Field names are the spec's ProtoJSON (camelCase,
- * enum values such as `TASK_STATE_WORKING`). No Tenant state is read here.
- */
 /** The A2A version this endpoint speaks (`A2A-Version`, Major.Minor). */
 export declare const A2A_VERSION = "1.0";
 export type TaskState = "TASK_STATE_SUBMITTED" | "TASK_STATE_WORKING" | "TASK_STATE_INPUT_REQUIRED" | "TASK_STATE_AUTH_REQUIRED" | "TASK_STATE_COMPLETED" | "TASK_STATE_FAILED" | "TASK_STATE_CANCELED" | "TASK_STATE_REJECTED";
@@ -34,11 +28,15 @@ export interface Message {
     contextId?: string;
     taskId?: string;
     metadata?: Record<string, unknown>;
+    /** The extensions whose data the message carries (A2A §4.6). */
+    extensions?: string[];
 }
 export interface Artifact {
     artifactId: string;
     name?: string;
     parts: Part[];
+    metadata?: Record<string, unknown>;
+    extensions?: string[];
 }
 export interface TaskStatus {
     state: TaskState;
@@ -51,6 +49,54 @@ export interface Task {
     status: TaskStatus;
     artifacts?: Artifact[];
     history?: Message[];
+    /** Profile v2 data about the whole task: `progress/v1`, `telemetry/v1`, `effects/v1`. */
+    metadata?: Record<string, unknown>;
+}
+/** A change of a task's status, as a push delivers it (`StreamResponse.statusUpdate`). */
+export interface TaskStatusUpdateEvent {
+    taskId: string;
+    contextId: string;
+    status: TaskStatus;
+    metadata?: Record<string, unknown>;
+}
+/** An artifact of a task, as a push delivers it (`StreamResponse.artifactUpdate`). */
+export interface TaskArtifactUpdateEvent {
+    taskId: string;
+    contextId: string;
+    artifact: Artifact;
+    append?: boolean;
+    lastChunk?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** One push's body: A2A's `StreamResponse`, one of its cases. */
+export type StreamResponse = {
+    statusUpdate: TaskStatusUpdateEvent;
+} | {
+    artifactUpdate: TaskArtifactUpdateEvent;
+} | {
+    task: Task;
+};
+/** How a push authenticates to its receiver (A2A `AuthenticationInfo`): `Authorization: <scheme> <credentials>`. */
+export interface PushAuthentication {
+    scheme: string;
+    credentials: string;
+}
+/** A push notification config as a client gives it (A2A `TaskPushNotificationConfig`). */
+export interface PushConfigInput {
+    /** The config's id within its task; the Runtime makes one when absent. */
+    id?: string;
+    url: string;
+    /** Sent back as `X-A2A-Notification-Token` with every push. */
+    token?: string;
+    authentication?: PushAuthentication;
+}
+/** A push notification config as the Runtime answers it. */
+export interface TaskPushNotificationConfig {
+    id: string;
+    taskId: string;
+    url: string;
+    token?: string;
+    authentication?: PushAuthentication;
 }
 /** The standard JSON-RPC codes and the A2A codes (spec §5.4, §9.5). */
 export declare const A2A_ERRORS: {
@@ -106,9 +152,13 @@ export declare class A2aError extends Error {
     readonly metadata: Readonly<Record<string, string>>;
     /** `google.rpc.BadRequest` field violations, for invalid parameters. */
     readonly field?: string | undefined;
+    /** `ErrorInfo.reason` when it is more precise than the kind's, as `CONTEXT_BUSY`. */
+    readonly reason?: string | undefined;
     constructor(kind: A2aErrorKind, message: string, metadata?: Readonly<Record<string, string>>, 
     /** `google.rpc.BadRequest` field violations, for invalid parameters. */
-    field?: string | undefined);
+    field?: string | undefined, 
+    /** `ErrorInfo.reason` when it is more precise than the kind's, as `CONTEXT_BUSY`. */
+    reason?: string | undefined);
 }
 export declare const a2aFail: (kind: A2aErrorKind, message: string, metadata?: Record<string, string>, field?: string) => never;
 export type JsonRpcId = string | number | null;
@@ -136,9 +186,15 @@ export interface RawFile {
     readonly mediaType?: string;
     readonly filename?: string;
 }
+/** A file sent by URL: fetched by the Runtime (`guardedFetch`), then stored as a `raw` one is. */
+export interface UrlFile {
+    readonly url: string;
+    readonly mediaType?: string;
+    readonly filename?: string;
+}
 /**
  * A client's message reduced to what the Runtime runs: text, one JSON value, or text and files
- * sent inline.
+ * sent inline or by URL.
  */
 export type MessageInput = {
     content: string;
@@ -147,7 +203,17 @@ export type MessageInput = {
 } | {
     files: readonly ({
         text: string;
-    } | RawFile)[];
+    } | RawFile | UrlFile)[];
+};
+/** What a message to a busy context does (profile v2 §1): queued, or refused with `CONTEXT_BUSY`. */
+export type Delivery = "queue" | "reject";
+/** A caller's answer to an open interaction (`interactions/v1` on the reply message). */
+export type InteractionAnswer = {
+    interactionId: string;
+    approved: boolean;
+} | {
+    interactionId: string;
+    value: unknown;
 };
 export interface SendParams {
     messageId: string;
@@ -156,8 +222,20 @@ export interface SendParams {
     input: MessageInput;
     returnImmediately: boolean;
     historyLength?: number;
+    /** `configuration.taskPushNotificationConfig`: where this task's updates go. */
+    push?: PushConfigInput;
+    /** `metadata.delivery`; default `queue`. */
+    delivery: Delivery;
+    /** The answer the message carries under `interactions/v1`. */
+    answer?: InteractionAnswer;
 }
 export declare function parseHistoryLength(value: unknown, field: string): number | undefined;
+/**
+ * A push notification config (A2A `TaskPushNotificationConfig`) at `field`: an http(s) `url`, an
+ * optional `id`, `token` and `authentication` (`scheme`, `credentials`). Its `taskId`, when
+ * present, is the caller's to check.
+ */
+export declare function parsePushConfig(value: unknown, field: string): PushConfigInput;
 /** `SendMessage` params (spec §3.2.1), checked in the order a client can fix them. */
 export declare function parseSendParams(params: Record<string, unknown>): SendParams;
 /** `GetTask` and `CancelTask` params: the task id (and `historyLength` for `GetTask`). */
@@ -165,3 +243,21 @@ export declare function parseTaskParams(params: Record<string, unknown>): {
     id: string;
     historyLength?: number;
 };
+/** `CreateTaskPushNotificationConfig` params: a `TaskPushNotificationConfig` naming its task. */
+export declare function parseCreatePushParams(params: Record<string, unknown>): {
+    taskId: string;
+    config: PushConfigInput;
+};
+/** `GetTaskPushNotificationConfig` and `DeleteTaskPushNotificationConfig` params. */
+export declare function parsePushConfigRef(params: Record<string, unknown>): {
+    taskId: string;
+    id: string;
+};
+/** The most configs one page of `ListTaskPushNotificationConfigs` holds. */
+export declare const PUSH_CONFIG_PAGE = 100;
+/** `ListTaskPushNotificationConfigs` params: the task, and paging. */
+export declare function parseListPushParams(params: Record<string, unknown>): {
+    taskId: string;
+    pageSize: number;
+    pageToken?: string;
+};

package/dist/api/a2a/protocol.js

@@ -1,9 +1,11 @@
 /**
  * A2A 1.0 over JSON-RPC: the wire types the Runtime answers with, the envelope, the error
- * codes and the parameter checks (Host feature `a2a-endpoint`). Only what v1 serves is typed:
- * text, data and file parts, tasks, the card. Field names are the spec's ProtoJSON (camelCase,
- * enum values such as `TASK_STATE_WORKING`). No Tenant state is read here.
+ * codes and the parameter checks (Host features `a2a-endpoint` and `a2a-profile-v2`). Only what
+ * the Runtime serves is typed: text, data, `raw` and `url` parts, tasks, their status and
+ * artifact updates (push), push configs, the card. Field names are the spec's ProtoJSON
+ * (camelCase, enum values such as `TASK_STATE_WORKING`). No Tenant state is read here.
  */
+import { A2A_EXTENSIONS } from "./extensions.js";
 /** The A2A version this endpoint speaks (`A2A-Version`, Major.Minor). */
 export const A2A_VERSION = "1.0";
 export const TERMINAL_STATES = new Set([
@@ -31,13 +33,17 @@ export class A2aError extends Error {
     kind;
     metadata;
     field;
+    reason;
     constructor(kind, message, metadata = {}, 
     /** `google.rpc.BadRequest` field violations, for invalid parameters. */
-    field) {
+    field, 
+    /** `ErrorInfo.reason` when it is more precise than the kind's, as `CONTEXT_BUSY`. */
+    reason) {
         super(message);
         this.kind = kind;
         this.metadata = metadata;
         this.field = field;
+        this.reason = reason;
         this.name = "A2aError";
     }
 }
@@ -52,7 +58,7 @@ export function jsonRpcError(id, error) {
     const data = [
         {
             "@type": "type.googleapis.com/google.rpc.ErrorInfo",
-            reason,
+            reason: error.reason ?? reason,
             domain: "a2a-protocol.org",
             metadata: { ...error.metadata },
         },
@@ -98,10 +104,30 @@ export function parseEnvelope(text) {
         request: {
             id: safeId,
             method: body.method,
-            params: body.params ?? {},
+            params: protoJsonKeys(body.params ?? {}),
         },
     };
 }
+/**
+ * Params with ProtoJSON's original field names (`task_id`, `return_immediately`) read as their
+ * lowerCamel JSON names, as ProtoJSON parsers must accept both. A part's `data` and any
+ * `metadata` are the caller's own values and keep their keys.
+ */
+function protoJsonKeys(value) {
+    if (Array.isArray(value))
+        return value.map(protoJsonKeys);
+    if (!isObject(value))
+        return value;
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+        const name = key.includes("_") ? key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase()) : key;
+        // The lowerCamel name wins when a client sends both.
+        if (name !== key && Object.hasOwn(value, name))
+            continue;
+        out[name] = name === "data" || name === "metadata" ? child : protoJsonKeys(child);
+    }
+    return out;
+}
 /** `A2A-Version` as Major.Minor; empty means 0.3 (spec §3.6.2). */
 export function checkVersion(value) {
     const trimmed = (value ?? "").trim();
@@ -142,10 +168,89 @@ function partKind(part, field) {
         return a2aFail("invalidParams", `${field}.text must be a string`, {}, `${field}.text`);
     if (kinds[0] === "raw" && typeof part.raw !== "string")
         return a2aFail("invalidParams", `${field}.raw must be base64 bytes`, {}, `${field}.raw`);
+    if (kinds[0] === "url" && !isHttpUrl(part.url))
+        return a2aFail("invalidParams", `${field}.url must be an http or https URL`, {}, `${field}.url`);
     for (const key of ["mediaType", "filename"])
         if (part[key] !== undefined && typeof part[key] !== "string")
             return a2aFail("invalidParams", `${field}.${key} must be a string`, {}, `${field}.${key}`);
-    return kinds[0] === "raw" ? "raw" : kinds[0] === "url" ? "url" : kinds[0];
+    return kinds[0];
+}
+function isHttpUrl(value) {
+    if (typeof value !== "string" || value.length > 2048)
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+/** The longest push token and credentials kept: a header value, not a document. */
+const MAX_SECRET = 1024;
+/**
+ * A push notification config (A2A `TaskPushNotificationConfig`) at `field`: an http(s) `url`, an
+ * optional `id`, `token` and `authentication` (`scheme`, `credentials`). Its `taskId`, when
+ * present, is the caller's to check.
+ */
+export function parsePushConfig(value, field) {
+    if (!isObject(value))
+        return a2aFail("invalidParams", `${field} must be an object`, {}, field);
+    if (!isHttpUrl(value.url))
+        a2aFail("invalidParams", `${field}.url must be an http or https URL`, {}, `${field}.url`);
+    const id = value.id === undefined || value.id === "" ? undefined : checkId(value.id, `${field}.id`, true);
+    if (value.token !== undefined && (typeof value.token !== "string" || value.token.length > MAX_SECRET))
+        a2aFail("invalidParams", `${field}.token must be a string of at most ${MAX_SECRET} characters`, {}, `${field}.token`);
+    let authentication;
+    if (value.authentication !== undefined && value.authentication !== null) {
+        const auth = value.authentication;
+        if (!isObject(auth) ||
+            typeof auth.scheme !== "string" ||
+            !/^[A-Za-z0-9!#$%&'*+.^_`|~-]{1,64}$/.test(auth.scheme) ||
+            typeof auth.credentials !== "string" ||
+            auth.credentials.length > MAX_SECRET ||
+            /[\r\n]/.test(auth.credentials))
+            a2aFail("invalidParams", `${field}.authentication needs an HTTP scheme and credentials`, {}, `${field}.authentication`);
+        authentication = {
+            scheme: auth.scheme,
+            credentials: auth.credentials,
+        };
+    }
+    return {
+        url: value.url,
+        ...(id !== undefined ? { id } : {}),
+        ...(typeof value.token === "string" && value.token !== "" ? { token: value.token } : {}),
+        ...(authentication ? { authentication } : {}),
+    };
+}
+/** `metadata.delivery`: `queue` (the default) or `reject`. */
+function parseDelivery(metadata) {
+    const delivery = metadata.delivery;
+    if (delivery === undefined || delivery === null)
+        return "queue";
+    if (delivery !== "queue" && delivery !== "reject")
+        return a2aFail("invalidParams", 'message.metadata.delivery must be "queue" or "reject"', {}, "message.metadata.delivery");
+    return delivery;
+}
+/** The answer under `interactions/v1`, when the message carries one. */
+function parseAnswer(metadata) {
+    const field = `message.metadata["${A2A_EXTENSIONS.interactions}"]`;
+    const raw = metadata[A2A_EXTENSIONS.interactions];
+    if (raw === undefined || raw === null)
+        return undefined;
+    if (!isObject(raw))
+        return a2aFail("invalidParams", `${field} must be an object`, {}, field);
+    const interactionId = checkId(raw.interactionId, `${field}.interactionId`, true);
+    if (raw.approved !== undefined) {
+        if (typeof raw.approved !== "boolean")
+            a2aFail("invalidParams", `${field}.approved must be a boolean`, {}, `${field}.approved`);
+        if (raw.value !== undefined)
+            a2aFail("invalidParams", `${field} takes approved or value, not both`, {}, field);
+        return { interactionId, approved: raw.approved };
+    }
+    if (!("value" in raw))
+        return a2aFail("invalidParams", `${field} needs approved or value`, {}, field);
+    return { interactionId, value: raw.value };
 }
 /** `SendMessage` params (spec §3.2.1), checked in the order a client can fix them. */
 export function parseSendParams(params) {
@@ -161,12 +266,19 @@ export function parseSendParams(params) {
         a2aFail("invalidParams", "At least one part is required", {}, "message.parts");
     const parts = message.parts;
     const kinds = parts.map((part, index) => partKind(part, `message.parts[${index}]`));
+    if (message.metadata !== undefined && message.metadata !== null && !isObject(message.metadata))
+        a2aFail("invalidParams", "message.metadata must be an object", {}, "message.metadata");
+    const metadata = (message.metadata ?? {});
+    // On the message (the profile's place), or on the request's own metadata.
+    const delivery = parseDelivery(metadata.delivery === undefined && isObject(params.metadata) ? params.metadata : metadata);
+    const answer = parseAnswer(metadata);
     const configuration = params.configuration;
-    if (configuration !== undefined && !isObject(configuration))
+    if (configuration !== undefined && configuration !== null && !isObject(configuration))
         a2aFail("invalidParams", "configuration must be an object", {}, "configuration");
     const config = (configuration ?? {});
-    if (config.taskPushNotificationConfig !== undefined && config.taskPushNotificationConfig !== null)
-        a2aFail("pushNotSupported", "Push notifications are not supported");
+    const push = config.taskPushNotificationConfig === undefined || config.taskPushNotificationConfig === null
+        ? undefined
+        : parsePushConfig(config.taskPushNotificationConfig, "configuration.taskPushNotificationConfig");
     if (config.returnImmediately !== undefined && typeof config.returnImmediately !== "boolean")
         a2aFail("invalidParams", "configuration.returnImmediately must be a boolean", {}, "configuration.returnImmediately");
     const historyLength = parseHistoryLength(config.historyLength, "configuration.historyLength");
@@ -175,21 +287,24 @@ export function parseSendParams(params) {
         input = { content: parts.map((part) => part.text).join("\n") };
     else if (kinds.length === 1 && kinds[0] === "data")
         input = { data: parts[0].data };
-    else if (kinds.includes("url"))
-        return a2aFail("contentTypeNotSupported", "File URLs are not fetched yet; send the bytes inline as raw", { accepted: "raw" });
     else if (kinds.includes("data"))
         return a2aFail("contentTypeNotSupported", "This agent accepts text and file parts, or a single data part", { accepted: "text/plain,application/json" });
     else
         input = {
-            files: parts.map((part, index) => kinds[index] === "text"
-                ? { text: part.text }
-                : {
-                    raw: part.raw,
+            files: parts.map((part, index) => {
+                const named = {
                     ...(part.mediaType !== undefined ? { mediaType: part.mediaType } : {}),
                     ...(part.filename !== undefined ? { filename: part.filename } : {}),
-                }),
+                };
+                return kinds[index] === "text"
+                    ? { text: part.text }
+                    : kinds[index] === "url"
+                        ? { url: part.url, ...named }
+                        : { raw: part.raw, ...named };
+            }),
         };
-    if ("content" in input && input.content.trim() === "")
+    // An answer may carry its value only in metadata: its parts are then what a person reads.
+    if ("content" in input && input.content.trim() === "" && answer === undefined)
         a2aFail("invalidParams", "The message has no text", {}, "message.parts");
     return {
         messageId,
@@ -198,6 +313,9 @@ export function parseSendParams(params) {
         input,
         returnImmediately: config.returnImmediately === true,
         ...(historyLength !== undefined ? { historyLength } : {}),
+        ...(push ? { push } : {}),
+        delivery,
+        ...(answer ? { answer } : {}),
     };
 }
 /** `GetTask` and `CancelTask` params: the task id (and `historyLength` for `GetTask`). */
@@ -207,3 +325,36 @@ export function parseTaskParams(params) {
     const historyLength = parseHistoryLength(params.historyLength, "historyLength");
     return { id: params.id, ...(historyLength !== undefined ? { historyLength } : {}) };
 }
+/** `taskId` of a push config method's params. */
+function pushTaskId(params) {
+    if (typeof params.taskId !== "string" || params.taskId === "")
+        return a2aFail("invalidParams", "taskId is required", {}, "taskId");
+    return params.taskId;
+}
+/** `CreateTaskPushNotificationConfig` params: a `TaskPushNotificationConfig` naming its task. */
+export function parseCreatePushParams(params) {
+    const taskId = pushTaskId(params);
+    // A2A 1.0 sends the config itself; an earlier draft nested it under `config`.
+    const config = isObject(params.config) ? { ...params.config, ...(params.id ? { id: params.id } : {}) } : params;
+    return { taskId, config: parsePushConfig(config, isObject(params.config) ? "config" : "params") };
+}
+/** `GetTaskPushNotificationConfig` and `DeleteTaskPushNotificationConfig` params. */
+export function parsePushConfigRef(params) {
+    const taskId = pushTaskId(params);
+    const id = checkId(params.id, "id", true);
+    return { taskId, id };
+}
+/** The most configs one page of `ListTaskPushNotificationConfigs` holds. */
+export const PUSH_CONFIG_PAGE = 100;
+/** `ListTaskPushNotificationConfigs` params: the task, and paging. */
+export function parseListPushParams(params) {
+    const taskId = pushTaskId(params);
+    const size = params.pageSize;
+    if (size !== undefined && size !== null && size !== 0 && (typeof size !== "number" || !Number.isInteger(size) || size < 1))
+        a2aFail("invalidParams", "pageSize must be a positive integer", {}, "pageSize");
+    const pageSize = Math.min(typeof size === "number" && size > 0 ? size : PUSH_CONFIG_PAGE, PUSH_CONFIG_PAGE);
+    const token = params.pageToken;
+    if (token !== undefined && token !== null && token !== "" && typeof token !== "string")
+        a2aFail("invalidParams", "pageToken must be a string", {}, "pageToken");
+    return { taskId, pageSize, ...(typeof token === "string" && token !== "" ? { pageToken: token } : {}) };
+}