nexus-ai-pro 2.20.2 → 2.22.0

package/dist/decisions/integrations.js

@@ -1,3 +1,4 @@
+import { boxOverlap, } from './core.js';
 export function decisionRoute(decisions, options) {
     return async (graph) => {
         const { answers } = await decisions.decide({
@@ -128,9 +129,23 @@ export function decisionEvaluator(decisions, options) {
         const answer = answers.judged;
         const metadata = {
             confidence: answer.confidence,
-            probabilities: answer.type === 'yes-no' ? { yes: answer.probability } : answer.probabilities,
+            ...(answer.type === 'box'
+                ? { box: answer.box }
+                : { probabilities: answer.type === 'yes-no' ? { yes: answer.probability } : answer.probabilities }),
             model,
         };
+        if (answer.type === 'box') {
+            const where = options.where?.(context);
+            if (!where)
+                return { key: options.key, score: answer.confidence, metadata };
+            const overlap = boxOverlap(answer.box, where);
+            return {
+                key: options.key,
+                score: overlap,
+                passed: overlap >= (options.overlap ?? 0.5),
+                metadata,
+            };
+        }
         if (answer.type === 'yes-no') {
             const passWhen = options.passing !== false;
             return {

package/dist/decisions/mock.d.ts

@@ -7,8 +7,9 @@ export interface MockDecisionProviderOptions {
     /** The model it reports. Defaults to `mock-decision`. */
     model?: string;
     /**
-     * Answers each question with its probabilities, from the question's name, the question, and the
-     * state. Returning `undefined`, or leaving it out, answers with an even spread: confidence 0.
+     * Answers each question with its probabilities, or a box, from the question's name, the question,
+     * and the state, pictures and all. Returning `undefined`, or leaving it out, answers with an even
+     * spread, and a box with the whole picture: confidence 0.
      */
     answer?: (name: string, question: DecisionProviderQuestion, state: DecisionState) => DecisionDistribution | undefined;
     /** Fails every call with this error, or the error the function returns. */
@@ -18,7 +19,8 @@ export interface MockDecisionProviderOptions {
 }
 /**
  * Answers decisions as `answer` says, without a model, and keeps every request it was asked in
- * `requests`. It takes every question type, 255 options, and 10 levels, as TypeSafe AI's Jev does.
+ * `requests`. It takes every question type, pictures, 255 options, and 10 levels, as TypeSafe AI's Jev
+ * does.
  */
 export declare class MockDecisionProvider implements DecisionProvider {
     private readonly options;

package/dist/decisions/mock.js

@@ -7,9 +7,10 @@ export class MockDecisionProvider {
         this.info = {
             name: options.name ?? 'mock',
             capabilities: {
-                types: ['yes-no', 'choice', 'score'],
+                types: ['yes-no', 'choice', 'score', 'box'],
                 maxOptions: 255,
                 maxLevels: 10,
+                images: true,
                 defaultModel: options.model ?? 'mock-decision',
             },
         };
@@ -37,6 +38,8 @@ export class MockDecisionProvider {
 function evenly(question) {
     if (question.type === 'yes-no')
         return { type: 'yes-no', yes: 0.5 };
+    if (question.type === 'box')
+        return { type: 'box', box: { top: 0, bottom: 1, left: 0, right: 1 }, confidence: 0 };
     if (question.type === 'choice') {
         return {
             type: 'choice',

package/dist/decisions/pictures.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The pictures a decision's state holds: image parts, or image assets, anywhere in an object or a
+ * list, each named by its path, which a question writes in backticks, such as `photo`, `faces.happy`,
+ * or `frames[2].frame`.
+ */
+import { type MediaResolveOptions } from '../evaluate/media.js';
+import type { MediaPart } from '../types/evaluate.js';
+/** A picture in a decision's state, and where it is. */
+export interface DecisionPicture {
+    /** Its path in the state, as a question names it in backticks: `photo`, `faces.happy`, or `frames[2].frame`. */
+    path: string;
+    /** The picture: an image part, `{ type: 'image', source }`, or an image asset. */
+    part: MediaPart;
+}
+/** A picture's bytes, read for a provider that sends them. */
+export interface ReadDecisionPicture extends DecisionPicture {
+    /** Its bytes. */
+    bytes: Uint8Array;
+    /** Its MIME type, as its first bytes say, whatever it was declared as. */
+    mimeType: string;
+    /** Its width in pixels, from its header. */
+    width?: number;
+    /** Its height in pixels. */
+    height?: number;
+}
+/** Every picture in a state, in the order they appear, each with its path. A picture used twice is listed at both. */
+export declare function statePictures(state: unknown): DecisionPicture[];
+/**
+ * The state with each picture replaced by what `replace` returns for it, copying only the objects and
+ * lists on the way to one, so a state without pictures comes back as it was given.
+ */
+export declare function replacePictures(state: unknown, replace: (picture: DecisionPicture) => unknown): unknown;
+/**
+ * Identifies a picture without its bytes, for a cache key or a trace: a digest of what it holds, or
+ * where it is when it is a file or at a URL, so a picture changed at the same path is keyed the same.
+ */
+export declare function pictureDigest(part: MediaPart): string;
+/**
+ * Reads a picture's bytes, with the media family's readers: bytes and base64 as they are, a file with
+ * `readFile`, a URL with `fetch`, and a stored asset from `assets`. Throws `DecisionError`
+ * `DECISION_INVALID`, naming the picture's path, for one that cannot be read or is not a picture.
+ */
+export declare function readPicture(picture: DecisionPicture, options?: MediaResolveOptions): Promise<ReadDecisionPicture>;

package/dist/decisions/pictures.js

@@ -0,0 +1,103 @@
+import { resolveMedia } from '../evaluate/media.js';
+import { asMediaPart } from '../evaluate/trace.js';
+import { sha256Hex } from '../utils/sha256.js';
+import { DecisionError } from './errors.js';
+const MAX_DEPTH = 256;
+export function statePictures(state) {
+    const found = [];
+    replacePictures(state, (picture) => {
+        found.push(picture);
+        return picture.part;
+    });
+    return found;
+}
+export function replacePictures(state, replace) {
+    const above = new Set();
+    const visit = (item, path, depth) => {
+        if (item === null || typeof item !== 'object' || depth > MAX_DEPTH || above.has(item))
+            return item;
+        if (ArrayBuffer.isView(item) || item instanceof ArrayBuffer)
+            return item;
+        const part = pictureOf(item);
+        if (part)
+            return replace({ path, part });
+        above.add(item);
+        try {
+            if (Array.isArray(item)) {
+                let changed = false;
+                const copy = item.map((entry, index) => {
+                    const next = visit(entry, `${path}[${index}]`, depth + 1);
+                    if (next !== entry)
+                        changed = true;
+                    return next;
+                });
+                return changed ? copy : item;
+            }
+            const prototype = Object.getPrototypeOf(item);
+            if (prototype !== Object.prototype && prototype !== null)
+                return item;
+            let changed = false;
+            const copy = {};
+            for (const [key, entry] of Object.entries(item)) {
+                const next = visit(entry, path ? `${path}.${key}` : key, depth + 1);
+                if (next !== entry)
+                    changed = true;
+                copy[key] = next;
+            }
+            return changed ? copy : item;
+        }
+        finally {
+            above.delete(item);
+        }
+    };
+    return visit(state, '', 0);
+}
+export function pictureDigest(part) {
+    const source = (part.type === 'asset' ? part.asset.location : part.source);
+    if (typeof source.base64 === 'string')
+        return `sha256:${sha256Hex(source.base64)}`;
+    const bytes = source.buffer ?? source.data;
+    if (bytes instanceof Uint8Array)
+        return `sha256:${sha256Hex(bytes)}`;
+    if (typeof source.path === 'string')
+        return `path:${source.path}`;
+    if (typeof source.url === 'string')
+        return `url:${source.url}`;
+    if (typeof source.assetId === 'string')
+        return `asset:${source.assetId}`;
+    if (source.asset && typeof source.asset === 'object')
+        return pictureDigest({ type: 'asset', asset: source.asset });
+    return `sha256:${sha256Hex(JSON.stringify(source) ?? '')}`;
+}
+export async function readPicture(picture, options = {}) {
+    const media = await resolveMedia(picture.part, options);
+    if (!media.bytes) {
+        const why = media.unreadable ??
+            (media.path !== undefined
+                ? `it is the file ${media.path}, and no readFile was given to read it`
+                : media.url !== undefined
+                    ? `it is at ${media.url}, and no fetch was given to fetch it`
+                    : 'it holds no bytes');
+        throw new DecisionError(`The picture at \`${picture.path}\` could not be read: ${why}`, 'DECISION_INVALID');
+    }
+    if (media.kind !== 'image' || !media.mimeType?.startsWith('image/')) {
+        throw new DecisionError(`The picture at \`${picture.path}\` is not an image its bytes name${media.mimeType ? `, but ${media.mimeType}` : ''}`, 'DECISION_INVALID');
+    }
+    return {
+        ...picture,
+        bytes: media.bytes,
+        mimeType: media.mimeType,
+        ...(media.width !== undefined ? { width: media.width } : {}),
+        ...(media.height !== undefined ? { height: media.height } : {}),
+    };
+}
+function pictureOf(item) {
+    const part = asMediaPart(item);
+    if (!part)
+        return undefined;
+    if (part.type === 'image')
+        return part;
+    if (part.type === 'asset' && part.asset.mimeType.startsWith('image/'))
+        return part;
+    return undefined;
+}

package/dist/decisions/typesafe.d.ts

@@ -1,4 +1,10 @@
-import { type DecisionCallContext, type DecisionProvider, type DecisionProviderInfo, type DecisionProviderRequest, type DecisionProviderResult } from './core.js';
+/**
+ * TypeSafe AI's decision models, Jev first, over its System One API: every question of a decision in
+ * one call, each answered with its probabilities, or with a box around something in a picture, and no
+ * text to parse.
+ */
+import type { MediaResolveOptions } from '../evaluate/media.js';
+import type { DecisionCallContext, DecisionProvider, DecisionProviderInfo, DecisionProviderRequest, DecisionProviderResult } from './core.js';
 /** Options for `TypeSafeDecisionProvider`. */
 export interface TypeSafeDecisionProviderOptions {
     /** A TypeSafe AI API key, from its console. A tenant's resolved credential replaces it per call. */
@@ -15,6 +21,18 @@ export interface TypeSafeDecisionProviderOptions {
      * than its usual context, and marks as experimental.
      */
     longContext?: boolean;
+    /**
+     * Reads the pictures a state holds by reference, with the media family's readers: `readFile` for a
+     * file, `fetch` for a URL, and `assets` for a stored asset. A picture held as bytes or base64 needs
+     * none of them. Without them, a picture by reference fails the decision, naming it.
+     */
+    media?: MediaResolveOptions;
+    /**
+     * How a decision's pictures travel: `multipart`, the default, each as a part of its own beside the
+     * request, as bytes; or `base64`, within the JSON request, a third larger. Either way a request
+     * holds at most 32 MiB, so multipart carries more.
+     */
+    pictures?: 'multipart' | 'base64';
     /** How long a call may take before it fails, in milliseconds. Defaults to 30 seconds. */
     timeoutMs?: number;
     /** Headers added to every request. */
@@ -24,9 +42,12 @@ export interface TypeSafeDecisionProviderOptions {
 }
 /**
  * TypeSafe AI's System One API (`POST /v1/systemone`): Jev, a model that answers only typed
- * questions, a yes or no ("noul"), a choice among up to 255 options, or a score on up to ten levels,
- * each with its probabilities, and bills for input tokens alone. Every question of a decision goes in
- * one call and is answered in isolation, against the same state.
+ * questions, a yes or no ("noul"), a choice among up to 255 options, a score on up to ten levels, or a
+ * box around something in a picture, and bills for input tokens alone. Every question of a decision
+ * goes in one call and is answered in isolation, against the same state. The pictures a state holds
+ * are sent as the API's assets, each as a part of a multipart request unless `pictures` says
+ * `base64`, with the `TypeSafe-Danger-Zone-Images` header it requires for them and for a box, both of
+ * which it marks as experimental; a box needs Jev 1.14 or later.
  *
  * ```ts
  * const decisions = new DecisionManager({ providers: { jev: new TypeSafeDecisionProvider({ apiKey: process.env.TYPESAFE_API_KEY! }) } });
@@ -34,12 +55,19 @@ export interface TypeSafeDecisionProviderOptions {
  */
 export declare class TypeSafeDecisionProvider implements DecisionProvider {
     private readonly options;
-    /** Its name and what it takes: every question type, 255 options, and 10 levels. */
+    /** Its name and what it takes: every question type, pictures, 255 options, and 10 levels. */
     readonly info: DecisionProviderInfo;
     constructor(options: TypeSafeDecisionProviderOptions);
     /** Answers every question of a decision in one call. */
     decide(request: DecisionProviderRequest, context: DecisionCallContext): Promise<DecisionProviderResult>;
     /** The models the key may use, from `GET /v1/models`. */
     listModels(context?: Partial<DecisionCallContext>): Promise<string[]>;
+    /**
+     * The state with each picture replaced by a reference of its own, and the pictures as assets by those
+     * references; a state without pictures as it was. A new reference per picture per request, as the
+     * API advises, since it matches a reference wherever its text appears. Sent multipart, each picture's
+     * part is named by its reference too.
+     */
+    private withAssets;
     private call;
 }

package/dist/decisions/typesafe.js

@@ -1,5 +1,11 @@
+import { encodeBase64 } from '../utils/base64.js';
 import { linkSignals } from '../utils/signals.js';
-import { DecisionError, } from './core.js';
+import { DecisionError } from './errors.js';
+import { readPicture, replacePictures, statePictures } from './pictures.js';
+const PICTURE_BYTES = 16 * 1024 * 1024;
+const PICTURE_SIDE = { min: 280, max: 1568 };
+const REQUEST_BYTES = 32 * 1024 * 1024;
+const PART_OVERHEAD = 256;
 export class TypeSafeDecisionProvider {
     options;
     info;
@@ -8,16 +14,40 @@ export class TypeSafeDecisionProvider {
         this.info = {
             name: 'typesafe',
             capabilities: {
-                types: ['yes-no', 'choice', 'score'],
+                types: ['yes-no', 'choice', 'score', 'box'],
                 maxOptions: 255,
                 maxLevels: 10,
+                images: true,
                 defaultModel: options.model ?? 'jev-latest',
             },
         };
     }
     async decide(request, context) {
+        context.signal.throwIfAborted();
+        const boxes = Object.keys(request.questions).filter((name) => request.questions[name]?.type === 'box');
+        const before = boxes.length ? beforeBoxes(request.model) : undefined;
+        if (before) {
+            throw new DecisionError(`TypeSafe AI answers a box, such as "${boxes[0]}", on Jev 1.14 or later, not ${before}`, 'DECISION_UNSUPPORTED');
+        }
+        const multipart = (this.options.pictures ?? 'multipart') === 'multipart';
+        const { state, assets, parts } = await this.withAssets(request.state, context, multipart);
         const questions = Object.fromEntries(Object.entries(request.questions).map(([name, question]) => [name, wireQuestion(question)]));
-        const payload = await this.call('/v1/systemone', { method: 'POST', body: JSON.stringify({ model: request.model, state: request.state, questions }) }, context);
+        const json = JSON.stringify({ model: request.model, state, questions, ...(assets ? { assets } : {}) });
+        const size = new TextEncoder().encode(json).byteLength +
+            (parts.length ? parts.reduce((total, part) => total + part.bytes.byteLength + PART_OVERHEAD, PART_OVERHEAD) : 0);
+        if (assets && size > REQUEST_BYTES) {
+            throw new DecisionError(`The decision is ${size} bytes with its pictures, and TypeSafe AI takes at most ${REQUEST_BYTES}`, 'DECISION_INVALID');
+        }
+        let body = json;
+        if (parts.length) {
+            const form = new FormData();
+            form.append('request', json);
+            for (const part of parts) {
+                form.append(part.name, new Blob([part.bytes], { type: `image/${part.format}` }), `${part.name}.${part.format === 'png' ? 'png' : 'jpg'}`);
+            }
+            body = form;
+        }
+        const payload = await this.call('/v1/systemone', { method: 'POST', body }, context, assets || boxes.length ? { 'TypeSafe-Danger-Zone-Images': 'true' } : {});
         const distributions = {};
         for (const [name, question] of Object.entries(request.questions)) {
             const answer = payload.answers?.[name];
@@ -51,7 +81,29 @@ export class TypeSafeDecisionProvider {
             : String(item?.id ?? item?.name ?? ''))
             .filter(Boolean);
     }
-    async call(path, init, context) {
+    async withAssets(state, context, multipart) {
+        const pictures = typeof state === 'string' ? [] : statePictures(state);
+        if (pictures.length === 0)
+            return { state, parts: [] };
+        const read = await Promise.all(pictures.map((picture) => readPicture(picture, this.options.media)));
+        context.signal.throwIfAborted();
+        const references = new Map();
+        const assets = {};
+        const parts = [];
+        for (const picture of read) {
+            const format = fitting(picture);
+            const reference = globalThis.crypto.randomUUID();
+            references.set(picture.path, reference);
+            if (multipart) {
+                assets[reference] = { type: 'image', format, part: reference };
+                parts.push({ name: reference, format, bytes: picture.bytes });
+            }
+            else
+                assets[reference] = { type: 'image', format, data_base64: encodeBase64(picture.bytes) };
+        }
+        return { state: replacePictures(state, (picture) => references.get(picture.path)), assets, parts };
+    }
+    async call(path, init, context, extra = {}) {
         const credential = await context.credential?.(this.info.name);
         const linked = linkSignals([context.signal, AbortSignal.timeout(this.options.timeoutMs ?? 30_000)]);
         const signal = linked.signal;
@@ -61,9 +113,10 @@ export class TypeSafeDecisionProvider {
             response = await (this.options.fetch ?? fetch)(`${(this.options.baseUrl ?? 'https://api.typesafe.ai').replace(/\/+$/, '')}${path}`, {
                 ...init,
                 headers: {
-                    ...(init.body ? { 'content-type': 'application/json' } : {}),
+                    ...(typeof init.body === 'string' ? { 'content-type': 'application/json' } : {}),
                     authorization: `Bearer ${credential?.apiKey ?? this.options.apiKey}`,
                     ...(this.options.longContext ? { 'TypeSafe-Danger-Zone-Long-Context': 'true' } : {}),
+                    ...extra,
                     ...this.options.headers,
                     ...credential?.headers,
                 },
@@ -89,7 +142,51 @@ export class TypeSafeDecisionProvider {
         }
     }
 }
+function beforeBoxes(model) {
+    const version = /^jev-(\d+)\.(\d+)/.exec(model);
+    if (!version)
+        return undefined;
+    const [major, minor] = [Number(version[1]), Number(version[2])];
+    return major < 1 || (major === 1 && minor < 14) ? model : undefined;
+}
+function fitting(picture) {
+    const at = `The picture at \`${picture.path}\``;
+    const refuse = (why) => new DecisionError(`${at} ${why}; TypeSafe AI refuses it rather than convert or resize it`, 'DECISION_INVALID');
+    if (picture.mimeType !== 'image/png' && picture.mimeType !== 'image/jpeg') {
+        throw refuse(`is ${picture.mimeType}, and TypeSafe AI takes PNG and JPEG`);
+    }
+    if (picture.mimeType === 'image/png' && animated(picture.bytes))
+        throw refuse('is an animated PNG');
+    if (picture.bytes.length > PICTURE_BYTES) {
+        throw refuse(`is ${picture.bytes.length} bytes, over TypeSafe AI's ${PICTURE_BYTES}`);
+    }
+    const { width, height } = picture;
+    if (width === undefined || height === undefined)
+        throw refuse('has a header its size cannot be read from');
+    if ([width, height].some((side) => side < PICTURE_SIDE.min || side > PICTURE_SIDE.max)) {
+        throw refuse(`is ${width} by ${height} pixels, and TypeSafe AI takes ${PICTURE_SIDE.min} to ${PICTURE_SIDE.max} a side`);
+    }
+    return picture.mimeType === 'image/png' ? 'png' : 'jpeg';
+}
+function animated(bytes) {
+    let offset = 8;
+    while (offset + 8 <= bytes.length) {
+        const length = ((bytes[offset] ?? 0) << 24) |
+            ((bytes[offset + 1] ?? 0) << 16) |
+            ((bytes[offset + 2] ?? 0) << 8) |
+            (bytes[offset + 3] ?? 0);
+        const type = String.fromCharCode(...bytes.subarray(offset + 4, offset + 8));
+        if (type === 'acTL')
+            return true;
+        if (type === 'IDAT' || type === 'IEND' || length < 0)
+            return false;
+        offset += 12 + length;
+    }
+    return false;
+}
 function wireQuestion(question) {
+    if (question.type === 'box')
+        return { type: 'box', instructions: question.question };
     const instructions = question.question ? { instructions: question.question } : {};
     if (question.type === 'yes-no') {
         const criteria = {
@@ -118,21 +215,37 @@ function distributionOf(name, question, answer) {
             throw invalidAnswer(name, 'choice', answer);
         return { type: 'choice', probabilities: answer.probabilities };
     }
+    if (question.type === 'box') {
+        const box = answer.box;
+        if (!box || typeof answer.confidence !== 'number')
+            throw invalidAnswer(name, 'box', answer);
+        const edges = box;
+        return {
+            type: 'box',
+            box: { top: edges.top, bottom: edges.bottom, left: edges.left, right: edges.right },
+            confidence: answer.confidence,
+        };
+    }
     if (!answer.probabilities)
         throw invalidAnswer(name, 'score', answer);
     const probabilities = answer.probabilities;
     return { type: 'score', probabilities: question.levels.map((_, level) => probabilities[String(level)] ?? 0) };
 }
 function invalidAnswer(name, type, answer) {
-    return new DecisionError(`TypeSafe AI answered "${name}" without the ${type} probabilities it asks for: ${JSON.stringify(answer).slice(0, 200)}`, 'DECISION_FAILED');
+    return new DecisionError(`TypeSafe AI answered "${name}" without the ${type} it asks for: ${JSON.stringify(answer).slice(0, 200)}`, 'DECISION_FAILED');
 }
 function failure(status, text) {
-    if (status === 422) {
+    if (status === 422 || status === 400 || status === 413) {
         let detail = text.slice(0, 300);
         try {
             const parsed = JSON.parse(text);
             if (Array.isArray(parsed.detail)) {
-                detail = parsed.detail.map((item) => `${(item.loc ?? []).join('.')}: ${item.msg ?? 'invalid'}`).join('; ');
+                detail = parsed.detail
+                    .map((item) => `${(item.loc ?? []).join('.')}: ${item.msg ?? 'invalid'}`)
+                    .join('; ');
+            }
+            else if (typeof parsed.detail === 'string') {
+                detail = parsed.detail;
             }
         }
         catch {

package/dist/doctor/index.d.ts

@@ -1,12 +1,3 @@
-/**
- * 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. */
@@ -97,6 +88,12 @@ export interface DoctorOptions {
     models?: NexusAIConfig['models'];
     /** How the application is deployed. */
     deployment?: DoctorDeployment;
+    /**
+     * A release to check readiness for: `3.0` lists, for the stores `deployment` describes, what 3.0's
+     * defaults would change and what to do first, or confirms the preview of them is on. Without it, the
+     * check is skipped.
+     */
+    upgrade?: '3.0';
     /** Replaces the clock, for tests. */
     now?: () => Date;
 }

package/dist/doctor/index.js

@@ -1,3 +1,4 @@
+import { nexusDefaults } from '../core/defaults.js';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 const PEERS = {
@@ -55,6 +56,7 @@ export async function diagnose(options = {}) {
     await run('health', 'Provider health', () => healthCheck(options.ai));
     await run('topology', 'Settings that only work in one process', () => topologyCheck(options.deployment));
     await run('settings', 'Opt-in settings a deployment needs', () => settingsCheck(options.deployment));
+    await run('upgrade', 'What 3.0 changes', () => upgradeCheck(options.upgrade, options.deployment));
     const failures = checks.filter((check) => check.status === 'fail').length;
     const warnings = checks.filter((check) => check.status === 'warn').length;
     return { checks, ok: failures === 0, failures, warnings };
@@ -266,6 +268,45 @@ function settingsCheck(deployment) {
         return { status: 'ok', detail: 'No store lacks a setting a deployment needs.' };
     return { status: 'warn', detail: `${findings.join('; ')}.`, hint: [...hints].join(' ') };
 }
+async function upgradeCheck(upgrade, deployment) {
+    if (upgrade === undefined)
+        return { status: 'skip', detail: 'No release asked about: pass upgrade 3.0.' };
+    if (upgrade !== '3.0')
+        throw new Error(`Readiness is checked for 3.0, not ${JSON.stringify(upgrade)}`);
+    if (nexusDefaults() === '3.0') {
+        return { status: 'ok', detail: "3.0's defaults are on already: what runs here is what 3.0 runs." };
+    }
+    const stores = Object.entries(deployment?.stores ?? {});
+    if (stores.length === 0)
+        return { status: 'skip', detail: 'No stores described.' };
+    const findings = [];
+    for (const [name, value] of stores) {
+        const kind = kindOf(value);
+        if (kind === 'Tracer') {
+            const tracer = value;
+            if (tracer.incremental === false && tracer.store && tracer.store.durable !== false) {
+                findings.push(`${name} writes each trace when its root finishes; 3.0 writes each run as it starts and ends, unless it is created with incremental: false`);
+            }
+        }
+        if (kind === 'RedisOperationStore' && value.indexed === false) {
+            findings.push(`${name} reads every record to find queued work; 3.0 keeps an index, unless it is created with index: false: first run 2.2 or later on every worker sharing its prefix, and call reindex() once`);
+        }
+        if (kind === 'Deployments' && typeof value.list === 'function') {
+            const records = await value.list();
+            const unrecorded = records.filter((record) => record.version === 0 && record.bucketStrategy === undefined);
+            if (unrecorded.length > 0) {
+                findings.push(`${name} has not yet recorded ${unrecorded.map((record) => record.assistant).join(', ')}; 3.0 would first record ${unrecorded.length === 1 ? 'it' : 'them'} with hash-v2, unless registered with bucketStrategy: 'fnv1a-v1'`);
+            }
+        }
+    }
+    if (findings.length === 0)
+        return { status: 'ok', detail: "Nothing described here changes under 3.0's defaults." };
+    return {
+        status: 'warn',
+        detail: `${findings.join('; ')}.`,
+        hint: "Run with 3.0's defaults now: call useDefaults('3.0') before creating anything, or set NEXUS_DEFAULTS=3.0.",
+    };
+}
 function kindOf(value) {
     return value?.constructor?.name;
 }

package/dist/embeddings/adapters.d.ts

@@ -52,7 +52,7 @@ export declare class GoogleEmbeddingProvider extends HttpEmbeddingProvider {
     readonly info: EmbeddingProviderInfo;
     constructor(options?: EmbeddingAdapterOptions);
     protected authHeaders(key: string | undefined): Record<string, string>;
-    /** Embeds a batch of inputs: texts, or parts with images, audio, and documents. */
+    /** Embeds a batch of inputs: texts, or parts with images, audio, video, and documents. */
     embed(request: EmbeddingProviderRequest, context: EmbeddingProviderCallContext): Promise<EmbeddingProviderResult>;
 }
 /** Cohere v2 `/embed`. */

package/dist/embeddings/adapters.js

@@ -100,7 +100,7 @@ export class GoogleEmbeddingProvider extends HttpEmbeddingProvider {
                 models: ['gemini-embedding-001', 'gemini-embedding-2', 'text-embedding-004'],
                 maxBatchSize: 100,
                 maxInputTokens: 8192,
-                inputModalities: ['text', 'image', 'audio', 'document'],
+                inputModalities: ['text', 'image', 'audio', 'video', 'document'],
                 dimensions: true,
                 inputTypes: ['document', 'query', 'classification', 'clustering'],
                 encodingFormats: ['float'],
@@ -149,10 +149,10 @@ export class CohereEmbeddingProvider extends HttpEmbeddingProvider {
             name: 'cohere',
             defaultModel: options.model || 'embed-v4.0',
             capabilities: {
-                models: ['embed-v4.0', 'embed-english-v3.0', 'embed-multilingual-v3.0'],
+                models: ['embed-v5.0-pro', 'embed-v5.0-fast', 'embed-v4.0', 'embed-english-v3.0', 'embed-multilingual-v3.0'],
                 maxBatchSize: 96,
                 inputModalities: ['text', 'image'],
-                dimensions: [256, 512, 1024, 1536],
+                dimensions: [256, 512, 768, 1024, 1536, 2048],
                 inputTypes: ['document', 'query', 'classification', 'clustering'],
                 encodingFormats: ['float'],
                 truncate: true,