@nylorun/runtime 0.36.1-beta → 0.37.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/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/meta/_journal.json

@@ -274,6 +274,27 @@
       "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
     }
   ]
 }

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);