@juspay/neurolink 5.0.0 → 5.1.0

package/dist/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, streamText as aiStreamText, Output, } from "ai";
+import { streamText as aiStreamText, 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/providers/googleAIStudio.d.ts

@@ -1,6 +1,8 @@
 import type { ZodType, ZodTypeDef } from "zod";
-import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult, type LanguageModelV1 } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { GenerateResult } from "../types/generate-types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
 export declare class GoogleAIStudio implements AIProvider {
     private modelName;
     /**
@@ -19,31 +21,22 @@ export declare class GoogleAIStudio implements AIProvider {
      */
     get model(): LanguageModelV1;
     /**
-     * Processes text using streaming approach with enhanced error handling callbacks
-     * @param prompt - The input text prompt to analyze
-     * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to StreamTextResult or null if operation fails
+     * PRIMARY METHOD: Stream content using AI (recommended for new code)
+     * Future-ready for multi-modal capabilities with current text focus
      */
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     /**
      * Processes text using non-streaming approach with optional schema validation
      * @param prompt - The input text prompt to analyze
      * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to GenerateTextResult or null if operation fails
-     */
-    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
-    /**
-     * Alias for generateText() - CLI-SDK consistency
-     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
-     * @param analysisSchema - Optional schema for output validation
-     * @returns Promise resolving to GenerateTextResult or null
+     * @returns Promise resolving to GenerateResult or null if operation fails
      */
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
     /**
-     * Short alias for generateText() - CLI-SDK consistency
+     * Short alias for generate() - CLI-SDK consistency
      * @param optionsOrPrompt - TextGenerationOptions object or prompt string
      * @param analysisSchema - Optional schema for output validation
-     * @returns Promise resolving to GenerateTextResult or null
+     * @returns Promise resolving to GenerateResult or null
      */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
 }

package/dist/providers/googleAIStudio.js

@@ -101,21 +101,38 @@ export class GoogleAIStudio {
         return this.getModel();
     }
     /**
-     * Processes text using streaming approach with enhanced error handling callbacks
-     * @param prompt - The input text prompt to analyze
-     * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to StreamTextResult or null if operation fails
+     * PRIMARY METHOD: Stream content using AI (recommended for new code)
+     * Future-ready for multi-modal capabilities with current text focus
      */
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "GoogleAIStudio.streamText";
+    async stream(optionsOrPrompt, analysisSchema) {
+        const functionTag = "GoogleAIStudio.stream";
         const provider = "google-ai";
         let chunkCount = 0;
+        const startTime = Date.now();
         try {
             // Parse parameters - support both string and options object
             const options = typeof optionsOrPrompt === "string"
-                ? { prompt: optionsOrPrompt }
+                ? { input: { text: optionsOrPrompt } }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, timeout = getDefaultTimeout(provider, "stream"), } = options;
+            // 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");
+            }
+            // Convert StreamOptions for internal use
+            const convertedOptions = {
+                prompt: options.input.text,
+                provider: options.provider,
+                model: options.model,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt,
+                timeout: options.timeout,
+                schema: options.schema,
+                tools: options.tools,
+            };
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, timeout = getDefaultTimeout(provider, "stream"), } = convertedOptions;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -147,7 +164,7 @@ export class GoogleAIStudio {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     const errorStack = error instanceof Error ? error.stack : undefined;
-                    logger.error(`[${functionTag}] Stream text error`, {
+                    logger.error(`[${functionTag}] Stream error`, {
                         provider,
                         modelName: this.modelName,
                         error: errorMessage,
@@ -157,7 +174,7 @@ export class GoogleAIStudio {
                     });
                 },
                 onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream text finished`, {
+                    logger.debug(`[${functionTag}] Stream finished`, {
                         provider,
                         modelName: this.modelName,
                         finishReason: event.finishReason,
@@ -169,7 +186,7 @@ export class GoogleAIStudio {
                 },
                 onChunk: (event) => {
                     chunkCount++;
-                    logger.debug(`[${functionTag}] Stream text chunk`, {
+                    logger.debug(`[${functionTag}] Stream chunk`, {
                         provider,
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
@@ -178,15 +195,26 @@ export class GoogleAIStudio {
                     });
                 },
             };
-            if (analysisSchema) {
+            if (finalSchema) {
                 streamOptions.experimental_output = Output.object({
-                    schema: analysisSchema,
+                    schema: finalSchema,
                 });
             }
             const result = streamText(streamOptions);
-            // For streaming, we can't clean up immediately, but the timeout will auto-clean
-            // The user should handle the stream and any timeout errors
-            return result;
+            // Convert to StreamResult format
+            return {
+                stream: (async function* () {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: "google-ai",
+                model: this.modelName,
+                metadata: {
+                    streamId: `google-ai-${Date.now()}`,
+                    startTime,
+                },
+            };
         }
         catch (err) {
             // Log timeout errors specifically
@@ -202,11 +230,11 @@ export class GoogleAIStudio {
                 logger.error(`[${functionTag}] Exception`, {
                     provider,
                     modelName: this.modelName,
-                    message: "Error in streaming text",
+                    message: "Error in streaming content",
                     err: String(err),
                     promptLength: typeof optionsOrPrompt === "string"
                         ? optionsOrPrompt.length
-                        : optionsOrPrompt.prompt.length,
+                        : optionsOrPrompt.input?.text?.length || 0,
                 });
             }
             throw err; // Re-throw error to trigger fallback
@@ -216,10 +244,10 @@ export class GoogleAIStudio {
      * Processes text using non-streaming approach with optional schema validation
      * @param prompt - The input text prompt to analyze
      * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to GenerateTextResult or null if operation fails
+     * @returns Promise resolving to GenerateResult or null if operation fails
      */
-    async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "GoogleAIStudio.generateText";
+    async generate(optionsOrPrompt, analysisSchema) {
+        const functionTag = "GoogleAIStudio.generate";
         const provider = "google-ai";
         const startTime = Date.now();
         try {
@@ -284,7 +312,19 @@ export class GoogleAIStudio {
                 if (options.enableEvaluation) {
                     result.evaluation = await evaluateResponse(prompt, result.text, options.context, options.evaluationDomain, options.toolUsageContext, options.conversationHistory);
                 }
-                return result;
+                return {
+                    content: result.text,
+                    provider: "google-ai",
+                    model: this.modelName || "gemini-2.5-pro",
+                    usage: result.usage
+                        ? {
+                            inputTokens: result.usage.promptTokens,
+                            outputTokens: result.usage.completionTokens,
+                            totalTokens: result.usage.totalTokens,
+                        }
+                        : undefined,
+                    responseTime: Date.now() - startTime,
+                };
             }
             finally {
                 // Always cleanup timeout
@@ -313,21 +353,12 @@ export class GoogleAIStudio {
         }
     }
     /**
-     * Alias for generateText() - CLI-SDK consistency
-     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
-     * @param analysisSchema - Optional schema for output validation
-     * @returns Promise resolving to GenerateTextResult or null
-     */
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
-    /**
-     * Short alias for generateText() - CLI-SDK consistency
+     * Short alias for generate() - CLI-SDK consistency
      * @param optionsOrPrompt - TextGenerationOptions object or prompt string
      * @param analysisSchema - Optional schema for output validation
-     * @returns Promise resolving to GenerateTextResult or null
+     * @returns Promise resolving to GenerateResult or null
      */
     async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+        return this.generate(optionsOrPrompt, analysisSchema);
     }
 }

package/dist/providers/googleVertexAI.d.ts

@@ -1,6 +1,8 @@
 import type { ZodType, ZodTypeDef } from "zod";
-import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
+import { type Schema } from "ai";
+import type { GenerateResult } from "../types/generate-types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
 export declare class GoogleVertexAI implements AIProvider {
     private modelName;
     /**
@@ -13,26 +15,20 @@ export declare class GoogleVertexAI implements AIProvider {
      * @private
      */
     private getModel;
-    /**
-     * Processes text using streaming approach with enhanced error handling callbacks
-     * @param prompt - The input text prompt to analyze
-     * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to StreamTextResult or null if operation fails
-     */
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
     /**
      * Processes text using non-streaming approach with optional schema validation
      * @param prompt - The input text prompt to analyze
      * @param analysisSchema - Optional Zod schema or Schema object for output validation
-     * @returns Promise resolving to GenerateTextResult or null if operation fails
+     * @returns Promise resolving to GenerateResult or null if operation fails
      */
-    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
     /**
-     * Alias for generateText() - CLI-SDK consistency
+     * PRIMARY METHOD: Stream content using AI (recommended for new code)
+     * Future-ready for multi-modal capabilities with current text focus
      */
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     /**
-     * Short alias for generateText() - CLI-SDK consistency
+     * Short alias for generate() - CLI-SDK consistency
      */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
 }