@nylorun/runtime 0.14.0-beta → 0.15.0-beta

package/dist/vault/host-model.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The Tenant's host model credential in plaintext: reading it to call the provider, and
+ * writing back a credential the provider adapter refreshed (OAuth). Only the Model Gate holds
+ * one (`gates/`; `scripts/check-boundaries.mjs` enforces it), so the loop process never reads a
+ * model credential. `VaultService` seals the credential but never reads it back.
+ *
+ * Decryption runs after the read commits; the key is resolved before the write's transaction.
+ */
+import type { SessionStore } from "../store/types.js";
+import { type HostModelSecret } from "./service.js";
+export interface HostModelVaultOptions {
+    readonly store: SessionStore;
+    /** The Tenant's key-encryption key; may throw when it is missing. */
+    readonly kek: () => Buffer;
+}
+export declare class HostModelVault {
+    private readonly store;
+    private readonly kek;
+    constructor(options: HostModelVaultOptions);
+    /** Reads the active host model secret. Decrypts after the read commits. */
+    readHostModel(): Promise<HostModelSecret | undefined>;
+    /** Replaces the active host model's secret, keeping its binding. */
+    updateHostCredential(credential: {
+        type: "api_key" | "oauth";
+        key?: string;
+        env?: Record<string, string>;
+        refresh?: string;
+        access?: string;
+        expires?: number;
+    }): Promise<void>;
+}

package/dist/vault/host-model.js

@@ -0,0 +1,57 @@
+import { encryptSecret } from "./crypto.js";
+import { VaultError } from "./error.js";
+import { activeHostCredentialRow, HOST_VAULT_ID, hostModelAad, modelBinding, readHostPayload, } from "./service.js";
+export class HostModelVault {
+    store;
+    kek;
+    constructor(options) {
+        this.store = options.store;
+        this.kek = options.kek;
+    }
+    /** Reads the active host model secret. Decrypts after the read commits. */
+    async readHostModel() {
+        const row = await this.store.tx((t) => activeHostCredentialRow(t));
+        if (!row)
+            return undefined;
+        const binding = modelBinding(row);
+        const payload = readHostPayload(this.kek(), row, binding);
+        const credential = binding.authType === "oauth"
+            ? { type: "oauth", ...payload.oauth }
+            : {
+                type: "api_key",
+                key: payload.apiKey,
+                ...(payload.env ? { env: payload.env } : {}),
+            };
+        return {
+            provider: binding.provider,
+            model: binding.model,
+            ...(binding.baseUrl ? { baseUrl: binding.baseUrl } : {}),
+            ...(binding.settings ? { settings: binding.settings } : {}),
+            authType: binding.authType,
+            credential,
+        };
+    }
+    /** Replaces the active host model's secret, keeping its binding. */
+    async updateHostCredential(credential) {
+        const kek = this.kek();
+        await this.store.tx(async (t) => {
+            const row = await activeHostCredentialRow(t);
+            if (!row)
+                throw new VaultError(404, "Model provider is not configured");
+            const binding = modelBinding(row);
+            const payload = credential.type === "oauth"
+                ? { oauth: credential }
+                : {
+                    apiKey: credential.key,
+                    ...(credential.env ? { env: credential.env } : {}),
+                };
+            const sealed = encryptSecret(kek, hostModelAad(binding.provider, binding.model), Buffer.from(JSON.stringify(payload), "utf8"));
+            await t.updateCredential(HOST_VAULT_ID, row.id, {
+                type: "model",
+                bindingJson: JSON.stringify({ ...binding, authType: credential.type }),
+                ...sealed,
+                rotatedAt: new Date().toISOString(),
+            });
+        });
+    }
+}

package/dist/vault/service.d.ts

@@ -1,5 +1,6 @@
 import type { CreateCredentialRequest, CreateVaultRequest, CredentialInfo, CredentialSelection, HostModelProviderInfo, HostModelView, PutHostModelRequest, CustomModelSettings, RotateCredentialRequest, SelectHostModelRequest, VaultInfo } from "@nylorun/core/contracts";
-import type { SessionStore, Tx } from "../store/types.js";
+import type { SessionStore, Tx, VaultCredentialRow } from "../store/types.js";
+export declare const HOST_VAULT_ID = "host";
 export type HostModelSecret = {
     provider: string;
     model: string;
@@ -87,16 +88,6 @@ export declare class VaultService {
     }>;
     putHostModel(body: PutHostModelRequest): Promise<HostModelView>;
     selectHostModel(body: SelectHostModelRequest): Promise<HostModelView>;
-    /** Reads the active host model secret. Decrypts after the read commits. */
-    readHostModel(): Promise<HostModelSecret | undefined>;
-    updateHostCredential(credential: {
-        type: "api_key" | "oauth";
-        key?: string;
-        env?: Record<string, string>;
-        refresh?: string;
-        access?: string;
-        expires?: number;
-    }): Promise<void>;
     /** Calls the token endpoint outside any transaction, then stores the result. */
     /**
      * Refreshes an OAuth grant once for every concurrent use in this process. A rotating refresh
@@ -117,12 +108,32 @@ export declare class VaultService {
     private validateHostModel;
     private insertHostCredential;
     private hostModelView;
-    private hostModelRows;
-    private hostCredentialRowFor;
-    private activeHostCredentialRow;
-    private activeProviderId;
     private setActiveProvider;
     private deleteHostProviderRows;
     private credentialRow;
     private audit;
 }
+/** The host vault's model credential rows that parse. */
+export declare function hostModelRows(t: Tx): Promise<VaultCredentialRow[]>;
+/** The host model credential of `provider`. */
+export declare function hostCredentialRowFor(t: Tx, provider: string): Promise<VaultCredentialRow | undefined>;
+/** The provider the host model selection names, or the only (or legacy) one configured. */
+export declare function activeProviderId(t: Tx): Promise<string | undefined>;
+/** The active host model credential row (ciphertext), in `t`. */
+export declare function activeHostCredentialRow(t: Tx): Promise<VaultCredentialRow | undefined>;
+export declare function readHostPayload(kek: Buffer, row: VaultCredentialRow, binding: ModelBinding): HostSecretPayload;
+type ModelBinding = {
+    provider: string;
+    model: string;
+    baseUrl?: string;
+    settings?: CustomModelSettings;
+    authType: "api_key" | "oauth";
+};
+type HostSecretPayload = {
+    apiKey?: string;
+    env?: Record<string, string>;
+    oauth?: HostModelSecret["credential"];
+};
+export declare function modelBinding(row: VaultCredentialRow): ModelBinding;
+export declare function hostModelAad(provider: string, model: string): Buffer;
+export {};

package/dist/vault/service.js

@@ -34,10 +34,12 @@
  * listHostProviders(): Promise<{ providers: HostModelProviderInfo[] }>
  * putHostModel(body: PutHostModelRequest): Promise<HostModelView>
  * selectHostModel(body: SelectHostModelRequest): Promise<HostModelView>
- * readHostModel(): Promise<HostModelSecret | undefined>
- * updateHostCredential(credential): Promise<void>
  * ```
  *
+ * Reading the host model's secret and writing back a refreshed one are `HostModelVault`'s
+ * (`vault/host-model.ts`), which only the Model Gate uses: this service seals the host model's
+ * credential but never reads it back.
+ *
  * ## Transactions and I/O
  *
  * - No network I/O runs inside a transaction. The KEK getter may touch the
@@ -65,7 +67,7 @@ import { hostModelCatalog } from "../model/catalog.js";
 import { normalizeVaultUrl } from "./url.js";
 const REFRESH_SKEW_MS = 60_000;
 const REFRESH_TIMEOUT_MS = 30_000;
-const HOST_VAULT_ID = "host";
+export const HOST_VAULT_ID = "host";
 const HOST_MODEL_ID = "host-model";
 export class VaultService {
     store;
@@ -375,9 +377,9 @@ export class VaultService {
     }
     async listHostProviders() {
         return this.store.tx(async (t) => {
-            const active = await this.activeProviderId(t);
+            const active = await activeProviderId(t);
             const catalog = new Map(hostModelCatalog().providers.map((provider) => [provider.id, provider.name]));
-            const providers = (await this.hostModelRows(t)).map((row) => {
+            const providers = (await hostModelRows(t)).map((row) => {
                 const binding = modelBinding(row);
                 return {
                     id: binding.provider,
@@ -434,7 +436,7 @@ export class VaultService {
         const kek = this.kek();
         return this.store.tx((t) => this.replay(t, `host-model-select:${body.idempotencyKey}`, body, async () => {
             this.validateHostModel(body);
-            const row = await this.hostCredentialRowFor(t, body.provider);
+            const row = await hostCredentialRowFor(t, body.provider);
             if (!row)
                 throw new VaultError(404, "Model provider is not configured");
             const binding = modelBinding(row);
@@ -462,51 +464,6 @@ export class VaultService {
             return this.hostModelView(t);
         }));
     }
-    /** Reads the active host model secret. Decrypts after the read commits. */
-    async readHostModel() {
-        const row = await this.store.tx((t) => this.activeHostCredentialRow(t));
-        if (!row)
-            return undefined;
-        const binding = modelBinding(row);
-        const payload = readHostPayload(this.kek(), row, binding);
-        const credential = binding.authType === "oauth"
-            ? { type: "oauth", ...payload.oauth }
-            : {
-                type: "api_key",
-                key: payload.apiKey,
-                ...(payload.env ? { env: payload.env } : {}),
-            };
-        return {
-            provider: binding.provider,
-            model: binding.model,
-            ...(binding.baseUrl ? { baseUrl: binding.baseUrl } : {}),
-            ...(binding.settings ? { settings: binding.settings } : {}),
-            authType: binding.authType,
-            credential,
-        };
-    }
-    async updateHostCredential(credential) {
-        const kek = this.kek();
-        await this.store.tx(async (t) => {
-            const row = await this.activeHostCredentialRow(t);
-            if (!row)
-                throw new VaultError(404, "Model provider is not configured");
-            const binding = modelBinding(row);
-            const payload = credential.type === "oauth"
-                ? { oauth: credential }
-                : {
-                    apiKey: credential.key,
-                    ...(credential.env ? { env: credential.env } : {}),
-                };
-            const sealed = encryptSecret(kek, hostModelAad(binding.provider, binding.model), Buffer.from(JSON.stringify(payload), "utf8"));
-            await t.updateCredential(HOST_VAULT_ID, row.id, {
-                type: "model",
-                bindingJson: JSON.stringify({ ...binding, authType: credential.type }),
-                ...sealed,
-                rotatedAt: new Date().toISOString(),
-            });
-        });
-    }
     // --- internals -----------------------------------------------------------------
     /** Calls the token endpoint outside any transaction, then stores the result. */
     /**
@@ -725,7 +682,7 @@ export class VaultService {
         });
     }
     async hostModelView(t) {
-        const row = await this.activeHostCredentialRow(t);
+        const row = await activeHostCredentialRow(t);
         if (!row)
             return { configured: false };
         const binding = modelBinding(row);
@@ -738,65 +695,12 @@ export class VaultService {
             ...(binding.settings ? { settings: binding.settings } : {}),
         };
     }
-    async hostModelRows(t) {
-        return (await t.credentialsForVault(HOST_VAULT_ID, { type: "model" })).filter((row) => {
-            try {
-                modelBinding(row);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        });
-    }
-    async hostCredentialRowFor(t, provider) {
-        const preferred = hostModelCredentialId(provider);
-        const rows = await this.hostModelRows(t);
-        return (rows.find((row) => row.id === preferred) ??
-            rows.find((row) => modelBinding(row).provider === provider));
-    }
-    async activeHostCredentialRow(t) {
-        const active = await this.activeProviderId(t);
-        if (!active)
-            return undefined;
-        return this.hostCredentialRowFor(t, active);
-    }
-    async activeProviderId(t) {
-        const vault = await t.getVault(HOST_VAULT_ID);
-        if (vault?.metadataJson) {
-            let activeProvider;
-            try {
-                activeProvider = JSON.parse(vault.metadataJson).activeProvider;
-            }
-            catch {
-                /* Fall through to the only configured provider. */
-            }
-            if (typeof activeProvider === "string" && activeProvider) {
-                try {
-                    if (await this.hostCredentialRowFor(t, activeProvider))
-                        return activeProvider;
-                }
-                catch {
-                    /* An invalid provider id falls through, as before. */
-                }
-            }
-        }
-        const rows = await this.hostModelRows(t);
-        if (rows.length === 0)
-            return undefined;
-        if (rows.length === 1)
-            return modelBinding(rows[0]).provider;
-        const legacy = rows.find((row) => row.id === HOST_MODEL_ID);
-        if (legacy)
-            return modelBinding(legacy).provider;
-        return modelBinding(rows[0]).provider;
-    }
     async setActiveProvider(t, provider) {
         await this.ensureHostVault(t);
         await t.updateVaultMetadata(HOST_VAULT_ID, JSON.stringify({ activeProvider: provider }));
     }
     async deleteHostProviderRows(t, provider) {
-        const ids = (await this.hostModelRows(t))
+        const ids = (await hostModelRows(t))
             .filter((row) => modelBinding(row).provider === provider)
             .map((row) => row.id);
         ids.push(hostModelCredentialId(provider));
@@ -862,7 +766,64 @@ function readPayload(kek, row) {
         plaintext.fill(0);
     }
 }
-function readHostPayload(kek, row, binding) {
+/** The host vault's model credential rows that parse. */
+export async function hostModelRows(t) {
+    return (await t.credentialsForVault(HOST_VAULT_ID, { type: "model" })).filter((row) => {
+        try {
+            modelBinding(row);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** The host model credential of `provider`. */
+export async function hostCredentialRowFor(t, provider) {
+    const preferred = hostModelCredentialId(provider);
+    const rows = await hostModelRows(t);
+    return (rows.find((row) => row.id === preferred) ??
+        rows.find((row) => modelBinding(row).provider === provider));
+}
+/** The provider the host model selection names, or the only (or legacy) one configured. */
+export async function activeProviderId(t) {
+    const vault = await t.getVault(HOST_VAULT_ID);
+    if (vault?.metadataJson) {
+        let activeProvider;
+        try {
+            activeProvider = JSON.parse(vault.metadataJson).activeProvider;
+        }
+        catch {
+            /* Fall through to the only configured provider. */
+        }
+        if (typeof activeProvider === "string" && activeProvider) {
+            try {
+                if (await hostCredentialRowFor(t, activeProvider))
+                    return activeProvider;
+            }
+            catch {
+                /* An invalid provider id falls through, as before. */
+            }
+        }
+    }
+    const rows = await hostModelRows(t);
+    if (rows.length === 0)
+        return undefined;
+    if (rows.length === 1)
+        return modelBinding(rows[0]).provider;
+    const legacy = rows.find((row) => row.id === HOST_MODEL_ID);
+    if (legacy)
+        return modelBinding(legacy).provider;
+    return modelBinding(rows[0]).provider;
+}
+/** The active host model credential row (ciphertext), in `t`. */
+export async function activeHostCredentialRow(t) {
+    const active = await activeProviderId(t);
+    if (!active)
+        return undefined;
+    return hostCredentialRowFor(t, active);
+}
+export function readHostPayload(kek, row, binding) {
     const plaintext = decryptSecret(kek, hostModelAad(binding.provider, binding.model), Buffer.from(row.nonce), Buffer.from(row.ciphertext), Buffer.from(row.wrappedDek), row.kekId);
     try {
         return JSON.parse(plaintext.toString("utf8"));
@@ -933,7 +894,7 @@ function requireTimestamp(value) {
         throw new VaultError(400, "Credential expiry is invalid");
     return new Date(Date.parse(value)).toISOString();
 }
-function modelBinding(row) {
+export function modelBinding(row) {
     const binding = JSON.parse(row.bindingJson);
     if (!binding.provider || !binding.model || !binding.authType)
         throw new VaultError(500, "Host model credential is unreadable");
@@ -944,7 +905,7 @@ function hostModelCredentialId(provider) {
         throw new VaultError(400, "Invalid provider id");
     return `${HOST_MODEL_ID}:${provider}`;
 }
-function hostModelAad(provider, model) {
+export function hostModelAad(provider, model) {
     return Buffer.from(canonical({
         scope: "host",
         vaultId: HOST_VAULT_ID,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.14.0-beta";
+export declare const RUNTIME_VERSION = "0.15.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.14.0-beta";
+export const RUNTIME_VERSION = "0.15.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.14.0-beta",
+  "version": "0.15.0-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -45,7 +45,7 @@
     "provenance": true
   },
   "scripts": {
-    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json && node scripts/build-openapi.mjs",
+    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json && node scripts/copy-migrations.mjs && node scripts/build-openapi.mjs",
     "check": "npm run build && npm test && node scripts/check-package.mjs",
     "typecheck": "node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
@@ -54,7 +54,9 @@
     "test:stack:down": "node test/stack/up.mjs down",
     "prepack": "npm run build",
     "clean": "node -e \"import('node:fs').then(({rmSync})=>rmSync('dist',{recursive:true,force:true}))\"",
-    "start": "node dist/host/main.js"
+    "start": "node dist/host/main.js",
+    "db:generate": "drizzle-kit generate",
+    "db:studio": "drizzle-kit studio"
   },
   "dependencies": {
     "@ag-ui/core": "~1.0.0",
@@ -63,10 +65,11 @@
     "@hono/node-server": "^2.1.1",
     "@hono/zod-openapi": "^1.6.3",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@nylorun/core": "0.9.0-beta",
-    "@nylorun/harness": "0.21.0-beta",
+    "@nylorun/core": "0.10.0-beta",
+    "@nylorun/harness": "0.21.1-beta",
     "@restatedev/restate-sdk": "1.16.9",
     "@s2-dev/streamstore": "0.27.0",
+    "drizzle-orm": "^0.45.3",
     "hono": "^4.13.12",
     "jose": "^6.2.12",
     "just-bash": "3.4.2",
@@ -82,6 +85,7 @@
     "@types/node": "^26.5.0",
     "@types/pg": "^8.23.1",
     "@typescript/native": "npm:typescript@^7.0.2",
+    "drizzle-kit": "^0.31.11",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "vitest": "^5.0.1"
   }

package/dist/store/memory.d.ts

@@ -1,69 +0,0 @@
-import { MemoryRecord } from "../streams/relay/memory.js";
-import { type CommitListener, type DocTable, type EndpointRow, type BasinGenerations, type PrincipalRow, type PublishableKeyRow, type SessionOwnership, type SessionStore, type SessionStoreOptions, type SigningKeyRow, type StoreHealth, type SubjectUsageRow, type Tx, type VaultAuditRow, type VaultCredentialRow, type VaultIdempotencyRow, type VaultRow } from "./types.js";
-/** Schema version the fake reports; it has no migrations. */
-export declare const MEMORY_SCHEMA_VERSION = 1;
-type SessionMeta = SessionOwnership;
-interface State {
-    /** JSON text per id, like a `body` column. */
-    docs: Record<DocTable, Map<string, string>>;
-    sessionMeta: Map<string, SessionMeta>;
-    /** sessionId → its log head: the next seq and the basin generation it was started in. */
-    heads: Map<string, {
-        head: number;
-        generation: number;
-    }>;
-    basin: BasinGenerations;
-    endpoints: Map<string, EndpointRow>;
-    principals: Map<string, PrincipalRow>;
-    vaults: Map<string, VaultRow>;
-    credentials: Map<string, VaultCredentialRow>;
-    audit: VaultAuditRow[];
-    idempotency: Map<string, VaultIdempotencyRow>;
-    settings: Map<string, string>;
-    signingKeys: Map<string, SigningKeyRow>;
-    subjectEpochs: Map<string, number>;
-    subjectUsage: Map<string, SubjectUsageRow>;
-    publishableKeys: Map<string, PublishableKeyRow>;
-}
-/**
- * The data behind in-memory Session Stores: what a database is to its connections. Several
- * `MemorySessionStore`s on one `MemoryStoreData` see each other's commits and serialize their
- * transactions together, as several processes on one Tenant schema would; it outlives them,
- * so a test can close a Tenant and open it again.
- */
-export declare class MemoryStoreData {
-    /** @internal */ state: State;
-    /** @internal */ queue: Promise<void>;
-    /** The record of committed events, read back by the stream relay. */
-    readonly record: MemoryRecord;
-}
-/**
- * In-memory `SessionStore` for unit tests. Not a supported profile.
- *
- * Transactions are serialized (one at a time), each works on a copy of the
- * state and replaces it on commit, so a throw rolls back everything: documents,
- * sequences, record rows and `afterCommit` callbacks. Commit listeners see
- * only this store's commits, as with a Postgres connection.
- */
-export declare class MemorySessionStore implements SessionStore {
-    /** Shared with other stores on the same data; a fresh, private one by default. */
-    private readonly data;
-    readonly tenantId: string;
-    private readonly active;
-    private readonly listeners;
-    private readonly now;
-    private readonly onError;
-    private closed;
-    constructor(options: SessionStoreOptions, 
-    /** Shared with other stores on the same data; a fresh, private one by default. */
-    data?: MemoryStoreData);
-    tx<T>(fn: (t: Tx) => Promise<T>): Promise<T>;
-    onCommit(listener: CommitListener): () => void;
-    record(): MemoryRecord;
-    health(): Promise<StoreHealth>;
-    close(): Promise<void>;
-    private acquire;
-}
-/** The time column a signing key's new state stamps. */
-export declare function signingKeyStamp(state: SigningKeyRow["state"], at: string): Partial<SigningKeyRow>;
-export {};