@juspay/neurolink 5.0.0 → 5.2.0

package/dist/lib/providers/function-calling-provider.js

@@ -3,7 +3,7 @@
  * Integrates MCP tools directly with AI SDK's function calling capabilities
  * This is the missing piece that enables true AI function calling!
  */
-import { generateText as aiGenerateText, Output, } from "ai";
+import { generateText as aiGenerate, Output, } from "ai";
 import { getAvailableFunctionTools, executeFunctionCall, isFunctionCallingAvailable, } from "../mcp/function-calling.js";
 import { createExecutionContext } from "../mcp/context-manager.js";
 import { mcpLogger } from "../mcp/logging.js";
@@ -22,31 +22,88 @@ export class FunctionCallingProvider {
         this.sessionId = options.sessionId || `function-calling-${Date.now()}`;
         this.userId = options.userId || "function-calling-user";
     }
+    /**
+     * PRIMARY METHOD: Stream content using AI (recommended for new code)
+     * Future-ready for multi-modal capabilities with current text focus
+     */
+    async stream(optionsOrPrompt, analysisSchema) {
+        const functionTag = "FunctionCallingProvider.stream";
+        const startTime = Date.now();
+        // Parse parameters - support both string and options object
+        const options = typeof optionsOrPrompt === "string"
+            ? { input: { text: optionsOrPrompt } }
+            : optionsOrPrompt;
+        // Validate input
+        if (!options?.input?.text ||
+            typeof options.input.text !== "string" ||
+            options.input.text.trim() === "") {
+            throw new Error("Stream options must include input.text as a non-empty string");
+        }
+        // Use base provider's stream implementation
+        const baseResult = await this.baseProvider.stream(options);
+        if (!baseResult) {
+            throw new Error("No stream response received from provider");
+        }
+        // Return the result with function-calling metadata
+        return {
+            ...baseResult,
+            provider: "function-calling",
+            model: options.model || "unknown",
+            metadata: {
+                streamId: `function-calling-${Date.now()}`,
+                startTime,
+            },
+        };
+    }
     /**
      * Generate text with real function calling support
      */
-    async generateText(optionsOrPrompt, analysisSchema) {
+    async generate(optionsOrPrompt, analysisSchema) {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const functionTag = "FunctionCallingProvider.generateText";
+        const functionTag = "FunctionCallingProvider.generate";
         // If function calling is disabled, use base provider
         if (!this.enableFunctionCalling) {
             mcpLogger.debug(`[${functionTag}] Function calling disabled, using base provider`);
-            return this.baseProvider.generateText(options, analysisSchema);
+            const result = await this.baseProvider.generate(options, analysisSchema);
+            if (!result) {
+                return {
+                    content: "No response generated",
+                    provider: "function-calling",
+                    model: "unknown",
+                };
+            }
+            return result;
         }
         try {
             // Check if function calling is available
             const functionsAvailable = await isFunctionCallingAvailable();
             if (!functionsAvailable) {
                 mcpLogger.debug(`[${functionTag}] No functions available, using base provider`);
-                return this.baseProvider.generateText(options, analysisSchema);
+                const result = await this.baseProvider.generate(options, analysisSchema);
+                if (!result) {
+                    return {
+                        content: "No response generated",
+                        provider: "function-calling",
+                        model: "unknown",
+                    };
+                }
+                return result;
             }
             // Get available function tools
             const { tools, toolMap } = await getAvailableFunctionTools();
             if (tools.length === 0) {
                 mcpLogger.debug(`[${functionTag}] No tools available, using base provider`);
-                return this.baseProvider.generateText(options, analysisSchema);
+                const result = await this.baseProvider.generate(options, analysisSchema);
+                if (!result) {
+                    return {
+                        content: "No response generated",
+                        provider: "function-calling",
+                        model: "unknown",
+                    };
+                }
+                return result;
             }
             mcpLogger.debug(`[${functionTag}] Function calling enabled with ${tools.length} tools`);
             // Create execution context
@@ -55,11 +112,15 @@ export class FunctionCallingProvider {
                 userId: this.userId,
                 aiProvider: this.baseProvider.constructor.name,
             });
-            // Use the AI SDK's native function calling by calling generateText directly
+            // Use the AI SDK's native function calling by calling generate directly
             // We need to get the underlying model from the base provider
-            const result = await this.generateTextWithTools(options, tools, toolMap, context, analysisSchema);
+            const result = await this.generateWithTools(options, tools, toolMap, context, analysisSchema);
             if (!result) {
-                return null;
+                return {
+                    content: "No response generated",
+                    provider: "function-calling",
+                    model: "unknown",
+                };
             }
             // Enhance result with function calling metadata
             const enhancedResult = {
@@ -77,18 +138,26 @@ export class FunctionCallingProvider {
         }
         catch (error) {
             mcpLogger.warn(`[${functionTag}] Function calling failed, using base provider:`, error);
-            return this.baseProvider.generateText(options, analysisSchema);
+            const result = await this.baseProvider.generate(options, analysisSchema);
+            if (!result) {
+                return {
+                    content: "No response generated",
+                    provider: "function-calling",
+                    model: "unknown",
+                };
+            }
+            return result;
         }
     }
     /**
      * Generate text using AI SDK's native function calling
      */
-    async generateTextWithTools(options, tools, toolMap, context, analysisSchema) {
-        const functionTag = "FunctionCallingProvider.generateTextWithTools";
+    async generateWithTools(options, tools, toolMap, context, analysisSchema) {
+        const functionTag = "FunctionCallingProvider.generateWithTools";
         try {
             // Convert our tools to AI SDK format with proper execution
             const toolsWithExecution = this.convertToAISDKTools(tools, toolMap, context);
-            mcpLogger.debug(`[${functionTag}] Calling AI SDK generateText with ${Object.keys(toolsWithExecution).length} tools and maxSteps: 5`);
+            mcpLogger.debug(`[${functionTag}] Calling AI SDK generate with ${Object.keys(toolsWithExecution).length} tools and maxSteps: 5`);
             mcpLogger.debug(`[${functionTag}] Sanitized tool names:`, Object.keys(toolsWithExecution));
             // Log the first few tools to debug the issue
             const toolNames = Object.keys(toolsWithExecution);
@@ -99,9 +168,17 @@ export class FunctionCallingProvider {
             const modelInfo = await this.getModelFromProvider();
             if (!modelInfo) {
                 mcpLogger.warn(`[${functionTag}] Could not get model from provider, falling back to base provider`);
-                return this.baseProvider.generateText(options, analysisSchema);
+                const result = await this.baseProvider.generate(options, analysisSchema);
+                if (!result) {
+                    return {
+                        content: "No response generated",
+                        provider: "function-calling",
+                        model: "unknown",
+                    };
+                }
+                return result;
             }
-            // Use AI SDK's generateText directly with tools
+            // Use AI SDK's generate directly with tools
             const generateOptions = {
                 model: modelInfo.model,
                 prompt: options.prompt,
@@ -118,13 +195,29 @@ export class FunctionCallingProvider {
                     schema: analysisSchema,
                 });
             }
-            const result = await aiGenerateText(generateOptions);
-            mcpLogger.debug(`[${functionTag}] AI SDK generateText completed`, {
+            const result = await aiGenerate(generateOptions);
+            mcpLogger.debug(`[${functionTag}] AI SDK generate completed`, {
                 toolCalls: result.toolCalls?.length || 0,
                 finishReason: result.finishReason,
                 usage: result.usage,
             });
-            return result;
+            return {
+                content: result.text,
+                provider: "function-calling",
+                model: "unknown",
+                usage: result.usage
+                    ? {
+                        inputTokens: result.usage.promptTokens,
+                        outputTokens: result.usage.completionTokens,
+                        totalTokens: result.usage.totalTokens,
+                    }
+                    : undefined,
+                responseTime: 0,
+                toolsUsed: result.toolCalls?.map((tc) => tc.toolName) || [],
+                toolExecutions: [],
+                enhancedWithTools: (result.toolCalls?.length || 0) > 0,
+                availableTools: [],
+            };
         }
         catch (error) {
             mcpLogger.error(`[${functionTag}] Failed to generate text with tools:`, error);
@@ -299,56 +392,13 @@ CRITICAL INSTRUCTIONS:
 These functions provide accurate, real-time data. Use them actively to enhance your responses.`;
     }
     /**
-     * Stream text with function calling support
+     * Alias for generate() - CLI-SDK consistency
      */
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const options = typeof optionsOrPrompt === "string"
-            ? { prompt: optionsOrPrompt }
-            : optionsOrPrompt;
-        const functionTag = "FunctionCallingProvider.streamText";
-        // If function calling is disabled, use base provider
-        if (!this.enableFunctionCalling) {
-            mcpLogger.debug(`[${functionTag}] Function calling disabled, using base provider`);
-            return this.baseProvider.streamText(options, analysisSchema);
-        }
-        try {
-            // Check if function calling is available
-            const functionsAvailable = await isFunctionCallingAvailable();
-            if (!functionsAvailable) {
-                mcpLogger.debug(`[${functionTag}] No functions available, using base provider`);
-                return this.baseProvider.streamText(options, analysisSchema);
-            }
-            // Get available function tools
-            const { tools } = await getAvailableFunctionTools();
-            if (tools.length === 0) {
-                mcpLogger.debug(`[${functionTag}] No tools available, using base provider`);
-                return this.baseProvider.streamText(options, analysisSchema);
-            }
-            mcpLogger.debug(`[${functionTag}] Streaming with ${tools.length} functions available`);
-            // Enhance system prompt
-            const enhancedSystemPrompt = this.createFunctionAwareSystemPrompt(options.systemPrompt, tools);
-            // Stream with enhanced prompt
-            return this.baseProvider.streamText({
-                ...options,
-                systemPrompt: enhancedSystemPrompt,
-            }, analysisSchema);
-        }
-        catch (error) {
-            mcpLogger.warn(`[${functionTag}] Function calling failed, using base provider:`, error);
-            return this.baseProvider.streamText(options, analysisSchema);
-        }
-    }
-    /**
-     * Alias for generateText() - CLI-SDK consistency
-     */
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
     /**
-     * Short alias for generateText() - CLI-SDK consistency
+     * Short alias for generate() - CLI-SDK consistency
      */
     async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+        return this.generate(optionsOrPrompt, analysisSchema);
     }
 }
 /**

package/dist/lib/providers/google-ai-studio.d.ts

@@ -0,0 +1,23 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import { BaseProvider } from "../core/base-provider.js";
+/**
+ * Google AI Studio provider implementation using BaseProvider
+ * Migrated from original GoogleAIStudio class to new factory pattern
+ */
+export declare class GoogleAIStudioProvider extends BaseProvider {
+    constructor(modelName?: string, sdk?: any);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    /**
+     * 🔧 PHASE 2: Return AI SDK model instance for tool calling
+     */
+    protected getAISDKModel(): LanguageModelV1;
+    protected handleProviderError(error: any): Error;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    private getApiKey;
+    private validateStreamOptions;
+}
+export default GoogleAIStudioProvider;

package/dist/lib/providers/google-ai-studio.js

@@ -0,0 +1,107 @@
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { streamText } from "ai";
+import { GoogleAIModels } from "../core/types.js";
+import { BaseProvider } from "../core/base-provider.js";
+import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+// Environment variable setup
+if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY &&
+    process.env.GOOGLE_AI_API_KEY) {
+    process.env.GOOGLE_GENERATIVE_AI_API_KEY = process.env.GOOGLE_AI_API_KEY;
+}
+/**
+ * Google AI Studio provider implementation using BaseProvider
+ * Migrated from original GoogleAIStudio class to new factory pattern
+ */
+export class GoogleAIStudioProvider extends BaseProvider {
+    constructor(modelName, sdk) {
+        super(modelName, "google-ai", sdk);
+        logger.debug("GoogleAIStudioProvider initialized", {
+            model: this.modelName,
+            provider: this.providerName,
+            sdkProvided: !!sdk,
+        });
+    }
+    // ===================
+    // ABSTRACT METHOD IMPLEMENTATIONS
+    // ===================
+    getProviderName() {
+        return "google-ai";
+    }
+    getDefaultModel() {
+        return process.env.GOOGLE_AI_MODEL || GoogleAIModels.GEMINI_2_5_FLASH;
+    }
+    /**
+     * 🔧 PHASE 2: Return AI SDK model instance for tool calling
+     */
+    getAISDKModel() {
+        const apiKey = this.getApiKey();
+        const google = createGoogleGenerativeAI({ apiKey });
+        return google(this.modelName);
+    }
+    handleProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`Google AI request timed out: ${error.message}`);
+        }
+        if (error?.message?.includes("API_KEY_INVALID")) {
+            return new Error("Invalid Google AI API key. Please check your GOOGLE_AI_API_KEY environment variable.");
+        }
+        if (error?.message?.includes("RATE_LIMIT_EXCEEDED")) {
+            return new Error("Google AI rate limit exceeded. Please try again later.");
+        }
+        return new Error(`Google AI error: ${error?.message || "Unknown error"}`);
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        this.validateStreamOptions(options);
+        const apiKey = this.getApiKey();
+        const google = createGoogleGenerativeAI({ apiKey });
+        const model = google(this.modelName);
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        try {
+            const result = await streamText({
+                model,
+                prompt: options.input.text,
+                system: options.systemPrompt,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                tools: options.tools,
+                toolChoice: "auto",
+                abortSignal: timeoutController?.controller.signal,
+            });
+            timeoutController?.cleanup();
+            // Transform string stream to content object stream
+            const transformedStream = async function* () {
+                for await (const chunk of result.textStream) {
+                    yield { content: chunk };
+                }
+            };
+            return {
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
+            };
+        }
+        catch (error) {
+            throw this.handleProviderError(error);
+        }
+    }
+    // ===================
+    // HELPER METHODS
+    // ===================
+    getApiKey() {
+        const apiKey = process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+        if (!apiKey) {
+            throw new Error("GOOGLE_AI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY environment variable is not set");
+        }
+        return apiKey;
+    }
+    validateStreamOptions(options) {
+        if (!options.input?.text || options.input.text.trim().length === 0) {
+            throw new Error("Input text is required and cannot be empty");
+        }
+    }
+}
+export default GoogleAIStudioProvider;

package/dist/lib/providers/google-vertex.d.ts

@@ -0,0 +1,47 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import { BaseProvider } from "../core/base-provider.js";
+/**
+ * Google Vertex AI Provider v2 - BaseProvider Implementation
+ *
+ * PHASE 3.5: Simple BaseProvider wrap around existing @ai-sdk/google-vertex implementation
+ *
+ * Features:
+ * - Extends BaseProvider for shared functionality
+ * - Preserves existing Google Cloud authentication
+ * - Maintains Anthropic model support via dynamic imports
+ * - Uses pre-initialized Vertex instance for efficiency
+ * - Enhanced error handling with setup guidance
+ */
+export declare class GoogleVertexProvider extends BaseProvider {
+    private vertex;
+    private model;
+    private projectId;
+    private location;
+    private cachedAnthropicModel;
+    constructor(modelName?: string);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    /**
+     * Returns the Vercel AI SDK model instance for Google Vertex
+     * Handles both Google and Anthropic models
+     */
+    protected getAISDKModel(): Promise<LanguageModelV1>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected handleProviderError(error: any): Error;
+    private validateStreamOptions;
+    /**
+     * Check if Anthropic models are available
+     * @returns Promise<boolean> indicating if Anthropic support is available
+     */
+    hasAnthropicSupport(): Promise<boolean>;
+    /**
+     * Create an Anthropic model instance if available
+     * @param modelName Anthropic model name (e.g., 'claude-3-sonnet@20240229')
+     * @returns LanguageModelV1 instance or null if not available
+     */
+    createAnthropicModel(modelName: string): Promise<LanguageModelV1 | null>;
+}
+export default GoogleVertexProvider;

package/dist/lib/providers/google-vertex.js

@@ -0,0 +1,205 @@
+import { createVertex, } from "@ai-sdk/google-vertex";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
+import { logger } from "../utils/logger.js";
+import { TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+// Cache for anthropic module to avoid repeated imports
+let _createVertexAnthropic = null;
+let _anthropicImportAttempted = false;
+// Function to dynamically import anthropic support
+async function getCreateVertexAnthropic() {
+    if (_anthropicImportAttempted) {
+        return _createVertexAnthropic;
+    }
+    _anthropicImportAttempted = true;
+    try {
+        // Try to import the anthropic module - available in @ai-sdk/google-vertex ^2.2.0+
+        const anthropicModule = await import("@ai-sdk/google-vertex/anthropic");
+        _createVertexAnthropic = anthropicModule.createVertexAnthropic;
+        logger.debug("[GoogleVertexAI] Anthropic module successfully loaded");
+        return _createVertexAnthropic;
+    }
+    catch (error) {
+        // Anthropic module not available
+        logger.warn("[GoogleVertexAI] Anthropic module not available. Install @ai-sdk/google-vertex ^2.2.0 for Anthropic model support.");
+        return null;
+    }
+}
+// Configuration helpers
+const getVertexProjectId = () => {
+    const projectId = process.env.GOOGLE_CLOUD_PROJECT_ID ||
+        process.env.VERTEX_PROJECT_ID ||
+        process.env.GOOGLE_VERTEX_PROJECT;
+    if (!projectId) {
+        throw new Error(`❌ Google Vertex AI Provider Configuration Error\n\nMissing required environment variables: GOOGLE_CLOUD_PROJECT_ID or VERTEX_PROJECT_ID\n\n🔧 Step 1: Get Google Cloud Credentials\n1. Visit: https://console.cloud.google.com/\n2. Create or select a project\n3. Enable Vertex AI API\n4. Set up authentication\n\n🔧 Step 2: Set Environment Variables\nAdd to your .env file:\nGOOGLE_CLOUD_PROJECT_ID=your_project_id_here\nGOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json\n\n🔧 Step 3: Restart Application\nRestart your application to load the new environment variables.`);
+    }
+    return projectId;
+};
+const getVertexLocation = () => {
+    return (process.env.GOOGLE_CLOUD_LOCATION ||
+        process.env.VERTEX_LOCATION ||
+        process.env.GOOGLE_VERTEX_LOCATION ||
+        "us-central1");
+};
+const getDefaultVertexModel = () => {
+    return process.env.VERTEX_MODEL || "gemini-1.5-pro";
+};
+const hasGoogleCredentials = () => {
+    return !!(process.env.GOOGLE_APPLICATION_CREDENTIALS ||
+        process.env.GOOGLE_SERVICE_ACCOUNT_KEY ||
+        (process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
+            process.env.GOOGLE_AUTH_PRIVATE_KEY));
+};
+/**
+ * Google Vertex AI Provider v2 - BaseProvider Implementation
+ *
+ * PHASE 3.5: Simple BaseProvider wrap around existing @ai-sdk/google-vertex implementation
+ *
+ * Features:
+ * - Extends BaseProvider for shared functionality
+ * - Preserves existing Google Cloud authentication
+ * - Maintains Anthropic model support via dynamic imports
+ * - Uses pre-initialized Vertex instance for efficiency
+ * - Enhanced error handling with setup guidance
+ */
+export class GoogleVertexProvider extends BaseProvider {
+    vertex;
+    model;
+    projectId;
+    location;
+    cachedAnthropicModel = null;
+    constructor(modelName) {
+        super(modelName, "vertex");
+        // Validate Google Cloud credentials
+        if (!hasGoogleCredentials()) {
+            throw new Error(`❌ Google Vertex AI Provider Configuration Error\n\nMissing Google Cloud authentication. One of the following is required:\n\n🔧 Option 1: Service Account Key File\nGOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json\n\n🔧 Option 2: Service Account Key (Base64)\nGOOGLE_SERVICE_ACCOUNT_KEY=base64_encoded_key\n\n🔧 Option 3: Individual Credentials\nGOOGLE_AUTH_CLIENT_EMAIL=your-service-account@project.iam.gserviceaccount.com\nGOOGLE_AUTH_PRIVATE_KEY=-----BEGIN PRIVATE KEY-----...\n\n🔧 Step 4: Restart Application\nRestart your application to load the new environment variables.`);
+        }
+        // Initialize Google Cloud configuration
+        this.projectId = getVertexProjectId();
+        this.location = getVertexLocation();
+        const vertexConfig = {
+            project: this.projectId,
+            location: this.location,
+        };
+        // Create Vertex provider instance
+        this.vertex = createVertex(vertexConfig);
+        // Pre-initialize model for efficiency
+        this.model = this.vertex(this.modelName || getDefaultVertexModel());
+        logger.debug("Google Vertex AI BaseProvider v2 initialized", {
+            modelName: this.modelName,
+            projectId: this.projectId,
+            location: this.location,
+            provider: this.providerName,
+        });
+    }
+    getProviderName() {
+        return "vertex";
+    }
+    getDefaultModel() {
+        return getDefaultVertexModel();
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for Google Vertex
+     * Handles both Google and Anthropic models
+     */
+    async getAISDKModel() {
+        // Check if this is an Anthropic model
+        if (this.modelName && this.modelName.includes("claude")) {
+            // Return cached Anthropic model if available
+            if (this.cachedAnthropicModel) {
+                return this.cachedAnthropicModel;
+            }
+            // Create and cache new Anthropic model
+            const anthropicModel = await this.createAnthropicModel(this.modelName);
+            if (anthropicModel) {
+                this.cachedAnthropicModel = anthropicModel;
+                return anthropicModel;
+            }
+            // Fall back to regular model if Anthropic not available
+            logger.warn(`Anthropic model ${this.modelName} requested but not available, falling back to Google model`);
+        }
+        return this.model;
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        try {
+            this.validateStreamOptions(options);
+            const result = await streamText({
+                model: this.model,
+                prompt: options.input.text,
+                system: options.systemPrompt,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                temperature: options.temperature,
+            });
+            return {
+                stream: (async function* () {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: this.providerName,
+                model: this.modelName,
+            };
+        }
+        catch (error) {
+            throw this.handleProviderError(error);
+        }
+    }
+    handleProviderError(error) {
+        if (error.name === "TimeoutError") {
+            return new TimeoutError(`Google Vertex AI request timed out. Consider increasing timeout or using a lighter model.`, this.defaultTimeout);
+        }
+        if (error.message?.includes("PERMISSION_DENIED")) {
+            return new Error(`❌ Google Vertex AI Permission Denied\n\nYour Google Cloud credentials don't have permission to access Vertex AI.\n\n🔧 Required Steps:\n1. Ensure your service account has Vertex AI User role\n2. Check if Vertex AI API is enabled in your project\n3. Verify your project ID is correct\n4. Confirm your location/region has Vertex AI available`);
+        }
+        if (error.message?.includes("NOT_FOUND")) {
+            return new Error(`❌ Google Vertex AI Model Not Found\n\n${error.message}\n\n🔧 Check:\n1. Model name is correct (e.g., 'gemini-1.5-pro')\n2. Model is available in your region (${this.location})\n3. Your project has access to the model\n4. Model supports your request parameters`);
+        }
+        if (error.message?.includes("QUOTA_EXCEEDED")) {
+            return new Error(`❌ Google Vertex AI Quota Exceeded\n\n${error.message}\n\n🔧 Solutions:\n1. Check your Vertex AI quotas in Google Cloud Console\n2. Request quota increase if needed\n3. Try a different model or reduce request frequency\n4. Consider using a different region`);
+        }
+        if (error.message?.includes("INVALID_ARGUMENT")) {
+            return new Error(`❌ Google Vertex AI Invalid Request\n\n${error.message}\n\n🔧 Check:\n1. Request parameters are within model limits\n2. Input text is properly formatted\n3. Temperature and other settings are valid\n4. Model supports your request type`);
+        }
+        return new Error(`❌ Google Vertex AI Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check Google Cloud credentials and permissions\n2. Verify project ID and location settings\n3. Ensure Vertex AI API is enabled\n4. Check network connectivity`);
+    }
+    validateStreamOptions(options) {
+        if (!options.input?.text?.trim()) {
+            throw new Error("Prompt is required for streaming");
+        }
+        if (options.maxTokens &&
+            (options.maxTokens < 1 || options.maxTokens > 8192)) {
+            throw new Error("maxTokens must be between 1 and 8192 for Google Vertex AI");
+        }
+        if (options.temperature &&
+            (options.temperature < 0 || options.temperature > 2)) {
+            throw new Error("temperature must be between 0 and 2");
+        }
+    }
+    /**
+     * Check if Anthropic models are available
+     * @returns Promise<boolean> indicating if Anthropic support is available
+     */
+    async hasAnthropicSupport() {
+        const createVertexAnthropic = await getCreateVertexAnthropic();
+        return createVertexAnthropic !== null;
+    }
+    /**
+     * Create an Anthropic model instance if available
+     * @param modelName Anthropic model name (e.g., 'claude-3-sonnet@20240229')
+     * @returns LanguageModelV1 instance or null if not available
+     */
+    async createAnthropicModel(modelName) {
+        const createVertexAnthropic = await getCreateVertexAnthropic();
+        if (!createVertexAnthropic) {
+            return null;
+        }
+        const vertexAnthropic = createVertexAnthropic({
+            project: this.projectId,
+            location: this.location,
+        });
+        return vertexAnthropic(modelName);
+    }
+}
+export default GoogleVertexProvider;