@nylorun/runtime 0.36.1-beta → 0.38.0-beta

package/dist/reads/types.d.ts

@@ -1,4 +1,5 @@
 import type { ArtifactKind, ArtifactPage, ModelCallExportPage, ModelCallsPage, ToolCallsPage, SessionManifestView, SessionPage, SessionListItem, SessionUsageTotals, LiveEvent } from "@nylorun/core/contracts";
+import type { TurnRow } from "../store/types.js";
 export type ReadAccess = {
     owner?: string;
     agents?: readonly string[];
@@ -14,6 +15,12 @@ export type PageOptions = {
     limit: number;
     cursor?: string;
 };
+/** A page of the turn change feed: rows in the order they changed, and where to read on. */
+export type TurnChangeRows = {
+    turns: TurnRow[];
+    cursor: string;
+    hasMore: boolean;
+};
 export type ArtifactFilters = {
     sessionId?: string;
     kind?: ArtifactKind;
@@ -34,5 +41,17 @@ export interface ReadStore {
      * for a turn the session never had.
      */
     turnEvents(id: string, turnId: string, access: ReadAccess): Promise<LiveEvent[]>;
+    /**
+     * The turn index's change feed (Host feature `turns`): the turns `access` reaches (of one
+     * session with `sessionId`), in the order their transactions changed them, after `changedAfter`
+     * (a cursor it returned). Only changes below every transaction still running are read, so a
+     * change committed later never lands behind the cursor.
+     */
+    turnChanges(filters: {
+        sessionId?: string;
+    }, page: {
+        limit: number;
+        changedAfter?: string;
+    }, access: ReadAccess): Promise<TurnChangeRows>;
     close(): Promise<void>;
 }

package/dist/sandbox/join.d.ts

@@ -20,7 +20,13 @@ export declare class HostAuthError extends Error {
 }
 /** The Tenant's side of the exchange, as the Harness API listener calls it. */
 export interface HostAuthority {
-    join(request: HostJoinRequest): Promise<HostJoinAnswer>;
+    /**
+     * `imageEngine`: the Runtime version an engine the workload image carries reported (ADR-99);
+     * absent for an engine copied in.
+     */
+    join(request: HostJoinRequest, from?: {
+        imageEngine?: string;
+    }): Promise<HostJoinAnswer>;
     renew(hostToken: string): Promise<HostJoinAnswer>;
     /** The claims of a current host's token, for a connection; refuses a stale one. */
     verify(hostToken: string): Promise<HostClaims>;

package/dist/sandbox/join.js

@@ -85,7 +85,7 @@ export function hostAuthority(ctx) {
         return verdict.claims;
     };
     return {
-        async join(request) {
+        async join(request, from) {
             const { sandboxId, podUid, joinToken, volumeId } = request;
             if (!isAgentId(sandboxId) ||
                 typeof podUid !== "string" ||
@@ -146,6 +146,10 @@ export function hostAuthority(ctx) {
                     hostEpoch: epoch,
                     podUid,
                     ...(pod.volumeId === undefined && volumeId !== undefined ? { volumeId } : {}),
+                    // The engine the image carries, against the digest this pod runs (ADR-99).
+                    ...(from?.imageEngine === undefined
+                        ? {}
+                        : { engineImage: { version: from.imageEngine, ...(pod.imageDigest ? { digest: pod.imageDigest } : {}) } }),
                     ...(pod.desired === "running" ? { observed: "running", reason: null } : {}),
                 }, now);
                 if (pod.podUid !== podUid) {

package/dist/sandbox/pods/builtin.d.ts

@@ -0,0 +1,18 @@
+export { BUILTIN_ENGINE_ROOT, ENGINE_VERSION_PATTERN, IMAGE_ENGINE_HEADER } from "../../harness/image-engine.js";
+/** The engine an image carries, as the pod's record keeps it: its version, seen on `digest`. */
+export interface EngineImage {
+    readonly version: string;
+    readonly digest?: string;
+}
+/**
+ * Whether a pod of `image` (its pinned digest, or as asked) runs the engine the image carries:
+ * the Tenant lists its repository, and the engine recorded for that digest is this Runtime's
+ * version or not known yet.
+ */
+export declare function runsBuiltinEngine(input: {
+    readonly image: string | undefined;
+    readonly imageDigest: string | undefined;
+    readonly engineImage: EngineImage | undefined;
+    readonly listed: readonly string[] | undefined;
+    readonly runtimeVersion?: string;
+}): boolean;

package/dist/sandbox/pods/builtin.js

@@ -0,0 +1,33 @@
+/**
+ * An engine built into the workload's image (ADR-99): the Runtime image's tini, node and bundled
+ * engine under `/opt/nylorun`, which the sandboxes service runs with `entrypoint: "builtin"` and
+ * nothing copied in.
+ *
+ * The Tenant lists the images that carry one (`engine.images`, by repository). Such an engine is
+ * whichever Runtime version the image was built from, so it reports that version when it joins
+ * (`IMAGE_ENGINE_HEADER`, sent only by an engine running from `/opt/nylorun`), and the pod's
+ * record keeps it beside the digest it ran (`engineImage`). A pod runs the image's engine while
+ * that version is the Runtime's own, or not known yet for the digest it runs (a first start, which
+ * the Harness API version check at `hello` still guards); otherwise the engine is copied in, so a
+ * Runtime upgrade never leaves a pod on an older engine for more than that first turn.
+ */
+import { RUNTIME_VERSION } from "../../version.js";
+import { repositoryOf } from "./lifecycle.js";
+export { BUILTIN_ENGINE_ROOT, ENGINE_VERSION_PATTERN, IMAGE_ENGINE_HEADER } from "../../harness/image-engine.js";
+/**
+ * Whether a pod of `image` (its pinned digest, or as asked) runs the engine the image carries:
+ * the Tenant lists its repository, and the engine recorded for that digest is this Runtime's
+ * version or not known yet.
+ */
+export function runsBuiltinEngine(input) {
+    const image = input.imageDigest ?? input.image;
+    if (!image || !input.listed?.length)
+        return false;
+    const repository = repositoryOf(image);
+    if (!input.listed.some((entry) => repositoryOf(entry) === repository))
+        return false;
+    const known = input.engineImage !== undefined && input.imageDigest !== undefined && input.engineImage.digest === input.imageDigest
+        ? input.engineImage.version
+        : undefined;
+    return known === undefined || known === (input.runtimeVersion ?? RUNTIME_VERSION);
+}

package/dist/sandbox/pods/client.d.ts

@@ -5,11 +5,12 @@ export interface PodSpec {
     /** The workload image; the service defaults it to `python:3.13-slim`. */
     readonly image?: string;
     /**
-     * What the workload runs: `engine` (default), our engine copied from `harnessImage`, or
-     * `image`, the image's own entrypoint, for a custom harness built into it (R4.4).
+     * What the workload runs: `engine` (default), our engine copied from `harnessImage`;
+     * `builtin`, our engine the image carries under `/opt/nylorun` (ADR-99); or `image`, the image's
+     * own entrypoint, for a custom harness built into it (R4.4).
      */
-    readonly entrypoint?: "engine" | "image";
-    /** The Runtime image the engine is copied from; not with `entrypoint: "image"`. */
+    readonly entrypoint?: "engine" | "builtin" | "image";
+    /** The Runtime image the engine is copied from; not with `entrypoint: "builtin"` or `"image"`. */
     readonly harnessImage?: string;
     /** Replaces the engine command (diagnostics). */
     readonly command?: readonly string[];

package/dist/sandbox/pods/spec.js

@@ -8,6 +8,7 @@ import { DEFAULT_HARNESS } from "@nylorun/core/contracts";
 import { idleMsOf, memoryMiBOf } from "../policy.js";
 import { podTuningEnv } from "../../tuning.js";
 import { opIdOf } from "./lifecycle.js";
+import { runsBuiltinEngine } from "./builtin.js";
 /** The pod's grace period to stop when the Tenant sets none (D34). */
 export const DEFAULT_STOP_GRACE_SECONDS = 10;
 /** The volume's size when the sandbox asks for none. */
@@ -40,12 +41,24 @@ export function podSpecOf(input) {
     // Pinned by digest once a pod ran it (Q14).
     const image = pod.imageDigest ?? spec.image;
     const ours = (input.harness ?? DEFAULT_HARNESS) === DEFAULT_HARNESS;
+    // Our engine, built into an image the Tenant lists, while it is this Runtime's (ADR-99).
+    const builtin = ours &&
+        runsBuiltinEngine({
+            image: spec.image,
+            imageDigest: pod.imageDigest,
+            engineImage: pod.engineImage,
+            listed: config.engine?.images,
+        });
     return {
         opId: opIdOf(pod),
         mode: input.mode,
         ...(image ? { image } : {}),
         // A custom harness is its image: the pod runs the image's entrypoint, nothing copied in.
-        ...(ours ? { harnessImage: input.harnessImage } : { entrypoint: "image" }),
+        ...(!ours
+            ? { entrypoint: "image" }
+            : builtin
+                ? { entrypoint: "builtin" }
+                : { harnessImage: input.harnessImage }),
         cpus: spec.resources?.cpus ?? 1,
         memoryMiB: memoryMiBOf(spec),
         storageGiB: storageGiBOf(spec),

package/dist/store/postgres/drizzle/0039_a2a_push.sql

@@ -0,0 +1,32 @@
+CREATE TABLE "nylorun"."a2a_push_configs" (
+	"session_id" text COLLATE "C" NOT NULL,
+	"task_id" text COLLATE "C" NOT NULL,
+	"config_id" text COLLATE "C" NOT NULL,
+	"context_id" text NOT NULL,
+	"turn_id" text COLLATE "C" NOT NULL,
+	"url" text NOT NULL,
+	"token" text,
+	"authentication" json,
+	"base_url" text NOT NULL,
+	"extensions" json NOT NULL,
+	"trace_id" text,
+	"next_seq" bigint NOT NULL,
+	"created_at" timestamp with time zone DEFAULT clock_timestamp() NOT NULL,
+	"done_at" timestamp with time zone,
+	CONSTRAINT "a2a_push_configs_pkey" PRIMARY KEY("session_id","task_id","config_id")
+);
+--> statement-breakpoint
+CREATE TABLE "nylorun"."a2a_pushes" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"session_id" text COLLATE "C" NOT NULL,
+	"task_id" text COLLATE "C" NOT NULL,
+	"config_id" text COLLATE "C" NOT NULL,
+	"body" text NOT NULL,
+	"created_at" timestamp with time zone DEFAULT clock_timestamp() NOT NULL,
+	"attempts" integer DEFAULT 0 NOT NULL,
+	"retry_at" timestamp with time zone,
+	"parked_at" timestamp with time zone
+);
+--> statement-breakpoint
+CREATE INDEX "a2a_push_configs_done_at" ON "nylorun"."a2a_push_configs" USING btree ("done_at");--> statement-breakpoint
+CREATE INDEX "a2a_pushes_created_at" ON "nylorun"."a2a_pushes" USING btree ("created_at");

package/dist/store/postgres/drizzle/0040_turn_index.sql

@@ -0,0 +1,23 @@
+CREATE TABLE "nylorun"."turns" (
+	"session_id" text COLLATE "C" NOT NULL,
+	"turn_id" text COLLATE "C" NOT NULL,
+	"agent_id" text COLLATE "C" NOT NULL,
+	"owner_user_id" text COLLATE "C",
+	"a2a_context_id" text COLLATE "C",
+	"status" text NOT NULL,
+	"started_at" text COLLATE "C" NOT NULL,
+	"ended_at" text COLLATE "C",
+	"changed_at" text COLLATE "C" NOT NULL,
+	"totals" json,
+	"waiting_for" text,
+	"queued_message_ids" text[] DEFAULT '{}' NOT NULL,
+	"first_seq" bigint NOT NULL,
+	"last_seq" bigint NOT NULL,
+	"txid" "xid8" DEFAULT pg_current_xact_id() NOT NULL,
+	CONSTRAINT "turns_pkey" PRIMARY KEY("session_id","turn_id")
+);
+--> statement-breakpoint
+CREATE INDEX "turns_turn" ON "nylorun"."turns" USING btree ("turn_id");--> statement-breakpoint
+CREATE INDEX "turns_changes" ON "nylorun"."turns" USING btree ("txid","session_id","turn_id");--> statement-breakpoint
+CREATE INDEX "turns_owner_changes" ON "nylorun"."turns" USING btree ("owner_user_id","txid");--> statement-breakpoint
+CREATE INDEX "turns_owner_agent" ON "nylorun"."turns" USING btree ("owner_user_id","agent_id","changed_at");

package/dist/store/postgres/drizzle/0041_turn_index_backfill.sql

@@ -0,0 +1,88 @@
+-- Custom SQL (a data change): the turn index (0040) for the turns the record already holds. Each
+-- turn's row is what `Tx.event` would have written for its lifecycle events (`command.message`,
+-- `command.approve`, `command.respond`, `turn.paused`, `turn.completed`, `turn.failed`,
+-- `turn.cancelled`): its status from the last of them (and, paused, what its first open
+-- interaction asks for), its start from the first, and the queued messages it took. Its session's
+-- Agent, owner and A2A context come from the session row as it is now. Rows written from here on
+-- come from `Tx.event`, in the transaction of the event.
+WITH lifecycle AS (
+	SELECT "session_id", "seq", "type", nylorun.doc("body") AS doc
+	FROM "nylorun_streams"."session_events"
+	WHERE "type" IN (
+		'command.message', 'command.approve', 'command.respond',
+		'turn.paused', 'turn.completed', 'turn.failed', 'turn.cancelled'
+	)
+), turned AS (
+	SELECT "session_id", doc->>'turnId' AS turn_id, "seq", "type", doc
+	FROM lifecycle
+	WHERE doc->>'turnId' IS NOT NULL
+), bounds AS (
+	SELECT "session_id", turn_id, min("seq") AS first_seq,
+		min(doc->>'time') AS started_at,
+		coalesce(
+			array_remove(
+				array_agg(doc->'payload'->>'queuedMessageId' ORDER BY "seq")
+					FILTER (WHERE "type" = 'command.message'),
+				NULL
+			),
+			'{}'
+		) AS queued_message_ids
+	FROM turned
+	GROUP BY "session_id", turn_id
+), latest AS (
+	-- A turn's further messages (a queued batch) change nothing but its queued messages.
+	SELECT DISTINCT ON (t."session_id", t.turn_id) t."session_id", t.turn_id, t."seq", t."type", t.doc
+	FROM turned t
+	JOIN bounds b ON b."session_id" = t."session_id" AND b.turn_id = t.turn_id
+	WHERE NOT (t."type" = 'command.message' AND t."seq" > b.first_seq)
+	ORDER BY t."session_id", t.turn_id, t."seq" DESC
+)
+INSERT INTO "nylorun"."turns" (
+	"session_id", "turn_id", "agent_id", "owner_user_id", "a2a_context_id", "status",
+	"started_at", "ended_at", "changed_at", "totals", "waiting_for", "queued_message_ids",
+	"first_seq", "last_seq"
+)
+SELECT
+	b."session_id",
+	b.turn_id,
+	coalesce(s."agent_id", ''),
+	s."owner_user_id",
+	nylorun.doc(s."body")->'info'->'a2a'->>'contextId',
+	CASE l."type"
+		WHEN 'turn.completed' THEN 'completed'
+		WHEN 'turn.failed' THEN 'failed'
+		WHEN 'turn.cancelled' THEN 'cancelled'
+		WHEN 'turn.paused' THEN 'paused'
+		ELSE 'running'
+	END,
+	b.started_at,
+	CASE WHEN l."type" IN ('turn.completed', 'turn.failed', 'turn.cancelled') THEN l.doc->>'time' END,
+	l.doc->>'time',
+	CASE WHEN l."type" IN ('turn.completed', 'turn.failed', 'turn.cancelled')
+		AND jsonb_typeof(l.doc->'payload'->'totals'->'steps') = 'number'
+		AND jsonb_typeof(l.doc->'payload'->'totals'->'tokens') = 'number'
+		AND jsonb_typeof(l.doc->'payload'->'totals'->'costUsd') = 'number'
+		THEN json_build_object(
+			'steps', l.doc->'payload'->'totals'->'steps',
+			'tokens', l.doc->'payload'->'totals'->'tokens',
+			'costUsd', l.doc->'payload'->'totals'->'costUsd'
+		) END,
+	CASE WHEN l."type" = 'turn.paused' AND jsonb_typeof(l.doc->'payload'->'interactions') = 'array' THEN (
+		SELECT CASE
+			WHEN x.e->'interaction'->>'kind' = 'connection'
+				OR x.e->'interaction'->'metadata'->>'kind' = 'connection' THEN 'connection'
+			WHEN x.e->'interaction'->>'kind' = 'approval' THEN 'approval'
+			ELSE 'question'
+		END
+		FROM jsonb_array_elements(l.doc->'payload'->'interactions') WITH ORDINALITY AS x(e, i)
+		WHERE (x.e->>'status' IS NULL OR x.e->>'status' = 'interaction')
+			AND jsonb_typeof(x.e->'interaction'->'id') = 'string'
+		ORDER BY x.i
+		LIMIT 1
+	) END,
+	b.queued_message_ids,
+	b.first_seq,
+	l."seq"
+FROM bounds b
+JOIN latest l ON l."session_id" = b."session_id" AND l.turn_id = b.turn_id
+LEFT JOIN "nylorun"."sessions" s ON s."id" = b."session_id";

package/dist/store/postgres/drizzle/0042_worker_engine_image.sql

@@ -0,0 +1 @@
+ALTER TABLE "nylorun"."agents" ADD COLUMN "engine_image" json;

package/dist/store/postgres/drizzle/meta/_journal.json

@@ -274,6 +274,34 @@
       "when": 1792484344984,
       "tag": "0038_t6_agent_manifest_source",
       "breakpoints": true
+    },
+    {
+      "idx": 39,
+      "version": "7",
+      "when": 1793445550433,
+      "tag": "0039_a2a_push",
+      "breakpoints": true
+    },
+    {
+      "idx": 40,
+      "version": "7",
+      "when": 1793448351698,
+      "tag": "0040_turn_index",
+      "breakpoints": true
+    },
+    {
+      "idx": 41,
+      "version": "7",
+      "when": 1793448353003,
+      "tag": "0041_turn_index_backfill",
+      "breakpoints": true
+    },
+    {
+      "idx": 42,
+      "version": "7",
+      "when": 1793509192153,
+      "tag": "0042_worker_engine_image",
+      "breakpoints": true
     }
   ]
 }

package/dist/store/postgres/reads.js

@@ -11,7 +11,7 @@ import { database, driverError } from "./db.js";
 import { createPostgresReadClient } from "./connect.js";
 import { hostTuning } from "../../tuning.js";
 import { toolCallDuration, toolCallStatus } from "../../harness-api/tool-status.js";
-import { effects, artifacts, modelUsage, sandboxes, sessions, sessionEvents, tenantSettings, } from "./schema.js";
+import { effects, artifacts, modelUsage, sandboxes, sessions, sessionEvents, tenantSettings, turns, } from "./schema.js";
 const sessionFields = {
     id: sessions.id,
     agentId: sessions.agentId,
@@ -101,6 +101,20 @@ function publicToolCall(body) {
         durationMs: toolCallDuration(body) ?? null,
     };
 }
+/** The change feed's cursor key: the last row's `[txid, sessionId, turnId]`. */
+function turnChangeKey(key) {
+    if (key === undefined)
+        return undefined;
+    const [txid, sessionId, turnId] = key;
+    if (key.length !== 3 ||
+        typeof txid !== "string" ||
+        typeof sessionId !== "string" ||
+        typeof turnId !== "string" ||
+        !/^\d{1,20}$/.test(txid) ||
+        BigInt(txid) > 18446744073709551615n)
+        return fail(400, "Invalid cursor key", { code: "cursor_invalid" });
+    return [txid, sessionId, turnId];
+}
 function keyOf(key, length, timestamp = false, nullable = false) {
     if (key &&
         (key.length !== length ||
@@ -316,6 +330,32 @@ export function createPostgresReadStore(source, tenantId) {
                 .orderBy(asc(sessionEvents.seq));
             return rows.map((row) => row.body);
         }),
+        turnChanges: (filters, page, access) => read(async (tx) => {
+            if (filters.sessionId !== undefined)
+                await requireSession(tx, filters.sessionId, access);
+            const cursor = readCursor(tenantId, "turns", { sessionId: filters.sessionId ?? null });
+            const key = turnChangeKey(cursor.decode(page.changedAfter));
+            const rows = await tx
+                .select()
+                .from(turns)
+                .where(and(
+            // Below every transaction still running: one that commits later sorts after.
+            sql `${turns.txid} < pg_snapshot_xmin(pg_current_snapshot())`, key
+                ? sql `(${turns.txid}, ${turns.sessionId}, ${turns.turnId}) > (${key[0]}::xid8, ${key[1]}, ${key[2]})`
+                : undefined, filters.sessionId === undefined ? undefined : eq(turns.sessionId, filters.sessionId), access.owner === undefined ? undefined : eq(turns.ownerUserId, access.owner), access.agents === undefined ? undefined : grantsWhere(turns.agentId, access.agents)))
+                .orderBy(asc(turns.txid), asc(turns.sessionId), asc(turns.turnId))
+                .limit(page.limit + 1);
+            const items = rows.slice(0, page.limit);
+            const last = items.at(-1);
+            return {
+                turns: items,
+                // Echoed when nothing changed; a first read starts before every row.
+                cursor: last
+                    ? cursor.encode([last.txid, last.sessionId, last.turnId])
+                    : (page.changedAfter ?? cursor.encode(["0", "", ""])),
+                hasMore: rows.length > page.limit,
+            };
+        }),
         exportModel: (after, limit) => read(async (tx) => {
             const cursor = readCursor(tenantId, "model-export", {});
             const key = keyOf(cursor.decode(after), 2);