nexus-ai-pro 2.7.0 → 2.9.0

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/deep-agent/helpers.d.ts

@@ -6,6 +6,10 @@
  * its checkpoints to the deep agent's checkpointer. A crash leaves the helper's finished steps behind
  * it: collecting the task in a new process carries the helper on from its last checkpoint, and a call
  * the agent repeats after the crash finds the same thread instead of starting the helper again.
+ *
+ * The helpers an agent creates are recorded on a thread of their own beside its own, before the call
+ * that creates one returns, so an agent resumed in another process counts them against its `max` and
+ * delegates to them again by name.
  */
 import { type CreateAgentOptions } from '../agent/create-agent.js';
 import type { PermissionPolicyLike } from '../agent/permissions.js';

package/dist/deep-agent/helpers.js

@@ -1,11 +1,55 @@
 import { agentInput, createAgent, } from '../agent/create-agent.js';
 const MARK = 'deepAgentHelper';
+const CREATED = 'deepAgentCreatedHelpers';
 export function helperTools(setup) {
     const declared = new Map(setup.declared.map((helper) => [helper.name, helper]));
     const created = new Map();
     const graphs = new Map();
     const live = new Map();
-    const spec = (name, instructions, thread) => {
+    const recorded = new Map();
+    const createdThread = (thread) => `${thread || 'thread'}/helpers-created`;
+    const loadCreated = (thread) => {
+        const checkpointer = setup.checkpointer;
+        if (!checkpointer || !setup.create)
+            return Promise.resolve();
+        let loading = recorded.get(thread);
+        if (!loading) {
+            loading = (async () => {
+                const stored = await checkpointer.get(createdThread(thread));
+                const records = (stored?.metadata?.[CREATED] ?? []);
+                const mine = created.get(thread) ?? new Map();
+                for (const record of records) {
+                    if (!mine.has(record.name))
+                        mine.set(record.name, { ...record, created: true });
+                }
+                created.set(thread, mine);
+            })();
+            loading.catch(() => recorded.delete(thread));
+            recorded.set(thread, loading);
+        }
+        return loading;
+    };
+    const recordCreated = async (thread, mine) => {
+        const checkpointer = setup.checkpointer;
+        if (!checkpointer)
+            return;
+        const threadId = createdThread(thread);
+        const records = [...mine.values()].map(({ created: _created, ...record }) => record);
+        await checkpointer.put({
+            version: 2,
+            id: `${threadId}:${records.length}`,
+            threadId,
+            step: records.length,
+            state: {},
+            next: [],
+            tasks: [],
+            status: 'completed',
+            interrupts: [],
+            createdAt: new Date().toISOString(),
+            metadata: { [CREATED]: records },
+        });
+    };
+    const spec = async (name, instructions, thread) => {
         const helper = declared.get(name);
         if (helper) {
             return {
@@ -17,6 +61,7 @@ export function helperTools(setup) {
                 created: false,
             };
         }
+        await loadCreated(thread);
         const mine = created.get(thread) ?? new Map();
         const existing = mine.get(name);
         if (existing)
@@ -42,6 +87,13 @@ export function helperTools(setup) {
         };
         mine.set(name, made);
         created.set(thread, mine);
+        try {
+            await recordCreated(thread, mine);
+        }
+        catch (error) {
+            mine.delete(name);
+            throw error;
+        }
         return made;
     };
     const graph = (helper, durable) => {
@@ -165,7 +217,7 @@ export function helperTools(setup) {
         },
         capabilities: [],
         execute: async (args, context = {}) => {
-            const helper = spec(String(args.agent ?? ''), typeof args.instructions === 'string' ? args.instructions : undefined, context.threadId ?? '');
+            const helper = await spec(String(args.agent ?? ''), typeof args.instructions === 'string' ? args.instructions : undefined, context.threadId ?? '');
             const task = String(args.task ?? '');
             const call = context.toolCallId ?? Math.random().toString(36).slice(2, 10);
             if (args.background !== true) {
@@ -211,8 +263,8 @@ export function helperTools(setup) {
                 const mark = stored.metadata?.[MARK];
                 const name = mark?.name ?? task.slice(0, task.lastIndexOf('@'));
                 const helper = mark?.created
-                    ? spec(name, mark.instructions, context.threadId ?? '')
-                    : spec(name, undefined, context.threadId ?? '');
+                    ? await spec(name, mark.instructions, context.threadId ?? '')
+                    : await spec(name, undefined, context.threadId ?? '');
                 await start(helper, undefined, threadId, context);
             }
             const entry = live.get(threadId);

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. */

package/dist/embeddings/adapters.js

@@ -1,6 +1,7 @@
 import { decodeBase64 } from '../utils/base64.js';
 import { createProviderHttpError, toNexusProviderError } from '../providers/errors.js';
-import { EmbeddingProviderResponseError } from './errors.js';
+import { EmbeddingProviderResponseError, EmbeddingValidationError } from './errors.js';
+import { GOOGLE_TASK_TYPES, googleParts, usesTaskPrefix } from './google-wire.js';
 class HttpEmbeddingProvider {
     options;
     constructor(options = {}) {
@@ -82,12 +83,6 @@ export class OpenAIEmbeddingProvider extends HttpEmbeddingProvider {
         };
     }
 }
-const GOOGLE_TASK_TYPES = {
-    document: 'RETRIEVAL_DOCUMENT',
-    query: 'RETRIEVAL_QUERY',
-    classification: 'CLASSIFICATION',
-    clustering: 'CLUSTERING',
-};
 export class GoogleEmbeddingProvider extends HttpEmbeddingProvider {
     info;
     constructor(options = {}) {
@@ -96,9 +91,10 @@ export class GoogleEmbeddingProvider extends HttpEmbeddingProvider {
             name: 'google',
             defaultModel: options.model || 'gemini-embedding-001',
             capabilities: {
-                models: ['gemini-embedding-001', 'text-embedding-004'],
+                models: ['gemini-embedding-001', 'gemini-embedding-2', 'text-embedding-004'],
                 maxBatchSize: 100,
-                maxInputTokens: 2048,
+                maxInputTokens: 8192,
+                inputModalities: ['text', 'image', 'audio', 'document'],
                 dimensions: true,
                 inputTypes: ['document', 'query', 'classification', 'clustering'],
                 encodingFormats: ['float'],
@@ -112,11 +108,13 @@ export class GoogleEmbeddingProvider extends HttpEmbeddingProvider {
     async embed(request, context) {
         const model = request.model;
         const qualified = model.startsWith('models/') ? model : `models/${model}`;
+        const prefixed = usesTaskPrefix(model);
+        const contents = request.contents ?? request.input.map((text) => [{ type: 'text', text }]);
         const payload = (await this.post(`${this.baseUrl('https://generativelanguage.googleapis.com/v1beta')}/${qualified}:batchEmbedContents`, {
-            requests: request.input.map((text) => ({
+            requests: contents.map((parts) => ({
                 model: qualified,
-                content: { parts: [{ text }] },
-                taskType: request.inputType ? GOOGLE_TASK_TYPES[request.inputType] : undefined,
+                content: { parts: googleParts(parts, prefixed ? request.inputType : undefined) },
+                taskType: request.inputType && !prefixed ? GOOGLE_TASK_TYPES[request.inputType] : undefined,
                 outputDimensionality: request.dimensions,
                 ...request.providerOptions,
             })),
@@ -147,6 +145,7 @@ export class CohereEmbeddingProvider extends HttpEmbeddingProvider {
             capabilities: {
                 models: ['embed-v4.0', 'embed-english-v3.0', 'embed-multilingual-v3.0'],
                 maxBatchSize: 96,
+                inputModalities: ['text', 'image'],
                 dimensions: [256, 512, 1024, 1536],
                 inputTypes: ['document', 'query', 'classification', 'clustering'],
                 encodingFormats: ['float'],
@@ -158,7 +157,9 @@ export class CohereEmbeddingProvider extends HttpEmbeddingProvider {
     async embed(request, context) {
         const payload = (await this.post(`${this.baseUrl('https://api.cohere.com/v2')}/embed`, {
             model: request.model,
-            texts: request.input,
+            ...(request.contents
+                ? { inputs: request.contents.map((parts) => ({ content: parts.map(cohereContent) })) }
+                : { texts: request.input }),
             input_type: COHERE_INPUT_TYPES[request.inputType ?? 'document'],
             embedding_types: ['float'],
             output_dimension: request.dimensions,
@@ -177,6 +178,16 @@ export class CohereEmbeddingProvider extends HttpEmbeddingProvider {
         };
     }
 }
+function cohereContent(part) {
+    if (part.type === 'text')
+        return { type: 'text', text: part.text };
+    if (part.type === 'image' && part.data !== undefined) {
+        return { type: 'image_url', image_url: { url: `data:${part.mimeType};base64,${part.data}` } };
+    }
+    throw new EmbeddingValidationError(part.type === 'image'
+        ? 'Cohere embeds an image from its bytes, sent as a data URI, not from a URL; pass the image as bytes'
+        : `Cohere embeds text and images, not ${part.type}`);
+}
 export class MistralEmbeddingProvider extends OpenAIEmbeddingProvider {
     constructor(options = {}) {
         super({

package/dist/embeddings/batch-google.d.ts

@@ -0,0 +1,40 @@
+import type { BatchJobRef, BatchJobState, BatchProviderCallContext } from '../types/batch.js';
+import type { EmbeddingBatchOutputItem, EmbeddingBatchProvider, EmbeddingBatchProviderInfo, EmbeddingBatchProviderRequest } from './batch.js';
+/** Options for Gemini's embedding batch tier. */
+export interface GoogleEmbeddingBatchProviderOptions {
+    /** Gemini API key, sent as `x-goog-api-key`. */
+    apiKey: string;
+    /** API base URL. Defaults to `https://generativelanguage.googleapis.com/v1beta`. */
+    baseUrl?: string;
+    /** Headers added to every request. */
+    headers?: Record<string, string>;
+    /** Replaces the global `fetch`. */
+    fetch?: typeof fetch;
+}
+/**
+ * Gemini's Batch API for embeddings (`asyncBatchEmbedContent`): half price, inline requests under
+ * 20 MB, and results inline, in the order submitted. It takes text, images, audio, and PDFs on a model
+ * that does, such as gemini-embedding-2. The wire shape follows Google's API reference and its own
+ * clients; it graduates with a recorded live run.
+ */
+export declare class GoogleEmbeddingBatchProvider implements EmbeddingBatchProvider {
+    private readonly options;
+    /** Always `google`, with its batch limits. */
+    readonly info: EmbeddingBatchProviderInfo;
+    constructor(options: GoogleEmbeddingBatchProviderOptions);
+    /**
+     * Sends every input inline as one batch. Results come back in the same order, so the ref keeps the
+     * ids in that order.
+     */
+    submit(request: EmbeddingBatchProviderRequest, context: BatchProviderCallContext): Promise<BatchJobRef>;
+    /** Reads a batch's state and counts. */
+    poll(ref: BatchJobRef, context: BatchProviderCallContext): Promise<BatchJobState>;
+    /** Every input's vector or error, matched to its id by position. */
+    results(ref: BatchJobRef, context: BatchProviderCallContext): Promise<EmbeddingBatchOutputItem[]>;
+    /** Cancels a batch. */
+    cancel(ref: BatchJobRef, context: BatchProviderCallContext): Promise<BatchJobState>;
+    /** The batch resource, whether Google answers with it or with an operation that holds it. */
+    private read;
+    private state;
+    private request;
+}

package/dist/embeddings/batch-google.js

@@ -0,0 +1,128 @@
+import { BatchCapabilityError, BatchProviderResponseError } from '../batch/errors.js';
+import { GOOGLE_TASK_TYPES, googleParts, usesTaskPrefix } from './google-wire.js';
+const INLINE_BYTES = 20 * 1024 * 1024;
+const STATES = {
+    PENDING: 'validating',
+    RUNNING: 'in_progress',
+    SUCCEEDED: 'completed',
+    FAILED: 'failed',
+    CANCELLED: 'cancelled',
+    EXPIRED: 'expired',
+};
+export class GoogleEmbeddingBatchProvider {
+    options;
+    info = {
+        name: 'google',
+        capabilities: {
+            maxBytes: INLINE_BYTES,
+            supportsCancel: true,
+            discount: 0.5,
+            inputModalities: ['text', 'image', 'audio', 'document'],
+        },
+    };
+    constructor(options) {
+        this.options = options;
+    }
+    async submit(request, context) {
+        const qualified = request.model.startsWith('models/') ? request.model : `models/${request.model}`;
+        const prefixed = usesTaskPrefix(request.model);
+        const body = JSON.stringify({
+            batch: {
+                displayName: request.metadata?.key ?? 'nexus-embeddings',
+                inputConfig: {
+                    requests: {
+                        requests: request.items.map((item) => ({
+                            request: {
+                                model: qualified,
+                                content: {
+                                    parts: googleParts(item.contents ?? [{ type: 'text', text: item.input }], prefixed ? request.inputType : undefined),
+                                },
+                                ...(request.inputType && !prefixed ? { taskType: GOOGLE_TASK_TYPES[request.inputType] } : {}),
+                                ...(request.dimensions !== undefined ? { outputDimensionality: request.dimensions } : {}),
+                            },
+                        })),
+                    },
+                },
+            },
+        });
+        if (body.length > INLINE_BYTES) {
+            throw new BatchCapabilityError('google', 'maxBytes', `An inline Gemini batch holds at most 20 MB; this one is ${Math.ceil(body.length / 1024 / 1024)} MB, so split it`);
+        }
+        const created = (await this.request(`/${qualified}:asyncBatchEmbedContent`, { method: 'POST', body }, context));
+        const name = created.name ?? created.metadata?.name;
+        if (!name)
+            throw new BatchProviderResponseError('google', 'the batch response returned no name');
+        return { id: name, provider: 'google', metadata: { customIds: request.items.map((item) => item.customId) } };
+    }
+    async poll(ref, context) {
+        return this.state(ref, await this.read(ref, context));
+    }
+    async results(ref, context) {
+        const batch = await this.read(ref, context);
+        const output = batch.output;
+        if (output?.responsesFile) {
+            throw new BatchProviderResponseError('google', 'the batch wrote its results to a file; this adapter reads inline results');
+        }
+        const ids = (ref.metadata?.customIds ?? []);
+        const responses = output?.inlinedEmbedContentResponses?.inlinedResponses ?? [];
+        return responses.map((entry, index) => {
+            const customId = ids[index] ?? String(index);
+            const values = entry.response?.embedding?.values;
+            if (Array.isArray(values))
+                return { customId, vector: values };
+            return {
+                customId,
+                error: {
+                    message: entry.error?.message ?? 'the response carried no embedding',
+                    ...(entry.error?.code !== undefined ? { code: String(entry.error.code) } : {}),
+                },
+            };
+        });
+    }
+    async cancel(ref, context) {
+        await this.request(`/${ref.id}:cancel`, { method: 'POST' }, context);
+        return this.poll(ref, context);
+    }
+    async read(ref, context) {
+        const answer = (await this.request(`/${ref.id}`, {}, context));
+        return { ...answer, ...answer.metadata };
+    }
+    state(ref, batch) {
+        const status = STATES[(batch.state ?? '').replace(/^(BATCH|JOB)_STATE_/, '')] ?? 'in_progress';
+        const stats = batch.batchStats;
+        const count = (key) => Number(stats?.[key] ?? 0);
+        return {
+            ref,
+            status,
+            ...(stats
+                ? {
+                    counts: {
+                        total: count('requestCount'),
+                        completed: count('successfulRequestCount'),
+                        failed: count('failedRequestCount'),
+                    },
+                }
+                : {}),
+            ...(batch.createTime ? { createdAt: batch.createTime } : {}),
+            ...(batch.endTime ? { completedAt: batch.endTime } : {}),
+            ...(batch.error
+                ? { error: { message: batch.error.message ?? 'batch failed', code: String(batch.error.code ?? '') } }
+                : {}),
+            raw: batch,
+        };
+    }
+    async request(path, init, context) {
+        const fetchImpl = this.options.fetch ?? fetch;
+        const base = (this.options.baseUrl ?? 'https://generativelanguage.googleapis.com/v1beta').replace(/\/+$/, '');
+        const response = await fetchImpl(`${base}${path}`, {
+            ...init,
+            headers: { 'content-type': 'application/json', 'x-goog-api-key': this.options.apiKey, ...this.options.headers },
+            signal: context.signal,
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            throw new BatchProviderResponseError('google', `${path} failed: ${response.status} ${text.slice(0, 500)}`);
+        }
+        return text ? JSON.parse(text) : {};
+    }
+}