@nylorun/runtime 0.23.0-beta → 0.25.0-beta

package/dist/store/postgres/reads.js

@@ -1,12 +1,15 @@
 import { z } from "zod";
 /** Drizzle read projections on a separate, read-only Tenant pool. */
-import { and, asc, desc, eq, gt, inArray, isNull, lt, ne, or, sql, } from "drizzle-orm";
+import { and, asc, desc, eq, exists, gt, inArray, isNull, lt, ne, or, sql, } from "drizzle-orm";
+import { isArtifactId } from "@nylorun/core/compatibility";
 import { readCursor } from "../../reads/cursor.js";
 import { fail } from "../../tenant/http.js";
+import { artifactView } from "../../artifacts/service.js";
 import { sandboxWorkspaceKey } from "../../sandbox/records.js";
 import { database, driverError } from "./db.js";
 import { createPostgresReadClient } from "./connect.js";
-import { modelUsage, sandboxResources, sandboxes, sessions, sessionEvents, } from "./schema.js";
+import { toolCallDuration, toolCallStatus } from "../../harness-api/tool-status.js";
+import { effects, artifacts, modelUsage, environments, sandboxes, sessions, sessionEvents, } from "./schema.js";
 const sessionFields = {
     id: sessions.id,
     agentId: sessions.agentId,
@@ -14,7 +17,7 @@ const sessionFields = {
     status: sessions.status,
     activeTurnId: sql `${sessions.body}->>'activeTurnId'`,
     lastTurnId: sql `${sessions.body}->>'lastTurnId'`,
-    sandboxId: sessions.sandboxId,
+    environmentId: sessions.environmentId,
     createdAt: sessions.createdAt,
 };
 function accessWhere(access) {
@@ -23,6 +26,7 @@ function accessWhere(access) {
 function publicCall(row) {
     return {
         id: row.id,
+        effectId: row.effectKey,
         sessionId: row.sessionId,
         turnId: row.turnId,
         agentId: row.agentId,
@@ -44,6 +48,34 @@ function publicCall(row) {
         },
     };
 }
+function publicToolCall(body) {
+    const { request } = body;
+    const status = toolCallStatus(body);
+    const value = body.outcome?.value;
+    const error = value?.kind === "failed"
+        ? { code: String(value.code ?? "tool.failed"), message: String(value.message ?? "") }
+        : status === "uncertain"
+            ? { code: "uncertain", message: body.error ?? "" }
+            : null;
+    return {
+        effectId: request.effectId,
+        turnId: request.turnId,
+        callId: typeof request.context?.callId === "string" ? request.context.callId : null,
+        toolName: request.toolName ?? null,
+        kind: body.toolKind ?? null,
+        server: body.server ?? null,
+        skill: body.skill ?? null,
+        plugin: body.plugin ?? null,
+        status,
+        // A row written before R5 counted no sends: it was sent once.
+        attempts: body.attempts ?? 1,
+        input: request.input ?? null,
+        error,
+        startedAt: body.startedAt ?? null,
+        settledAt: body.settledAt ?? null,
+        durationMs: toolCallDuration(body) ?? null,
+    };
+}
 function keyOf(key, length, timestamp = false, nullable = false) {
     if (key &&
         (key.length !== length ||
@@ -87,6 +119,39 @@ export function createPostgresReadStore(source, tenantId) {
     }
     return {
         close: () => pool.end({ timeout: 2 }),
+        artifacts: (filters, page, access) => read(async (tx) => {
+            if (filters.sessionId !== undefined)
+                await requireSession(tx, filters.sessionId, access);
+            const cursor = readCursor(tenantId, "artifacts", {
+                sessionId: filters.sessionId ?? null,
+                kind: filters.kind ?? null,
+                labels: Object.entries(filters.labels).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
+            });
+            const key = keyOf(cursor.decode(page.cursor), 2, true);
+            if (key && !isArtifactId(key[1]))
+                fail(400, "Invalid artifact cursor key", { code: "cursor_invalid" });
+            const rows = await tx
+                .select()
+                .from(artifacts)
+                .where(and(access.owner === undefined && access.agents === undefined
+                ? undefined
+                : exists(tx.select({ id: sessions.id })
+                    .from(sessions)
+                    .where(and(eq(sessions.id, artifacts.sessionId), accessWhere(access)))), filters.sessionId === undefined
+                ? undefined
+                : eq(artifacts.sessionId, filters.sessionId), filters.kind === undefined ? undefined : eq(artifacts.kind, filters.kind), 
+            // Labels are a flat string map serialized by JSON.stringify. Match its exact
+            // key/value pair: jsonb rejects NUL/unpaired surrogate escapes labels may hold.
+            ...Object.entries(filters.labels).map(([k, v]) => sql `strpos(${artifacts.labelsJson}, ${JSON.stringify(k) + ":" + JSON.stringify(v)}) > 0`), key ? sql `(${artifacts.createdAt}, ${artifacts.id}) < (${key[0]}, ${key[1]})` : undefined))
+                .orderBy(desc(artifacts.createdAt), desc(artifacts.id))
+                .limit(page.limit + 1);
+            const items = rows.slice(0, page.limit);
+            const last = items.at(-1);
+            return {
+                artifacts: items.map((row) => artifactView(row)),
+                nextCursor: rows.length > page.limit && last ? cursor.encode([last.createdAt, last.id]) : null,
+            };
+        }),
         sessions: (filters, page, access) => read(async (tx) => {
             const cursor = readCursor(tenantId, "sessions", filters);
             const key = keyOf(cursor.decode(page.cursor), 2, true, true);
@@ -98,9 +163,9 @@ export function createPostgresReadStore(source, tenantId) {
             const rows = await tx
                 .select(fields)
                 .from(sessions)
-                .where(and(accessWhere(access), position, filters.agentId === undefined ? undefined : eq(sessions.agentId, filters.agentId), filters.status === undefined ? undefined : eq(sessions.status, filters.status), filters.sandboxId === undefined
+                .where(and(accessWhere(access), position, filters.agentId === undefined ? undefined : eq(sessions.agentId, filters.agentId), filters.status === undefined ? undefined : eq(sessions.status, filters.status), filters.environmentId === undefined
                 ? undefined
-                : eq(sessions.sandboxId, filters.sandboxId), filters.ownerUserId === undefined
+                : eq(sessions.environmentId, filters.environmentId), filters.ownerUserId === undefined
                 ? undefined
                 : eq(sessions.ownerUserId, filters.ownerUserId)))
                 .orderBy(sql `${sessions.createdAt} desc nulls last`, desc(sessions.id))
@@ -182,6 +247,37 @@ export function createPostgresReadStore(source, tenantId) {
                 asOf: new Date().toISOString(),
             };
         }),
+        toolCalls: (id, turnId, page, access) => read(async (tx) => {
+            await requireSession(tx, id, access);
+            const cursor = readCursor(tenantId, "tool-calls", { sessionId: id, turnId });
+            const key = keyOf(cursor.decode(page.cursor), 2);
+            // In the order of their first send; a row written before R5 has no `startedAt`.
+            const startedAt = sql `coalesce(${effects.body}->>'startedAt', '')`;
+            const rows = await tx
+                .select({ id: effects.id, body: effects.body, startedAt })
+                .from(effects)
+                .where(and(eq(effects.sessionId, id), eq(effects.kind, "tool"), turnId === undefined ? undefined : eq(effects.turnId, turnId), key ? sql `(${startedAt}, ${effects.id}) > (${key[0]}, ${key[1]})` : undefined))
+                .orderBy(asc(startedAt), asc(effects.id))
+                .limit(page.limit + 1);
+            const items = rows.slice(0, page.limit);
+            const last = items.at(-1);
+            return {
+                calls: items.map((row) => publicToolCall(row.body)),
+                nextCursor: rows.length > page.limit && last ? cursor.encode([last.startedAt, last.id]) : null,
+                asOf: new Date().toISOString(),
+            };
+        }),
+        turnEvents: (id, turnId, access) => read(async (tx) => {
+            await requireSession(tx, id, access);
+            // The record has no turn column: one session's rows, on the turn id in the event (no
+            // index yet, R8).
+            const rows = await tx
+                .select({ body: sessionEvents.body })
+                .from(sessionEvents)
+                .where(and(eq(sessionEvents.sessionId, id), sql `${sessionEvents.body}->>'turnId' = ${turnId}`))
+                .orderBy(asc(sessionEvents.seq));
+            return rows.map((row) => row.body);
+        }),
         exportModel: (after, limit) => read(async (tx) => {
             const cursor = readCursor(tenantId, "model-export", {});
             const key = keyOf(cursor.decode(after), 2);
@@ -205,19 +301,19 @@ export function createPostgresReadStore(source, tenantId) {
                 asOf: new Date().toISOString(),
             };
         }),
-        sandboxes: (labels, page, access, grants) => read(async (tx) => {
-            const cursor = readCursor(tenantId, "sandboxes", labels);
+        environments: (labels, page, access, grants) => read(async (tx) => {
+            const cursor = readCursor(tenantId, "environments", labels);
             const key = keyOf(cursor.decode(page.cursor), 1);
             const allowed = grants === undefined
                 ? undefined
                 : or(...grants.map((grant) => grant.endsWith("/*")
-                    ? sql `starts_with(${sandboxResources.id}, ${grant.slice(0, -1)})`
-                    : eq(sandboxResources.id, grant)));
+                    ? sql `starts_with(${environments.id}, ${grant.slice(0, -1)})`
+                    : eq(environments.id, grant)));
             const rows = await tx
                 .select()
-                .from(sandboxResources)
-                .where(and(grants?.length === 0 ? sql `false` : allowed, key ? gt(sandboxResources.id, key[0]) : undefined, or(isNull(sandboxResources.desired), ne(sandboxResources.desired, "deleted")), ...Object.entries(labels).map(([k, v]) => sql `${sandboxResources.labels}::jsonb->>${k} = ${v}`)))
-                .orderBy(asc(sandboxResources.id))
+                .from(environments)
+                .where(and(grants?.length === 0 ? sql `false` : allowed, key ? gt(environments.id, key[0]) : undefined, or(isNull(environments.desired), ne(environments.desired, "deleted")), ...Object.entries(labels).map(([k, v]) => sql `${environments.labels}::jsonb->>${k} = ${v}`)))
+                .orderBy(asc(environments.id))
                 .limit(page.limit + 1);
             const items = [];
             for (const row of rows.slice(0, page.limit)) {
@@ -226,7 +322,7 @@ export function createPostgresReadStore(source, tenantId) {
                     items: sql `coalesce(json_agg(json_build_object('id', ${sessions.id}, 'activeTurnId', ${sessions.body}->>'activeTurnId') order by ${sessions.id}), '[]'::json)`,
                 })
                     .from(sessions)
-                    .where(and(eq(sessions.sandboxId, row.id), accessWhere(access)));
+                    .where(and(eq(sessions.environmentId, row.id), accessWhere(access)));
                 const [compute] = await tx
                     .select({ body: sandboxes.body })
                     .from(sandboxes)
@@ -237,14 +333,23 @@ export function createPostgresReadStore(source, tenantId) {
                     id: row.id,
                     kind: row.kind,
                     labels: row.labels,
-                    spec: row.spec,
+                    manifest: row.recipe,
+                    ...(row.manifestName === null ? {} : { manifestName: row.manifestName }),
+                    ...(row.manifestVersion === null ? {} : { manifestVersion: row.manifestVersion }),
+                    ...(row.manifestHash === null ? {} : { manifestHash: row.manifestHash }),
+                    ...(row.forkedFrom ? { forkedFrom: row.forkedFrom } : {}),
+                    version: row.version,
+                    appliedVersion: row.appliedVersion,
+                    ownerUserId: row.ownerUserId,
                     state: isPod
                         ? row.observed === "running"
                             ? "running"
                             : row.observed === "creating"
                                 ? "creating"
                                 : "stopped"
-                        : (compute?.body?.state ?? "ready"),
+                        : row.kind === "none"
+                            ? "ready"
+                            : (compute?.body?.state ?? "ready"),
                     ...(isPod
                         ? {
                             pod: {
@@ -252,11 +357,12 @@ export function createPostgresReadStore(source, tenantId) {
                                 observed: row.observed,
                                 volumeGeneration: row.volumeGen,
                                 hostEpoch: row.hostEpoch,
-                                ...(row.expiresAt ? { expiresAt: new Date(row.expiresAt).toISOString() } : {}),
                                 ...(row.reason ? { reason: row.reason } : {}),
+                                ...(row.imageDigest ? { imageDigest: row.imageDigest } : {}),
                             },
                         }
                         : {}),
+                    lastUsedAt: new Date(row.lastUsedAt).toISOString(),
                     sessions: related.items,
                     createdAt: row.createdAt,
                     updatedAt: row.updatedAt,
@@ -264,7 +370,7 @@ export function createPostgresReadStore(source, tenantId) {
             }
             const last = items.at(-1);
             return {
-                sandboxes: items,
+                environments: items,
                 nextCursor: rows.length > page.limit && last ? cursor.encode([last.id]) : null,
             };
         }),

package/dist/store/postgres/record-writer.d.ts

@@ -1,9 +1,9 @@
-import type { RecordWriter, SandboxRecordWriter } from "../../record/index.js";
+import type { RecordWriter, EnvironmentRecordWriter } from "../../record/index.js";
 import type { Transaction } from "./db.js";
 /**
- * The sandbox stream writer of transaction `db` (`record/sandbox.ts`): the only inserts into
- * `sandbox_events`. The caller holds the sandbox row's lock, which orders its events.
+ * The Environment stream writer of transaction `db` (`record/environment.ts`): the only inserts
+ * into `environment_events`. The caller holds the Environment row's lock, which orders its events.
  */
-export declare function postgresSandboxRecordWriter(db: Transaction): SandboxRecordWriter;
+export declare function postgresEnvironmentRecordWriter(db: Transaction): EnvironmentRecordWriter;
 /** The record writer of transaction `db`. */
 export declare function postgresRecordWriter(db: Transaction): RecordWriter;

package/dist/store/postgres/record-writer.js

@@ -5,22 +5,22 @@
  * run in the store's transaction under the caller's session row lock.
  */
 import { eq, sql } from "drizzle-orm";
-import { sandboxEvents, sessionEvents, sessionLogHeads, tenant } from "./schema.js";
+import { environmentEvents, sessionEvents, sessionLogHeads, tenant } from "./schema.js";
 /**
- * The sandbox stream writer of transaction `db` (`record/sandbox.ts`): the only inserts into
- * `sandbox_events`. The caller holds the sandbox row's lock, which orders its events.
+ * The Environment stream writer of transaction `db` (`record/environment.ts`): the only inserts
+ * into `environment_events`. The caller holds the Environment row's lock, which orders its events.
  */
-export function postgresSandboxRecordWriter(db) {
+export function postgresEnvironmentRecordWriter(db) {
     return {
-        async nextSeq(sandboxId) {
+        async nextSeq(environmentId) {
             const [row] = await db
-                .select({ next: sql `coalesce(max(${sandboxEvents.seq}) + 1, 0)`.mapWith(Number) })
-                .from(sandboxEvents)
-                .where(eq(sandboxEvents.sandboxId, sandboxId));
+                .select({ next: sql `coalesce(max(${environmentEvents.seq}) + 1, 0)`.mapWith(Number) })
+                .from(environmentEvents)
+                .where(eq(environmentEvents.environmentId, environmentId));
             return row?.next ?? 0;
         },
         async insert(row) {
-            await db.insert(sandboxEvents).values(row);
+            await db.insert(environmentEvents).values(row);
         },
     };
 }

package/dist/store/postgres/record.d.ts

@@ -1,5 +1,12 @@
+import type { LiveEvent } from "@nylorun/core/contracts";
 import type { Sql } from "postgres";
 import type { RecordReader } from "../../streams/relay/types.js";
 export declare function createPostgresRecordReader(sql: Sql, options: {
     tenantId: string;
 }): RecordReader;
+/**
+ * The trace projector's read of a turn's start (R7.2): the `command.message` that started turn
+ * `turnId` of `sessionId`, or undefined when the log has none. One session's rows, filtered on
+ * the turn id in the event (the record has no turn column; no index yet, R8).
+ */
+export declare function createPostgresTurnMessages(sql: Sql): (sessionId: string, turnId: string) => Promise<LiveEvent | undefined>;

package/dist/store/postgres/record.js

@@ -1,13 +1,14 @@
 /**
  * Reads the record back for the stream relay (Durable Streams §7.2–7.3): a session's rows to
  * refill a gap in S2, every log head to reconcile after a fresh slot, and the Tenant's current
- * basin generation to tell obsolete rows apart.
+ * basin generation to tell obsolete rows apart. The trace projector reads a turn's start
+ * (`createPostgresTurnMessages`).
  *
  * The database holds one Tenant, so the record has no Tenant column: the reader is made for
  * that Tenant (`tenantId`), fills `RecordRow.tenantId` and `LogHead.tenantId` with it, and
  * reads nothing for any other id.
  */
-import { and, asc, eq, gt, gte, lt } from "drizzle-orm";
+import { and, asc, eq, gt, gte, lt, sql as sql_ } from "drizzle-orm";
 import { database, driverError } from "./db.js";
 import { sessionEvents, sessionLogHeads, tenant } from "./schema.js";
 export function createPostgresRecordReader(sql, options) {
@@ -58,3 +59,23 @@ export function createPostgresRecordReader(sql, options) {
         },
     };
 }
+/**
+ * The trace projector's read of a turn's start (R7.2): the `command.message` that started turn
+ * `turnId` of `sessionId`, or undefined when the log has none. One session's rows, filtered on
+ * the turn id in the event (the record has no turn column; no index yet, R8).
+ */
+export function createPostgresTurnMessages(sql) {
+    const db = database(sql);
+    return async (sessionId, turnId) => {
+        const [row] = await db
+            .select({ body: sessionEvents.body })
+            .from(sessionEvents)
+            .where(and(eq(sessionEvents.sessionId, sessionId), eq(sessionEvents.type, "command.message"), sql_ `${sessionEvents.body}->>'turnId' = ${turnId}`))
+            .orderBy(asc(sessionEvents.seq))
+            .limit(1)
+            .catch((error) => {
+            throw driverError(error);
+        });
+        return row?.body;
+    };
+}