nexus-ai-pro 2.7.0 → 2.8.0

package/dist/batch/openai.d.ts

@@ -1,42 +1,33 @@
 import type { BatchJobRef, BatchJobState, BatchOutputItem, BatchProvider, BatchProviderCallContext, BatchProviderInfo, BatchSubmitRequest } from '../types/batch.js';
+import { type OpenAIBatchClientOptions } from './openai-client.js';
 /** Options for the OpenAI batch provider. */
-export interface OpenAIBatchProviderOptions {
-    /** OpenAI API key. */
-    apiKey: string;
-    /** API base URL. Defaults to `https://api.openai.com/v1`. */
-    baseUrl?: string;
-    /** Sent as the `OpenAI-Organization` header. */
-    organization?: string;
-    /** Headers added to every request. */
-    headers?: Record<string, string>;
-    /** Replaces the global `fetch`. */
-    fetch?: typeof fetch;
-    /** Endpoint every item targets. Defaults to chat completions. */
+export interface OpenAIBatchProviderOptions extends OpenAIBatchClientOptions {
+    /**
+     * Endpoint every item targets. Defaults to chat completions. Embeddings are batched by
+     * `OpenAIEmbeddingBatchProvider`, on `nexus-ai-pro/embeddings/batch/openai`; this adapter refuses
+     * `/v1/embeddings`, since its items are completions.
+     */
     endpoint?: '/v1/chat/completions' | '/v1/embeddings' | (string & {});
 }
 /**
  * OpenAI's Batch API: half price, 24-hour window.
  *
- * The wire protocol is a JSONL upload, a batch pointing at it, then a JSONL download — three
- * different content types across four endpoints, which is why this adapter is larger than a
- * synchronous one.
+ * The wire protocol is a JSONL upload, a batch pointing at it, then JSONL downloads of what succeeded
+ * and what failed — three different content types across four endpoints, which is why this adapter
+ * is larger than a synchronous one.
  */
 export declare class OpenAIBatchProvider implements BatchProvider {
     private readonly options;
     /** Always `openai`, with its batch limits. */
     readonly info: BatchProviderInfo;
+    private readonly client;
     constructor(options: OpenAIBatchProviderOptions);
     /** Uploads the items as JSONL and creates a batch over them. */
     submit(request: BatchSubmitRequest, context: BatchProviderCallContext): Promise<BatchJobRef>;
     /** Reads a batch's status and counts. */
     poll(ref: BatchJobRef, context: BatchProviderCallContext): Promise<BatchJobState>;
-    /** Downloads a finished batch's results. Empty until the output file exists. */
+    /** Downloads a finished batch's results: what succeeded and what failed. Empty until they exist. */
     results(ref: BatchJobRef, context: BatchProviderCallContext): Promise<BatchOutputItem[]>;
     /** Cancels a batch. Items already processed keep their results. */
     cancel(ref: BatchJobRef, context: BatchProviderCallContext): Promise<BatchJobState>;
-    private toState;
-    private toOutputItem;
-    private request;
-    private requestText;
-    private send;
 }

package/dist/batch/openai.js

@@ -1,15 +1,6 @@
 import { buildMeta } from '../core/usage.js';
-import { BatchProviderResponseError } from './errors.js';
-const STATUS_MAP = {
-    validating: 'validating',
-    in_progress: 'in_progress',
-    finalizing: 'finalizing',
-    completed: 'completed',
-    failed: 'failed',
-    expired: 'expired',
-    cancelling: 'cancelling',
-    cancelled: 'cancelled',
-};
+import { BatchCapabilityError } from './errors.js';
+import { lineError, OpenAIBatchClient } from './openai-client.js';
 export class OpenAIBatchProvider {
     options;
     info = {
@@ -22,13 +13,17 @@ export class OpenAIBatchProvider {
             discount: 0.5,
         },
     };
+    client;
     constructor(options) {
         this.options = options;
+        this.client = new OpenAIBatchClient(options);
     }
     async submit(request, context) {
         const endpoint = this.options.endpoint ?? '/v1/chat/completions';
-        const jsonl = request.items
-            .map((item) => JSON.stringify({
+        if (endpoint === '/v1/embeddings') {
+            throw new BatchCapabilityError('openai', 'endpoint', 'OpenAIBatchProvider batches completions; batch embeddings with OpenAIEmbeddingBatchProvider from nexus-ai-pro/embeddings/batch/openai');
+        }
+        const { batch, fileId } = await this.client.create(request.items.map((item) => ({
             custom_id: item.customId,
             method: 'POST',
             url: endpoint,
@@ -38,124 +33,37 @@ export class OpenAIBatchProvider {
                 max_tokens: item.request.maxTokens,
                 temperature: item.request.temperature,
             },
-        }))
-            .join('\n');
-        const form = new FormData();
-        form.append('purpose', 'batch');
-        form.append('file', new Blob([jsonl], { type: 'application/jsonl' }), 'batch.jsonl');
-        const file = (await this.request('/files', { method: 'POST', body: form }, context));
-        if (!file.id)
-            throw new BatchProviderResponseError('openai', 'the file upload returned no id');
-        const batch = (await this.request('/batches', {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({
-                input_file_id: file.id,
-                endpoint,
-                completion_window: request.completionWindow ?? '24h',
-                metadata: request.metadata,
-            }),
-        }, context));
-        if (!batch.id)
-            throw new BatchProviderResponseError('openai', 'the batch response returned no id');
-        return { id: batch.id, provider: 'openai', metadata: { inputFileId: file.id, endpoint } };
+        })), { endpoint, completionWindow: request.completionWindow, metadata: request.metadata }, context);
+        return { id: batch.id, provider: 'openai', metadata: { inputFileId: fileId, endpoint } };
     }
     async poll(ref, context) {
-        const batch = (await this.request(`/batches/${encodeURIComponent(ref.id)}`, {}, context));
-        return this.toState(ref, batch);
+        return this.client.state(ref, await this.client.read(ref.id, context));
     }
     async results(ref, context) {
-        const batch = (await this.request(`/batches/${encodeURIComponent(ref.id)}`, {}, context));
-        if (!batch.output_file_id)
-            return [];
-        const body = await this.requestText(`/files/${encodeURIComponent(batch.output_file_id)}/content`, context);
-        return body
-            .split('\n')
-            .filter((line) => line.trim().length > 0)
-            .map((line) => this.toOutputItem(line));
+        return (await this.client.lines(ref.id, context)).map(toOutputItem);
     }
     async cancel(ref, context) {
-        const batch = (await this.request(`/batches/${encodeURIComponent(ref.id)}/cancel`, { method: 'POST' }, context));
-        return this.toState(ref, batch);
-    }
-    toState(ref, batch) {
-        const counts = batch.request_counts;
-        return {
-            ref,
-            status: STATUS_MAP[batch.status ?? ''] ?? 'in_progress',
-            counts: counts
-                ? { total: counts.total ?? 0, completed: counts.completed ?? 0, failed: counts.failed ?? 0 }
-                : undefined,
-            createdAt: batch.created_at ? new Date(batch.created_at * 1000).toISOString() : undefined,
-            completedAt: batch.completed_at ? new Date(batch.completed_at * 1000).toISOString() : undefined,
-            expiresAt: batch.expires_at ? new Date(batch.expires_at * 1000).toISOString() : undefined,
-            error: batch.errors?.data?.[0]
-                ? { message: batch.errors.data[0].message ?? 'batch failed', code: batch.errors.data[0].code }
-                : undefined,
-            raw: batch,
-        };
-    }
-    toOutputItem(line) {
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch (error) {
-            throw new BatchProviderResponseError('openai', 'an output line was not valid JSON', error);
-        }
-        const customId = parsed.custom_id ?? '';
-        if (parsed.error) {
-            return { customId, error: { message: parsed.error.message ?? 'batch item failed', code: parsed.error.code } };
-        }
-        const body = parsed.response?.body;
-        const status = parsed.response?.status_code ?? 200;
-        if (!body || status >= 400) {
-            return { customId, error: { message: `batch item failed with status ${status}`, status } };
-        }
-        const choice = body.choices?.[0];
-        const response = {
-            content: choice?.message?.content ?? '',
-            role: 'assistant',
-            finishReason: choice?.finish_reason === 'length' ? 'length' : 'stop',
-            meta: buildMeta({
-                provider: 'openai',
-                model: body.model ?? '',
-                latencyMs: 0,
-                inputTokens: body.usage?.prompt_tokens,
-                outputTokens: body.usage?.completion_tokens,
-            }),
-        };
-        return { customId, response };
-    }
-    async request(path, init, context) {
-        const response = await this.send(path, init, context);
-        return response.json();
-    }
-    async requestText(path, context) {
-        const response = await this.send(path, {}, context);
-        return response.text();
-    }
-    async send(path, init, context) {
-        const fetchImpl = this.options.fetch ?? fetch;
-        const baseUrl = (this.options.baseUrl || 'https://api.openai.com/v1').replace(/\/$/, '');
-        const headers = {
-            authorization: `Bearer ${this.options.apiKey}`,
-            ...(this.options.organization ? { 'openai-organization': this.options.organization } : {}),
-            ...this.options.headers,
-            ...(init.headers ?? {}),
-        };
-        const response = await fetchImpl(`${baseUrl}${path}`, { ...init, headers, signal: context.signal });
-        if (!response.ok) {
-            throw new BatchProviderResponseError('openai', `${path} failed: ${response.status} ${await safeText(response)}`);
-        }
-        return response;
+        return this.client.state(ref, await this.client.cancel(ref.id, context));
     }
 }
-async function safeText(response) {
-    try {
-        return (await response.text()).slice(0, 500);
-    }
-    catch {
-        return '';
-    }
+function toOutputItem(line) {
+    const customId = line.custom_id ?? '';
+    const error = lineError(line);
+    if (error)
+        return { customId, error };
+    const body = line.response?.body;
+    const choice = body.choices?.[0];
+    const response = {
+        content: choice?.message?.content ?? '',
+        role: 'assistant',
+        finishReason: choice?.finish_reason === 'length' ? 'length' : 'stop',
+        meta: buildMeta({
+            provider: 'openai',
+            model: body.model ?? '',
+            latencyMs: 0,
+            inputTokens: body.usage?.prompt_tokens,
+            outputTokens: body.usage?.completion_tokens,
+        }),
+    };
+    return { customId, response };
 }

package/dist/batch/poll.d.ts

@@ -0,0 +1,18 @@
+import { type BatchJobState } from '../types/batch.js';
+/** How a batch is waited on. */
+export interface BatchPollOptions {
+    /** The first wait between polls, in milliseconds. */
+    intervalMs: number;
+    /** The longest wait, once backoff has grown it. */
+    maxIntervalMs: number;
+    /** Stops waiting. The provider-side batch keeps running. */
+    signal: AbortSignal;
+    /** Called with each state that is not yet final. */
+    onState?: (state: BatchJobState) => void;
+}
+/**
+ * Polls a batch until it reaches a status it never leaves. A batch measured in hours does not deserve
+ * a fixed short interval: the wait grows by half each time up to the maximum, which keeps the poll
+ * count sane without delaying a fast batch, which the first few short polls still catch.
+ */
+export declare function pollUntilSettled(poll: () => Promise<BatchJobState>, options: BatchPollOptions): Promise<BatchJobState>;

package/dist/batch/poll.js

@@ -0,0 +1,29 @@
+import { isTerminalBatchStatus } from '../types/batch.js';
+export async function pollUntilSettled(poll, options) {
+    let interval = options.intervalMs;
+    let state = await poll();
+    while (!isTerminalBatchStatus(state.status)) {
+        if (options.signal.aborted)
+            throw options.signal.reason ?? new Error('aborted');
+        options.onState?.(state);
+        await delay(interval, options.signal);
+        interval = Math.min(Math.round(interval * 1.5), options.maxIntervalMs);
+        state = await poll();
+    }
+    return state;
+}
+function delay(ms, signal) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        function onAbort() {
+            clearTimeout(timer);
+            resolve();
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/dist/cli/models.d.ts

@@ -0,0 +1,36 @@
+import { type RegistryData } from '../models/data.js';
+import { type ParsedArgs } from './args.js';
+/** How the command reaches the outside: replaced in tests. */
+export interface ModelsCommandIo {
+    fetch: typeof fetch;
+    env: Record<string, string | undefined>;
+}
+/**
+ * `nexus models export | check | refresh`: registry data as a file the application keeps.
+ *
+ * `export` writes the bundled data, as a file to start from. `check` validates a file and says how it
+ * differs from the bundled data. `refresh` lists each provider's models with the keys in the
+ * environment and compares them with the data: what the data lacks, and what the provider no longer
+ * lists. Prices are not in any provider's model list, so they stay a check against its pricing page.
+ */
+export declare function runModelsCommand(subcommand: string, { positionals, flags }: ParsedArgs, io?: ModelsCommandIo): Promise<void>;
+/** How the data compares with what one provider lists. */
+export interface RefreshRow {
+    /** The provider. */
+    provider: string;
+    /** Models the provider lists that the data does not have. */
+    missing: string[];
+    /** Models the data has for the provider that it no longer lists. */
+    unlisted: string[];
+}
+/** Compares registry data with each provider's model list, completion and embedding models alike. */
+export declare function refreshReport(data: RegistryData, listings: Record<string, string[]>): RefreshRow[];
+interface ProviderList {
+    /** The environment variable that holds its key. */
+    env: string;
+    /** Every model id it lists. */
+    list(key: string, fetch: typeof globalThis.fetch): Promise<string[]>;
+}
+/** Each provider's own model list, read with the application's key: nothing else is contacted. */
+export declare const PROVIDER_LISTS: Record<string, ProviderList>;
+export {};

package/dist/cli/models.js

@@ -0,0 +1,170 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { bundledRegistryData, checkRegistryData, diffRegistryData, } from '../models/data.js';
+import { CliUsageError, flagBool, listFlag, printTable, stringFlag, writeJson } from './args.js';
+export async function runModelsCommand(subcommand, { positionals, flags }, io = { fetch: globalThis.fetch, env: process.env }) {
+    if (subcommand === 'export') {
+        const text = `${JSON.stringify(bundledRegistryData(), null, 2)}\n`;
+        const out = stringFlag(flags, 'out');
+        if (out) {
+            await writeFile(out, text);
+            console.log(`Wrote the bundled registry data to ${out}.`);
+        }
+        else
+            process.stdout.write(text);
+        return;
+    }
+    if (subcommand === 'check') {
+        const file = positionals[0];
+        if (!file)
+            throw new CliUsageError('Usage: nexus models check <registry.json> [--json]');
+        const text = await readFile(file, 'utf8');
+        const problems = checkRegistryData(text);
+        const diff = problems.length
+            ? undefined
+            : diffRegistryData(bundledRegistryData(), JSON.parse(text));
+        if (flagBool(flags, 'json'))
+            writeJson({ valid: problems.length === 0, problems, diff });
+        else if (problems.length) {
+            console.error(`${file} is not valid registry data:`);
+            for (const problem of problems)
+                console.error(`  - ${problem}`);
+        }
+        else
+            printDiff(file, diff);
+        if (problems.length)
+            process.exitCode = 1;
+        return;
+    }
+    if (subcommand === 'refresh') {
+        const file = stringFlag(flags, 'file');
+        const data = file ? JSON.parse(await readFile(file, 'utf8')) : bundledRegistryData();
+        const wanted = listFlag(flags, 'providers') ?? Object.keys(PROVIDER_LISTS);
+        const unknown = wanted.filter((provider) => !(provider in PROVIDER_LISTS));
+        if (unknown.length) {
+            throw new CliUsageError(`Unknown provider ${unknown.join(', ')}. Choose from ${Object.keys(PROVIDER_LISTS).join(', ')}.`);
+        }
+        const listings = {};
+        const skipped = [];
+        for (const provider of wanted) {
+            const source = PROVIDER_LISTS[provider];
+            const key = io.env[source.env];
+            if (!key) {
+                skipped.push(`${provider} (no ${source.env})`);
+                continue;
+            }
+            listings[provider] = await source.list(key, io.fetch);
+        }
+        const report = refreshReport(data, listings);
+        if (flagBool(flags, 'json'))
+            writeJson({ report, skipped });
+        else
+            printRefresh(report, skipped);
+        if (flagBool(flags, 'strict') && report.some((row) => row.missing.length || row.unlisted.length))
+            process.exitCode = 1;
+        return;
+    }
+    throw new CliUsageError(`Unknown models command "${subcommand}". Use export, check, or refresh, or no command to list.`);
+}
+export function refreshReport(data, listings) {
+    return Object.entries(listings).map(([provider, listed]) => {
+        const known = new Set([
+            ...Object.entries(data.models)
+                .filter(([, entry]) => entry.provider === provider)
+                .map(([name]) => name),
+            ...Object.entries(data.embeddingModels ?? {})
+                .filter(([, entry]) => entry.provider === provider)
+                .map(([name]) => name),
+        ]);
+        const offered = new Set(listed);
+        return {
+            provider,
+            missing: [...offered].filter((name) => !known.has(name)).sort(),
+            unlisted: [...known].filter((name) => !offered.has(name)).sort(),
+        };
+    });
+}
+export const PROVIDER_LISTS = {
+    openai: { env: 'OPENAI_API_KEY', list: openAiStyle('https://api.openai.com/v1/models') },
+    anthropic: {
+        env: 'ANTHROPIC_API_KEY',
+        async list(key, fetch) {
+            const ids = [];
+            let after;
+            for (;;) {
+                const page = (await getJson(fetch, `https://api.anthropic.com/v1/models?limit=1000${after ? `&after_id=${encodeURIComponent(after)}` : ''}`, { 'x-api-key': key, 'anthropic-version': '2023-06-01' }));
+                ids.push(...(page.data ?? []).map((model) => model.id));
+                if (!page.has_more || !page.last_id)
+                    return ids;
+                after = page.last_id;
+            }
+        },
+    },
+    google: {
+        env: 'GOOGLE_API_KEY',
+        async list(key, fetch) {
+            const ids = [];
+            let token;
+            for (;;) {
+                const page = (await getJson(fetch, `https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000${token ? `&pageToken=${encodeURIComponent(token)}` : ''}`, { 'x-goog-api-key': key }));
+                ids.push(...(page.models ?? []).map((model) => model.name.replace(/^models\//, '')));
+                if (!page.nextPageToken)
+                    return ids;
+                token = page.nextPageToken;
+            }
+        },
+    },
+    mistral: { env: 'MISTRAL_API_KEY', list: openAiStyle('https://api.mistral.ai/v1/models') },
+    cohere: {
+        env: 'COHERE_API_KEY',
+        async list(key, fetch) {
+            const ids = [];
+            let token;
+            for (;;) {
+                const page = (await getJson(fetch, `https://api.cohere.com/v1/models?page_size=1000${token ? `&page_token=${encodeURIComponent(token)}` : ''}`, { authorization: `Bearer ${key}` }));
+                ids.push(...(page.models ?? []).map((model) => model.name));
+                if (!page.next_page_token)
+                    return ids;
+                token = page.next_page_token;
+            }
+        },
+    },
+    groq: { env: 'GROQ_API_KEY', list: openAiStyle('https://api.groq.com/openai/v1/models') },
+    deepseek: { env: 'DEEPSEEK_API_KEY', list: openAiStyle('https://api.deepseek.com/models') },
+};
+function openAiStyle(url) {
+    return async (key, fetch) => {
+        const page = (await getJson(fetch, url, { authorization: `Bearer ${key}` }));
+        return (page.data ?? []).map((model) => model.id);
+    };
+}
+async function getJson(fetch, url, headers) {
+    const response = await fetch(url, { headers });
+    if (!response.ok)
+        throw new Error(`${new URL(url).host} answered ${response.status} listing its models`);
+    return response.json();
+}
+function printDiff(file, diff) {
+    console.log(`${file} is valid registry data. Against the bundled data:`);
+    console.log(`  ${diff.added.length} added, ${diff.removed.length} removed, ${diff.changed.length} changed, ${diff.aliases.length} aliases moved`);
+    for (const name of diff.added)
+        console.log(`  + ${name}`);
+    for (const name of diff.removed)
+        console.log(`  - ${name}`);
+    for (const { model, changes } of diff.changed) {
+        console.log(`  ~ ${model}: ${changes.map(({ field, from, to }) => `${field} ${JSON.stringify(from)} -> ${JSON.stringify(to)}`).join(', ')}`);
+    }
+    for (const { alias, from, to } of diff.aliases)
+        console.log(`  @ ${alias}: ${from ?? '(none)'} -> ${to ?? '(none)'}`);
+}
+function printRefresh(report, skipped) {
+    if (report.length) {
+        printTable(report.map((row) => ({
+            provider: row.provider,
+            'listed, not in the data': row.missing.join(', ') || '-',
+            'in the data, not listed': row.unlisted.join(', ') || '-',
+        })), ['provider', 'listed, not in the data', 'in the data, not listed']);
+    }
+    if (skipped.length)
+        console.log(`Skipped: ${skipped.join(', ')}.`);
+    console.log('Prices are not in any provider list: check new and changed entries against each pricing page.');
+}

package/dist/cli.js

@@ -24,9 +24,16 @@ async function main() {
         case 'scan':
             await runScan(parsed);
             return;
-        case 'models':
+        case 'models': {
+            const [subcommand, ...args] = parsed.positionals;
+            if (subcommand) {
+                const { runModelsCommand } = await import('./cli/models.js');
+                await runModelsCommand(subcommand, { ...parsed, positionals: args });
+                return;
+            }
             runModels(parsed);
             return;
+        }
         case 'eval': {
             const [subcommand, ...args] = parsed.positionals;
             if (subcommand === 'run' || subcommand === 'compare' || subcommand === 'gate') {
@@ -401,6 +408,9 @@ function printHelp() {
 Usage:
   nexus scan [paths...] [--json] [--max-bytes 1000000] [--no-fail] [--reveal-values]
   nexus models [--provider openai] [--json]
+  nexus models export [--out registry.json]
+  nexus models check <registry.json> [--json]
+  nexus models refresh [--file registry.json] [--providers openai,anthropic] [--strict] [--json]
   nexus eval <eval.json|eval.mjs> [--json]
   nexus eval run <eval.mjs> [--out experiment.json] [--experiments dir] [--baseline baseline.json] [--fail-on-regression]
                  [--name n] [--concurrency 4] [--repetitions 1] [--timeout-ms n] [--json]

package/dist/doctor/index.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Checks a deployment before it serves traffic: the runtime, credentials, the database and its
+ * migrations, Redis, the operation queue, the model registry, provider health, and settings that
+ * only work in one process. `nexus doctor` runs the same checks from a shell.
+ *
+ * Every check is cheap and read-only, and anything heavy — the model registry, the migration lists —
+ * is loaded only when its check runs, so an application can call `diagnose()` at boot or from a
+ * health endpoint.
+ */
+import type { NexusAIConfig } from '../types/config.js';
 import type { SchemaMigration } from '../utils/schema-migrations.js';
 /** How one check came out: `fail` breaks the deployment, `warn` needs a look, `skip` had nothing to check. */
 export type DoctorStatus = 'ok' | 'warn' | 'fail' | 'skip';
@@ -78,8 +88,13 @@ export interface DoctorOptions {
             stale?: boolean;
         }>;
     };
-    /** How old the bundled model registry may be, in days. Defaults to the registry's own window. */
+    /** How old the model registry may be, in days. Defaults to the registry's own window. */
     registryMaxAgeDays?: number;
+    /**
+     * The application's model registry configuration, such as `withRegistryData()` produced, so the
+     * registry's age is measured from the data it supplies rather than the bundled data.
+     */
+    models?: NexusAIConfig['models'];
     /** How the application is deployed. */
     deployment?: DoctorDeployment;
     /** Replaces the clock, for tests. */

package/dist/doctor/index.js

@@ -47,7 +47,7 @@ export async function diagnose(options = {}) {
     await run('node', 'Node.js version', () => nodeCheck(options.nodeVersion ?? process.versions.node));
     await run('peers', 'Optional packages', () => peersCheck(options.resolvePackage ?? defaultResolver()));
     await run('credentials', 'Provider credentials', () => credentialsCheck(options.env ?? process.env));
-    await run('registry', 'Model registry age', () => registryCheck(now(), options.registryMaxAgeDays));
+    await run('registry', 'Model registry age', () => registryCheck(now(), options.registryMaxAgeDays, options.models));
     await run('database', 'Database connectivity', () => databaseCheck(options.database));
     await run('migrations', 'Schema migrations', () => migrationsCheck(options.database));
     await run('redis', 'Redis', () => redisCheck(options.redis));
@@ -97,14 +97,19 @@ function credentialsCheck(env) {
             hint: 'Set the API key of each hosted provider you use, such as OPENAI_API_KEY. Local providers need none.',
         };
 }
-async function registryCheck(now, maxAgeDays) {
+async function registryCheck(now, maxAgeDays, models) {
     const { checkRegistryFreshness } = await import('../models/registry.js');
-    const freshness = checkRegistryFreshness({ now, ...(maxAgeDays === undefined ? {} : { maxAgeDays }) });
+    const freshness = checkRegistryFreshness({
+        now,
+        ...(maxAgeDays === undefined ? {} : { maxAgeDays }),
+        ...(models ? { config: { models } } : {}),
+    });
+    const which = models?.verifiedAt ? 'supplied' : 'bundled';
     return freshness.stale
         ? {
             status: 'warn',
-            detail: `The bundled registry was verified ${freshness.ageDays} days ago (${freshness.verifiedAt}), past its ${freshness.maxAgeDays}-day window.`,
-            hint: 'Upgrade nexus-ai-pro, or override stale entries with models.registry.',
+            detail: `The ${which} registry was verified ${freshness.ageDays} days ago (${freshness.verifiedAt}), past its ${freshness.maxAgeDays}-day window.`,
+            hint: 'Supply newer registry data with withRegistryData(), checked by nexus models check, or upgrade nexus-ai-pro.',
         }
         : { status: 'ok', detail: `Verified ${freshness.ageDays} days ago (${freshness.verifiedAt}).` };
 }

package/dist/embeddings/adapters.d.ts

@@ -52,7 +52,7 @@ export declare class GoogleEmbeddingProvider extends HttpEmbeddingProvider {
     readonly info: EmbeddingProviderInfo;
     constructor(options?: EmbeddingAdapterOptions);
     protected authHeaders(): Record<string, string>;
-    /** Embeds a batch of texts. */
+    /** Embeds a batch of inputs: texts, or parts with images, audio, and documents. */
     embed(request: EmbeddingProviderRequest, context: EmbeddingProviderCallContext): Promise<EmbeddingProviderResult>;
 }
 /** Cohere v2 `/embed`. */
@@ -60,7 +60,7 @@ export declare class CohereEmbeddingProvider extends HttpEmbeddingProvider {
     /** Provider name, capabilities, and models. */
     readonly info: EmbeddingProviderInfo;
     constructor(options?: EmbeddingAdapterOptions);
-    /** Embeds a batch of texts. */
+    /** Embeds a batch of inputs: texts, or parts with images. */
     embed(request: EmbeddingProviderRequest, context: EmbeddingProviderCallContext): Promise<EmbeddingProviderResult>;
 }
 /** Mistral `/v1/embeddings`, which follows the OpenAI request and response shape. */