@juspay/neurolink 12.14.20 → 12.15.0

package/dist/core/baseProvider.d.ts

@@ -1,7 +1,7 @@
 import type { AIProviderName } from "../constants/enums.js";
 import type { EvaluationData } from "../index.js";
 import type { NeuroLink } from "../neurolink.js";
-import type { UnknownRecord, MiddlewareFactoryOptions, StreamOptions, StreamResult, AIProvider, AnalyticsData, EnhancedGenerateResult, TextGenerationOptions, TextGenerationResult, ValidationSchema } from "../types/index.js";
+import type { UnknownRecord, MiddlewareFactoryOptions, StreamOptions, StreamResult, AIProvider, AnalyticsData, EnhancedGenerateResult, TextGenerationOptions, TextGenerationResult, ValidationSchema, EmbedInput } from "../types/index.js";
 import { TelemetryHandler } from "./modules/TelemetryHandler.js";
 import type { LanguageModel, ModelMessage, RawUsageObject, Tool, ToolCallRepairFunction, ToolSet } from "../types/index.js";
 export declare abstract class BaseProvider implements AIProvider {
@@ -320,7 +320,7 @@ export declare abstract class BaseProvider implements AIProvider {
      * Providers that support embeddings (OpenAI, Google Vertex, Amazon Bedrock)
      * should override this method with their specific implementation.
      *
-     * @param text - The text to embed
+     * @param input - Text string or EmbedInput with text/image/mimeType
      * @param _modelName - Optional embedding model name (provider-specific)
      * @returns Promise resolving to the embedding vector (array of numbers)
      * @throws Error if the provider does not support embeddings
@@ -330,9 +330,12 @@ export declare abstract class BaseProvider implements AIProvider {
      * const provider = await ProviderFactory.createProvider('openai', 'text-embedding-3-small');
      * const embedding = await provider.embed('Hello world');
      * console.log(embedding); // [0.123, -0.456, ...]
+     *
+     * // Multi-modal embedding (Bedrock Titan Image / Nova)
+     * const multiEmbedding = await provider.embed({ text: "a photo", image: imageBuffer, mimeType: "image/png" });
      * ```
      */
-    embed(text: string, _modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, _modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple texts in a single batch
      *

package/dist/core/baseProvider.js

@@ -1772,7 +1772,7 @@ export class BaseProvider {
      * Providers that support embeddings (OpenAI, Google Vertex, Amazon Bedrock)
      * should override this method with their specific implementation.
      *
-     * @param text - The text to embed
+     * @param input - Text string or EmbedInput with text/image/mimeType
      * @param _modelName - Optional embedding model name (provider-specific)
      * @returns Promise resolving to the embedding vector (array of numbers)
      * @throws Error if the provider does not support embeddings
@@ -1782,11 +1782,15 @@ export class BaseProvider {
      * const provider = await ProviderFactory.createProvider('openai', 'text-embedding-3-small');
      * const embedding = await provider.embed('Hello world');
      * console.log(embedding); // [0.123, -0.456, ...]
+     *
+     * // Multi-modal embedding (Bedrock Titan Image / Nova)
+     * const multiEmbedding = await provider.embed({ text: "a photo", image: imageBuffer, mimeType: "image/png" });
      * ```
      */
-    async embed(text, _modelName) {
+    async embed(input, _modelName) {
+        const textLength = typeof input === "string" ? input.length : (input.text?.length ?? 0);
         logger.warn(`embed() called on ${this.providerName} which does not have a native implementation`, {
-            textLength: text.length,
+            textLength,
         });
         throw new Error(`Embedding generation is not supported by the ${this.providerName} provider. ` +
             `Supported providers: openai, vertex/google, bedrock, cohere, voyage, jina. ` +

package/dist/providers/amazonBedrock/client.d.ts

@@ -2,7 +2,7 @@ import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
 import type { AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import type { NeuroLink } from "../../neurolink.js";
-import type { StreamOptions, StreamResult, EnhancedGenerateResult, TextGenerationOptions } from "../../types/index.js";
+import type { EmbedInput, StreamOptions, StreamResult, EnhancedGenerateResult, TextGenerationOptions } from "../../types/index.js";
 export declare class AmazonBedrockProvider extends BaseProvider {
     private bedrockClient;
     private conversationHistory;
@@ -76,13 +76,15 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     checkBedrockHealth(): Promise<void>;
     protected formatProviderError(error: unknown): Error;
     /**
-     * Generate embeddings for text using Amazon Bedrock embedding models
-     * Uses the native AWS SDK InvokeModel command for Titan embeddings
-     * @param text - The text to embed
+     * Generate embeddings for text or multi-modal input using Amazon Bedrock.
+     * Supports both text-only models (Titan Embed Text) and multi-modal models
+     * (Titan Embed Image, Nova Multimodal Embeddings).
+     *
+     * @param input - Text string or EmbedInput with text/image/mimeType
      * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
      * @returns Promise resolving to the embedding vector
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple texts in a single batch
      * @param texts - The texts to embed

package/dist/providers/amazonBedrock/client.js

@@ -10,6 +10,7 @@ import { createBedrockLoopAdapter } from "./loopAdapter.js";
 import { AuthenticationError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { classifyProviderError } from "../../utils/errorClassifier.js";
 import { isAbortError, withTimeout } from "../../utils/errorHandling.js";
+import { ImageProcessor } from "../../utils/imageProcessor.js";
 import { logger } from "../../utils/logger.js";
 import { resolveSamplingParams } from "../../models/modelRegistry.js";
 import { buildMultimodalMessagesArray } from "../../utils/messageBuilder.js";
@@ -18,6 +19,36 @@ import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
 import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { bedrockTracer } from "./constants.js";
 import { loadBedrockControl } from "./utils.js";
+/**
+ * The only image formats Nova Multimodal Embeddings accepts.
+ *
+ * An allowlist rather than a derivation from the mimetype, because every
+ * shortcut here produces a value Nova rejects for some ordinary input:
+ * splitting on "/" yields `svg+xml` for an SVG and `jpeg; charset=binary`
+ * when the mimetype carries parameters, and normalising `jpeg` to `jpg` —
+ * the natural-looking direction — turns the single most common input into
+ * the one spelling that is not on this list.
+ */
+const NOVA_IMAGE_FORMATS = {
+    "image/png": "png",
+    "image/jpeg": "jpeg",
+    "image/jpg": "jpeg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+};
+/**
+ * Nova's format name for `mimeType`, or undefined when Nova has no name for it.
+ *
+ * Deliberately not defaulting to png. The RAG image path accepts bmp, tiff and
+ * avif, none of which Nova names, so a default would hand AWS a BMP labelled as
+ * a PNG — bytes and declared format disagreeing, with no error and no way for
+ * the caller to tell it happened. An unnamed format is surfaced to the caller
+ * instead; see the throw at the call site.
+ */
+function novaImageFormat(mimeType) {
+    const normalized = (mimeType ?? "").split(";").at(0)?.trim().toLowerCase();
+    return NOVA_IMAGE_FORMATS[normalized ?? ""];
+}
 export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
     conversationHistory = [];
@@ -1162,24 +1193,100 @@ export class AmazonBedrockProvider extends BaseProvider {
         return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     /**
-     * Generate embeddings for text using Amazon Bedrock embedding models
-     * Uses the native AWS SDK InvokeModel command for Titan embeddings
-     * @param text - The text to embed
+     * Generate embeddings for text or multi-modal input using Amazon Bedrock.
+     * Supports both text-only models (Titan Embed Text) and multi-modal models
+     * (Titan Embed Image, Nova Multimodal Embeddings).
+     *
+     * @param input - Text string or EmbedInput with text/image/mimeType
      * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
      * @returns Promise resolving to the embedding vector
      */
-    async embed(text, modelName) {
-        const embeddingModelName = modelName || "amazon.titan-embed-text-v2:0";
+    async embed(input, modelName) {
+        // Normalize input to EmbedInput shape
+        const embedInput = typeof input === "string" ? { text: input } : input;
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel();
+        const isNovaModel = embeddingModelName.includes("nova") &&
+            embeddingModelName.includes("multimodal");
+        const isMultiModalModel = embeddingModelName.includes("image") ||
+            embeddingModelName.includes("multimodal") ||
+            embeddingModelName === "amazon.titan-embed-image-v1" ||
+            isNovaModel;
         logger.debug("Generating embedding", {
             provider: this.providerName,
             model: embeddingModelName,
-            textLength: text.length,
+            hasText: typeof embedInput.text === "string",
+            hasImage: embedInput.image !== undefined,
+            isMultiModalModel,
         });
         try {
-            // Titan Embed models expect a specific input format
-            const requestBody = JSON.stringify({
-                inputText: text,
-            });
+            // Build request body based on model type
+            let requestBody;
+            if (embedInput.image && !isMultiModalModel) {
+                throw new ProviderError(`${this.providerName} model ${embeddingModelName} does not support image embeddings`, this.providerName);
+            }
+            if (isNovaModel) {
+                // Nova Multimodal Embeddings uses SINGLE_EMBEDDING + singleEmbeddingParams
+                // for BOTH text-only and image requests. Nova requires exactly one
+                // modality per request — combined image+text is rejected explicitly
+                // rather than silently dropping one of them.
+                if (embedInput.image && embedInput.text) {
+                    throw new ProviderError(`${this.providerName} model ${embeddingModelName} does not support combined image+text embeddings; provide exactly one of image or text`, this.providerName);
+                }
+                const singleEmbeddingParams = {
+                    embeddingPurpose: "GENERIC_RETRIEVAL",
+                };
+                if (embedInput.image) {
+                    const imageBuffer = Buffer.isBuffer(embedInput.image)
+                        ? embedInput.image
+                        : Buffer.from(embedInput.image, "base64");
+                    const imageFormat = novaImageFormat(embedInput.mimeType);
+                    if (imageFormat === undefined) {
+                        throw new ProviderError(`${this.providerName} model ${embeddingModelName} does not support image format ` +
+                            `'${embedInput.mimeType ?? "unknown"}'; supported formats are ` +
+                            `${Object.keys(NOVA_IMAGE_FORMATS).join(", ")}`, this.providerName);
+                    }
+                    singleEmbeddingParams.image = {
+                        detailLevel: "STANDARD_IMAGE",
+                        format: imageFormat,
+                        source: {
+                            // Bounded on purpose. `Buffer.toString("base64")` allocates ~4/3
+                            // the buffer in one go, so an oversized image exhausts memory
+                            // before the request is ever built. The chat-image path already
+                            // routes through this guard (messageBuilder.ts); the embed paths
+                            // never adopted it, even though ImageLoader enforces the same
+                            // ceiling for images it loads itself.
+                            bytes: ImageProcessor.safeBase64Convert(imageBuffer, "bedrock nova embed image"),
+                        },
+                    };
+                }
+                if (embedInput.text) {
+                    singleEmbeddingParams.text = {
+                        value: embedInput.text,
+                        truncationMode: "NONE",
+                    };
+                }
+                requestBody = JSON.stringify({
+                    taskType: "SINGLE_EMBEDDING",
+                    singleEmbeddingParams,
+                });
+            }
+            else if (embedInput.image) {
+                // Titan Multimodal Embeddings expects inputImage as a base64 string
+                const imageBuffer = Buffer.isBuffer(embedInput.image)
+                    ? embedInput.image
+                    : Buffer.from(embedInput.image, "base64");
+                requestBody = JSON.stringify({
+                    inputText: embedInput.text ?? "",
+                    // Same ceiling as the Nova branch above.
+                    inputImage: ImageProcessor.safeBase64Convert(imageBuffer, "bedrock titan embed image"),
+                });
+            }
+            else {
+                // Text-only embedding (Titan Embed Text)
+                requestBody = JSON.stringify({
+                    inputText: embedInput.text ?? "",
+                });
+            }
             const command = new InvokeModelCommand({
                 modelId: embeddingModelName,
                 contentType: "application/json",
@@ -1187,23 +1294,25 @@ export class AmazonBedrockProvider extends BaseProvider {
                 body: requestBody,
             });
             const response = await withTimeout(this.bedrockClient.send(command), 60_000, new Error("Bedrock embedding API call timed out"));
-            // Parse the response
+            // Parse the response — Titan returns `embedding`, Nova returns `embeddings[0].embedding`
             const responseBody = JSON.parse(new TextDecoder().decode(response.body));
-            if (!responseBody.embedding || !Array.isArray(responseBody.embedding)) {
+            const embedding = isNovaModel
+                ? responseBody.embeddings?.at(0)?.embedding
+                : responseBody.embedding;
+            if (!Array.isArray(embedding)) {
                 throw new Error("Invalid embedding response from Bedrock");
             }
             logger.debug("Embedding generated successfully", {
                 provider: this.providerName,
                 model: embeddingModelName,
-                embeddingDimension: responseBody.embedding.length,
+                embeddingDimension: embedding.length,
             });
-            return responseBody.embedding;
+            return embedding;
         }
         catch (error) {
             logger.error("Embedding generation failed", {
                 error: error instanceof Error ? error.message : String(error),
                 model: embeddingModelName,
-                textLength: text.length,
             });
             throw this.handleProviderError(error);
         }
@@ -1215,7 +1324,7 @@ export class AmazonBedrockProvider extends BaseProvider {
      * @returns Promise resolving to an array of embedding vectors
      */
     async embedMany(texts, modelName) {
-        const embeddingModelName = modelName || "amazon.titan-embed-text-v2:0";
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel();
         logger.debug("Generating batch embeddings", {
             provider: this.providerName,
             model: embeddingModelName,

package/dist/providers/cohere.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../constants/enums.js";
-import type { NeurolinkCredentials } from "../types/index.js";
+import type { EmbedInput, NeurolinkCredentials } from "../types/index.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
  * Cohere Provider — direct HTTP, no AI SDK.
@@ -41,7 +41,7 @@ export declare class CohereProvider extends OpenAIChatCompletionsProvider {
      * lives on the native API (POST /v2/embed). Documented at
      * https://docs.cohere.com/reference/embed.
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Batch embedding via Cohere's native /v2/embed endpoint. Cohere caps at
      * 96 inputs per request; larger batches are chunked.

package/dist/providers/cohere.js

@@ -115,7 +115,11 @@ export class CohereProvider extends OpenAIChatCompletionsProvider {
      * lives on the native API (POST /v2/embed). Documented at
      * https://docs.cohere.com/reference/embed.
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const vectors = await this.embedMany([text], modelName);
         if (!vectors[0]) {
             throw new ProviderError("Cohere /v2/embed returned no embeddings.", "cohere");

package/dist/providers/googleAiStudio/client.d.ts

@@ -1,6 +1,6 @@
 import { type AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
-import type { ZodUnknownSchema, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult } from "../../types/index.js";
+import type { EmbedInput, ZodUnknownSchema, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult } from "../../types/index.js";
 import type { LanguageModel, Schema } from "../../types/index.js";
 export declare class GoogleAIStudioProvider extends BaseProvider {
     private credentials?;
@@ -74,11 +74,11 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     protected getDefaultEmbeddingModel(): string;
     /**
      * Generate embeddings for text using Google AI Studio embedding models
-     * @param text - The text to embed
+     * @param input - The text to embed (string or EmbedInput)
      * @param modelName - The embedding model to use (default: gemini-embedding-001)
      * @returns Promise resolving to the embedding vector
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple texts in a single batch
      * @param texts - The texts to embed

package/dist/providers/googleAiStudio/client.js

@@ -1571,11 +1571,15 @@ export class GoogleAIStudioProvider extends BaseProvider {
     }
     /**
      * Generate embeddings for text using Google AI Studio embedding models
-     * @param text - The text to embed
+     * @param input - The text to embed (string or EmbedInput)
      * @param modelName - The embedding model to use (default: gemini-embedding-001)
      * @returns Promise resolving to the embedding vector
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "gemini-embedding-001";
         logger.debug("Generating embedding", {
             provider: this.providerName,

package/dist/providers/googleVertex/client.d.ts

@@ -1,7 +1,7 @@
 import type { ZodType } from "zod";
 import { AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
-import type { EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult, VertexAnthropicMessage, ChatMessage, MinimalChatMessage } from "../../types/index.js";
+import type { EmbedInput, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult, VertexAnthropicMessage, ChatMessage, MinimalChatMessage } from "../../types/index.js";
 import type { Schema, LanguageModel } from "../../types/index.js";
 export declare function buildAnthropicHistoryMessages(conversationMessages: Array<ChatMessage | MinimalChatMessage>): VertexAnthropicMessage[];
 export declare function appendUserMessage(messages: VertexAnthropicMessage[], content: VertexAnthropicMessage["content"]): void;
@@ -424,7 +424,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * provider", and `neurolink rag index --provider=vertex` fails even
      * though the SDK conceptually supports it.
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Batch-embed an array of strings via Vertex @google/genai.
      * Mirrors {@link embed} but returns one vector per input string.

package/dist/providers/googleVertex/client.js

@@ -6500,7 +6500,11 @@ export class GoogleVertexProvider extends BaseProvider {
      * provider", and `neurolink rag index --provider=vertex` fails even
      * though the SDK conceptually supports it.
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "text-embedding-004";
         logger.debug("Generating embedding", {
             provider: this.providerName,

package/dist/providers/jina.d.ts

@@ -1,6 +1,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+import type { EmbedInput, NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
 import type { LanguageModel } from "../types/index.js";
 /**
  * Jina AI Provider — embeddings + reranking.
@@ -23,7 +23,7 @@ export declare class JinaProvider extends BaseProvider {
     protected getAISDKModel(): LanguageModel;
     protected executeStream(_options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     protected formatProviderError(error: unknown): Error;
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     /**
      * Rerank a list of documents against a query.

package/dist/providers/jina.js

@@ -76,7 +76,11 @@ export class JinaProvider extends BaseProvider {
         }
         return new ProviderError(`Jina AI error: ${message}`, "jina");
     }
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const vectors = await this.callEmbeddings([text], modelName);
         if (!vectors[0]) {
             throw new Error("Jina AI returned no embedding for the provided text");

package/dist/providers/litellm/client.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../../constants/enums.js";
-import type { OpenAICompatBuildBodyArgs, OpenAICompatStreamLifecycleListeners } from "../../types/index.js";
+import type { EmbedInput, OpenAICompatBuildBodyArgs, OpenAICompatStreamLifecycleListeners } from "../../types/index.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /** Test hook: reset the discovery caches (state is module-global). */
 export declare function clearLiteLLMModelLimitsCache(): void;
@@ -87,7 +87,7 @@ export declare class LiteLLMProvider extends OpenAIChatCompletionsProvider {
     /**
      * Generate an embedding for a single text input via native /v1/embeddings.
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple text inputs via native /v1/embeddings.
      */

package/dist/providers/litellm/client.js

@@ -466,7 +466,11 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
     /**
      * Generate an embedding for a single text input via native /v1/embeddings.
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModelName = modelName ||
             process.env.LITELLM_EMBEDDING_MODEL ||
             "gemini-embedding-001";

package/dist/providers/ollama/client.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../../constants/enums.js";
-import type { NeurolinkCredentials, StreamOptions, TextGenerationOptions } from "../../types/index.js";
+import type { EmbedInput, NeurolinkCredentials, StreamOptions, TextGenerationOptions } from "../../types/index.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /**
  * Ollama Provider — direct HTTP, no AI SDK.
@@ -62,7 +62,7 @@ export declare class OllamaProvider extends OpenAIChatCompletionsProvider {
      * Uses `OLLAMA_EMBEDDING_MODEL` (default `nomic-embed-text`); the embedding
      * model must be pulled locally (`ollama pull nomic-embed-text`).
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple text inputs via native /v1/embeddings.
      */

package/dist/providers/ollama/client.js

@@ -214,7 +214,11 @@ export class OllamaProvider extends OpenAIChatCompletionsProvider {
      * Uses `OLLAMA_EMBEDDING_MODEL` (default `nomic-embed-text`); the embedding
      * model must be pulled locally (`ollama pull nomic-embed-text`).
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModel = modelName ||
             process.env.OLLAMA_EMBEDDING_MODEL ||
             DEFAULT_EMBEDDING_MODEL;

package/dist/providers/openAI/client.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../../constants/enums.js";
-import type { EnhancedGenerateResult, NeurolinkCredentials, OpenAICompatStreamLifecycleListeners, TextGenerationOptions } from "../../types/index.js";
+import type { EmbedInput, EnhancedGenerateResult, NeurolinkCredentials, OpenAICompatStreamLifecycleListeners, TextGenerationOptions } from "../../types/index.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /**
  * OpenAI Provider — direct HTTP, no AI SDK.
@@ -38,11 +38,11 @@ export declare class OpenAIProvider extends OpenAIChatCompletionsProvider {
     /**
      * Generate an embedding for a single text input via native /v1/embeddings.
      *
-     * @param text - The text to embed
+     * @param input - The text to embed (string or EmbedInput)
      * @param modelName - The embedding model to use (default: text-embedding-3-small)
      * @returns Promise resolving to the embedding vector
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple texts in a single batch via native /v1/embeddings.
      *

package/dist/providers/openAI/client.js

@@ -220,11 +220,15 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
     /**
      * Generate an embedding for a single text input via native /v1/embeddings.
      *
-     * @param text - The text to embed
+     * @param input - The text to embed (string or EmbedInput)
      * @param modelName - The embedding model to use (default: text-embedding-3-small)
      * @returns Promise resolving to the embedding vector
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModelName = modelName || this.getDefaultEmbeddingModel();
         logger.debug("Generating embedding", {
             provider: this.providerName,

package/dist/providers/voyage.d.ts

@@ -1,6 +1,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+import type { EmbedInput, NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
 import type { LanguageModel } from "../types/index.js";
 /**
  * Voyage AI Provider — embedding-only.
@@ -29,7 +29,7 @@ export declare class VoyageProvider extends BaseProvider {
     protected getAISDKModel(): LanguageModel;
     protected executeStream(_options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     protected formatProviderError(error: unknown): Error;
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     /**
      * POST /embeddings — Voyage accepts up to 128 inputs per request.

package/dist/providers/voyage.js

@@ -86,7 +86,11 @@ export class VoyageProvider extends BaseProvider {
         return new ProviderError(`Voyage AI error: ${message}`, "voyage");
     }
     // ===== Embedding implementations =====
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const vectors = await this.callEmbeddings([text], modelName);
         if (!vectors[0]) {
             throw new ProviderError("Voyage AI returned no embedding for the provided text", "voyage");

package/dist/rag/document/MDocument.d.ts

@@ -99,9 +99,27 @@ export declare class MDocument {
      * Generate embeddings for all chunks
      * @param provider - Embedding provider name
      * @param modelName - Embedding model name
+     * @param imageData - Optional array of image data (Buffer or base64) aligned with chunks,
+     *                    enabling multi-modal embeddings for providers that support them
+     * @param mimeType - MIME type of the images (default: "image/png"). Pass an
+     *                    array to declare a per-image MIME type aligned with
+     *                    `imageData`; a plain string applies to every image.
      * @returns This MDocument instance (for chaining)
      */
-    embed(provider?: string, modelName?: string): Promise<MDocument>;
+    embed(provider?: string, modelName?: string, imageData?: Array<Buffer | string>, mimeType?: string | string[]): Promise<MDocument>;
+    /**
+     * Generate multi-modal embeddings for all chunks using text + optional image data.
+     * Uses a provider that supports multi-modal embeddings (e.g. Bedrock Titan Image).
+     *
+     * @param provider - Embedding provider name
+     * @param modelName - Embedding model name
+     * @param imageData - Optional array of image data (Buffer or base64) aligned with chunks
+     * @param mimeType - MIME type of the images (default: "image/png"). Pass an
+     *                    array to declare a per-image MIME type aligned with
+     *                    `imageData`; a plain string applies to every image.
+     * @returns This MDocument instance (for chaining)
+     */
+    embedMultiModal(provider?: string, modelName?: string, imageData?: Array<Buffer | string>, mimeType?: string | string[]): Promise<MDocument>;
     /**
      * Get document ID
      */