@nylorun/runtime 0.36.1-beta → 0.38.0-beta

package/dist/tenant/runtime.js

@@ -17,7 +17,8 @@ import { createSessionStreams, endAllStreams, } from "./session-streams.js";
 import { closeStreams, streamsStatus, wireStreams, } from "./streams.js";
 import { abortAll, abortLocal, createWorkState, drain, waitForIdle, } from "./scheduler.js";
 import { advance } from "./advance.js";
-import { sweep } from "./sweep.js";
+import { outboxFields, sweep } from "./sweep.js";
+import { deliverPush } from "../api/a2a/push.js";
 import { TenantWorkers, WORKER_ID, } from "./worker.js";
 import { authorize } from "./effects.js";
 import { inProcessToolGate, openMcpThrough } from "../gates/tool-gate.js";
@@ -276,7 +277,10 @@ export class TenantRuntime {
                 },
                 send: (request) => request.kind === "wake"
                     ? ctx.wake(request.sessionId, request.wake)
-                    : ctx.sandboxSignal(request.sandboxId, request.signal),
+                    : request.kind === "push"
+                        ? // An A2A push goes to the caller's URL, not to the execution (`api/a2a/push.ts`).
+                            deliverPush(ctx, request.push)
+                        : ctx.sandboxSignal(request.sandboxId, request.signal),
                 ...(hooks.execution?.stuckInvocations
                     ? {
                         stuckInvocations: () => hooks.execution.stuckInvocations(config.tenantId),
@@ -296,9 +300,7 @@ export class TenantRuntime {
                 }
                 catch (error) {
                     config.logger.warn("outbox delivery after commit failed; the sweep sends it again", {
-                        ...(request.kind === "wake"
-                            ? { sessionId: request.sessionId, reason: request.wake.reason }
-                            : { sandboxId: request.sandboxId, signal: request.signal.kind }),
+                        ...outboxFields(request),
                         message: error instanceof Error ? error.message : String(error),
                     });
                     return false;

package/dist/tenant/session-model.d.ts

@@ -5,7 +5,8 @@
  * turn's start describes it (`turn.start.model`). The Tenant's model, and every other session's,
  * stay as they are. While its provider is disconnected the session uses the Tenant's model again.
  */
-import type { SessionModelChoice, SessionModelView } from "@nylorun/core/contracts";
+import { type SessionModelChoice, type SessionModelView } from "@nylorun/core/contracts";
+import type { Tx } from "../store/types.js";
 import { type SessionAccess, type TenantContext } from "./context.js";
 /** The model the session's next turn uses, and where it comes from. */
 export declare function readSessionModel(ctx: TenantContext, id: string, access: SessionAccess | undefined): Promise<SessionModelView>;
@@ -14,3 +15,12 @@ export declare function readSessionModel(ctx: TenantContext, id: string, access:
  * Tenant's. A turn calls one model: the choice changes only while no turn runs or waits.
  */
 export declare function chooseSessionModel(ctx: TenantContext, id: string, choice: SessionModelChoice | undefined, access: SessionAccess | undefined): Promise<SessionModelView>;
+/**
+ * The model a new session starts with (Host feature `agent-model`): the one its version's
+ * `harness.model` names, as `chooseSessionModel` would take it, or undefined when it names none or
+ * one the Tenant cannot use now (a provider not connected, a model its catalog does not list), so
+ * the Tenant's model applies. Never fails the session.
+ */
+export declare function agentModelOf(t: Tx, harness: {
+    readonly model?: unknown;
+}): Promise<SessionModelChoice | undefined>;

package/dist/tenant/session-model.js

@@ -1,3 +1,11 @@
+/**
+ * A session's own model (Host feature `session-model`): one of a connected provider's models,
+ * which the session's turns use in place of the Tenant's. It is kept on the session
+ * (`Session.model`): the Model Gate reads it at each call (`HostModelVault.readHostModel`) and a
+ * turn's start describes it (`turn.start.model`). The Tenant's model, and every other session's,
+ * stay as they are. While its provider is disconnected the session uses the Tenant's model again.
+ */
+import { agentModelChoice } from "@nylorun/core/contracts";
 import { catalogModel, hostModelCatalog } from "../model/catalog.js";
 import { hostCredentialRowFor, modelBinding } from "../vault/service.js";
 import { takesMessages } from "./commands.js";
@@ -28,19 +36,40 @@ export async function chooseSessionModel(ctx, id, choice, access) {
     });
     return ctx.vault.getSessionModel(session.model);
 }
+/**
+ * The model a new session starts with (Host feature `agent-model`): the one its version's
+ * `harness.model` names, as `chooseSessionModel` would take it, or undefined when it names none or
+ * one the Tenant cannot use now (a provider not connected, a model its catalog does not list), so
+ * the Tenant's model applies. Never fails the session.
+ */
+export async function agentModelOf(t, harness) {
+    if (typeof harness.model !== "string")
+        return undefined;
+    const choice = agentModelChoice(harness.model);
+    return choice && (await choiceIssue(t, choice)) === undefined ? choice : undefined;
+}
 /** A choice names a connected provider and, when its catalog lists models, one of them. */
 async function checkChoice(t, choice) {
+    const issue = await choiceIssue(t, choice);
+    if (issue)
+        fail(issue.status, issue.message, { code: issue.code });
+}
+/** Why `choice` is not one the Tenant can use now; undefined when it is. */
+async function choiceIssue(t, choice) {
     if (!/^[a-zA-Z0-9._-]+$/.test(choice.provider))
-        fail(400, "Invalid provider id", { code: "invalid_request" });
+        return { status: 400, message: "Invalid provider id", code: "invalid_request" };
     const row = await hostCredentialRowFor(t, choice.provider);
     if (!row)
-        fail(422, `Model provider ${choice.provider} is not connected: connect it in Model Settings first`, {
+        return {
+            status: 422,
+            message: `Model provider ${choice.provider} is not connected: connect it in Model Settings first`,
             code: "request_rejected",
-        });
+        };
     // A custom endpoint serves the models it names; the provider's own model is always one.
     if (choice.provider === "custom" || modelBinding(row).model === choice.model)
-        return;
+        return undefined;
     const listed = hostModelCatalog().providers.find((provider) => provider.id === choice.provider);
     if (listed && listed.models.length > 0 && !catalogModel(choice.provider, choice.model))
-        fail(422, `Unknown model ${choice.model} for provider ${choice.provider}`, { code: "request_rejected" });
+        return { status: 422, message: `Unknown model ${choice.model} for provider ${choice.provider}`, code: "request_rejected" };
+    return undefined;
 }

package/dist/tenant/sessions.d.ts

@@ -30,7 +30,8 @@ export declare function listSessions(ctx: TenantContext, agentId: string | null,
  * the session's, with the spec of what the Agent runs pinned now, and the Agent's vault holds the
  * session's credentials. It pins the manifest version the Agent runs (`definition`), as the loop
  * manifest that version's harness section makes, and the harness that section names (`pinOf`);
- * a turn's first segment pins the version the Agent runs then (`repinTurn`).
+ * a turn's first segment pins the version the Agent runs then (`repinTurn`). When that version
+ * names a model the Tenant can use (`harness.model`), the session starts with it as its own.
  */
 export declare function putSession(ctx: TenantContext, id: string, body: PutSessionRequest, access?: SessionAccess, options?: {
     /**

package/dist/tenant/sessions.js

@@ -15,6 +15,7 @@ import { openAgent, recordAttachment } from "./agents.js";
 import { harnessOf, reachesAgent, } from "./context.js";
 import { fail } from "./http.js";
 import { definitionFileIssues } from "./definition-files.js";
+import { agentModelOf } from "./session-model.js";
 import { limitsInForce, readTenantLimits } from "./limits.js";
 /** A session's creation identity: everything but the request id. */
 const sessionIdentity = (value) => {
@@ -51,7 +52,8 @@ export async function listSessions(ctx, agentId, access) {
  * the session's, with the spec of what the Agent runs pinned now, and the Agent's vault holds the
  * session's credentials. It pins the manifest version the Agent runs (`definition`), as the loop
  * manifest that version's harness section makes, and the harness that section names (`pinOf`);
- * a turn's first segment pins the version the Agent runs then (`repinTurn`).
+ * a turn's first segment pins the version the Agent runs then (`repinTurn`). When that version
+ * names a model the Tenant can use (`harness.model`), the session starts with it as its own.
  */
 export async function putSession(ctx, id, body, access, options = {}) {
     const opaque = access !== undefined;
@@ -87,13 +89,16 @@ export async function openSessionIn(ctx, t, id, body, access, options = {}) {
         opaque,
     });
     // The version the Agent runs, both sections (T3): its loop manifest, harness and sandbox spec.
-    const { pin } = await pinOf(t, agent);
+    const { pin, version } = await pinOf(t, agent);
     await checkSkillLimit(t, pin.manifest, agent);
     const config = await readSandboxConfig(t);
     // Placement (D38, D52): where this session's harness may run, decided now and kept.
     checkPlacement(config, agent.kind, pin.harness);
     if (agent.kind === "pod")
         await requirePods(ctx.pods, `Agent ${agent.id}`);
+    // The model the version names (`harness.model`, Host feature `agent-model`) is the new
+    // session's own, as `chooseSessionModel` would make it, when the Tenant can use it now.
+    const model = await agentModelOf(t, version.body.harness);
     const created = {
         id,
         agentId: agent.id,
@@ -110,6 +115,7 @@ export async function openSessionIn(ctx, t, id, body, access, options = {}) {
         environmentId: agent.id,
         environmentVersion: agent.version,
         ...(pin.sandbox === undefined ? {} : { sandbox: pin.sandbox }),
+        ...(model === undefined ? {} : { model }),
     };
     await t.put("sessions", id, created);
     await recordAttachment(t, id, agent.id);

package/dist/tenant/sweep.d.ts

@@ -1,5 +1,6 @@
 import type { PendingRequest } from "../store/types.js";
 import type { TenantContext } from "./context.js";
+import type { OutboxRequest } from "../store/types.js";
 export declare function sweep(ctx: TenantContext): Promise<void>;
 /**
  * Deliver the outbox rows that are due (`Tx.pendingOutbox`: older than `graceMs`, or whose
@@ -14,6 +15,8 @@ export declare function sweep(ctx: TenantContext): Promise<void>;
  * delivered.
  */
 export declare function deliverOutbox(ctx: Pick<TenantContext, "store" | "send" | "config">, graceMs?: number, budgetMs?: number): Promise<PendingRequest[]>;
+/** What a log says of an outbox request: which session, sandbox or push, never a body. */
+export declare function outboxFields(request: OutboxRequest): Record<string, unknown>;
 /** Settle pending workflow `agent` effects whose linked turn already finished. */
 export declare function reconcileLinkedAgents(ctx: Pick<TenantContext, "store">): Promise<void>;
 /**

package/dist/tenant/sweep.js

@@ -38,7 +38,12 @@
  *    timer is armed, later overdue ones only, and runs past `triggerRunRetentionMs` are deleted.
  * 5. **Control signals.** Signals on the control bus older than `sweep.signalRetentionMs` are
  *    deleted: followers read back only the last two minutes (`store/postgres/control.ts`).
- * 6. **Hooks.** Callbacks registered with `ctx.onSweep`.
+ * 6. **A2A pushes** (`api/a2a/push.ts`): every session with a push config still following its
+ *    task is pumped (its new events become `push` outbox rows, which step 1 of the next pass, or
+ *    the delivery after commit, sends), and configs of tasks long finished are deleted. A push
+ *    row that fails is retried with the Host tuning's `a2a.pushRetry` and dropped once it is
+ *    `a2a.pushMaxAgeMs` old, never parked: the change feed covers what it said.
+ * 7. **Hooks.** Callbacks registered with `ctx.onSweep`.
  *
  * Every step runs one transaction per session it changes (a linked agent and its workflow
  * share one, child first), so the sweep follows the lock order in `store/types.ts`. A failing
@@ -51,6 +56,7 @@ import { sweepPendingSeeds } from "../artifacts/disk.js";
 import { pendingAgentEffects, reconcilePendingAgentEffect, } from "../core/flow-host.js";
 import { hostTuning } from "../tuning.js";
 import { sweepStartChecks } from "./agent-versions.js";
+import { pumpPushes, pushRetry } from "../api/a2a/push.js";
 /*
  * The sweep's timings are the Host tuning's `sweep` group (`tuning.ts`):
  * - `outboxGraceMs`: how old an outbox row is before the sweep delivers it, unless its delivery
@@ -127,6 +133,8 @@ export async function sweep(ctx) {
         ["seeds", () => sweepPendingSeeds(ctx)],
         // A harness elsewhere closes its own idle MCP connections.
         ["mcp", async () => ctx.mcp?.sweep()],
+        // A2A pushes: new events of sessions with push configs become push outbox rows.
+        ["a2a-push", () => pumpPushes(ctx)],
         [
             "signals",
             () => ctx.store.tx((t) => t.pruneSignals(new Date(now.getTime() - hostTuning().sweep.signalRetentionMs))),
@@ -201,24 +209,44 @@ export async function deliverOutbox(ctx, graceMs = 0, budgetMs = hostTuning().sw
             return delivered;
     }
 }
-/** Records a failed delivery of `row`: retried with backoff, parked after the last attempt. */
+/** What a log says of an outbox request: which session, sandbox or push, never a body. */
+export function outboxFields(request) {
+    return request.kind === "wake"
+        ? { sessionId: request.sessionId, reason: request.wake.reason }
+        : request.kind === "push"
+            ? { sessionId: request.push.sessionId, taskId: request.push.taskId, pushId: request.push.id }
+            : { sandboxId: request.sandboxId, signal: request.signal.kind };
+}
+/**
+ * Records a failed delivery of `row`: retried with backoff, parked after the last attempt. An
+ * A2A push is retried on its own backoff until it is too old, then deleted (`pushRetry`).
+ */
 async function failed(ctx, row, error) {
     const attempts = row.attempts + 1;
+    const fields = {
+        rowId: row.id,
+        ...outboxFields(row.request),
+        attempts,
+        message: error instanceof Error ? error.message : String(error),
+    };
+    if (row.kind === "push") {
+        const retry = pushRetry(attempts, row.createdAt);
+        if (retry === "drop") {
+            await ctx.store.tx((t) => t.deleteOutbox([row]));
+            ctx.config.logger.warn("a2a push dropped after its last retry; the change feed covers it", fields);
+        }
+        else {
+            await ctx.store.tx((t) => t.failOutbox(row, { retryInMs: retry.retryInMs, park: false }));
+            ctx.config.logger.warn("a2a push failed; the sweep sends it again", fields);
+        }
+        return;
+    }
     // Parked after `sweep.outboxAttempts` failed deliveries (`Tx.failOutbox`); tried again after
     // `outboxRetry.minMs`, doubled each time.
     const { outboxAttempts, outboxRetry } = hostTuning().sweep;
     const park = attempts >= outboxAttempts;
     const retryInMs = Math.min(outboxRetry.minMs * 2 ** (attempts - 1), outboxRetry.maxMs);
     await ctx.store.tx((t) => t.failOutbox(row, { retryInMs, park }));
-    const { request } = row;
-    const fields = {
-        rowId: row.id,
-        ...(request.kind === "wake"
-            ? { sessionId: request.sessionId, reason: request.wake.reason }
-            : { sandboxId: request.sandboxId, signal: request.signal.kind }),
-        attempts,
-        message: error instanceof Error ? error.message : String(error),
-    };
     if (park)
         ctx.config.logger.error("outbox row parked: its delivery keeps failing", fields);
     else

package/dist/tenant/types.d.ts

@@ -79,8 +79,31 @@ export interface TenantConfig {
      * of webhook URLs and the OAuth resource. Absent: the origin each request reached.
      */
     publicUrl?: string;
+    /** The A2A server's settings (Runtime config `a2a`, Host feature `a2a-profile-v2`). */
+    a2a?: A2aConfig;
     logger: Logger;
 }
+/**
+ * Runtime config `a2a` (`NYLORUN_A2A_*`): how the A2A server pushes task updates (profile v2).
+ * Without `push.secret` the Runtime serves no push notifications: the card says
+ * `pushNotifications: false` and the push methods answer `PushNotificationNotSupportedError`.
+ */
+export interface A2aConfig {
+    push?: {
+        /**
+         * `a2a.push.secret` (`NYLORUN_A2A_PUSH_SECRET`): the installation's Standard Webhooks secret,
+         * `whsec_<base64>`, that signs every push (`webhook-signature`). Receivers verify with it.
+         */
+        secret?: string;
+        /**
+         * `a2a.push.allowHosts` (`NYLORUN_A2A_PUSH_ALLOW_HOSTS`, comma-separated): the `host:port`s
+         * (`host:*` for any port) a push, or a file `url` part the Runtime fetches, may reach although they are private,
+         * loopback or link-local (a receiver on the Docker bridge). Every other URL of those is
+         * refused, whatever `delivery.privateAddresses` says.
+         */
+        allowHosts?: readonly string[];
+    };
+}
 export interface Logger {
     info(message: string, fields?: Record<string, unknown>): void;
     warn(message: string, fields?: Record<string, unknown>): void;

package/dist/tuning.d.ts

@@ -122,6 +122,15 @@ export declare const HostTuningSchema: z.ZodObject<{
         }, z.core.$strict>>;
         stalePodMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    a2a: z.ZodPrefault<z.ZodObject<{
+        pushRetry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        pushMaxAgeMs: z.ZodDefault<z.ZodNumber>;
+        pushTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        pushConfigRetentionMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     triggers: z.ZodPrefault<z.ZodObject<{
         lateGraceMs: z.ZodDefault<z.ZodNumber>;
         intervalCheckFires: z.ZodDefault<z.ZodNumber>;

package/dist/tuning.js

@@ -208,6 +208,17 @@ export const HostTuningSchema = z
         /** How long a pod row may go unchanged before the sweep checks it. */
         stalePodMs: ms(MINUTE),
     }),
+    /** The A2A server's push notifications (Host feature `a2a-profile-v2`). */
+    a2a: group({
+        /** The wait after a push's failed delivery, doubled after each. */
+        pushRetry: backoff(5_000, 10 * MINUTE),
+        /** How long a push is tried before it is dropped: the change feed covers what it said. */
+        pushMaxAgeMs: ms(24 * HOUR),
+        /** How long one push's request may take. */
+        pushTimeoutMs: ms(10_000),
+        /** How long a finished task's push configs are kept, for `GetTaskPushNotificationConfig`. */
+        pushConfigRetentionMs: ms(7 * 24 * HOUR),
+    }),
     /** Triggers (track T4, D74): server timing; the Tenant's own bounds are its Runtime limits. */
     triggers: group({
         /**

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.36.1-beta";
+export declare const RUNTIME_VERSION = "0.38.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/server/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.36.1-beta";
+export const RUNTIME_VERSION = "0.38.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.36.1-beta",
+  "version": "0.38.0-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -65,8 +65,8 @@
     "@hono/node-server": "^2.1.5",
     "@hono/zod-openapi": "^1.6.3",
     "@modelcontextprotocol/sdk": "^1.32.1",
-    "@nylorun/core": "0.31.0-beta",
-    "@nylorun/harness": "0.29.7-beta",
+    "@nylorun/core": "0.33.0-beta",
+    "@nylorun/harness": "0.30.1-beta",
     "@restatedev/restate-sdk": "1.17.3",
     "@restatedev/restate-sdk-clients": "1.17.3",
     "@s2-dev/streamstore": "0.28.0",