@nylorun/runtime 0.27.0-beta → 0.29.0-beta

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

@@ -225,6 +225,48 @@
       "when": 1792094620175,
       "tag": "0031_protocol_15_mcp_snapshot",
       "breakpoints": true
+    },
+    {
+      "idx": 32,
+      "version": "7",
+      "when": 1792098220175,
+      "tag": "0032_agents",
+      "breakpoints": true
+    },
+    {
+      "idx": 33,
+      "version": "7",
+      "when": 1792161078177,
+      "tag": "0033_agent_versions",
+      "breakpoints": true
+    },
+    {
+      "idx": 34,
+      "version": "7",
+      "when": 1792163689759,
+      "tag": "0034_protocol_17_session_queue",
+      "breakpoints": true
+    },
+    {
+      "idx": 35,
+      "version": "7",
+      "when": 1792164194039,
+      "tag": "0035_t4_triggers",
+      "breakpoints": true
+    },
+    {
+      "idx": 36,
+      "version": "7",
+      "when": 1792172016681,
+      "tag": "0036_t5_memories",
+      "breakpoints": true
+    },
+    {
+      "idx": 37,
+      "version": "7",
+      "when": 1792238141315,
+      "tag": "0037_model_usage_cost_split",
+      "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, environments, sandboxes, sessions, sessionEvents, tenantSettings, } from "./schema.js";
+import { effects, artifacts, modelUsage, sandboxes, sessions, sessionEvents, tenantSettings, } from "./schema.js";
 const sessionFields = {
     id: sessions.id,
     agentId: sessions.agentId,
@@ -19,11 +19,30 @@ const sessionFields = {
     status: sessions.status,
     activeTurnId: sql `${sessions.body}->>'activeTurnId'`,
     lastTurnId: sql `${sessions.body}->>'lastTurnId'`,
-    environmentId: sessions.environmentId,
     createdAt: sessions.createdAt,
 };
+/** Rows whose Agent id an Agent grant (`*`, an id, or a `p/*` prefix) reaches; none reach nothing. */
+function grantsWhere(column, grants) {
+    if (grants.includes("*"))
+        return sql `true`;
+    if (grants.length === 0)
+        return sql `false`;
+    return or(...grants.map((grant) => grant.endsWith("/*") ? sql `starts_with(${column}, ${grant.slice(0, -1)})` : eq(column, grant)));
+}
 function accessWhere(access) {
-    return and(access.owner === undefined ? undefined : eq(sessions.ownerUserId, access.owner), access.agents === undefined ? undefined : inArray(sessions.agentId, [...access.agents]));
+    return and(access.owner === undefined ? undefined : eq(sessions.ownerUserId, access.owner), access.agents === undefined ? undefined : grantsWhere(sessions.agentId, access.agents));
+}
+/** A row's cost by token kind, when the adapter kept it (migration 0037). */
+function costSplitOf(row) {
+    const { costInputUsd, costCacheReadUsd, costCacheWriteUsd, costOutputUsd } = row;
+    if (costInputUsd === null || costCacheReadUsd === null || costCacheWriteUsd === null || costOutputUsd === null)
+        return null;
+    return {
+        input: costInputUsd,
+        cacheRead: costCacheReadUsd,
+        cacheWrite: costCacheWriteUsd,
+        output: costOutputUsd,
+    };
 }
 function publicCall(row) {
     return {
@@ -31,10 +50,12 @@ function publicCall(row) {
         effectId: row.effectKey,
         sessionId: row.sessionId,
         turnId: row.turnId,
-        agentId: row.agentId,
+        manifestName: row.manifestName,
         provider: row.provider,
         model: row.model,
         at: row.createdAt,
+        startedAt: row.startedAt,
+        endedAt: row.endedAt,
         outcome: "completed",
         usage: {
             inputTokens: row.inputTokens,
@@ -47,6 +68,7 @@ function publicCall(row) {
             duplicate: row.duplicate,
             tokensReported: row.tokensReported,
             costKnown: row.costKnown,
+            costSplit: costSplitOf(row),
         },
     };
 }
@@ -166,9 +188,7 @@ 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.environmentId === undefined
-                ? undefined
-                : eq(sessions.environmentId, filters.environmentId), filters.ownerUserId === 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.manifest === undefined ? undefined : eq(sessions.manifestName, filters.manifest), filters.ownerUserId === undefined
                 ? undefined
                 : eq(sessions.ownerUserId, filters.ownerUserId)))
                 .orderBy(sql `${sessions.createdAt} desc nulls last`, desc(sessions.id))
@@ -189,8 +209,8 @@ export function createPostgresReadStore(source, tenantId) {
                 .select({
                 sessionId: sessions.id,
                 agentId: sessions.agentId,
+                definition: sql `${sessions.body}->'definition'`,
                 manifestHash: sql `${sessions.body}->>'manifestHash'`,
-                implementationVersion: sql `${sessions.body}->>'implementationVersion'`,
                 manifest: sql `${sessions.body}->'manifest'`,
             })
                 .from(sessions)
@@ -220,11 +240,26 @@ export function createPostgresReadStore(source, tenantId) {
                 unpricedCalls: sql `count(*) filter (where ${modelUsage.costKnown} = false)`.mapWith(Number),
                 unreportedCalls: sql `count(*) filter (where ${modelUsage.tokensReported} = false)`.mapWith(Number),
                 unknownQualityCalls: sql `count(*) filter (where ${modelUsage.tokensReported} is null or ${modelUsage.costKnown} is null)`.mapWith(Number),
+                costInput: sum(modelUsage.costInputUsd),
+                costCacheRead: sum(modelUsage.costCacheReadUsd),
+                costCacheWrite: sum(modelUsage.costCacheWriteUsd),
+                costOutput: sum(modelUsage.costOutputUsd),
+                splitCalls: sql `count(${modelUsage.costInputUsd})`.mapWith(Number),
+                // The gate's timing is ISO text; a row timed before migration 0022 has none.
+                modelTimeMs: sql `coalesce(round(sum(extract(epoch from (${modelUsage.endedAt}::timestamptz - ${modelUsage.startedAt}::timestamptz)) * 1000)), 0)`.mapWith(Number),
+                timedCalls: sql `count(*) filter (where ${modelUsage.startedAt} is not null and ${modelUsage.endedAt} is not null)`.mapWith(Number),
             })
                 .from(modelUsage)
                 .where(and(eq(modelUsage.sessionId, id), turnId === undefined ? undefined : eq(modelUsage.turnId, turnId)));
+            const { costInput, costCacheRead, costCacheWrite, costOutput, ...rest } = totals;
             return {
-                ...totals,
+                ...rest,
+                costSplit: {
+                    input: costInput,
+                    cacheRead: costCacheRead,
+                    cacheWrite: costCacheWrite,
+                    output: costOutput,
+                },
                 sessionId: id,
                 turnId: turnId ?? null,
                 asOf: new Date().toISOString(),
@@ -304,83 +339,5 @@ export function createPostgresReadStore(source, tenantId) {
                 asOf: new Date().toISOString(),
             };
         }),
-        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(${environments.id}, ${grant.slice(0, -1)})`
-                    : eq(environments.id, grant)));
-            const rows = await tx
-                .select()
-                .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 tenantLimits = await readTenantLimits({
-                getSetting: async (setting) => (await tx.select({ value: tenantSettings.value }).from(tenantSettings).where(eq(tenantSettings.key, setting)))[0]
-                    ?.value,
-            });
-            const items = [];
-            for (const row of rows.slice(0, page.limit)) {
-                const [related] = await tx
-                    .select({
-                    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.environmentId, row.id), accessWhere(access)));
-                const [compute] = await tx
-                    .select({ body: sandboxes.body })
-                    .from(sandboxes)
-                    .where(eq(sandboxes.id, sandboxWorkspaceKey(tenantId, row.id)))
-                    .limit(1);
-                const isPod = row.kind === "pod";
-                items.push({
-                    id: row.id,
-                    kind: row.kind,
-                    labels: row.labels,
-                    manifest: row.recipe,
-                    ...(row.manifestName === null ? {} : { manifestName: row.manifestName }),
-                    ...(row.manifestVersion === null ? {} : { manifestVersion: row.manifestVersion }),
-                    ...(row.manifestHash === null ? {} : { manifestHash: row.manifestHash }),
-                    limits: limitsInForce(tenantLimits, row.recipe.limits),
-                    ...(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"
-                        : row.kind === "none"
-                            ? "ready"
-                            : (compute?.body?.state ?? "ready"),
-                    ...(isPod
-                        ? {
-                            pod: {
-                                desired: row.desired,
-                                observed: row.observed,
-                                volumeGeneration: row.volumeGen,
-                                hostEpoch: row.hostEpoch,
-                                ...(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,
-                });
-            }
-            const last = items.at(-1);
-            return {
-                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, EnvironmentRecordWriter } from "../../record/index.js";
+import type { RecordWriter, AgentRecordWriter } from "../../record/index.js";
 import type { Transaction } from "./db.js";
 /**
- * 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.
+ * The Agent stream writer of transaction `db` (`record/agent.ts`): the only inserts into
+ * `agent_events`. The caller holds the Agent row's lock, which orders its events.
  */
-export declare function postgresEnvironmentRecordWriter(db: Transaction): EnvironmentRecordWriter;
+export declare function postgresAgentRecordWriter(db: Transaction): AgentRecordWriter;
 /** 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 { environmentEvents, sessionEvents, sessionLogHeads, tenant } from "./schema.js";
+import { agentEvents, sessionEvents, sessionLogHeads, tenant } from "./schema.js";
 /**
- * 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.
+ * The Agent stream writer of transaction `db` (`record/agent.ts`): the only inserts into
+ * `agent_events`. The caller holds the Agent row's lock, which orders its events.
  */
-export function postgresEnvironmentRecordWriter(db) {
+export function postgresAgentRecordWriter(db) {
     return {
-        async nextSeq(environmentId) {
+        async nextSeq(agentId) {
             const [row] = await db
-                .select({ next: sql `coalesce(max(${environmentEvents.seq}) + 1, 0)`.mapWith(Number) })
-                .from(environmentEvents)
-                .where(eq(environmentEvents.environmentId, environmentId));
+                .select({ next: sql `coalesce(max(${agentEvents.seq}) + 1, 0)`.mapWith(Number) })
+                .from(agentEvents)
+                .where(eq(agentEvents.agentId, agentId));
             return row?.next ?? 0;
         },
         async insert(row) {
-            await db.insert(environmentEvents).values(row);
+            await db.insert(agentEvents).values(row);
         },
     };
 }