@juspay/neurolink 9.17.2 → 9.19.0

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";
@@ -11,7 +11,7 @@ import { logger } from "../utils/logger.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
 import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { buildNativeToolDeclarations, buildNativeConfig, computeMaxSteps, collectStreamChunks, extractTextFromParts, executeNativeToolCalls, handleMaxStepsTermination, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
+import { buildNativeToolDeclarations, buildNativeConfig, computeMaxSteps, collectStreamChunks, extractTextFromParts, executeNativeToolCalls, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
 // Create Google GenAI client
@@ -444,9 +444,13 @@ export class GoogleAIStudioProvider extends BaseProvider {
             // Get tools consistently with generate method (include user-provided RAG tools)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const baseTools = shouldUseTools ? await this.getAllTools() : {};
-            const tools = shouldUseTools
+            const rawTools = shouldUseTools
                 ? { ...baseTools, ...(options.tools || {}) }
                 : {};
+            // Sanitize tool schemas for Gemini proto compatibility (converts anyOf/oneOf unions to string)
+            const tools = Object.keys(rawTools).length > 0
+                ? sanitizeToolsForGemini(rawTools)
+                : rawTools;
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
@@ -1027,6 +1031,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/googleNativeGemini3.d.ts

@@ -8,7 +8,7 @@
  * This module extracts the functions that are duplicated between the two
  * providers so they can share a single implementation.
  */
-import type { Tool } from "ai";
+import { type Tool } from "ai";
 import type { ThinkingConfig } from "../utils/thinkingConfig.js";
 /** A single native @google/genai function declaration. */
 export type NativeFunctionDeclaration = {
@@ -44,6 +44,29 @@ export type CollectedChunkResult = {
     inputTokens: number;
     outputTokens: number;
 };
+/**
+ * Sanitize a JSON Schema for Gemini's proto-based API.
+ *
+ * Gemini cannot handle `anyOf`/`oneOf` union types in function declarations
+ * because its proto format expects a single `type` field, not a list of types.
+ * This function recursively converts unions to `string` type (the most
+ * permissive primitive that can represent any value as text).
+ *
+ * Also removes `$schema`, `additionalProperties`, and `default` keys that
+ * Gemini's proto format doesn't support.
+ */
+export declare function sanitizeSchemaForGemini(schema: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Sanitize Vercel AI SDK tools for Gemini compatibility.
+ *
+ * For the Vercel AI SDK path (non-native), tool parameters are Zod schemas that
+ * get converted to JSON Schema internally by @ai-sdk/google. This conversion
+ * doesn't sanitize union types (anyOf/oneOf), causing Gemini proto errors.
+ *
+ * This function pre-converts each tool's Zod parameters to sanitized JSON Schema
+ * and re-wraps with the Vercel AI SDK's jsonSchema() helper.
+ */
+export declare function sanitizeToolsForGemini(tools: Record<string, Tool>): Record<string, Tool>;
 /**
  * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and an execute map.
  *

package/dist/providers/googleNativeGemini3.js

@@ -9,11 +9,127 @@
  * providers so they can share a single implementation.
  */
 import { randomUUID } from "node:crypto";
+import { jsonSchema as aiJsonSchema, tool as createAISDKTool, } from "ai";
 import { DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, } from "../core/constants.js";
 import { logger } from "../utils/logger.js";
 import { convertZodToJsonSchema, inlineJsonSchema, isZodSchema, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
 // ── Functions ──
+/**
+ * Sanitize a JSON Schema for Gemini's proto-based API.
+ *
+ * Gemini cannot handle `anyOf`/`oneOf` union types in function declarations
+ * because its proto format expects a single `type` field, not a list of types.
+ * This function recursively converts unions to `string` type (the most
+ * permissive primitive that can represent any value as text).
+ *
+ * Also removes `$schema`, `additionalProperties`, and `default` keys that
+ * Gemini's proto format doesn't support.
+ */
+export function sanitizeSchemaForGemini(schema) {
+    // If this node has anyOf/oneOf, collapse to string type
+    if (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)) {
+        const unionKey = schema.anyOf ? "anyOf" : "oneOf";
+        const variants = schema[unionKey];
+        // Check if it's a nullable union (e.g., anyOf: [{type: "string"}, {type: "null"}])
+        const nonNullVariants = variants.filter((v) => v.type !== "null" && v.type !== "undefined");
+        if (nonNullVariants.length === 1) {
+            // Simple nullable — use the non-null type with nullable flag
+            const base = sanitizeSchemaForGemini({ ...nonNullVariants[0] });
+            base.nullable = true;
+            if (schema.description) {
+                base.description = schema.description;
+            }
+            return base;
+        }
+        // Multi-type union — collapse to string with description noting the original types
+        const types = nonNullVariants.map((v) => v.type || "unknown").join(" | ");
+        const result = { type: "string" };
+        const desc = schema.description
+            ? `${schema.description} (accepts: ${types})`
+            : `Value as string (accepts: ${types})`;
+        result.description = desc;
+        if (variants.some((v) => v.type === "null")) {
+            result.nullable = true;
+        }
+        return result;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        // Skip keys unsupported by Gemini proto format
+        if (key === "$schema" ||
+            key === "additionalProperties" ||
+            key === "default") {
+            continue;
+        }
+        if (key === "properties" && value && typeof value === "object") {
+            const properties = {};
+            for (const [propName, propSchema] of Object.entries(value)) {
+                if (propSchema && typeof propSchema === "object") {
+                    properties[propName] = sanitizeSchemaForGemini(propSchema);
+                }
+                else {
+                    properties[propName] = propSchema;
+                }
+            }
+            result[key] = properties;
+        }
+        else if (key === "items" && value && typeof value === "object") {
+            if (Array.isArray(value)) {
+                result[key] = value.map((item) => item && typeof item === "object"
+                    ? sanitizeSchemaForGemini(item)
+                    : item);
+            }
+            else {
+                result[key] = sanitizeSchemaForGemini(value);
+            }
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Sanitize Vercel AI SDK tools for Gemini compatibility.
+ *
+ * For the Vercel AI SDK path (non-native), tool parameters are Zod schemas that
+ * get converted to JSON Schema internally by @ai-sdk/google. This conversion
+ * doesn't sanitize union types (anyOf/oneOf), causing Gemini proto errors.
+ *
+ * This function pre-converts each tool's Zod parameters to sanitized JSON Schema
+ * and re-wraps with the Vercel AI SDK's jsonSchema() helper.
+ */
+export function sanitizeToolsForGemini(tools) {
+    const sanitized = {};
+    for (const [name, tool] of Object.entries(tools)) {
+        try {
+            const params = tool.parameters;
+            if (params &&
+                typeof params === "object" &&
+                "_def" in params &&
+                typeof params.parse === "function") {
+                const rawJsonSchema = convertZodToJsonSchema(params);
+                const inlined = inlineJsonSchema(rawJsonSchema);
+                const sanitizedSchema = sanitizeSchemaForGemini(inlined);
+                sanitized[name] = createAISDKTool({
+                    description: tool.description || `Tool: ${name}`,
+                    parameters: aiJsonSchema(sanitizedSchema),
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    execute: tool.execute,
+                });
+            }
+            else {
+                sanitized[name] = tool;
+            }
+        }
+        catch (error) {
+            logger.warn(`[Gemini] Failed to sanitize tool "${name}", using original`, { error: error instanceof Error ? error.message : String(error) });
+            sanitized[name] = tool;
+        }
+    }
+    return sanitized;
+}
 /**
  * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and an execute map.
  *
@@ -38,10 +154,7 @@ export function buildNativeToolDeclarations(tools) {
             else {
                 rawSchema = { type: "object", properties: {} };
             }
-            decl.parametersJsonSchema = inlineJsonSchema(rawSchema);
-            if (decl.parametersJsonSchema.$schema) {
-                delete decl.parametersJsonSchema.$schema;
-            }
+            decl.parametersJsonSchema = sanitizeSchemaForGemini(inlineJsonSchema(rawSchema));
         }
         functionDeclarations.push(decl);
         if (tool.execute) {

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