@nylorun/runtime 0.7.0-beta → 0.8.0-beta

package/dist/vault/service.js

@@ -2,8 +2,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { canonical } from "../core/store.js";
 import { decryptSecret, encryptSecret, VaultCryptoError, } from "./crypto.js";
 import { VaultError } from "./error.js";
+import { hostModelCatalog } from "../model/catalog.js";
 import { normalizeVaultUrl } from "./url.js";
 const REFRESH_SKEW_MS = 60_000;
+const HOST_VAULT_ID = "host";
+const HOST_MODEL_ID = "host-model";
 export class VaultService {
     db;
     tx;
@@ -34,7 +37,7 @@ export class VaultService {
     }
     listVaults(ownerUserId) {
         const rows = this.db
-            .prepare(`SELECT id FROM vaults WHERE owner_user_id=? ORDER BY created_at, id`)
+            .prepare(`SELECT id FROM vaults WHERE owner_user_id=? AND scope='user' ORDER BY created_at, id`)
             .all(ownerUserId);
         return rows.map((row) => this.vaultInfo(row.id));
     }
@@ -156,6 +159,8 @@ export class VaultService {
             const vault = this.vaultRow(id);
             if (!vault)
                 throw new VaultError(404, "Vault not found");
+            if (vault.scope === "host")
+                throw new VaultError(400, "Host vault cannot be attached to a session");
             if (vault.owner_user_id !== ownerUserId)
                 throw new VaultError(403, "Vault belongs to another user");
         }
@@ -274,6 +279,142 @@ export class VaultService {
             headers: { authorization: `Bearer ${token}` },
         };
     }
+    getHostModel() {
+        const row = this.activeHostCredentialRow();
+        if (!row)
+            return { configured: false };
+        const binding = modelBinding(row);
+        return {
+            configured: true,
+            provider: binding.provider,
+            model: binding.model,
+            authType: binding.authType,
+            ...(binding.baseUrl ? { baseUrl: binding.baseUrl } : {}),
+        };
+    }
+    listHostProviders() {
+        const active = this.activeProviderId();
+        const catalog = new Map(hostModelCatalog().providers.map((provider) => [provider.id, provider.name]));
+        const providers = this.hostModelRows().map((row) => {
+            const binding = modelBinding(row);
+            return {
+                id: binding.provider,
+                name: catalog.get(binding.provider) ??
+                    (binding.provider === "custom"
+                        ? "Custom OpenAI-compatible"
+                        : binding.provider),
+                model: binding.model,
+                authType: binding.authType,
+                ...(binding.baseUrl ? { baseUrl: binding.baseUrl } : {}),
+                lastUpdated: row.rotated_at ?? row.created_at,
+                active: binding.provider === active,
+            };
+        });
+        providers.sort((left, right) => left.name.localeCompare(right.name));
+        return { providers };
+    }
+    putHostModel(body) {
+        return this.tx(() => this.replay(`host-model:${body.idempotencyKey}`, body, () => {
+            this.validateHostModel(body);
+            this.ensureHostVault();
+            const credentialId = hostModelCredentialId(body.provider);
+            this.deleteHostProviderRows(body.provider);
+            const payload = body.auth.type === "api_key"
+                ? {
+                    apiKey: body.auth.key,
+                    ...(body.auth.env ? { env: body.auth.env } : {}),
+                }
+                : { oauth: body.auth };
+            this.insertHostCredential({
+                id: credentialId,
+                provider: body.provider,
+                model: body.model,
+                baseUrl: body.baseUrl,
+                authType: body.auth.type,
+                payload,
+            });
+            this.setActiveProvider(body.provider);
+            this.audit({
+                actor: "application",
+                action: "rotate",
+                vaultId: HOST_VAULT_ID,
+                credentialId,
+                outcome: "rotated",
+            });
+            return this.getHostModel();
+        }));
+    }
+    selectHostModel(body) {
+        return this.tx(() => this.replay(`host-model-select:${body.idempotencyKey}`, body, () => {
+            this.validateHostModel(body);
+            const row = this.hostCredentialRowFor(body.provider);
+            if (!row)
+                throw new VaultError(404, "Model provider is not configured");
+            const binding = modelBinding(row);
+            const payload = this.readHostPayload(row, binding);
+            const credentialId = hostModelCredentialId(body.provider);
+            this.deleteHostProviderRows(body.provider);
+            this.insertHostCredential({
+                id: credentialId,
+                provider: body.provider,
+                model: body.model,
+                baseUrl: body.baseUrl,
+                authType: binding.authType,
+                payload,
+            });
+            this.setActiveProvider(body.provider);
+            this.audit({
+                actor: "application",
+                action: "rotate",
+                vaultId: HOST_VAULT_ID,
+                credentialId,
+                outcome: "rotated",
+            });
+            return this.getHostModel();
+        }));
+    }
+    readHostModel() {
+        const row = this.activeHostCredentialRow();
+        if (!row)
+            return undefined;
+        const binding = modelBinding(row);
+        const payload = this.readHostPayload(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 } : {}),
+            authType: binding.authType,
+            credential,
+        };
+    }
+    updateHostCredential(credential) {
+        this.tx(() => {
+            const row = this.activeHostCredentialRow();
+            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 aad = hostModelAad(binding.provider, binding.model);
+            const sealed = encryptSecret(this.kek(), aad, Buffer.from(JSON.stringify(payload), "utf8"));
+            this.db
+                .prepare(`UPDATE vault_credentials
+           SET type='model', binding_json=?, kek_id=?, nonce=?, ciphertext=?, wrapped_dek=?, rotated_at=?
+           WHERE id=?`)
+                .run(JSON.stringify({ ...binding, authType: credential.type }), sealed.kekId, sealed.nonce, sealed.ciphertext, sealed.wrappedDek, new Date().toISOString(), row.id);
+        });
+    }
     reject(route) {
         this.audit({
             actor: "executor",
@@ -413,7 +554,7 @@ export class VaultService {
     }
     vaultInfo(id) {
         const row = this.vaultRow(id);
-        if (!row)
+        if (!row || row.scope === "host")
             throw new VaultError(404, "Vault not found");
         return {
             id: row.id,
@@ -427,9 +568,134 @@ export class VaultService {
     }
     vaultRow(id) {
         return this.db
-            .prepare(`SELECT id, name, owner_user_id, metadata_json, created_at FROM vaults WHERE id=?`)
+            .prepare(`SELECT id, name, owner_user_id, metadata_json, created_at, scope FROM vaults WHERE id=?`)
             .get(id);
     }
+    ensureHostVault() {
+        const existing = this.vaultRow(HOST_VAULT_ID);
+        if (existing?.scope === "host")
+            return;
+        if (existing)
+            throw new VaultError(409, "Host vault id is already used");
+        this.db
+            .prepare(`INSERT INTO vaults(id,name,owner_user_id,metadata_json,created_at,scope) VALUES(?,?,?,?,?,?)`)
+            .run(HOST_VAULT_ID, "Host", "host", null, new Date().toISOString(), "host");
+    }
+    validateHostModel(body) {
+        if (body.provider === "custom") {
+            if (!body.baseUrl)
+                throw new VaultError(400, "A base URL is required for a custom provider.");
+            let url;
+            try {
+                url = new URL(body.baseUrl);
+            }
+            catch {
+                throw new VaultError(400, "Base URL must be an HTTP(S) URL.");
+            }
+            if (!["http:", "https:"].includes(url.protocol))
+                throw new VaultError(400, "Base URL must be an HTTP(S) URL.");
+            return;
+        }
+        if (body.baseUrl)
+            throw new VaultError(400, "A base URL is only valid for a custom provider.");
+        const provider = hostModelCatalog().providers.find((item) => item.id === body.provider);
+        if (!provider)
+            throw new VaultError(400, "Unknown model provider.");
+        if (!provider.models.some((item) => item.id === body.model))
+            throw new VaultError(400, "Unknown model.");
+    }
+    insertHostCredential(input) {
+        const aad = hostModelAad(input.provider, input.model);
+        const sealed = encryptSecret(this.kek(), aad, Buffer.from(JSON.stringify(input.payload), "utf8"));
+        this.db
+            .prepare(`INSERT INTO vault_credentials(
+          id, vault_id, name, type, binding_json, expires_at, created_at, rotated_at,
+          kek_id, nonce, ciphertext, wrapped_dek
+        ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`)
+            .run(input.id, HOST_VAULT_ID, input.provider, "model", JSON.stringify({
+            provider: input.provider,
+            model: input.model,
+            ...(input.baseUrl ? { baseUrl: input.baseUrl } : {}),
+            authType: input.authType,
+        }), null, new Date().toISOString(), null, sealed.kekId, sealed.nonce, sealed.ciphertext, sealed.wrappedDek);
+    }
+    readHostPayload(row, binding) {
+        const plaintext = decryptSecret(this.kek(), hostModelAad(binding.provider, binding.model), Buffer.from(row.nonce), Buffer.from(row.ciphertext), Buffer.from(row.wrapped_dek), row.kek_id);
+        try {
+            return JSON.parse(plaintext.toString("utf8"));
+        }
+        finally {
+            plaintext.fill(0);
+        }
+    }
+    hostModelRows() {
+        return this.db
+            .prepare(`SELECT id, vault_id, name, type, binding_json, expires_at, created_at, rotated_at,
+                  kek_id, nonce, ciphertext, wrapped_dek
+           FROM vault_credentials WHERE vault_id=? AND type='model'
+           ORDER BY created_at, id`)
+            .all(HOST_VAULT_ID).filter((row) => {
+            try {
+                modelBinding(row);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    hostCredentialRowFor(provider) {
+        const preferred = hostModelCredentialId(provider);
+        const rows = this.hostModelRows();
+        return (rows.find((row) => row.id === preferred) ??
+            rows.find((row) => modelBinding(row).provider === provider));
+    }
+    activeHostCredentialRow() {
+        const active = this.activeProviderId();
+        if (!active)
+            return undefined;
+        return this.hostCredentialRowFor(active);
+    }
+    activeProviderId() {
+        const vault = this.vaultRow(HOST_VAULT_ID);
+        if (vault?.metadata_json) {
+            try {
+                const metadata = JSON.parse(vault.metadata_json);
+                if (typeof metadata.activeProvider === "string" &&
+                    metadata.activeProvider &&
+                    this.hostCredentialRowFor(metadata.activeProvider))
+                    return metadata.activeProvider;
+            }
+            catch {
+                /* Fall through to the only configured provider. */
+            }
+        }
+        const rows = this.hostModelRows();
+        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;
+    }
+    setActiveProvider(provider) {
+        this.ensureHostVault();
+        this.db
+            .prepare(`UPDATE vaults SET metadata_json=? WHERE id=?`)
+            .run(JSON.stringify({ activeProvider: provider }), HOST_VAULT_ID);
+    }
+    deleteHostProviderRows(provider) {
+        const ids = this.hostModelRows()
+            .filter((row) => modelBinding(row).provider === provider)
+            .map((row) => row.id);
+        ids.push(hostModelCredentialId(provider));
+        for (const id of new Set(ids))
+            this.db
+                .prepare(`DELETE FROM vault_credentials WHERE id=? AND vault_id=?`)
+                .run(id, HOST_VAULT_ID);
+    }
     credentialInfo(vaultId, id) {
         const row = this.credentialRow(vaultId, id);
         return {
@@ -449,7 +715,7 @@ export class VaultService {
                 kek_id, nonce, ciphertext, wrapped_dek
          FROM vault_credentials WHERE id=? AND vault_id=?`)
             .get(id, vaultId);
-        if (!row || (row.type !== "bearer" && row.type !== "oauth"))
+        if (!row || row.type === "model")
             throw new VaultError(404, "Credential not found");
         return row;
     }
@@ -529,6 +795,27 @@ function requireTimestamp(value) {
         throw new VaultError(400, "Credential expiry is invalid");
     return new Date(Date.parse(value)).toISOString();
 }
+function modelBinding(row) {
+    const binding = JSON.parse(row.binding_json);
+    if (!binding.provider || !binding.model || !binding.authType)
+        throw new VaultError(500, "Host model credential is unreadable");
+    return binding;
+}
+function hostModelCredentialId(provider) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(provider))
+        throw new VaultError(400, "Invalid provider id");
+    return `${HOST_MODEL_ID}:${provider}`;
+}
+function hostModelAad(provider, model) {
+    return Buffer.from(canonical({
+        scope: "host",
+        vaultId: HOST_VAULT_ID,
+        credentialId: HOST_MODEL_ID,
+        type: "model",
+        provider,
+        model,
+    }), "utf8");
+}
 function credentialAad(vaultId, credentialId, type, url) {
     return Buffer.from(canonical({ vaultId, credentialId, type, url }), "utf8");
 }

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const RUNTIME_VERSION = "0.8.0-beta";

package/dist/version.js

@@ -0,0 +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.8.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.7.0-beta",
+  "version": "0.8.0-beta",
   "description": "SQLite agent execution host and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -29,7 +29,8 @@
     "./configuration": {
       "types": "./dist/configuration.d.ts",
       "import": "./dist/configuration.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -54,8 +55,12 @@
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@earendil-works/pi-ai": "0.85.1",
     "@hono/node-server": "^2.1.1",
-    "@nylorun/harness": "0.16.0-beta",
-    "@nylorun/core": "0.2.0-beta"
+    "@nylorun/harness": "0.17.0-beta",
+    "@nylorun/core": "0.3.0-beta",
+    "just-bash": "3.4.2"
+  },
+  "optionalDependencies": {
+    "microsandbox": "0.7.2"
   },
   "devDependencies": {
     "@types/node": "^26.5.0",

package/dist/config.d.ts

@@ -1,20 +0,0 @@
-import type { ModelAdapter } from "@nylorun/core/define";
-import type { SessionStore } from "./sessions/store.js";
-import type { RuntimeMedia } from "./media.js";
-import type { ModelEnvironment } from "./model/http-model.js";
-export interface RuntimeConfig {
-    readonly onModelCall?: ModelAdapter;
-    readonly createModel?: (options: import("./model/defaults.js").ModelFactoryOptions) => ModelAdapter;
-    readonly observer?: (event: {
-        readonly type: string;
-    }) => void | Promise<void>;
-    readonly sessions?: SessionStore;
-    readonly media?: RuntimeMedia;
-    readonly environment?: ModelEnvironment;
-    readonly tokens?: boolean;
-    readonly delivery?: {
-        readonly previewBytes?: number;
-        readonly eventBytes?: number;
-        readonly eventCount?: number;
-    };
-}

package/dist/model/defaults.d.ts

@@ -1,17 +0,0 @@
-import type { ModelAdapter } from "@nylorun/core/define";
-import { type ModelEnvironment } from "./http-model.js";
-export interface ModelPreview {
-    readonly invocationId: string;
-    readonly text: string;
-}
-export interface ModelFactoryOptions {
-    readonly environment?: ModelEnvironment;
-    readonly media?: import("../media.js").RuntimeMedia;
-    readonly onPreview?: (preview: ModelPreview) => void;
-}
-/** Installed only by the Node launcher before application imports. */
-export declare function installNodeModelFactory(factory: (options: ModelFactoryOptions) => ModelAdapter): void;
-export declare function defaultModel(options: ModelFactoryOptions): ModelAdapter;
-export declare function processEnvironment(): ModelEnvironment;
-export declare function installRuntimeLifecycle(register: (close: () => Promise<void>) => void): void;
-export declare function registerRuntimeLifecycle(close: () => Promise<void>): void;

package/dist/model/defaults.js

@@ -1,21 +0,0 @@
-import { httpModel } from "./http-model.js";
-let nodeFactory;
-/** Installed only by the Node launcher before application imports. */
-export function installNodeModelFactory(factory) {
-    nodeFactory = factory;
-}
-export function defaultModel(options) {
-    return options.environment === undefined && nodeFactory
-        ? nodeFactory(options)
-        : httpModel(options);
-}
-export function processEnvironment() {
-    return typeof process === "undefined" ? {} : process.env;
-}
-let runtimeLifecycle;
-export function installRuntimeLifecycle(register) {
-    runtimeLifecycle = register;
-}
-export function registerRuntimeLifecycle(close) {
-    runtimeLifecycle?.(close);
-}

package/dist/model/http-model.d.ts

@@ -1,12 +0,0 @@
-import type { ModelAdapter } from "@nylorun/core/define";
-import type { ModelFactoryOptions } from "./defaults.js";
-export type ModelEnvironment = Readonly<Record<string, string | undefined>>;
-export interface HttpModelOptions extends ModelFactoryOptions {
-    readonly provider?: "openai" | "custom" | "anthropic";
-    readonly model?: string;
-    readonly apiKey?: string;
-    readonly baseUrl?: string;
-    readonly fetch?: typeof fetch;
-}
-/** Fetch-only adapter for OpenAI-compatible and Anthropic HTTP endpoints. */
-export declare function httpModel(options?: HttpModelOptions): ModelAdapter;