nexus-ai-pro 2.0.0 → 2.2.0

package/dist-cjs/sqlite/store.js

@@ -1,7 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteStore = void 0;
 exports.sqliteStoreMigration = sqliteStoreMigration;
+exports.sqliteStoreMigrations = sqliteStoreMigrations;
 const helpers_js_1 = require("../store/helpers.js");
 const client_js_1 = require("./client.js");
 const DEFAULT_TABLE = 'nexus_store';
@@ -25,6 +59,16 @@ function sqliteStoreMigration(options = {}) {
         `CREATE INDEX IF NOT EXISTS "${name}_expiry" ON ${table} (expires_at) WHERE expires_at IS NOT NULL`,
     ];
 }
+function sqliteStoreMigrations(options = {}) {
+    return [
+        {
+            component: `store:${options.table ?? DEFAULT_TABLE}`,
+            version: 1,
+            name: 'create the store table',
+            statements: sqliteStoreMigration(options),
+        },
+    ];
+}
 class SqliteStore {
     options;
     client;
@@ -36,9 +80,9 @@ class SqliteStore {
         this.table = (0, client_js_1.quoteSqliteTable)(options.table ?? DEFAULT_TABLE);
         this.now = options.now ?? (() => new Date());
     }
-    async migrate() {
-        for (const statement of sqliteStoreMigration(this.options))
-            await this.client.exec(statement);
+    async migrate(options = {}) {
+        const { applySqliteMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applySqliteMigrations(this.client, sqliteStoreMigrations(this.options), options);
     }
     async put(namespace, key, value, options = {}) {
         if (!key.trim())

package/dist-cjs/sqlite/vectors.d.ts

@@ -1,5 +1,7 @@
 import { type EmbeddingProvider, type VectorDocument, type VectorSearchOptions, type VectorSearchResult, type VectorStore } from '../hallucination/retrieval.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type SqliteDatabaseLike, type SqliteLikeClient } from './client.js';
+import type { SqliteMigrateOptions } from './migrations.js';
 /** Options for the SQLite vector store. */
 export interface SqliteVectorStoreOptions {
     /** Width of every vector. Must match the embedding function's output. */
@@ -20,6 +22,10 @@ export interface SqliteVectorStoreOptions {
 export declare function sqliteVectorStoreMigration(options?: {
     table?: string;
 }): string;
+/** The versioned schema, which `migrate()` applies. Version 1 is the 2.0 table. */
+export declare function sqliteVectorStoreMigrations(options?: {
+    table?: string;
+}): SchemaMigration[];
 /**
  * Retrieval chunks in SQLite: one file, no server, the same contract as every other store.
  *
@@ -34,8 +40,11 @@ export declare class SqliteVectorStore implements VectorStore {
     private readonly table;
     private readonly embed;
     constructor(database: SqliteLikeClient | SqliteDatabaseLike, options: SqliteVectorStoreOptions);
-    /** Creates the table unless it exists. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, each inside
+     * `BEGIN IMMEDIATE`. Never runs implicitly. Safe on a file an older release created.
+     */
+    migrate(options?: SqliteMigrateOptions): Promise<MigrationResult>;
     /** Adds chunks, or replaces those whose id exists, embedding those without a vector in one batch. */
     add(documents: VectorDocument[]): Promise<void>;
     /** The chunks most similar to a query, best first. */

package/dist-cjs/sqlite/vectors.js

@@ -1,7 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteVectorStore = void 0;
 exports.sqliteVectorStoreMigration = sqliteVectorStoreMigration;
+exports.sqliteVectorStoreMigrations = sqliteVectorStoreMigrations;
 const retrieval_js_1 = require("../hallucination/retrieval.js");
 const vector_helpers_js_1 = require("../rag/vector-helpers.js");
 const client_js_1 = require("./client.js");
@@ -9,6 +43,16 @@ function sqliteVectorStoreMigration(options = {}) {
     const table = (0, client_js_1.quoteSqliteTable)(options.table ?? 'nexus_vectors');
     return `CREATE TABLE IF NOT EXISTS ${table} (id TEXT PRIMARY KEY, content TEXT NOT NULL, source TEXT, metadata TEXT, embedding BLOB NOT NULL)`;
 }
+function sqliteVectorStoreMigrations(options = {}) {
+    return [
+        {
+            component: `vectors:${options.table ?? 'nexus_vectors'}`,
+            version: 1,
+            name: 'create the vectors table',
+            statements: [sqliteVectorStoreMigration(options)],
+        },
+    ];
+}
 class SqliteVectorStore {
     options;
     client;
@@ -21,8 +65,9 @@ class SqliteVectorStore {
         this.table = (0, client_js_1.quoteSqliteTable)(options.table ?? 'nexus_vectors');
         this.embed = options.embed ?? ((texts) => (0, retrieval_js_1.createHashEmbeddings)(texts, options.dimensions));
     }
-    async migrate() {
-        await this.client.exec(sqliteVectorStoreMigration(this.options));
+    async migrate(options = {}) {
+        const { applySqliteMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applySqliteMigrations(this.client, sqliteVectorStoreMigrations(this.options), options);
     }
     async add(documents) {
         if (documents.length === 0)

package/dist-cjs/store/tenant.d.ts

@@ -0,0 +1,12 @@
+import type { Store } from '../types/store.js';
+/** The first namespace part under which every tenant's items live, so they never meet an application's own. */
+export declare const TENANT_NAMESPACE = "nexus:tenant";
+/**
+ * One tenant's view of a long-term store: every namespace it reads or writes is placed under
+ * `['nexus:tenant', tenantId]`, and every item it returns has that prefix taken off again. A search
+ * or a namespace listing cannot reach past it, so another tenant's items are not merely filtered out
+ * but never read. Works over any store — memory, Redis, Postgres, SQLite — with no schema change.
+ *
+ * A graph run given a `tenantId` sees its store through this view as `context.store`.
+ */
+export declare function tenantStore(store: Store, tenantId: string): Store;

package/dist-cjs/store/tenant.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TENANT_NAMESPACE = void 0;
+exports.tenantStore = tenantStore;
+const tenant_js_1 = require("../utils/tenant.js");
+exports.TENANT_NAMESPACE = 'nexus:tenant';
+function tenantStore(store, tenantId) {
+    const root = [exports.TENANT_NAMESPACE, (0, tenant_js_1.assertTenantId)(tenantId)];
+    const scope = (namespace) => [...root, ...namespace];
+    const unscope = (item) => ({ ...item, namespace: item.namespace.slice(root.length) });
+    return {
+        put(namespace, key, value, options) {
+            return store.put(scope(namespace), key, value, options);
+        },
+        async get(namespace, key) {
+            const item = await store.get(scope(namespace), key);
+            return item ? unscope(item) : undefined;
+        },
+        delete(namespace, key) {
+            return store.delete(scope(namespace), key);
+        },
+        async search(namespacePrefix, options) {
+            return (await store.search(scope(namespacePrefix), options)).map(unscope);
+        },
+        async listNamespaces(options = {}) {
+            const namespaces = await store.listNamespaces({
+                prefix: scope(options.prefix ?? []),
+                ...(options.limit === undefined ? {} : { limit: options.limit }),
+            });
+            return namespaces.map((namespace) => namespace.slice(root.length)).filter((namespace) => namespace.length > 0);
+        },
+    };
+}

package/dist-cjs/tenancy/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * One tenant model for every store.
+ *
+ * Each function returns one tenant's view of a shared store, implementing the same contract as the
+ * store itself, so a tenant's code takes a `TraceStore`, a `PromptStore`, or a `VectorStore` as it
+ * always did and cannot reach past its tenant. Names and keys are placed under the tenant's prefix
+ * (`tenant/<id>/`) and records carry `tenantId`, so the views work over the memory, Redis, Postgres,
+ * SQLite, and file stores alike, with no schema change. A tenant id is letters, digits, `_`, and `-`,
+ * so no tenant's prefix is the start of another's.
+ */
+import type { CacheAdapter } from '../cache/adapters.js';
+import type { VectorStore } from '../hallucination/retrieval.js';
+import type { AssetPutOptions, AssetSignOptions, AssetStore } from '../images/asset-support.js';
+import type { RollupStore } from '../tracing/rollups.js';
+import type { DatasetStore, ExperimentStore } from '../types/evaluate.js';
+import type { OperationStore } from '../types/operations.js';
+import type { PromptStore } from '../types/prompts.js';
+import type { Store } from '../types/store.js';
+import type { TraceStore } from '../types/tracing.js';
+export { TENANT_NAMESPACE, tenantStore } from '../store/tenant.js';
+export { assertTenantId, TenantIdError } from '../utils/tenant.js';
+/**
+ * One tenant's traces. Every run saved through it is stamped `metadata.tenantId`, the field rollups,
+ * the studio, and the Postgres tenant index read; `get()`, `query()`, and `tree()` return only runs so
+ * stamped, and feedback reaches only the tenant's own runs. `prune()` is left out, since it would
+ * remove every tenant's old runs.
+ */
+export declare function tenantTraceStore(store: TraceStore, tenantId: string): TraceStore;
+/**
+ * One tenant's operations. Records it creates carry `tenantId`, and their idempotency keys are
+ * placed under the tenant's prefix, so two tenants using the same key never collide. Reads, updates,
+ * deletes, recovery, and queue listings see only the tenant's records; `listQueued()` and `stats()`
+ * pass the tenant to the store as a filter, which Postgres and SQLite answer from an index.
+ */
+export declare function tenantOperationStore<TResult = unknown>(store: OperationStore<TResult>, tenantId: string): OperationStore<TResult>;
+/**
+ * One tenant's prompts. Every prompt name is placed under the tenant's prefix on the way in and
+ * taken off on the way out, so the tenant sees its own names and `listNames()` lists only them. A
+ * `ContextHub` given this store keeps the tenant's context bundles apart the same way.
+ */
+export declare function tenantPromptStore(store: PromptStore, tenantId: string): PromptStore;
+/** One tenant's datasets: names placed under the tenant's prefix, and `list()` showing only its own. */
+export declare function tenantDatasetStore(store: DatasetStore, tenantId: string): DatasetStore;
+/**
+ * One tenant's experiments. Ids, names, and dataset names are placed under the tenant's prefix, so
+ * `get()` of another tenant's experiment id finds nothing and `list()` returns only the tenant's.
+ */
+export declare function tenantExperimentStore(store: ExperimentStore, tenantId: string): ExperimentStore;
+/**
+ * One tenant's retrieval chunks. Each chunk's id is placed under the tenant's prefix and its metadata
+ * stamped `tenantId`, and every search adds `tenantId` to its filter, which every vector store applies
+ * natively. A search never ranks another tenant's chunks, and `delete()` reaches only the tenant's.
+ */
+export declare function tenantVectorStore(store: VectorStore, tenantId: string): VectorStore;
+/**
+ * One tenant's cache: every key placed under the tenant's prefix, so a tenant can never read what
+ * another cached. `clear()` is left out, since it would clear every tenant's entries.
+ */
+export declare function tenantCache<T = unknown>(cache: CacheAdapter<T>, tenantId: string): CacheAdapter<T>;
+/** An asset store with the tenant bound, so no call can name another. Returned by `tenantAssetStore()`. */
+export interface TenantAssetStore {
+    /** The tenant every call acts for. */
+    readonly tenantId: string;
+    /** Stores an asset for the tenant. */
+    put(input: Parameters<AssetStore['put']>[0], options: Omit<AssetPutOptions, 'tenantId'>): ReturnType<AssetStore['put']>;
+    /** Reads one of the tenant's assets with its bytes. */
+    get(assetId: string): ReturnType<AssetStore['get']>;
+    /** Describes one of the tenant's assets. */
+    stat(assetId: string): ReturnType<AssetStore['stat']>;
+    /** Deletes one of the tenant's assets. */
+    delete(assetId: string): ReturnType<AssetStore['delete']>;
+    /** Signs a URL for one of the tenant's assets. */
+    sign(assetId: string, options?: AssetSignOptions): ReturnType<AssetStore['sign']>;
+}
+/**
+ * One tenant's assets. Asset stores already treat another tenant's asset as missing; this binds the
+ * tenant once, so code handed the view cannot pass a different one.
+ */
+export declare function tenantAssetStore(store: AssetStore, tenantId: string): TenantAssetStore;
+/** One tenant's rollups: rows it adds are counted for the tenant, and queries read only the tenant's rows. */
+export declare function tenantRollupStore(store: RollupStore, tenantId: string): RollupStore;
+/** The stores `tenantScope()` can scope. Each is optional. */
+export interface TenantStores {
+    /** Long-term memory. */
+    store?: Store;
+    /** Traces. */
+    traces?: TraceStore;
+    /** Operation records. */
+    operations?: OperationStore<unknown>;
+    /** Prompt versions and labels, and the context hub's bundles. */
+    prompts?: PromptStore;
+    /** Datasets. */
+    datasets?: DatasetStore;
+    /** Experiments. */
+    experiments?: ExperimentStore;
+    /** Retrieval chunks. */
+    vectors?: VectorStore;
+    /** A cache. */
+    cache?: CacheAdapter<unknown>;
+    /** Dashboard rollups. */
+    rollups?: RollupStore;
+}
+/**
+ * Scopes every given store to one tenant at once, keeping each one's type, so a request handler
+ * builds its tenant's view in one line.
+ *
+ * ```ts
+ * const scoped = tenantScope(principal.tenantId, { store, traces, prompts, vectors });
+ * ```
+ */
+export declare function tenantScope<T extends TenantStores>(tenantId: string, stores: T): T & {
+    readonly tenantId: string;
+};

package/dist-cjs/tenancy/index.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantIdError = exports.assertTenantId = exports.tenantStore = exports.TENANT_NAMESPACE = void 0;
+exports.tenantTraceStore = tenantTraceStore;
+exports.tenantOperationStore = tenantOperationStore;
+exports.tenantPromptStore = tenantPromptStore;
+exports.tenantDatasetStore = tenantDatasetStore;
+exports.tenantExperimentStore = tenantExperimentStore;
+exports.tenantVectorStore = tenantVectorStore;
+exports.tenantCache = tenantCache;
+exports.tenantAssetStore = tenantAssetStore;
+exports.tenantRollupStore = tenantRollupStore;
+exports.tenantScope = tenantScope;
+const tenant_js_1 = require("../utils/tenant.js");
+const tenant_js_2 = require("../store/tenant.js");
+var tenant_js_3 = require("../store/tenant.js");
+Object.defineProperty(exports, "TENANT_NAMESPACE", { enumerable: true, get: function () { return tenant_js_3.TENANT_NAMESPACE; } });
+Object.defineProperty(exports, "tenantStore", { enumerable: true, get: function () { return tenant_js_3.tenantStore; } });
+var tenant_js_4 = require("../utils/tenant.js");
+Object.defineProperty(exports, "assertTenantId", { enumerable: true, get: function () { return tenant_js_4.assertTenantId; } });
+Object.defineProperty(exports, "TenantIdError", { enumerable: true, get: function () { return tenant_js_4.TenantIdError; } });
+function names(tenantId) {
+    const prefix = (0, tenant_js_1.tenantPrefix)(tenantId);
+    return {
+        prefix,
+        in: (name) => `${prefix}${name}`,
+        owns: (name) => name.startsWith(prefix),
+        out: (name) => name.slice(prefix.length),
+    };
+}
+function stamped(metadata, tenantId) {
+    return metadata?.tenantId === tenantId;
+}
+function tenantTraceStore(store, tenantId) {
+    (0, tenant_js_1.tenantPrefix)(tenantId);
+    const own = (run) => (run && stamped(run.metadata, tenantId) ? run : undefined);
+    const prune = (tree) => ({
+        ...tree,
+        children: tree.children.filter((child) => stamped(child.metadata, tenantId)).map(prune),
+    });
+    return {
+        save: (run) => store.save({ ...run, metadata: { ...run.metadata, tenantId } }),
+        get: async (runId) => own(await store.get(runId)),
+        query: (query = {}) => store.query({ ...query, metadata: { ...query.metadata, tenantId } }),
+        async tree(traceId) {
+            const tree = await store.tree(traceId);
+            return tree && stamped(tree.metadata, tenantId) ? prune(tree) : undefined;
+        },
+        async addFeedback(runId, feedback) {
+            const run = own(await store.get(runId));
+            if (!run)
+                return;
+            if (store.addFeedback)
+                await store.addFeedback(runId, feedback);
+            else
+                await store.save({ ...run, feedback: [...(run.feedback ?? []), feedback] });
+        },
+    };
+}
+function tenantOperationStore(store, tenantId) {
+    const keys = names(tenantId);
+    const inward = (record) => ({
+        ...record,
+        tenantId,
+        ...(record.idempotencyKey ? { idempotencyKey: keys.in(record.idempotencyKey) } : {}),
+    });
+    const outward = (record) => {
+        if (!record || record.tenantId !== tenantId)
+            return undefined;
+        return record.idempotencyKey && keys.owns(record.idempotencyKey)
+            ? { ...record, idempotencyKey: keys.out(record.idempotencyKey) }
+            : record;
+    };
+    const own = (records) => records.map(outward).filter((record) => record !== undefined);
+    const filtered = (filter) => ({ ...filter, tenantId });
+    const view = {
+        create: (record) => store.create(inward(record)),
+        read: async (id) => outward(await store.read(id)),
+        async update(record, expectedSequence) {
+            if (record.tenantId !== undefined && record.tenantId !== tenantId)
+                return false;
+            if (!outward(await store.read(record.id)))
+                return false;
+            return store.update(inward(record), expectedSequence);
+        },
+    };
+    if (store.delete) {
+        const remove = store.delete.bind(store);
+        view.delete = async (id) => (outward(await store.read(id)) ? remove(id) : false);
+    }
+    if (store.claimExpired) {
+        const claim = store.claimExpired.bind(store);
+        view.claimExpired = async (now, limit) => own(await claim(now, limit));
+    }
+    if (store.findByIdempotencyKey) {
+        const find = store.findByIdempotencyKey.bind(store);
+        view.findByIdempotencyKey = async (key) => outward(await find(keys.in(key)));
+    }
+    if (store.list) {
+        const list = store.list.bind(store);
+        view.list = async () => own(await list());
+    }
+    if (store.listQueued) {
+        const listQueued = store.listQueued.bind(store);
+        view.listQueued = async (limit, filter) => own(await listQueued(limit, filtered(filter)));
+    }
+    if (store.stats) {
+        const stats = store.stats.bind(store);
+        view.stats = (now, filter) => stats(now, filtered(filter));
+    }
+    return view;
+}
+function tenantPromptStore(store, tenantId) {
+    const scoped = names(tenantId);
+    const named = (value) => ({ ...value, name: scoped.in(value.name) });
+    const unnamed = (value) => value && scoped.owns(value.name) ? { ...value, name: scoped.out(value.name) } : undefined;
+    const all = (values) => values.map(unnamed).filter((value) => value !== undefined);
+    return {
+        saveVersion: (version) => store.saveVersion(named(version)),
+        getVersion: async (name, version) => unnamed(await store.getVersion(scoped.in(name), version)),
+        listVersions: async (name, options) => all(await store.listVersions(scoped.in(name), options)),
+        getLabel: async (name, label) => unnamed(await store.getLabel(scoped.in(name), label)),
+        listLabels: async (name) => all(await store.listLabels(scoped.in(name))),
+        setLabel: (label, expected) => store.setLabel(named(label), expected),
+        deleteLabel: (name, label) => store.deleteLabel(scoped.in(name), label),
+        appendHistory: (entry) => store.appendHistory(named(entry)),
+        listHistory: async (name, options) => all(await store.listHistory(scoped.in(name), options)),
+        listNames: async () => (await store.listNames()).filter(scoped.owns).map(scoped.out).sort(),
+    };
+}
+function tenantDatasetStore(store, tenantId) {
+    const scoped = names(tenantId);
+    return {
+        save: (dataset) => store.save({ ...dataset, name: scoped.in(dataset.name) }),
+        async get(name, version) {
+            const dataset = await store.get(scoped.in(name), version);
+            return dataset ? { ...dataset, name: name } : undefined;
+        },
+        async list() {
+            return (await store.list())
+                .filter((entry) => scoped.owns(entry.name))
+                .map((entry) => ({ ...entry, name: scoped.out(entry.name) }));
+        },
+    };
+}
+function tenantExperimentStore(store, tenantId) {
+    const scoped = names(tenantId);
+    const inward = (experiment) => ({
+        ...experiment,
+        id: scoped.in(experiment.id),
+        name: scoped.in(experiment.name),
+        dataset: { ...experiment.dataset, name: scoped.in(experiment.dataset.name) },
+    });
+    const outward = (experiment) => experiment && scoped.owns(experiment.id)
+        ? {
+            ...experiment,
+            id: scoped.out(experiment.id),
+            name: scoped.out(experiment.name),
+            dataset: { ...experiment.dataset, name: scoped.out(experiment.dataset.name) },
+        }
+        : undefined;
+    return {
+        save: (experiment) => store.save(inward(experiment)),
+        get: async (id) => outward(await store.get(scoped.in(id))),
+        async list(filter = {}) {
+            const experiments = await store.list({
+                ...filter,
+                ...(filter.name === undefined ? {} : { name: scoped.in(filter.name) }),
+                ...(filter.dataset === undefined ? {} : { dataset: scoped.in(filter.dataset) }),
+            });
+            return experiments.map(outward).filter((experiment) => experiment !== undefined);
+        },
+    };
+}
+function tenantVectorStore(store, tenantId) {
+    const scoped = names(tenantId);
+    const outward = (results) => results
+        .filter((result) => scoped.owns(result.id) && stamped(result.metadata, tenantId))
+        .map((result) => {
+        const { tenantId: _owner, ...metadata } = result.metadata ?? {};
+        return { ...result, id: scoped.out(result.id), metadata };
+    });
+    const filtered = (options = {}) => ({
+        ...options,
+        filter: { ...options.filter, tenantId },
+    });
+    return {
+        add: (documents) => store.add(documents.map((document) => ({
+            ...document,
+            id: scoped.in(document.id),
+            metadata: { ...document.metadata, tenantId },
+        }))),
+        search: async (query, options) => outward(await store.search(query, filtered(options))),
+        searchVector: async (vector, options) => outward(await store.searchVector(vector, filtered(options))),
+        delete: (ids) => store.delete(ids.map(scoped.in)),
+    };
+}
+function tenantCache(cache, tenantId) {
+    const scoped = names(tenantId);
+    const view = {
+        get: (key) => cache.get(scoped.in(key)),
+        set: (key, value, ttlSeconds) => cache.set(scoped.in(key), value, ttlSeconds),
+    };
+    if (cache.delete) {
+        const remove = cache.delete.bind(cache);
+        view.delete = (key) => remove(scoped.in(key));
+    }
+    return view;
+}
+function tenantAssetStore(store, tenantId) {
+    (0, tenant_js_1.tenantPrefix)(tenantId);
+    return {
+        tenantId,
+        put: (input, options) => store.put(input, { ...options, tenantId }),
+        get: (assetId) => store.get(assetId, tenantId),
+        stat: (assetId) => store.stat(assetId, tenantId),
+        delete: (assetId) => store.delete(assetId, tenantId),
+        sign: (assetId, options) => store.sign(assetId, tenantId, options),
+    };
+}
+function tenantRollupStore(store, tenantId) {
+    (0, tenant_js_1.tenantPrefix)(tenantId);
+    return {
+        add: (key, totals) => store.add({ ...key, tenant: tenantId }, totals),
+        query: (query = {}) => store.query({ ...query, tenant: tenantId }),
+    };
+}
+function tenantScope(tenantId, stores) {
+    (0, tenant_js_1.tenantPrefix)(tenantId);
+    const scoped = {};
+    if (stores.store)
+        scoped.store = (0, tenant_js_2.tenantStore)(stores.store, tenantId);
+    if (stores.traces)
+        scoped.traces = tenantTraceStore(stores.traces, tenantId);
+    if (stores.operations)
+        scoped.operations = tenantOperationStore(stores.operations, tenantId);
+    if (stores.prompts)
+        scoped.prompts = tenantPromptStore(stores.prompts, tenantId);
+    if (stores.datasets)
+        scoped.datasets = tenantDatasetStore(stores.datasets, tenantId);
+    if (stores.experiments)
+        scoped.experiments = tenantExperimentStore(stores.experiments, tenantId);
+    if (stores.vectors)
+        scoped.vectors = tenantVectorStore(stores.vectors, tenantId);
+    if (stores.cache)
+        scoped.cache = tenantCache(stores.cache, tenantId);
+    if (stores.rollups)
+        scoped.rollups = tenantRollupStore(stores.rollups, tenantId);
+    return { ...stores, ...scoped, tenantId };
+}

package/dist-cjs/testing/record.d.ts

@@ -32,6 +32,40 @@ export interface RecordedResponse {
     body: string;
     /** How `body` is encoded. */
     bodyEncoding: 'utf8' | 'base64';
+    /**
+     * The body as it arrived, chunk by chunk, with when each came, when recorded with `timing`. A
+     * paced replay sends these; an instant one sends `body`, which holds the same bytes.
+     */
+    chunks?: RecordedChunk[];
+}
+/** One piece of a streamed response, and when it arrived. */
+export interface RecordedChunk {
+    /** Milliseconds after the response started. */
+    atMs: number;
+    /** The bytes, as text or base64. */
+    body: string;
+    /** How `body` is encoded. */
+    bodyEncoding: 'utf8' | 'base64';
+}
+/**
+ * How a replayed stream is paced, for a recording made with `timing`.
+ *
+ * - `instant` (the default) sends the whole body at once, as a recording without timing does.
+ * - `original` sends each chunk when it arrived, relative to the first.
+ * - A number scales the gaps: `0.1` is ten times faster, `2` twice as slow.
+ * - A function is awaited before each chunk, so a test can release them one at a time.
+ */
+export type ReplayPace = 'instant' | 'original' | number | ((chunk: ReplayChunkInfo) => Promise<void> | void);
+/** What a pacing function is told about the chunk it releases. */
+export interface ReplayChunkInfo {
+    /** Its position, from 0. */
+    index: number;
+    /** How many chunks the response has. */
+    count: number;
+    /** When it arrived when recorded, in milliseconds after the response started. */
+    atMs: number;
+    /** The recorded gap since the chunk before it, in milliseconds. */
+    delayMs: number;
 }
 /** One request and the response it got, as written to a fixture file. */
 export interface RecordedExchange {
@@ -86,6 +120,12 @@ export interface RecordOptions extends FixtureOptions {
     redact?: (exchange: RecordedExchange) => RecordedExchange;
     /** Replaces the system clock, for `recordedAt`. */
     now?: () => Date;
+    /**
+     * Keeps each chunk of a response and when it arrived, so a replay can reproduce a stream's pace
+     * as well as its bytes: for testing idle timeouts, cancellation, backpressure, and streaming UIs.
+     * Defaults to false.
+     */
+    timing?: boolean;
 }
 /** Options for replaying. */
 export interface ReplayOptions extends FixtureOptions {
@@ -96,6 +136,8 @@ export interface ReplayOptions extends FixtureOptions {
     onMissing?: 'throw' | 'live';
     /** The real fetch, for `onMissing: 'live'`. */
     fetch?: typeof globalThis.fetch;
+    /** How a stream recorded with `timing` is paced. Defaults to `instant`. */
+    pace?: ReplayPace;
 }
 /** A fetch that also lets a test wait for every fixture it has written. */
 export type RecordingFetch = typeof globalThis.fetch & {