nexus-ai-pro 2.0.0 → 2.2.0

package/dist-cjs/postgres/store.js

@@ -1,12 +1,56 @@
 "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.PostgresStore = void 0;
+exports.storeMigrations = storeMigrations;
 exports.storeMigration = storeMigration;
 const helpers_js_1 = require("../store/helpers.js");
 const client_js_1 = require("./client.js");
 const sql_js_1 = require("./sql.js");
 const DEFAULT_TABLE = 'nexus_store';
 const SEPARATOR = '\u001f';
+function storeMigrations(options = {}) {
+    return [
+        {
+            component: `store:${options.table ?? DEFAULT_TABLE}`,
+            version: 1,
+            name: 'create the store table',
+            statements: storeMigration(options),
+        },
+    ];
+}
 function storeMigration(options = {}) {
     const name = options.table ?? DEFAULT_TABLE;
     const table = (0, client_js_1.quoteTable)(name);
@@ -42,8 +86,9 @@ class PostgresStore {
         this.table = (0, client_js_1.quoteTable)(options.table ?? DEFAULT_TABLE);
         this.now = options.now ?? (() => new Date());
     }
-    async migrate() {
-        await (0, client_js_1.runStatements)(this.client, storeMigration(this.options));
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applyPostgresMigrations(this.client, storeMigrations(this.options), options);
     }
     async put(namespace, key, value, options = {}) {
         if (!key.trim())

package/dist-cjs/postgres/traces.d.ts

@@ -1,12 +1,19 @@
 import type { Run, RunFeedback, RunQuery, RunTree, TraceStore } from '../types/tracing.js';
+import type { MigrationResult, SchemaMigration } from '../utils/schema-migrations.js';
 import { type PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
 /** Options for the Postgres trace store. */
 export interface PostgresTraceStoreOptions {
     /** Table name, optionally schema-qualified. Defaults to `nexus_runs`. */
     table?: string;
 }
-/** The schema, as statements. */
+/** The schema, as statements: every migration's, in order. */
 export declare function traceStoreMigration(options?: PostgresTraceStoreOptions): string[];
+/**
+ * The versioned schema, which `migrate()` and `nexus db migrate` apply. Version 1 is the 2.0 table;
+ * version 2 indexes runs by `metadata.tenantId`, which a tenant-scoped trace store filters on.
+ */
+export declare function traceStoreMigrations(options?: PostgresTraceStoreOptions): SchemaMigration[];
 /**
  * Traces in Postgres.
  *
@@ -20,8 +27,11 @@ export declare class PostgresTraceStore implements TraceStore {
     private readonly options;
     private readonly table;
     constructor(client: PostgresLikeClient, options?: PostgresTraceStoreOptions);
-    /** Creates the table and indexes if they do not exist. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly. Safe on a database an older release created: what exists is kept.
+     */
+    migrate(options?: PostgresMigrateOptions): Promise<MigrationResult>;
     /** Stores a run, replacing an earlier version with the same id. */
     save(run: Run): Promise<void>;
     /** Reads a run. */

package/dist-cjs/postgres/traces.js

@@ -1,14 +1,65 @@
 "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.PostgresTraceStore = void 0;
 exports.traceStoreMigration = traceStoreMigration;
+exports.traceStoreMigrations = traceStoreMigrations;
 const query_js_1 = require("../tracing/query.js");
 const client_js_1 = require("./client.js");
 const sql_js_1 = require("./sql.js");
 const DEFAULT_TABLE = 'nexus_runs';
 function traceStoreMigration(options = {}) {
+    return traceStoreMigrations(options).flatMap((migration) => [...migration.statements]);
+}
+function traceStoreMigrations(options = {}) {
     const name = options.table ?? DEFAULT_TABLE;
     const table = (0, client_js_1.quoteTable)(name);
+    const component = `traces:${name}`;
+    return [
+        { component, version: 1, name: 'create the runs table', statements: createStatements(name, table) },
+        {
+            component,
+            version: 2,
+            name: 'index runs by tenant',
+            statements: [
+                `CREATE INDEX IF NOT EXISTS ${(0, client_js_1.quoteDerived)(name, 'tenant_started')} ON ${table} ((doc #>> '{metadata,tenantId}'), started_at DESC)`,
+            ],
+        },
+    ];
+}
+function createStatements(name, table) {
     return [
         `CREATE TABLE IF NOT EXISTS ${table} (
   id text PRIMARY KEY,
@@ -38,8 +89,9 @@ class PostgresTraceStore {
         this.options = options;
         this.table = (0, client_js_1.quoteTable)(options.table ?? DEFAULT_TABLE);
     }
-    async migrate() {
-        await (0, client_js_1.runStatements)(this.client, traceStoreMigration(this.options));
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applyPostgresMigrations(this.client, traceStoreMigrations(this.options), options);
     }
     async save(run) {
         await this.client.query(`INSERT INTO ${this.table} (id, trace_id, parent_id, name, kind, status, started_at, latency_ms, cost, model, provider, doc)
@@ -97,6 +149,10 @@ class PostgresTraceStore {
             where.push(`EXISTS (SELECT 1 FROM jsonb_array_elements(coalesce(doc -> 'feedback', '[]'::jsonb)) AS item WHERE item ->> 'key' = ${params.add(query.feedbackKey)})`);
         }
         for (const [field, expected] of Object.entries(query.metadata ?? {})) {
+            if (field === 'tenantId' && typeof expected === 'string') {
+                where.push(`doc #>> '{metadata,tenantId}' = ${params.add(expected)} AND jsonb_typeof(doc #> '{metadata,tenantId}') = 'string'`);
+                continue;
+            }
             where.push((0, sql_js_1.jsonFieldEquals)(`(doc -> 'metadata')`, field, expected, params));
         }
         const { rows } = await this.client.query(`SELECT doc::text AS doc FROM ${this.table}

package/dist-cjs/postgres/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 PostgresLikeClient } from './client.js';
+import type { PostgresMigrateOptions } from './migrations.js';
 /** Options for the pgvector store. */
 export interface PostgresVectorStoreOptions {
     /** Width of every vector. Must match the embedding function's output. */
@@ -15,6 +17,10 @@ export interface PostgresVectorStoreOptions {
      */
     index?: 'hnsw' | 'none';
 }
+/**
+ * The versioned schema, which `migrate()` and `nexus db migrate` apply. Version 1 is the 2.0 schema.
+ */
+export declare function vectorStoreMigrations(options: Omit<PostgresVectorStoreOptions, 'embed'>): SchemaMigration[];
 /** The schema, as statements: the pgvector extension, the table, and its index. */
 export declare function vectorStoreMigration(options: Omit<PostgresVectorStoreOptions, 'embed'>): string[];
 /**
@@ -30,8 +36,11 @@ export declare class PostgresVectorStore implements VectorStore {
     private readonly table;
     private readonly embed;
     constructor(client: PostgresLikeClient, options: PostgresVectorStoreOptions);
-    /** Creates the extension, table, and index. Never runs implicitly. */
-    migrate(): Promise<void>;
+    /**
+     * Applies this store's pending migrations, recorded in `nexus_schema_migrations`, under a lock.
+     * Never runs implicitly. Safe on a database an older release created: what exists is kept.
+     */
+    migrate(options?: PostgresMigrateOptions): 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/postgres/vectors.js

@@ -1,11 +1,55 @@
 "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.PostgresVectorStore = void 0;
+exports.vectorStoreMigrations = vectorStoreMigrations;
 exports.vectorStoreMigration = vectorStoreMigration;
 const retrieval_js_1 = require("../hallucination/retrieval.js");
 const client_js_1 = require("./client.js");
 const sql_js_1 = require("./sql.js");
 const DEFAULT_TABLE = 'nexus_vectors';
+function vectorStoreMigrations(options) {
+    return [
+        {
+            component: `vectors:${options.table ?? DEFAULT_TABLE}`,
+            version: 1,
+            name: 'create the vectors table',
+            statements: vectorStoreMigration(options),
+        },
+    ];
+}
 function vectorStoreMigration(options) {
     const dimensions = options.dimensions;
     if (!(Number.isInteger(dimensions) && dimensions > 0))
@@ -42,8 +86,9 @@ class PostgresVectorStore {
         this.table = (0, client_js_1.quoteTable)(options.table ?? DEFAULT_TABLE);
         this.embed = options.embed ?? ((texts) => (0, retrieval_js_1.createHashEmbeddings)(texts, options.dimensions));
     }
-    async migrate() {
-        await (0, client_js_1.runStatements)(this.client, vectorStoreMigration(this.options));
+    async migrate(options = {}) {
+        const { applyPostgresMigrations } = await Promise.resolve().then(() => __importStar(require('./migrations.js')));
+        return applyPostgresMigrations(this.client, vectorStoreMigrations(this.options), options);
     }
     async add(documents) {
         if (documents.length === 0)

package/dist-cjs/router/auto-router.d.ts

@@ -1,14 +1,37 @@
 import type { RouterContext, RouteDecision } from './types.js';
+/**
+ * Ranks configured providers' models for a request routed as `auto`.
+ *
+ * Everything that depends only on configuration — which models are candidates, which pass the
+ * allow and deny lists and the capability requirements, and how each scores for the strategy — is
+ * computed once into a plan and kept until the configuration changes. A request pays only for what
+ * can differ between requests: which circuits are open, and provider health.
+ */
 export declare class AutoRouter {
+    private readonly plans;
+    private readonly patterns;
+    private readonly registryIds;
+    /** Routes one request: the best candidate first, every other as a fallback in order. */
     route(ctx: RouterContext): RouteDecision;
+    /** Plans cached by this router, for tests and diagnostics. */
+    get planCount(): number;
+    /** The plan for a request's configuration, built on first use and kept until the configuration changes. */
+    private plan;
     /**
-     * Drops providers whose circuit is open.
-     *
-     * If that would leave nothing to route to, the original list is kept instead. Every circuit being
-     * open usually means a shared dependency is down rather than every provider individually, and
-     * attempting one call is strictly better than failing the request without trying anything.
+     * What a plan depends on, normalized into a string: the routing settings, the model settings, and
+     * the configured providers. A registry is identified by its object, so replacing
+     * `models.registry` builds a new plan; changing one in place does not.
      */
-    private withoutOpenCircuits;
+    private planKey;
+    private registryId;
+    private buildPlan;
+    /**
+     * The plan's candidates in order for this request. Providers whose circuit is open are left out,
+     * unless that would leave nothing: every circuit open usually means a shared dependency is down,
+     * and one attempt is strictly better than failing without trying. Health moves a whole provider
+     * up or down, so the per-provider lists are merged by their adjusted scores rather than re-sorted.
+     */
+    private rank;
     private getCandidates;
     /**
      * Scores a model for a strategy. For privacy, a model counts as local when its name says so or when
@@ -16,15 +39,19 @@ export declare class AutoRouter {
      * is preferred without renaming its models.
      */
     private score;
+    private capabilitiesOf;
     private localFallbackCapabilities;
     private costScore;
     private speedScore;
     private qualityScore;
     private preferencesForProvider;
     private isAllowed;
+    /** Whether a model meets the routing requirements: the boolean ones as two bitmask tests, the rest by value. */
     private matchesRequirements;
+    /** Whether a model name matches an allow or deny entry, with `*` as a wildcard. Patterns are compiled once. */
     private matchesModelPattern;
     private isProviderRunnable;
-    private healthScore;
+    /** Each provider's health adjustment for this request, or nothing when health does not apply. */
+    private healthOffsets;
 }
 export declare function routeDirectModel(model: string, ctx: RouterContext): RouteDecision;