@juspay/neurolink 9.17.2 → 9.18.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [9.18.0](https://github.com/juspay/neurolink/compare/v9.17.2...v9.18.0) (2026-03-07)
+
+### Features
+
+- **(sdk):** add embed() and embedMany() support across providers and server ([17243ad](https://github.com/juspay/neurolink/commit/17243ada417a192caa6e555f92df23938ddca6aa))
+
 ## [9.17.2](https://github.com/juspay/neurolink/compare/v9.17.1...v9.17.2) (2026-03-07)
 
 ### Bug Fixes

package/dist/core/baseProvider.d.ts

@@ -153,6 +153,19 @@ export declare abstract class BaseProvider implements AIProvider {
      * ```
      */
     embed(text: string, _modelName?: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     *
+     * This is a default implementation that throws an error.
+     * Providers that support embeddings should override this method.
+     * The AI SDK's embedMany automatically handles chunking for models with batch limits.
+     *
+     * @param texts - The texts to embed
+     * @param _modelName - Optional embedding model name (provider-specific)
+     * @returns Promise resolving to an array of embedding vectors
+     * @throws Error if the provider does not support embeddings
+     */
+    embedMany(texts: string[], _modelName?: string): Promise<number[][]>;
     /**
      * Get the default embedding model for this provider
      *

package/dist/core/baseProvider.js

@@ -756,6 +756,27 @@ export class BaseProvider {
             `Use an embedding model like text-embedding-3-small (OpenAI), text-embedding-004 (Vertex), ` +
             `or amazon.titan-embed-text-v2:0 (Bedrock).`);
     }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     *
+     * This is a default implementation that throws an error.
+     * Providers that support embeddings should override this method.
+     * The AI SDK's embedMany automatically handles chunking for models with batch limits.
+     *
+     * @param texts - The texts to embed
+     * @param _modelName - Optional embedding model name (provider-specific)
+     * @returns Promise resolving to an array of embedding vectors
+     * @throws Error if the provider does not support embeddings
+     */
+    async embedMany(texts, _modelName) {
+        logger.warn(`embedMany() called on ${this.providerName} which does not have a native implementation`, {
+            count: texts.length,
+        });
+        throw new Error(`Batch embedding generation is not supported by the ${this.providerName} provider. ` +
+            `Supported providers: openai, googleAiStudio, vertex/google, bedrock. ` +
+            `Use an embedding model like text-embedding-3-small (OpenAI), gemini-embedding-001 (Google AI), ` +
+            `text-embedding-004 (Vertex), or amazon.titan-embed-text-v2:0 (Bedrock).`);
+    }
     /**
      * Get the default embedding model for this provider
      *

package/dist/lib/core/baseProvider.d.ts

@@ -153,6 +153,19 @@ export declare abstract class BaseProvider implements AIProvider {
      * ```
      */
     embed(text: string, _modelName?: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     *
+     * This is a default implementation that throws an error.
+     * Providers that support embeddings should override this method.
+     * The AI SDK's embedMany automatically handles chunking for models with batch limits.
+     *
+     * @param texts - The texts to embed
+     * @param _modelName - Optional embedding model name (provider-specific)
+     * @returns Promise resolving to an array of embedding vectors
+     * @throws Error if the provider does not support embeddings
+     */
+    embedMany(texts: string[], _modelName?: string): Promise<number[][]>;
     /**
      * Get the default embedding model for this provider
      *

package/dist/lib/core/baseProvider.js

@@ -756,6 +756,27 @@ export class BaseProvider {
             `Use an embedding model like text-embedding-3-small (OpenAI), text-embedding-004 (Vertex), ` +
             `or amazon.titan-embed-text-v2:0 (Bedrock).`);
     }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     *
+     * This is a default implementation that throws an error.
+     * Providers that support embeddings should override this method.
+     * The AI SDK's embedMany automatically handles chunking for models with batch limits.
+     *
+     * @param texts - The texts to embed
+     * @param _modelName - Optional embedding model name (provider-specific)
+     * @returns Promise resolving to an array of embedding vectors
+     * @throws Error if the provider does not support embeddings
+     */
+    async embedMany(texts, _modelName) {
+        logger.warn(`embedMany() called on ${this.providerName} which does not have a native implementation`, {
+            count: texts.length,
+        });
+        throw new Error(`Batch embedding generation is not supported by the ${this.providerName} provider. ` +
+            `Supported providers: openai, googleAiStudio, vertex/google, bedrock. ` +
+            `Use an embedding model like text-embedding-3-small (OpenAI), gemini-embedding-001 (Google AI), ` +
+            `text-embedding-004 (Vertex), or amazon.titan-embed-text-v2:0 (Bedrock).`);
+    }
     /**
      * Get the default embedding model for this provider
      *

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

@@ -53,4 +53,11 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      * @returns Promise resolving to the embedding vector
      */
     embed(text: string, modelName?: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
 }

package/dist/lib/providers/amazonBedrock.js

@@ -1470,5 +1470,37 @@ export class AmazonBedrockProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    async embedMany(texts, modelName) {
+        const embeddingModelName = modelName || "amazon.titan-embed-text-v2:0";
+        logger.debug("Generating batch embeddings", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: texts.length,
+        });
+        try {
+            const embeddings = await Promise.all(texts.map((text) => this.embed(text, embeddingModelName)));
+            logger.debug("Batch embeddings generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                count: embeddings.length,
+                embeddingDimension: embeddings[0]?.length,
+            });
+            return embeddings;
+        }
+        catch (error) {
+            logger.error("Batch embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                count: texts.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
 }
 //# sourceMappingURL=amazonBedrock.js.map

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

@@ -75,6 +75,21 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      */
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
     private executeAudioStreamViaGeminiLive;
+    protected getDefaultEmbeddingModel(): string;
+    /**
+     * Generate embeddings for text using Google AI Studio embedding models
+     * @param text - The text to embed
+     * @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[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: gemini-embedding-001)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     private getApiKey;
 }
 export default GoogleAIStudioProvider;

package/dist/lib/providers/googleAiStudio.js

@@ -1,5 +1,5 @@
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { streamText } from "ai";
+import { embed, embedMany, streamText, } from "ai";
 import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enums.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -1027,6 +1027,86 @@ export class GoogleAIStudioProvider extends BaseProvider {
             },
         };
     }
+    getDefaultEmbeddingModel() {
+        return (process.env.GOOGLE_AI_EMBEDDING_MODEL ||
+            process.env.GOOGLE_EMBEDDING_MODEL ||
+            "gemini-embedding-001");
+    }
+    /**
+     * Generate embeddings for text using Google AI Studio embedding models
+     * @param text - The text to embed
+     * @param modelName - The embedding model to use (default: gemini-embedding-001)
+     * @returns Promise resolving to the embedding vector
+     */
+    async embed(text, modelName) {
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "gemini-embedding-001";
+        logger.debug("Generating embedding", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            textLength: text.length,
+        });
+        try {
+            const apiKey = this.getApiKey();
+            const google = createGoogleGenerativeAI({ apiKey });
+            const embeddingModel = google.textEmbeddingModel(embeddingModelName);
+            const result = await embed({
+                model: embeddingModel,
+                value: text,
+            });
+            logger.debug("Embedding generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                embeddingDimension: result.embedding.length,
+            });
+            return result.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);
+        }
+    }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: gemini-embedding-001)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    async embedMany(texts, modelName) {
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "gemini-embedding-001";
+        logger.debug("Generating batch embeddings", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: texts.length,
+        });
+        try {
+            const apiKey = this.getApiKey();
+            const google = createGoogleGenerativeAI({ apiKey });
+            const embeddingModel = google.textEmbeddingModel(embeddingModelName);
+            const result = await embedMany({
+                model: embeddingModel,
+                values: texts,
+            });
+            logger.debug("Batch embeddings generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                count: result.embeddings.length,
+                embeddingDimension: result.embeddings[0]?.length,
+            });
+            return result.embeddings;
+        }
+        catch (error) {
+            logger.error("Batch embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                count: texts.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
     getApiKey() {
         const apiKey = process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
         if (!apiKey) {

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

@@ -298,6 +298,13 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * @returns Promise resolving to the embedding vector
      */
     embed(text: string, modelName?: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: text-embedding-004)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     /**
      * Get model suggestions when a model is not found
      */

package/dist/lib/providers/googleVertex.js

@@ -1,6 +1,6 @@
 import { createVertex, } from "@ai-sdk/google-vertex";
 import { createVertexAnthropic, } from "@ai-sdk/google-vertex/anthropic";
-import { Output, streamText, } from "ai";
+import { embed, embedMany, Output, streamText, } from "ai";
 import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import dns from "node:dns";
 import fs from "fs";
@@ -2691,8 +2691,6 @@ export class GoogleVertexProvider extends BaseProvider {
             textLength: text.length,
         });
         try {
-            // Create embedding model using the AI SDK
-            const { embed } = await import("ai");
             // Create the Vertex provider with current settings
             const vertexSettings = await createVertexSettings(this.location);
             const vertex = createVertex(vertexSettings);
@@ -2719,6 +2717,44 @@ export class GoogleVertexProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: text-embedding-004)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    async embedMany(texts, modelName) {
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "text-embedding-004";
+        logger.debug("Generating batch embeddings", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: texts.length,
+        });
+        try {
+            const vertexSettings = await createVertexSettings(this.location);
+            const vertex = createVertex(vertexSettings);
+            const embeddingModel = vertex.textEmbeddingModel(embeddingModelName);
+            const result = await embedMany({
+                model: embeddingModel,
+                values: texts,
+            });
+            logger.debug("Batch embeddings generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                count: result.embeddings.length,
+                embeddingDimension: result.embeddings[0]?.length,
+            });
+            return result.embeddings;
+        }
+        catch (error) {
+            logger.error("Batch embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                count: texts.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
     /**
      * Get model suggestions when a model is not found
      */

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

@@ -59,5 +59,12 @@ export declare class OpenAIProvider extends BaseProvider {
      * @returns Promise resolving to the embedding vector
      */
     embed(text: string, modelName?: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: text-embedding-3-small)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
 }
 export default OpenAIProvider;

package/dist/lib/providers/openAI.js

@@ -1,5 +1,5 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { streamText } from "ai";
+import { embed, embedMany, streamText, } from "ai";
 import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -529,7 +529,6 @@ export class OpenAIProvider extends BaseProvider {
         });
         try {
             // Create embedding model using the AI SDK
-            const { embed } = await import("ai");
             // Create the OpenAI provider
             const openai = createOpenAI({
                 apiKey: getOpenAIApiKey(),
@@ -558,6 +557,46 @@ export class OpenAIProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: text-embedding-3-small)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    async embedMany(texts, modelName) {
+        const embeddingModelName = modelName || "text-embedding-3-small";
+        logger.debug("Generating batch embeddings", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: texts.length,
+        });
+        try {
+            const openai = createOpenAI({
+                apiKey: getOpenAIApiKey(),
+                fetch: createProxyFetch(),
+            });
+            const embeddingModel = openai.textEmbeddingModel(embeddingModelName);
+            const result = await embedMany({
+                model: embeddingModel,
+                values: texts,
+            });
+            logger.debug("Batch embeddings generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                count: result.embeddings.length,
+                embeddingDimension: result.embeddings[0]?.length,
+            });
+            return result.embeddings;
+        }
+        catch (error) {
+            logger.error("Batch embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                count: texts.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
 }
 // Export for factory registration
 export default OpenAIProvider;

package/dist/lib/server/routes/agentRoutes.js

@@ -4,7 +4,7 @@
  */
 import { ProviderFactory } from "../../factories/providerFactory.js";
 import { createStreamRedactor } from "../utils/redaction.js";
-import { AgentExecuteRequestSchema, validateRequest, } from "../utils/validation.js";
+import { AgentExecuteRequestSchema, createErrorResponse as createError, EmbedManyRequestSchema, EmbedRequestSchema, validateRequest, } from "../utils/validation.js";
 /**
  * Create agent routes
  */
@@ -107,6 +107,65 @@ export function createAgentRoutes(basePath = "/api") {
                 description: "List available AI providers",
                 tags: ["agent", "providers"],
             },
+            {
+                method: "POST",
+                path: `${basePath}/agent/embed`,
+                handler: async (ctx) => {
+                    const validation = validateRequest(EmbedRequestSchema, ctx.body, ctx.requestId);
+                    if (!validation.success) {
+                        return validation.error;
+                    }
+                    const request = validation.data;
+                    try {
+                        const providerName = request.provider || "openai";
+                        const provider = await ProviderFactory.createProvider(providerName, request.model);
+                        const embedding = await provider.embed(request.text, request.model);
+                        return {
+                            embedding,
+                            provider: providerName,
+                            model: request.model || "default",
+                            dimension: embedding.length,
+                        };
+                    }
+                    catch (error) {
+                        return createError("EXECUTION_FAILED", error instanceof Error
+                            ? error.message
+                            : "Embedding generation failed", undefined, ctx.requestId);
+                    }
+                },
+                description: "Generate embedding for a single text",
+                tags: ["agent", "embeddings"],
+            },
+            {
+                method: "POST",
+                path: `${basePath}/agent/embed-many`,
+                handler: async (ctx) => {
+                    const validation = validateRequest(EmbedManyRequestSchema, ctx.body, ctx.requestId);
+                    if (!validation.success) {
+                        return validation.error;
+                    }
+                    const request = validation.data;
+                    try {
+                        const providerName = request.provider || "openai";
+                        const provider = await ProviderFactory.createProvider(providerName, request.model);
+                        const embeddings = await provider.embedMany(request.texts, request.model);
+                        return {
+                            embeddings,
+                            provider: providerName,
+                            model: request.model || "default",
+                            count: embeddings.length,
+                            dimension: embeddings[0]?.length ?? 0,
+                        };
+                    }
+                    catch (error) {
+                        return createError("EXECUTION_FAILED", error instanceof Error
+                            ? error.message
+                            : "Batch embedding generation failed", undefined, ctx.requestId);
+                    }
+                },
+                description: "Generate embeddings for multiple texts in a batch",
+                tags: ["agent", "embeddings"],
+            },
         ],
     };
 }

package/dist/lib/server/types.d.ts

@@ -458,6 +458,56 @@ export type AgentExecuteResponse = {
     /** Response metadata */
     metadata?: Record<string, JsonValue>;
 };
+/**
+ * Embed request (single text)
+ */
+export type EmbedRequest = {
+    /** Text to embed */
+    text: string;
+    /** Provider to use (optional) */
+    provider?: string;
+    /** Embedding model to use (optional) */
+    model?: string;
+};
+/**
+ * Embed response (single text)
+ */
+export type EmbedResponse = {
+    /** The embedding vector */
+    embedding: number[];
+    /** Provider used */
+    provider: string;
+    /** Model used */
+    model: string;
+    /** Embedding dimension */
+    dimension: number;
+};
+/**
+ * Embed many request (batch texts)
+ */
+export type EmbedManyRequest = {
+    /** Texts to embed */
+    texts: string[];
+    /** Provider to use (optional) */
+    provider?: string;
+    /** Embedding model to use (optional) */
+    model?: string;
+};
+/**
+ * Embed many response (batch texts)
+ */
+export type EmbedManyResponse = {
+    /** The embedding vectors */
+    embeddings: number[][];
+    /** Provider used */
+    provider: string;
+    /** Model used */
+    model: string;
+    /** Number of embeddings */
+    count: number;
+    /** Embedding dimension */
+    dimension: number;
+};
 /**
  * Tool execution request
  */

package/dist/lib/server/utils/validation.d.ts

@@ -168,6 +168,38 @@ export declare const SessionMessagesQuerySchema: z.ZodObject<{
     offset?: string | undefined;
     limit?: string | undefined;
 }>;
+/**
+ * Embed request schema (single text)
+ */
+export declare const EmbedRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    provider?: string | undefined;
+    model?: string | undefined;
+}, {
+    text: string;
+    provider?: string | undefined;
+    model?: string | undefined;
+}>;
+/**
+ * Embed many request schema (batch texts)
+ */
+export declare const EmbedManyRequestSchema: z.ZodObject<{
+    texts: z.ZodArray<z.ZodString, "many">;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    texts: string[];
+    provider?: string | undefined;
+    model?: string | undefined;
+}, {
+    texts: string[];
+    provider?: string | undefined;
+    model?: string | undefined;
+}>;
 /**
  * Standardized error response format
  */

package/dist/lib/server/utils/validation.js

@@ -108,6 +108,25 @@ export const SessionMessagesQuerySchema = z.object({
         .pipe(z.number().nonnegative())
         .optional(),
 });
+/**
+ * Embed request schema (single text)
+ */
+export const EmbedRequestSchema = z.object({
+    text: z.string().min(1, "Text is required"),
+    provider: z.string().optional(),
+    model: z.string().optional(),
+});
+/**
+ * Embed many request schema (batch texts)
+ */
+export const EmbedManyRequestSchema = z.object({
+    texts: z
+        .array(z.string().min(1))
+        .min(1, "At least one text is required")
+        .max(2048, "Maximum 2048 texts per batch"),
+    provider: z.string().optional(),
+    model: z.string().optional(),
+});
 /**
  * Type guard to check if a value is an ErrorResponse
  */

package/dist/lib/types/providers.d.ts

@@ -329,6 +329,8 @@ export type AIProvider = {
     stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ValidationSchema): Promise<StreamResult>;
     generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
     gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
+    embed(text: string, modelName?: string): Promise<number[]>;
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     setupToolExecutor(sdk: {
         customTools: Map<string, unknown>;
         executeTool: (toolName: string, params: unknown) => Promise<unknown>;

package/dist/providers/amazonBedrock.d.ts

@@ -53,4 +53,11 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      * @returns Promise resolving to the embedding vector
      */
     embed(text: string, modelName?: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
 }

package/dist/providers/amazonBedrock.js

@@ -1470,4 +1470,36 @@ export class AmazonBedrockProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    async embedMany(texts, modelName) {
+        const embeddingModelName = modelName || "amazon.titan-embed-text-v2:0";
+        logger.debug("Generating batch embeddings", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: texts.length,
+        });
+        try {
+            const embeddings = await Promise.all(texts.map((text) => this.embed(text, embeddingModelName)));
+            logger.debug("Batch embeddings generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                count: embeddings.length,
+                embeddingDimension: embeddings[0]?.length,
+            });
+            return embeddings;
+        }
+        catch (error) {
+            logger.error("Batch embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                count: texts.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
 }

package/dist/providers/googleAiStudio.d.ts

@@ -75,6 +75,21 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      */
     generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
     private executeAudioStreamViaGeminiLive;
+    protected getDefaultEmbeddingModel(): string;
+    /**
+     * Generate embeddings for text using Google AI Studio embedding models
+     * @param text - The text to embed
+     * @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[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: gemini-embedding-001)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     private getApiKey;
 }
 export default GoogleAIStudioProvider;

package/dist/providers/googleAiStudio.js

@@ -1,5 +1,5 @@
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { streamText } from "ai";
+import { embed, embedMany, streamText, } from "ai";
 import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enums.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -1027,6 +1027,86 @@ export class GoogleAIStudioProvider extends BaseProvider {
             },
         };
     }
+    getDefaultEmbeddingModel() {
+        return (process.env.GOOGLE_AI_EMBEDDING_MODEL ||
+            process.env.GOOGLE_EMBEDDING_MODEL ||
+            "gemini-embedding-001");
+    }
+    /**
+     * Generate embeddings for text using Google AI Studio embedding models
+     * @param text - The text to embed
+     * @param modelName - The embedding model to use (default: gemini-embedding-001)
+     * @returns Promise resolving to the embedding vector
+     */
+    async embed(text, modelName) {
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "gemini-embedding-001";
+        logger.debug("Generating embedding", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            textLength: text.length,
+        });
+        try {
+            const apiKey = this.getApiKey();
+            const google = createGoogleGenerativeAI({ apiKey });
+            const embeddingModel = google.textEmbeddingModel(embeddingModelName);
+            const result = await embed({
+                model: embeddingModel,
+                value: text,
+            });
+            logger.debug("Embedding generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                embeddingDimension: result.embedding.length,
+            });
+            return result.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);
+        }
+    }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: gemini-embedding-001)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    async embedMany(texts, modelName) {
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "gemini-embedding-001";
+        logger.debug("Generating batch embeddings", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: texts.length,
+        });
+        try {
+            const apiKey = this.getApiKey();
+            const google = createGoogleGenerativeAI({ apiKey });
+            const embeddingModel = google.textEmbeddingModel(embeddingModelName);
+            const result = await embedMany({
+                model: embeddingModel,
+                values: texts,
+            });
+            logger.debug("Batch embeddings generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                count: result.embeddings.length,
+                embeddingDimension: result.embeddings[0]?.length,
+            });
+            return result.embeddings;
+        }
+        catch (error) {
+            logger.error("Batch embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                count: texts.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
     getApiKey() {
         const apiKey = process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
         if (!apiKey) {

package/dist/providers/googleVertex.d.ts

@@ -298,6 +298,13 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * @returns Promise resolving to the embedding vector
      */
     embed(text: string, modelName?: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: text-embedding-004)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     /**
      * Get model suggestions when a model is not found
      */

package/dist/providers/googleVertex.js

@@ -1,6 +1,6 @@
 import { createVertex, } from "@ai-sdk/google-vertex";
 import { createVertexAnthropic, } from "@ai-sdk/google-vertex/anthropic";
-import { Output, streamText, } from "ai";
+import { embed, embedMany, Output, streamText, } from "ai";
 import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import dns from "node:dns";
 import fs from "fs";
@@ -2691,8 +2691,6 @@ export class GoogleVertexProvider extends BaseProvider {
             textLength: text.length,
         });
         try {
-            // Create embedding model using the AI SDK
-            const { embed } = await import("ai");
             // Create the Vertex provider with current settings
             const vertexSettings = await createVertexSettings(this.location);
             const vertex = createVertex(vertexSettings);
@@ -2719,6 +2717,44 @@ export class GoogleVertexProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: text-embedding-004)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    async embedMany(texts, modelName) {
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "text-embedding-004";
+        logger.debug("Generating batch embeddings", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: texts.length,
+        });
+        try {
+            const vertexSettings = await createVertexSettings(this.location);
+            const vertex = createVertex(vertexSettings);
+            const embeddingModel = vertex.textEmbeddingModel(embeddingModelName);
+            const result = await embedMany({
+                model: embeddingModel,
+                values: texts,
+            });
+            logger.debug("Batch embeddings generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                count: result.embeddings.length,
+                embeddingDimension: result.embeddings[0]?.length,
+            });
+            return result.embeddings;
+        }
+        catch (error) {
+            logger.error("Batch embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                count: texts.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
     /**
      * Get model suggestions when a model is not found
      */

package/dist/providers/openAI.d.ts

@@ -59,5 +59,12 @@ export declare class OpenAIProvider extends BaseProvider {
      * @returns Promise resolving to the embedding vector
      */
     embed(text: string, modelName?: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: text-embedding-3-small)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
 }
 export default OpenAIProvider;

package/dist/providers/openAI.js

@@ -1,5 +1,5 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { streamText } from "ai";
+import { embed, embedMany, streamText, } from "ai";
 import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -529,7 +529,6 @@ export class OpenAIProvider extends BaseProvider {
         });
         try {
             // Create embedding model using the AI SDK
-            const { embed } = await import("ai");
             // Create the OpenAI provider
             const openai = createOpenAI({
                 apiKey: getOpenAIApiKey(),
@@ -558,6 +557,46 @@ export class OpenAIProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Generate embeddings for multiple texts in a single batch
+     * @param texts - The texts to embed
+     * @param modelName - The embedding model to use (default: text-embedding-3-small)
+     * @returns Promise resolving to an array of embedding vectors
+     */
+    async embedMany(texts, modelName) {
+        const embeddingModelName = modelName || "text-embedding-3-small";
+        logger.debug("Generating batch embeddings", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: texts.length,
+        });
+        try {
+            const openai = createOpenAI({
+                apiKey: getOpenAIApiKey(),
+                fetch: createProxyFetch(),
+            });
+            const embeddingModel = openai.textEmbeddingModel(embeddingModelName);
+            const result = await embedMany({
+                model: embeddingModel,
+                values: texts,
+            });
+            logger.debug("Batch embeddings generated successfully", {
+                provider: this.providerName,
+                model: embeddingModelName,
+                count: result.embeddings.length,
+                embeddingDimension: result.embeddings[0]?.length,
+            });
+            return result.embeddings;
+        }
+        catch (error) {
+            logger.error("Batch embedding generation failed", {
+                error: error instanceof Error ? error.message : String(error),
+                model: embeddingModelName,
+                count: texts.length,
+            });
+            throw this.handleProviderError(error);
+        }
+    }
 }
 // Export for factory registration
 export default OpenAIProvider;

package/dist/server/routes/agentRoutes.js

@@ -4,7 +4,7 @@
  */
 import { ProviderFactory } from "../../factories/providerFactory.js";
 import { createStreamRedactor } from "../utils/redaction.js";
-import { AgentExecuteRequestSchema, validateRequest, } from "../utils/validation.js";
+import { AgentExecuteRequestSchema, createErrorResponse as createError, EmbedManyRequestSchema, EmbedRequestSchema, validateRequest, } from "../utils/validation.js";
 /**
  * Create agent routes
  */
@@ -107,6 +107,65 @@ export function createAgentRoutes(basePath = "/api") {
                 description: "List available AI providers",
                 tags: ["agent", "providers"],
             },
+            {
+                method: "POST",
+                path: `${basePath}/agent/embed`,
+                handler: async (ctx) => {
+                    const validation = validateRequest(EmbedRequestSchema, ctx.body, ctx.requestId);
+                    if (!validation.success) {
+                        return validation.error;
+                    }
+                    const request = validation.data;
+                    try {
+                        const providerName = request.provider || "openai";
+                        const provider = await ProviderFactory.createProvider(providerName, request.model);
+                        const embedding = await provider.embed(request.text, request.model);
+                        return {
+                            embedding,
+                            provider: providerName,
+                            model: request.model || "default",
+                            dimension: embedding.length,
+                        };
+                    }
+                    catch (error) {
+                        return createError("EXECUTION_FAILED", error instanceof Error
+                            ? error.message
+                            : "Embedding generation failed", undefined, ctx.requestId);
+                    }
+                },
+                description: "Generate embedding for a single text",
+                tags: ["agent", "embeddings"],
+            },
+            {
+                method: "POST",
+                path: `${basePath}/agent/embed-many`,
+                handler: async (ctx) => {
+                    const validation = validateRequest(EmbedManyRequestSchema, ctx.body, ctx.requestId);
+                    if (!validation.success) {
+                        return validation.error;
+                    }
+                    const request = validation.data;
+                    try {
+                        const providerName = request.provider || "openai";
+                        const provider = await ProviderFactory.createProvider(providerName, request.model);
+                        const embeddings = await provider.embedMany(request.texts, request.model);
+                        return {
+                            embeddings,
+                            provider: providerName,
+                            model: request.model || "default",
+                            count: embeddings.length,
+                            dimension: embeddings[0]?.length ?? 0,
+                        };
+                    }
+                    catch (error) {
+                        return createError("EXECUTION_FAILED", error instanceof Error
+                            ? error.message
+                            : "Batch embedding generation failed", undefined, ctx.requestId);
+                    }
+                },
+                description: "Generate embeddings for multiple texts in a batch",
+                tags: ["agent", "embeddings"],
+            },
         ],
     };
 }

package/dist/server/types.d.ts

@@ -458,6 +458,56 @@ export type AgentExecuteResponse = {
     /** Response metadata */
     metadata?: Record<string, JsonValue>;
 };
+/**
+ * Embed request (single text)
+ */
+export type EmbedRequest = {
+    /** Text to embed */
+    text: string;
+    /** Provider to use (optional) */
+    provider?: string;
+    /** Embedding model to use (optional) */
+    model?: string;
+};
+/**
+ * Embed response (single text)
+ */
+export type EmbedResponse = {
+    /** The embedding vector */
+    embedding: number[];
+    /** Provider used */
+    provider: string;
+    /** Model used */
+    model: string;
+    /** Embedding dimension */
+    dimension: number;
+};
+/**
+ * Embed many request (batch texts)
+ */
+export type EmbedManyRequest = {
+    /** Texts to embed */
+    texts: string[];
+    /** Provider to use (optional) */
+    provider?: string;
+    /** Embedding model to use (optional) */
+    model?: string;
+};
+/**
+ * Embed many response (batch texts)
+ */
+export type EmbedManyResponse = {
+    /** The embedding vectors */
+    embeddings: number[][];
+    /** Provider used */
+    provider: string;
+    /** Model used */
+    model: string;
+    /** Number of embeddings */
+    count: number;
+    /** Embedding dimension */
+    dimension: number;
+};
 /**
  * Tool execution request
  */

package/dist/server/utils/validation.d.ts

@@ -168,6 +168,38 @@ export declare const SessionMessagesQuerySchema: z.ZodObject<{
     offset?: string | undefined;
     limit?: string | undefined;
 }>;
+/**
+ * Embed request schema (single text)
+ */
+export declare const EmbedRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    provider?: string | undefined;
+    model?: string | undefined;
+}, {
+    text: string;
+    provider?: string | undefined;
+    model?: string | undefined;
+}>;
+/**
+ * Embed many request schema (batch texts)
+ */
+export declare const EmbedManyRequestSchema: z.ZodObject<{
+    texts: z.ZodArray<z.ZodString, "many">;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    texts: string[];
+    provider?: string | undefined;
+    model?: string | undefined;
+}, {
+    texts: string[];
+    provider?: string | undefined;
+    model?: string | undefined;
+}>;
 /**
  * Standardized error response format
  */

package/dist/server/utils/validation.js

@@ -108,6 +108,25 @@ export const SessionMessagesQuerySchema = z.object({
         .pipe(z.number().nonnegative())
         .optional(),
 });
+/**
+ * Embed request schema (single text)
+ */
+export const EmbedRequestSchema = z.object({
+    text: z.string().min(1, "Text is required"),
+    provider: z.string().optional(),
+    model: z.string().optional(),
+});
+/**
+ * Embed many request schema (batch texts)
+ */
+export const EmbedManyRequestSchema = z.object({
+    texts: z
+        .array(z.string().min(1))
+        .min(1, "At least one text is required")
+        .max(2048, "Maximum 2048 texts per batch"),
+    provider: z.string().optional(),
+    model: z.string().optional(),
+});
 /**
  * Type guard to check if a value is an ErrorResponse
  */

package/dist/types/providers.d.ts

@@ -329,6 +329,8 @@ export type AIProvider = {
     stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ValidationSchema): Promise<StreamResult>;
     generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
     gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ValidationSchema): Promise<EnhancedGenerateResult | null>;
+    embed(text: string, modelName?: string): Promise<number[]>;
+    embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     setupToolExecutor(sdk: {
         customTools: Map<string, unknown>;
         executeTool: (toolName: string, params: unknown) => Promise<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.17.2",
+  "version": "9.18.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",