@nylorun/runtime 0.16.0-beta → 0.19.0-beta

package/dist/store/postgres/schema.js

@@ -1,40 +1,3 @@
-/**
- * The tables of a Tenant database (session-store.md §2–§3): the source drizzle-kit generates
- * the migrations from (`drizzle/`, `CONTRIBUTING.md` "Adding a migration") and the query
- * builder's view of them. Column names are the camelCase keys in snake_case (`casing:
- * "snake_case"`, here, in `db.ts` and in `drizzle.config.ts`).
- *
- * - `nylorun` holds the Tenant's state: the one `tenant` row, the document tables, Action
- *   endpoints, principals, vaults and credentials, signing keys, publishable keys, subject
- *   epochs and usage, settings, the model usage ledger, the model budgets, the Tool Gate's
- *   crossings and file artifacts with their versions.
- * - `nylorun_streams` holds the record (Durable Streams §6): `session_events`,
- *   `session_log_heads` and the relay's `relay_slots`. The relay's publication is custom SQL
- *   (`drizzle/0002_stream_relay.sql`).
- *
- * What the columns keep:
- *
- * - **Bodies are `json`, not `jsonb`** (`jsonText`), written as the text `JSON.stringify`
- *   wrote, so every string round-trips exactly, key order included. `jsonb` rejects the
- *   escapes `\u0000` (`22P05`) and unpaired surrogates (`\ud800`), which tool output can
- *   contain; `json` stores the text verbatim and checks only its syntax.
- * - **Indexed fields of a body are stored generated columns** read through
- *   `nylorun.doc(body)` (custom SQL, `drizzle/0000_foundation.sql`), which casts to `jsonb`
- *   after replacing those two escapes with `\ufffd`: the body is untouched, and only an indexed
- *   field that itself contained one (never an id, status or timestamp) would see U+FFFD.
- *   Queries never apply `->`/`->>` to a `json` body (Postgres de-escapes the whole text and
- *   fails on the same escapes); they read the generated columns.
- * - **Ids and timestamps compared as text are `COLLATE "C"`** (`textC`), so they order by code
- *   point whatever the database's collation.
- * - **Timestamps are ISO text**, except the session lease `owner_expires_at` and the record's
- *   `committed_at` (`timestamptz`).
- * - **Sealed secrets are `bytea` columns** (`bytes`), never inside a JSON body.
- * - Sessions carry the store-managed ownership columns (`owner`, `epoch`,
- *   `owner_expires_at`), which are never in `body`.
- *
- * Columns are listed in the order the tables have them, so a database created by these
- * migrations and one created by the hand-written migrations they replaced dump the same.
- */
 import { sql } from "drizzle-orm";
 import { bigint, boolean, check, customType, doublePrecision, foreignKey, index, integer, pgSchema, primaryKey, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
 export const TENANT_SCHEMA = "nylorun";
@@ -92,11 +55,14 @@ export const tenant = nylorun.table("tenant", {
     retiredGenerations: integer().array().notNull().default(sql `'{}'`),
 }, () => [check("tenant_singleton_check", sql `singleton`)]);
 export const definitions = documents("definitions");
+const xid8 = customType({ dataType: () => "xid8" });
 export const sessions = nylorun.table("sessions", {
     id: textC().primaryKey(),
     body: jsonText().notNull(),
     status: field("->>'status'"),
     agentId: field("->>'agentId'"),
+    /** Unknown for legacy sessions; assigned only on insert. */
+    createdAt: timestamp({ withTimezone: true, mode: "string" }).defaultNow(),
     /** The lease holder; store-managed, never in `body`. */
     owner: text(),
     epoch: bigint({ mode: "number" }).notNull().default(0),
@@ -106,6 +72,7 @@ export const sessions = nylorun.table("sessions", {
     /** The sandbox resource the session is attached to (`sandbox: { id }`). */
     sandboxId: field("->>'sandboxId'"),
 }, (t) => [
+    index("sessions_created").on(t.createdAt.desc().nullsLast(), t.id.desc().nullsFirst()),
     index("sessions_status").on(t.status, t.ownerExpiresAt),
     index("sessions_agent").on(t.agentId),
     index("sessions_owner_user").on(t.ownerUserId),
@@ -123,29 +90,16 @@ export const effects = nylorun.table("effects", {
     index("effects_session").on(t.sessionId, t.turnId, t.status),
     index("effects_status").on(t.status, t.kind),
 ]);
-export const actions = nylorun.table("actions", {
-    id: textC().primaryKey(),
-    body: jsonText().notNull(),
-    sessionId: field("->>'sessionId'"),
-    turnId: field("->>'turnId'"),
-    agentId: field("->>'agentId'"),
-    status: field("->>'status'"),
-    kind: field("->>'kind'"),
-    /** When the Action being delivered is lost (ISO text). */
-    deadlineAt: field("->>'deadlineAt'"),
-}, (t) => [
-    index("actions_session").on(t.sessionId, t.turnId, t.status),
-    index("actions_agent").on(t.agentId, t.status),
-    index("actions_status").on(t.status, t.kind),
-    index("actions_deadline").on(t.status, t.deadlineAt),
-]);
 export const sandboxes = documents("sandboxes");
 export const links = nylorun.table("links", {
     id: textC().primaryKey(),
     body: jsonText().notNull(),
     workflowSessionId: field("->>'workflowSessionId'"),
 }, (t) => [index("links_workflow").on(t.workflowSessionId)]);
-/** An application principal: who holds a key, by its SHA-256. */
+/**
+ * A principal: who holds a key, by its SHA-256, and what the key reaches (`role`, protocol 8):
+ * `application` the Runtime API, `management` the Management API, `studio` both.
+ */
 export const principals = nylorun.table("principals", {
     id: textC().primaryKey(),
     role: text().$type().notNull(),
@@ -160,11 +114,15 @@ export const vaults = nylorun.table("vaults", {
     /** JSON text, or null. */
     metadataJson: text(),
     createdAt: textC().notNull(),
-    scope: text({ enum: ["user", "host"] }).notNull().default("user"),
+    /**
+     * `user`: one person's (owner `ownerUserId`); `installation`: the installation's own,
+     * attachable to any session (owner `installation`); `host`: the model vault, never attached.
+     */
+    scope: text({ enum: ["user", "installation", "host"] }).notNull().default("user"),
 }, (t) => [
     index("vaults_owner").on(t.ownerUserId, t.createdAt, t.id),
     uniqueIndex("vaults_one_host").on(t.scope).where(sql `scope = 'host'`),
-    check("vaults_scope_check", sql `scope IN ('user', 'host')`),
+    check("vaults_scope_check", sql `scope IN ('user', 'installation', 'host')`),
 ]);
 /** A credential of a vault: its binding in the clear, its secret sealed. */
 export const vaultCredentials = nylorun.table("vault_credentials", {
@@ -207,11 +165,48 @@ export const vaultIdempotency = nylorun.table("vault_idempotency", {
     /** JSON text of the original response. */
     response: text().notNull(),
 });
+/**
+ * An MCP OAuth connect between its start and its callback (F9 C2): found by the SHA-256 of its
+ * `state`, used once, for ten minutes. The PKCE verifier and any client secret are sealed under
+ * the vault key (`sealBytes`), which only the keys module holds.
+ */
+export const oauthPending = nylorun.table("oauth_pending", {
+    stateHash: text().primaryKey(),
+    vaultId: text().notNull(),
+    /** The MCP server's name in the agent, the credential's name. */
+    server: text().notNull(),
+    /** The MCP server's URL (normalized): the credential's binding. */
+    url: text().notNull(),
+    tokenEndpoint: text().notNull(),
+    clientId: text().notNull(),
+    /** How the client authenticates at the token endpoint: `none`, `client_secret_basic` or `client_secret_post`. */
+    tokenEndpointAuth: text({ enum: ["none", "client_secret_basic", "client_secret_post"] }).notNull(),
+    /** The RFC 8707 resource indicator sent with the authorization request, if any. */
+    resource: text(),
+    kekId: text().notNull(),
+    /** Sealed; null for a public client. */
+    clientSecret: bytes(),
+    /** Sealed. */
+    codeVerifier: bytes().notNull(),
+    redirectUri: text().notNull(),
+    expiresAt: textC().notNull(),
+    createdAt: textC().notNull(),
+}, (t) => [
+    foreignKey({
+        name: "oauth_pending_vault_id_fkey",
+        columns: [t.vaultId],
+        foreignColumns: [vaults.id],
+    }).onDelete("cascade"),
+    index("oauth_pending_expires").on(t.expiresAt),
+]);
 export const tenantSettings = nylorun.table("tenant_settings", {
     key: text().primaryKey(),
     value: text().notNull(),
 });
-/** The Tenant's signing keys (subject tokens): the private half sealed, the public JWK not. */
+/**
+ * The Tenant's signing keys (capability links, run and host tokens): the
+ * private half sealed, the public JWK not.
+ */
 export const signingKeys = nylorun.table("signing_keys", {
     id: textC().primaryKey(),
     state: text({ enum: ["standby", "current", "previous", "revoked"] }).notNull(),
@@ -233,50 +228,6 @@ export const signingKeys = nylorun.table("signing_keys", {
     uniqueIndex("signing_keys_one_current").on(t.state).where(sql `state = 'current'`),
     uniqueIndex("signing_keys_one_previous").on(t.state).where(sql `state = 'previous'`),
 ]);
-/** Each subject's revocation epoch. */
-export const subjectEpochs = nylorun.table("subject_epochs", {
-    subject: textC().primaryKey(),
-    epoch: bigint({ mode: "number" }).notNull(),
-    revokedAt: text().notNull(),
-});
-/** Each subject's turn bucket: tokens left and when they were last refilled. */
-export const subjectUsage = nylorun.table("subject_usage", {
-    subject: textC().primaryKey(),
-    turnTokens: doublePrecision().notNull(),
-    refilledAt: text().notNull(),
-});
-/** Publishable keys (Host feature `browser-access`): public by design. */
-export const publishableKeys = nylorun.table("publishable_keys", {
-    id: textC().primaryKey(),
-    key: textC().notNull().unique("publishable_keys_key_key"),
-    name: text().notNull().unique("publishable_keys_name_key"),
-    /** JSON array of allowed origins. */
-    originsJson: text().notNull(),
-    createdAt: text().notNull(),
-    revokedAt: text(),
-});
-/**
- * Action endpoints: where the Runtime delivers each agent's Actions over HTTP, and the health
- * recent deliveries and the last ping report.
- */
-export const endpoints = nylorun.table("endpoints", {
-    agentId: textC().primaryKey(),
-    url: text().notNull(),
-    implementationVersion: text().notNull(),
-    manifestHash: text(),
-    timeoutMs: integer().notNull(),
-    maxConcurrent: integer().notNull(),
-    principalId: text(),
-    lastDeliveryAt: text(),
-    lastSuccessAt: text(),
-    lastErrorCode: text(),
-    lastErrorMessage: text(),
-    consecutiveFailures: integer().notNull().default(0),
-    servedImplementationVersion: text(),
-    servedManifestHash: text(),
-    createdAt: text().notNull(),
-    updatedAt: text().notNull(),
-});
 /**
  * The model usage ledger (P1.3): one row per model call a gate served, written after the call.
  * A second row for the same effect (a call the gate ran again after a gateway restart) is
@@ -287,6 +238,9 @@ export const modelUsage = nylorun.table("model_usage", {
     id: textC().primaryKey(),
     /** The model effect's id; unique per Tenant, since it carries the turn id. */
     effectKey: textC().notNull(),
+    tokensReported: boolean(),
+    costKnown: boolean(),
+    txid: xid8().notNull().default(sql `pg_current_xact_id()`),
     sessionId: textC().notNull(),
     turnId: textC().notNull(),
     agentId: textC().notNull(),
@@ -303,6 +257,8 @@ export const modelUsage = nylorun.table("model_usage", {
     duplicate: boolean().notNull(),
     createdAt: text().notNull(),
 }, (t) => [
+    index("model_usage_session").on(t.sessionId, t.createdAt, t.id),
+    index("model_usage_export").on(t.txid, t.id),
     index("model_usage_effect").on(t.effectKey),
     index("model_usage_agent").on(t.agentId, t.createdAt),
     index("model_usage_turn").on(t.turnId),
@@ -452,6 +408,33 @@ export const artifactContent = nylorun.table("artifact_content", {
     }).onDelete("cascade"),
     index("artifact_content_sha256").on(t.sha256),
 ]);
+/**
+ * The definition files the Tenant holds (track R2 M4): files a definition names by the SHA-256
+ * of their bytes (a skill's folder), uploaded with `PUT /v1/files/sha256:<hex>`. The bytes are
+ * in the Object store at `definitions/sha256/<hex>`; a row counts them only once they are
+ * stored. `sha256` is `sha256:<hex>`.
+ */
+export const definitionFiles = nylorun.table("definition_files", {
+    sha256: textC().primaryKey(),
+    /** What the file is part of: `skill` for now. */
+    kind: text().notNull(),
+    size: bigint({ mode: "number" }).notNull(),
+    contentType: text(),
+    createdAt: textC().notNull(),
+});
+/**
+ * Which definition version names which definition file: one row per agent id, manifest hash
+ * and file, written when the definition is stored. A later sweep deletes the files no
+ * definition uses.
+ */
+export const definitionFileUses = nylorun.table("definition_file_uses", {
+    agentId: textC().notNull(),
+    manifestHash: textC().notNull(),
+    sha256: textC().notNull(),
+}, (t) => [
+    primaryKey({ name: "definition_file_uses_pkey", columns: [t.agentId, t.manifestHash, t.sha256] }),
+    index("definition_file_uses_sha256").on(t.sha256),
+]);
 // ---------------------------------------------------------------------------
 // nylorun_streams: the record
 /**