@nylorun/runtime 0.36.1-beta → 0.37.0-beta

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 } : {}) };
+}

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

@@ -0,0 +1,76 @@
+import type { A2aPushConfigRow, OutboxPush, Tx } from "../../store/types.js";
+import type { TenantContext } from "../../tenant/context.js";
+import { type OutboundPolicy } from "../../tenant/outbound.js";
+import { type PushConfigInput, type TaskPushNotificationConfig } from "./protocol.js";
+/** The most push configs one task keeps. A constant of the profile, not a setting. */
+export declare const MAX_PUSH_CONFIGS = 10;
+/** Whether this Runtime serves push notifications: it has a secret to sign them with. */
+export declare function pushEnabled(ctx: Pick<TenantContext, "config">): boolean;
+/**
+ * The address policy a push, or a fetched file `url` part, is sent under: the Host's delivery
+ * policy, with private addresses refused unless `url`'s `host:port` is in `a2a.push.allowHosts`.
+ */
+export declare function pushPolicy(ctx: Pick<TenantContext, "config">, target: string): OutboundPolicy;
+/** Why the Runtime will not send to `target`, checked before a config is stored; else undefined. */
+export declare function pushRefusal(ctx: Pick<TenantContext, "config">, target: string): string | undefined;
+/** A config as A2A answers it. */
+export declare function configView(row: A2aPushConfigRow): TaskPushNotificationConfig;
+/** Where a config starts: the turn it follows and the first event it reads. */
+export interface PushStart {
+    readonly sessionId: string;
+    readonly contextId: string;
+    readonly taskId: string;
+    /** The turn, or a queued message's id until a turn takes it. */
+    readonly turnId: string;
+    readonly nextSeq: number;
+    readonly traceId?: string;
+    /** The task already ended: the config is stored, and nothing is pushed. */
+    readonly done?: boolean;
+    readonly baseUrl: string;
+    /** The extensions the caller activated; none named means all of them. */
+    readonly extensions: ReadonlySet<string>;
+}
+/**
+ * Stores `config` for a task (replacing one with its id), in `t`; the pump sends its updates.
+ * A URL the Runtime will not call is `InvalidParamsError`; past `MAX_PUSH_CONFIGS` too.
+ */
+export declare function savePushConfig(ctx: Pick<TenantContext, "config">, t: Tx, start: PushStart, config: PushConfigInput, configId: string): Promise<TaskPushNotificationConfig>;
+/**
+ * Pumps session `sessionId` on this process: at once, or again after the pump running now, so
+ * one process never pumps a session twice at the same time. Never rejects.
+ */
+export declare function kickPushes(ctx: TenantContext, sessionId: string): Promise<void>;
+/**
+ * Translates the events of session `sessionId` its configs have not read into push rows: reads
+ * the record from the lowest `nextSeq`, then, under the configs' locks, writes each config's
+ * updates and moves it on. A config stored behind what was read waits for the next pump.
+ */
+export declare function pumpSession(ctx: TenantContext, sessionId: string): Promise<void>;
+/**
+ * The Tenant sweep's push step: pumps every session with a config still following its task
+ * (commits on other processes reach them here), and deletes configs done longer than the Host
+ * tuning's `a2a.pushConfigRetentionMs`.
+ */
+export declare function pumpPushes(ctx: TenantContext): Promise<void>;
+/** A push the receiver did not take: the sweep sends it again. */
+export declare class PushFailed extends Error {
+    constructor(message: string);
+}
+/** The headers of one push attempt: Standard Webhooks, the config's token and authentication. */
+export declare function pushHeaders(secret: string, push: Pick<OutboxPush, "id" | "body">, config: {
+    token?: string | null;
+    authentication?: unknown;
+}, now?: number): Record<string, string>;
+/**
+ * Sends one push row (the Tenant's `send` for outbox kind `push`). Resolves `true` once it is
+ * done with: delivered (2xx), its config deleted, the receiver gone (`410`), or its URL refused
+ * by policy. Rejects with `PushFailed` (or the network's error) when it should be sent again.
+ */
+export declare function deliverPush(ctx: TenantContext, push: OutboxPush): Promise<boolean>;
+/**
+ * What the sweep does with a push that failed `attempts` times and was written at `createdAt`:
+ * try again after the backoff, or drop it once it would be past `a2a.pushMaxAgeMs`.
+ */
+export declare function pushRetry(attempts: number, createdAt: string, now?: number): {
+    retryInMs: number;
+} | "drop";