@nestjs/ai 0.0.1 → 0.0.2

package/dist/models/model-requests.js

@@ -4,9 +4,17 @@
  * not configure fails with a message of its own, not with Nest's missing-provider error.
  */
 const requested = new Set();
+const requestedEmbeddings = new Set();
 export function recordModelRequest(name) {
     requested.add(name);
 }
 export function requestedModelNames() {
     return [...requested];
 }
+/** Embedding injection requests use a separate namespace, even when the names are identical. */
+export function recordEmbeddingModelRequest(name) {
+    requestedEmbeddings.add(name);
+}
+export function requestedEmbeddingModelNames() {
+    return [...requestedEmbeddings];
+}

package/dist/runtime/embedding-call.d.ts

@@ -0,0 +1,38 @@
+import type { ResiliencePolicy } from '@nestjs/resilience';
+import { type EmbedManyResult, type EmbedResult } from 'ai';
+import type { AiEmbeddingCallOptions, AiEmbeddingSettings, AiEmbeddingUsageEvent } from '../interfaces/ai-embedding.interface.js';
+import type { AiModuleOptions } from '../interfaces/ai-module-options.interface.js';
+import type { AiEmbeddingModels, ResolvedEmbeddingModel } from '../models/ai-embedding-models.service.js';
+import { type PolicyPlan } from './model-policy.js';
+/** One operation's state. Clients and explicitly supplied resilience policies remain shared. */
+export interface EmbeddingPlan extends PolicyPlan<ResolvedEmbeddingModel> {
+    model: ResolvedEmbeddingModel;
+    label?: string;
+    settings: Pick<AiEmbeddingSettings, 'headers' | 'providerOptions'> & {
+        maxParallelCalls: number;
+    };
+    listeners: Array<(event: AiEmbeddingUsageEvent) => void | Promise<void>>;
+}
+/**
+ * Resolves only embedding settings: language generation defaults never reach an embedding provider.
+ */
+export declare function createEmbeddingPlan(options: AiEmbeddingCallOptions, models: AiEmbeddingModels, moduleOptions: AiModuleOptions, preset: (name: string) => ResiliencePolicy): EmbeddingPlan;
+interface EmbeddingExecution<R> {
+    result: R;
+    event: AiEmbeddingUsageEvent;
+    attempts: number;
+    cost?: number;
+}
+/**
+ * The SDK splits `values` into provider requests. The policy runs around each of them, through the
+ * SDK's middleware, so a timeout or a retry covers one request and never repeats the others. When a
+ * request fails for good, its siblings are aborted, so that a failed operation does not keep
+ * consuming provider capacity.
+ */
+export declare function runEmbedding(plan: EmbeddingPlan, input: {
+    value: string;
+}): Promise<EmbeddingExecution<EmbedResult>>;
+export declare function runEmbedding(plan: EmbeddingPlan, input: {
+    values: string[];
+}): Promise<EmbeddingExecution<EmbedManyResult>>;
+export {};

package/dist/runtime/embedding-call.js

@@ -0,0 +1,120 @@
+import { embed, embedMany, gateway, wrapEmbeddingModel, } from 'ai';
+import { AiConfigurationError } from '../errors/ai.errors.js';
+import { modelPolicy, runStep } from './model-policy.js';
+const NEVER_ABORTED = new AbortController().signal;
+const DEFAULT_MAX_PARALLEL_CALLS = 4;
+/**
+ * Resolves only embedding settings: language generation defaults never reach an embedding provider.
+ */
+export function createEmbeddingPlan(options, models, moduleOptions, preset) {
+    if (typeof options !== 'object' || options === null) {
+        throw new AiConfigurationError('Pass the embedding call its options: { value } or { values }, and the rest.');
+    }
+    const model = models.resolve(options.model);
+    const defaults = moduleOptions.embeddingDefaults ?? {};
+    const pick = (key) => options[key] ?? model.settings[key] ?? defaults[key];
+    const maxParallelCalls = pick('maxParallelCalls') ?? DEFAULT_MAX_PARALLEL_CALLS;
+    if (!Number.isSafeInteger(maxParallelCalls) || maxParallelCalls < 1) {
+        throw new AiConfigurationError('`maxParallelCalls` must be a finite positive whole number.');
+    }
+    const own = pick('resilience');
+    const policy = own === undefined
+        ? modelPolicy(model, { retry: pick('retry'), timeout: pick('timeout') }, 'ai:embedding')
+        : typeof own === 'string'
+            ? preset(own)
+            : own;
+    return {
+        model,
+        chain: [model],
+        signal: options.abortSignal ?? NEVER_ABORTED,
+        source: options.label ?? 'AiService',
+        fallbackIf: () => false,
+        policyFor: () => policy,
+        ...(options.label !== undefined && { label: options.label }),
+        settings: {
+            maxParallelCalls,
+            ...(pick('headers') !== undefined && { headers: pick('headers') }),
+            ...(pick('providerOptions') !== undefined && { providerOptions: pick('providerOptions') }),
+        },
+        listeners: [moduleOptions.onEmbeddingUsage, options.onEmbeddingUsage].filter((listener) => typeof listener === 'function'),
+    };
+}
+export async function runEmbedding(plan, input) {
+    const started = performance.now();
+    const many = 'values' in input;
+    if (many
+        ? !Array.isArray(input.values) || [...input.values].some((value) => typeof value !== 'string')
+        : typeof input.value !== 'string') {
+        throw new AiConfigurationError(many ? '`values` must be an array of strings.' : '`value` must be a string.');
+    }
+    const values = many ? [...input.values] : undefined;
+    const controller = new AbortController();
+    const signal = AbortSignal.any([plan.signal, controller.signal]);
+    let attempts = 0;
+    const wrapped = wrapEmbeddingModel({
+        model: modelObject(plan.model.model),
+        middleware: {
+            wrapEmbed: async ({ params, model }) => {
+                const { value, attempts: used } = await runStep({ ...plan, signal }, async (attempt) => {
+                    attempt.signal.throwIfAborted();
+                    return model.doEmbed({ ...params, abortSignal: attempt.signal });
+                });
+                attempts += used;
+                return value;
+            },
+        },
+    });
+    let result;
+    try {
+        signal.throwIfAborted();
+        const settings = {
+            model: wrapped,
+            headers: plan.settings.headers,
+            providerOptions: plan.settings.providerOptions,
+            abortSignal: signal,
+            maxRetries: 0,
+        };
+        result =
+            values !== undefined
+                ? await embedMany({
+                    ...settings,
+                    values,
+                    maxParallelCalls: plan.settings.maxParallelCalls,
+                })
+                : await embed({ ...settings, value: input.value });
+        signal.throwIfAborted();
+    }
+    finally {
+        controller.abort();
+    }
+    const pricing = plan.model.pricing;
+    const cost = pricing && Number.isFinite(result.usage.tokens)
+        ? (result.usage.tokens * pricing.input) / 1_000_000
+        : undefined;
+    return {
+        result,
+        attempts,
+        ...(cost !== undefined && { cost }),
+        event: {
+            operation: many ? 'embedMany' : 'embed',
+            ...(plan.label !== undefined && { label: plan.label }),
+            model: plan.model.info,
+            inputCount: values?.length ?? 1,
+            usage: { tokens: result.usage.tokens },
+            attempts,
+            durationMs: Math.round(performance.now() - started),
+            ...(cost !== undefined && { cost }),
+        },
+    };
+}
+/**
+ * `wrapEmbeddingModel()` takes model objects. An id resolves as the SDK resolves it: with its
+ * default provider, the gateway unless the application set another.
+ */
+function modelObject(model) {
+    if (typeof model !== 'string') {
+        return model;
+    }
+    const provider = (globalThis.AI_SDK_DEFAULT_PROVIDER ?? gateway);
+    return provider.embeddingModel(model);
+}

package/dist/runtime/model-policy.d.ts

@@ -1,8 +1,13 @@
 import { ResiliencePolicy, type RetryOptions } from '@nestjs/resilience';
 import type { ResolvedModel } from '../models/ai-models.service.js';
+import type { AiModelInfo } from '../interfaces/ai-result.interface.js';
+/** The identity the policy layer needs; generation and embedding registries stay separately typed. */
+export interface PolicyModel {
+    info: AiModelInfo;
+}
 /** What one attempt of a model call receives. */
-export interface StepAttempt {
-    model: ResolvedModel;
+export interface StepAttempt<M extends PolicyModel = ResolvedModel> {
+    model: M;
     /** 1-based, per model. */
     attempt: number;
     fallback: boolean;
@@ -14,14 +19,14 @@ export interface StepAttempt {
     emit(chunk: unknown): void;
 }
 /** How a call's models are retried, timed out and replaced. Internal. */
-export interface PolicyPlan {
-    chain: ResolvedModel[];
+export interface PolicyPlan<M extends PolicyModel = ResolvedModel> {
+    chain: M[];
     /** The caller's signal. */
     signal: AbortSignal;
     /** Labels the policies' events (`source`). */
     source: string;
     /** The model's own policy: an application's, or the one built from its `retry` and `timeout`. */
-    policyFor(model: ResolvedModel): ResiliencePolicy | undefined;
+    policyFor(model: M): ResiliencePolicy | undefined;
     fallbackIf: (error: unknown) => boolean;
 }
 /**
@@ -31,18 +36,18 @@ export interface PolicyPlan {
  * every attempt, the caller's abort reason, or what is not a model failure (an `AiOutputError`, a circuit breaker's
  * rejection) as it is.
  */
-export declare function runStep<T>(plan: PolicyPlan, run: (attempt: StepAttempt) => Promise<T>, emit?: (chunk: unknown) => void): Promise<{
+export declare function runStep<T, M extends PolicyModel = ResolvedModel>(plan: PolicyPlan<M>, run: (attempt: StepAttempt<M>) => Promise<T>, emit?: (chunk: unknown) => void): Promise<{
     value: T;
-    attempt: StepAttempt;
+    attempt: StepAttempt<M>;
     attempts: number;
 }>;
 /**
  * The model's own policy from its settings: `RetryPolicy` (honoring the provider's `retry-after`) around
  * `TimeoutPolicy`, either one left out when it is `false`.
  */
-export declare function modelPolicy(model: ResolvedModel, { retry, timeout }: {
+export declare function modelPolicy(model: PolicyModel, { retry, timeout }: {
     retry: RetryOptions | false | undefined;
     timeout: number | string | false | undefined;
-}): ResiliencePolicy | undefined;
+}, namespace?: string): ResiliencePolicy | undefined;
 /** What is retried by default: what the provider marks retryable (with network failures), and timeouts. */
 export declare function isRetryable(error: unknown): boolean;

package/dist/runtime/model-policy.js

@@ -98,24 +98,24 @@ export function runStep(plan, run, emit) {
  * The model's own policy from its settings: `RetryPolicy` (honoring the provider's `retry-after`) around
  * `TimeoutPolicy`, either one left out when it is `false`.
  */
-export function modelPolicy(model, { retry, timeout }) {
+export function modelPolicy(model, { retry, timeout }, namespace = 'ai') {
     const policies = [];
     if (retry !== false) {
-        policies.push(retryPolicy(model, retry ?? {}));
+        policies.push(retryPolicy(model, retry ?? {}, namespace));
     }
     if (timeout !== false) {
-        policies.push(new TimeoutPolicy({ timeout: toMilliseconds(timeout ?? DEFAULT_TIMEOUT, 'timeout'), name: `${nameOf(model)} timeout` }));
+        policies.push(new TimeoutPolicy({ timeout: toMilliseconds(timeout ?? DEFAULT_TIMEOUT, 'timeout'), name: `${nameOf(model, namespace)} timeout` }));
     }
     return policies.length > 0 ? ResiliencePolicy.wrap(...policies) : undefined;
 }
 const DEFAULT_TIMEOUT = '60s';
 const DEFAULT_BACKOFF = { delay: 1_000, factor: 2, maxDelay: 30_000 };
-function retryPolicy(model, retry) {
+function retryPolicy(model, retry, namespace) {
     const backoff = retry.backoff;
     const maxDelay = typeof backoff === 'object' && backoff.maxDelay !== undefined ? toMilliseconds(backoff.maxDelay, 'retry.backoff.maxDelay') : DEFAULT_BACKOFF.maxDelay;
     const retryIf = retry.retryIf ?? isRetryable;
     return new RetryPolicy({
-        name: `${nameOf(model)} retry`,
+        name: `${nameOf(model, namespace)} retry`,
         attempts: retry.attempts ?? 3,
         ...(retry.retryOnResult && { retryOnResult: retry.retryOnResult }),
         // A provider that asks for a longer wait than the backoff allows: on to the fallback.
@@ -185,8 +185,8 @@ function retryAfter(error) {
     const date = Date.parse(value);
     return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
 }
-function nameOf(model) {
-    return `ai:${labelOf(model)}`;
+function nameOf(model, namespace = 'ai') {
+    return `${namespace}:${labelOf(model)}`;
 }
 function labelOf(model) {
     return model.info.name ?? `${model.info.provider}:${model.info.modelId}`;

package/dist/services/ai.service.d.ts

@@ -1,10 +1,12 @@
 import { ModuleRef } from '@nestjs/core';
 import type { ModelMessage } from 'ai';
 import type { AiCallOptions, AiObjectCallOptions } from '../interfaces/ai-call-options.interface.js';
+import type { AiEmbedOptions, AiEmbedManyOptions, AiEmbedResult, AiEmbedManyResult } from '../interfaces/ai-embedding.interface.js';
 import type { AiModuleOptions } from '../interfaces/ai-module-options.interface.js';
 import type { AiObjectResult, AiTextResult } from '../interfaces/ai-result.interface.js';
 import type { AiSchema, InferSchemaOutput } from '../interfaces/ai-schema.interface.js';
 import { AiModels } from '../models/ai-models.service.js';
+import { AiEmbeddingModels } from '../models/ai-embedding-models.service.js';
 import { type StepOutcome } from '../runtime/steps.js';
 import { AiTextStream } from '../runtime/text-stream.js';
 import { AiTools } from '../tools/ai-tools.service.js';
@@ -21,8 +23,19 @@ export declare class AiService {
     private readonly tools;
     private readonly options;
     private readonly moduleRef;
+    private readonly embeddingModels;
     private readonly logger;
-    constructor(models: AiModels, tools: AiTools, options: AiModuleOptions, moduleRef: ModuleRef);
+    constructor(models: AiModels, tools: AiTools, options: AiModuleOptions, moduleRef: ModuleRef, embeddingModels: AiEmbeddingModels);
+    /**
+     * Embeds one string, with the embedding model's settings, Nest policies and embedding usage
+     * events.
+     */
+    embed(options: AiEmbedOptions): Promise<AiEmbedResult>;
+    /**
+     * Embeds strings in input order; the SDK batches requests, with bounded concurrency (default 4).
+     * Timeouts, retries and policies apply to each request.
+     */
+    embedMany(options: AiEmbedManyOptions): Promise<AiEmbedManyResult>;
     /** Generates text; with `tools`, calls them as the model asks, and answers when it is done. */
     generateText(options: AiCallOptions): Promise<AiTextResult>;
     /**

package/dist/services/ai.service.js

@@ -16,8 +16,10 @@ import { ResilienceService } from '@nestjs/resilience';
 import { AI_MODULE_OPTIONS } from '../ai.constants.js';
 import { AiConfigurationError, AiOutputError } from '../errors/ai.errors.js';
 import { AiModels } from '../models/ai-models.service.js';
+import { AiEmbeddingModels } from '../models/ai-embedding-models.service.js';
 import { runLoop, usageEvent } from '../runtime/agent-loop.js';
 import { createCallPlan } from '../runtime/call-plan.js';
+import { createEmbeddingPlan, runEmbedding } from '../runtime/embedding-call.js';
 import { runStep } from '../runtime/model-policy.js';
 import { generateStep } from '../runtime/steps.js';
 import { AiTextStream } from '../runtime/text-stream.js';
@@ -33,13 +35,54 @@ const NEVER_ABORTED = new AbortController().signal;
  * ```
  */
 let AiService = class AiService {
-    constructor(models, tools, options, moduleRef) {
+    constructor(models, tools, options, moduleRef, embeddingModels) {
         this.models = models;
         this.tools = tools;
         this.options = options;
         this.moduleRef = moduleRef;
+        this.embeddingModels = embeddingModels;
         this.logger = new Logger('AiModule');
     }
+    /**
+     * Embeds one string, with the embedding model's settings, Nest policies and embedding usage
+     * events.
+     */
+    async embed(options) {
+        const plan = createEmbeddingPlan(options, this.embeddingModels, this.options, (name) => this.preset(name));
+        const { result, event, attempts, cost } = await runEmbedding(plan, { value: options.value });
+        this.report(plan, event, 'onEmbeddingUsage');
+        return {
+            value: result.value,
+            embedding: result.embedding,
+            usage: result.usage,
+            warnings: result.warnings,
+            ...(result.response !== undefined && { response: result.response }),
+            ...(result.providerMetadata !== undefined && { providerMetadata: result.providerMetadata }),
+            model: plan.model.info,
+            attempts,
+            ...(cost !== undefined && { cost }),
+        };
+    }
+    /**
+     * Embeds strings in input order; the SDK batches requests, with bounded concurrency (default 4).
+     * Timeouts, retries and policies apply to each request.
+     */
+    async embedMany(options) {
+        const plan = createEmbeddingPlan(options, this.embeddingModels, this.options, (name) => this.preset(name));
+        const { result, event, attempts, cost } = await runEmbedding(plan, { values: options.values });
+        this.report(plan, event, 'onEmbeddingUsage');
+        return {
+            values: result.values,
+            embeddings: result.embeddings,
+            usage: result.usage,
+            warnings: result.warnings,
+            ...(result.responses !== undefined && { responses: result.responses }),
+            ...(result.providerMetadata !== undefined && { providerMetadata: result.providerMetadata }),
+            model: plan.model.info,
+            attempts,
+            ...(cost !== undefined && { cost }),
+        };
+    }
     /** Generates text; with `tools`, calls them as the model asks, and answers when it is done. */
     async generateText(options) {
         const plan = this.plan(options, options?.abortSignal ?? NEVER_ABORTED);
@@ -116,24 +159,25 @@ let AiService = class AiService {
         return service.preset(name);
     }
     /** Calls the usage listeners. They never fail the call: what they throw is logged. */
-    report(plan, event) {
+    report(plan, event, hook = 'onUsage') {
         for (const listener of plan.listeners) {
             try {
-                Promise.resolve(listener(event)).catch((error) => this.logListenerError(error));
+                Promise.resolve(listener(event)).catch((error) => this.logListenerError(error, hook));
             }
             catch (error) {
-                this.logListenerError(error);
+                this.logListenerError(error, hook);
             }
         }
     }
-    logListenerError(error) {
-        this.logger.error(`onUsage failed: ${error?.message ?? String(error)}`, error?.stack);
+    logListenerError(error, hook) {
+        this.logger.error(`${hook} failed: ${error?.message ?? String(error)}`, error?.stack);
     }
 };
 AiService = __decorate([
     Injectable(),
     __param(2, Inject(AI_MODULE_OPTIONS)),
     __metadata("design:paramtypes", [AiModels,
-        AiTools, Object, ModuleRef])
+        AiTools, Object, ModuleRef,
+        AiEmbeddingModels])
 ], AiService);
 export { AiService };

package/dist/testing/fake-embedding-model.d.ts

@@ -0,0 +1,57 @@
+import { MockEmbeddingModelV4 } from 'ai/test';
+type CallOptions = Parameters<MockEmbeddingModelV4['doEmbed']>[0];
+type EmbedResult = Awaited<ReturnType<MockEmbeddingModelV4['doEmbed']>>;
+/**
+ * One provider response of a fake embedding model, including one vector for each value in that
+ * call.
+ */
+export interface FakeEmbeddingTurn {
+    embeddings: number[][];
+    /** Default: 10 tokens per value. */
+    usage?: {
+        tokens: number;
+    };
+    /** Milliseconds before the answer; cancellation cuts the wait short. */
+    delay?: number;
+    warnings?: EmbedResult['warnings'];
+    providerMetadata?: EmbedResult['providerMetadata'];
+    response?: EmbedResult['response'];
+}
+/** A provider call the fake received. SDK batching can make several calls for one embedMany(). */
+export interface FakeEmbeddingModelCall {
+    values: string[];
+    options: CallOptions;
+}
+/** An embedding response, provider error, or function of the provider call. */
+export type FakeEmbeddingAnswer = FakeEmbeddingTurn | Error | ((call: FakeEmbeddingModelCall) => FakeEmbeddingAnswer | Promise<FakeEmbeddingAnswer>);
+/** Provider capabilities used by the SDK when it batches input values. */
+export interface FakeEmbeddingModelOptions {
+    provider?: string;
+    modelId?: string;
+    /** Omitted: no provider batch limit. */
+    maxEmbeddingsPerCall?: number;
+    /** Default true. */
+    supportsParallelCalls?: boolean;
+}
+/**
+ * An embedding model for offline tests. Answers provider calls in order, records them, and supports
+ * the SDK's batching. A function answers every call; reply() appends scripted responses. No vectors
+ * are generated implicitly.
+ *
+ * ```ts
+ * const model = new FakeEmbeddingModel([{ embeddings: [[0.1, 0.2]], usage: { tokens: 3 } }]);
+ * ```
+ */
+export declare class FakeEmbeddingModel extends MockEmbeddingModelV4 {
+    readonly calls: FakeEmbeddingModelCall[];
+    private readonly answers;
+    private readonly answerAll;
+    constructor(answers?: FakeEmbeddingAnswer[] | ((call: FakeEmbeddingModelCall) => FakeEmbeddingAnswer | Promise<FakeEmbeddingAnswer>), { provider, modelId, maxEmbeddingsPerCall, supportsParallelCalls, }?: FakeEmbeddingModelOptions);
+    /** Adds responses after the unused scripted responses. */
+    reply(...answers: FakeEmbeddingAnswer[]): this;
+    /** The last provider call, or undefined. */
+    get lastCall(): FakeEmbeddingModelCall | undefined;
+}
+/** new FakeEmbeddingModel(answers). */
+export declare function fakeEmbeddingModel(...answers: FakeEmbeddingAnswer[]): FakeEmbeddingModel;
+export {};

package/dist/testing/fake-embedding-model.js

@@ -0,0 +1,82 @@
+import { MockEmbeddingModelV4 } from 'ai/test';
+/**
+ * An embedding model for offline tests. Answers provider calls in order, records them, and supports
+ * the SDK's batching. A function answers every call; reply() appends scripted responses. No vectors
+ * are generated implicitly.
+ *
+ * ```ts
+ * const model = new FakeEmbeddingModel([{ embeddings: [[0.1, 0.2]], usage: { tokens: 3 } }]);
+ * ```
+ */
+export class FakeEmbeddingModel extends MockEmbeddingModelV4 {
+    constructor(answers = [], { provider = 'fake', modelId = 'fake-embedding-model', maxEmbeddingsPerCall, supportsParallelCalls = true, } = {}) {
+        super({
+            provider,
+            modelId,
+            maxEmbeddingsPerCall: maxEmbeddingsPerCall ?? null,
+            supportsParallelCalls,
+        });
+        this.calls = [];
+        this.answers = Array.isArray(answers) ? [...answers] : [];
+        this.answerAll = typeof answers === 'function' ? answers : undefined;
+        this.doEmbed = async (options) => {
+            this.doEmbedCalls.push(options);
+            const call = { values: [...options.values], options };
+            this.calls.push(call);
+            options.abortSignal?.throwIfAborted();
+            let answer = this.answerAll ?? this.answers.shift();
+            if (answer === undefined) {
+                throw new Error(`FakeEmbeddingModel: no answer left for call ${this.calls.length}. Give it more answers.`);
+            }
+            while (typeof answer === 'function') {
+                answer = await answer(call);
+            }
+            if (answer instanceof Error) {
+                throw answer;
+            }
+            if (answer.delay) {
+                await sleep(answer.delay, options.abortSignal);
+            }
+            options.abortSignal?.throwIfAborted();
+            return {
+                embeddings: answer.embeddings,
+                usage: answer.usage ?? { tokens: call.values.length * 10 },
+                warnings: answer.warnings ?? [],
+                ...(answer.providerMetadata !== undefined && {
+                    providerMetadata: answer.providerMetadata,
+                }),
+                ...(answer.response !== undefined && { response: answer.response }),
+            };
+        };
+    }
+    /** Adds responses after the unused scripted responses. */
+    reply(...answers) {
+        this.answers.push(...answers);
+        return this;
+    }
+    /** The last provider call, or undefined. */
+    get lastCall() {
+        return this.calls[this.calls.length - 1];
+    }
+}
+/** new FakeEmbeddingModel(answers). */
+export function fakeEmbeddingModel(...answers) {
+    return new FakeEmbeddingModel(answers);
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/dist/testing/index.d.ts

@@ -8,14 +8,20 @@
  */
 import type { INestApplicationContext } from '@nestjs/common';
 import type { TestingModuleBuilder } from '@nestjs/testing';
-import type { LanguageModel } from 'ai';
+import type { EmbeddingModel, LanguageModel } from 'ai';
 import type { AiCaller } from '../interfaces/ai-tool.interface.js';
 export { FakeModel, fakeModel, providerError, type FakeAnswer, type FakeModelCall, type FakeToolCall, type FakeTurn } from './fake-model.js';
+export { FakeEmbeddingModel, fakeEmbeddingModel, type FakeEmbeddingAnswer, type FakeEmbeddingModelCall, type FakeEmbeddingModelOptions, type FakeEmbeddingTurn, } from './fake-embedding-model.js';
 /**
  * Replaces configured models by name (`{ default: new FakeModel([...]) }`) in a testing module, keeping their other
  * options (pricing, fallback, timeouts). A name that is not configured fails at compile time.
  */
 export declare function overrideModels(builder: TestingModuleBuilder, models: Record<string, LanguageModel>): TestingModuleBuilder;
+/**
+ * Replaces configured embedding models by name, preserving their settings and pricing. Unknown
+ * names fail at startup.
+ */
+export declare function overrideEmbeddingModels(builder: TestingModuleBuilder, models: Record<string, EmbeddingModel>): TestingModuleBuilder;
 /**
  * Calls the agent function `name` with `input` as `caller`, as an agent's call does: the input validated by its
  * schema, its scopes checked, then its guards, interceptors, pipes and filters, then the method. Resolves with what the

package/dist/testing/index.js

@@ -1,6 +1,7 @@
-import { AI_MODEL_OVERRIDES } from '../ai.constants.js';
+import { AI_EMBEDDING_MODEL_OVERRIDES, AI_MODEL_OVERRIDES } from '../ai.constants.js';
 import { AiTools } from '../tools/ai-tools.service.js';
 export { FakeModel, fakeModel, providerError } from './fake-model.js';
+export { FakeEmbeddingModel, fakeEmbeddingModel, } from './fake-embedding-model.js';
 /**
  * Replaces configured models by name (`{ default: new FakeModel([...]) }`) in a testing module, keeping their other
  * options (pricing, fallback, timeouts). A name that is not configured fails at compile time.
@@ -8,6 +9,13 @@ export { FakeModel, fakeModel, providerError } from './fake-model.js';
 export function overrideModels(builder, models) {
     return builder.overrideProvider(AI_MODEL_OVERRIDES).useValue(models);
 }
+/**
+ * Replaces configured embedding models by name, preserving their settings and pricing. Unknown
+ * names fail at startup.
+ */
+export function overrideEmbeddingModels(builder, models) {
+    return builder.overrideProvider(AI_EMBEDDING_MODEL_OVERRIDES).useValue(models);
+}
 /**
  * Calls the agent function `name` with `input` as `caller`, as an agent's call does: the input validated by its
  * schema, its scopes checked, then its guards, interceptors, pipes and filters, then the method. Resolves with what the

package/package.json

@@ -1,7 +1,22 @@
 {
   "name": "@nestjs/ai",
-  "version": "0.0.1",
-  "description": "Nest - modern, fast, powerful node.js web framework (@ai)",
+  "version": "0.0.2",
+  "description": "Language models for NestJS: model calls with timeouts, retries and fallbacks, structured output, tools and agents, and streaming to the browser.",
+  "keywords": [
+    "nestjs",
+    "nest",
+    "ai",
+    "llm",
+    "agents",
+    "ai-agent",
+    "tools",
+    "tool-calling",
+    "openai",
+    "anthropic",
+    "ai-sdk",
+    "streaming",
+    "chat"
+  ],
   "author": "Kamil Mysliwiec",
   "license": "MIT",
   "url": "https://github.com/nestjs/ai#readme",