@juspay/neurolink 5.0.0 → 5.2.0

package/dist/lib/providers/anthropic.js

@@ -1,405 +1,111 @@
-/**
- * Anthropic AI Provider (Direct API)
- *
- * Direct integration with Anthropic's Claude models via their native API.
- * Supports Claude 3.5 Sonnet, Claude 3.5 Haiku, and Claude 3 Opus.
- */
-import { AIProviderName } from "../core/types.js";
+import { anthropic } from "@ai-sdk/anthropic";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
-import { evaluateResponse } from "../core/evaluation.js";
-import { createAnalytics } from "../core/analytics.js";
-import { createProxyFetch } from "../proxy/proxy-fetch.js";
-export class AnthropicProvider {
-    name = AIProviderName.ANTHROPIC;
-    apiKey;
-    baseURL;
-    defaultModel;
-    constructor() {
-        this.apiKey = this.getApiKey();
-        this.baseURL =
-            process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com";
-        this.defaultModel =
-            process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022";
-        logger.debug(`[AnthropicProvider] Initialized with model: ${this.defaultModel}`);
+// Configuration helpers
+const getAnthropicApiKey = () => {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        throw new Error(`❌ Anthropic Provider Configuration Error\n\nMissing required environment variable: ANTHROPIC_API_KEY\n\n🔧 Step 1: Get Anthropic API Key\n1. Visit: https://console.anthropic.com/\n2. Sign in or create an account\n3. Go to API Keys section\n4. Create a new API key\n\n🔧 Step 2: Set Environment Variable\nAdd to your .env file:\nANTHROPIC_API_KEY=your_api_key_here\n\n🔧 Step 3: Restart Application\nRestart your application to load the new environment variables.`);
+    }
+    return apiKey;
+};
+const getDefaultAnthropicModel = () => {
+    return process.env.ANTHROPIC_MODEL || "claude-3-5-sonnet-20241022";
+};
+/**
+ * Anthropic Provider v2 - BaseProvider Implementation
+ * Fixed syntax and enhanced with proper error handling
+ */
+export class AnthropicProvider extends BaseProvider {
+    model;
+    constructor(modelName, sdk) {
+        super(modelName, "anthropic", sdk);
+        // Initialize Anthropic model with API key validation
+        const apiKey = getAnthropicApiKey();
+        this.model = anthropic(this.modelName || getDefaultAnthropicModel());
+        logger.debug("Anthropic Provider v2 initialized", {
+            modelName: this.modelName,
+            provider: this.providerName,
+        });
     }
-    getApiKey() {
-        const apiKey = process.env.ANTHROPIC_API_KEY;
-        if (!apiKey) {
-            throw new Error("ANTHROPIC_API_KEY environment variable is required");
-        }
-        return apiKey;
+    getProviderName() {
+        return "anthropic";
     }
-    getModel() {
-        return this.defaultModel;
+    getDefaultModel() {
+        return getDefaultAnthropicModel();
     }
-    async makeRequest(endpoint, body, stream = false, signal) {
-        const url = `${this.baseURL}/v1/${endpoint}`;
-        const headers = {
-            "Content-Type": "application/json",
-            "x-api-key": this.apiKey,
-            "anthropic-version": "2023-06-01",
-            "anthropic-dangerous-direct-browser-access": "true", // Required for browser usage
-        };
-        logger.debug(`[AnthropicProvider.makeRequest] ${stream ? "Streaming" : "Non-streaming"} request to ${url}`);
-        logger.debug(`[AnthropicProvider.makeRequest] Model: ${body.model}, Max tokens: ${body.max_tokens}`);
-        const proxyFetch = createProxyFetch();
-        const response = await proxyFetch(url, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body),
-            signal, // Add abort signal for timeout support
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            logger.error(`[AnthropicProvider.makeRequest] API error ${response.status}: ${errorText}`);
-            throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
-        }
-        return response;
-    }
-    async generateText(optionsOrPrompt, schema) {
-        const functionTag = "AnthropicProvider.generateText";
-        const provider = "anthropic";
-        const startTime = Date.now();
-        logger.debug(`[${functionTag}] Starting text generation`);
-        // Parse parameters with backward compatibility
-        const options = typeof optionsOrPrompt === "string"
-            ? { prompt: optionsOrPrompt }
-            : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, "generate"), enableAnalytics = false, enableEvaluation = false, context, } = options;
-        logger.debug(`[${functionTag}] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}, Timeout: ${timeout}`);
-        const requestBody = {
-            model: this.getModel(),
-            max_tokens: maxTokens,
-            messages: [
-                {
-                    role: "user",
-                    content: prompt,
-                },
-            ],
-            temperature,
-            system: systemPrompt,
-        };
-        // Create timeout controller if timeout is specified
-        const timeoutController = createTimeoutController(timeout, provider, "generate");
-        try {
-            const response = await this.makeRequest("messages", requestBody, false, timeoutController?.controller.signal);
-            const data = await response.json();
-            // Clean up timeout if successful
-            timeoutController?.cleanup();
-            logger.debug(`[${functionTag}] Success. Generated ${data.usage.output_tokens} tokens`);
-            const content = data.content.map((block) => block.text).join("");
-            const result = {
-                content,
-                provider: this.name,
-                model: data.model,
-                usage: {
-                    promptTokens: data.usage.input_tokens,
-                    completionTokens: data.usage.output_tokens,
-                    totalTokens: data.usage.input_tokens + data.usage.output_tokens,
-                },
-                finishReason: data.stop_reason,
-            };
-            // Add analytics if enabled
-            if (options.enableAnalytics) {
-                result.analytics = createAnalytics(provider, this.defaultModel, result, Date.now() - startTime, options.context);
-            }
-            // Add evaluation if enabled
-            if (options.enableEvaluation) {
-                result.evaluation = await evaluateResponse(prompt, result.content, options.context);
-            }
-            return result;
-        }
-        catch (error) {
-            // Always cleanup timeout
-            timeoutController?.cleanup();
-            // Log timeout errors specifically
-            if (error instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    timeout: error.timeout,
-                    message: error.message,
-                });
-            }
-            else if (error?.name === "AbortError") {
-                // Convert AbortError to TimeoutError
-                const timeoutError = new TimeoutError(`${provider} generate operation timed out after ${timeout}`, timeoutController?.timeoutMs || 0, provider, "generate");
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    timeout: timeoutController?.timeoutMs,
-                    message: timeoutError.message,
-                });
-                throw timeoutError;
-            }
-            else {
-                logger.error(`[${functionTag}] Error:`, error);
-            }
-            throw error;
-        }
+    /**
+     * Returns the Vercel AI SDK model instance for Anthropic
+     */
+    getAISDKModel() {
+        return this.model;
     }
-    async streamText(optionsOrPrompt, schema) {
-        const functionTag = "AnthropicProvider.streamText";
-        const provider = "anthropic";
-        logger.debug(`[${functionTag}] Starting text streaming`);
-        // Parse parameters with backward compatibility
-        const options = typeof optionsOrPrompt === "string"
-            ? { prompt: optionsOrPrompt }
-            : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, "stream"), } = options;
-        logger.debug(`[${functionTag}] Streaming prompt: "${prompt.substring(0, 100)}...", Timeout: ${timeout}`);
-        const requestBody = {
-            model: this.getModel(),
-            max_tokens: maxTokens,
-            messages: [
-                {
-                    role: "user",
-                    content: prompt,
-                },
-            ],
-            temperature,
-            system: systemPrompt,
-            stream: true,
-        };
-        // Create timeout controller if timeout is specified
-        const timeoutController = createTimeoutController(timeout, provider, "stream");
-        try {
-            const response = await this.makeRequest("messages", requestBody, true, timeoutController?.controller.signal);
-            if (!response.body) {
-                throw new Error("No response body received");
-            }
-            // Return a StreamTextResult-like object with timeout signal
-            return {
-                textStream: this.createAsyncIterable(response.body, timeoutController?.controller.signal),
-                text: "",
-                usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-                finishReason: "end_turn",
-                // Store timeout controller for external cleanup if needed
-                _timeoutController: timeoutController,
-            };
+    handleProviderError(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`Anthropic request timed out: ${error.message}`);
         }
-        catch (error) {
-            // Cleanup timeout on error
-            timeoutController?.cleanup();
-            // Log timeout errors specifically
-            if (error instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    timeout: error.timeout,
-                    message: error.message,
-                });
-            }
-            else if (error?.name === "AbortError") {
-                // Convert AbortError to TimeoutError
-                const timeoutError = new TimeoutError(`${provider} stream operation timed out after ${timeout}`, timeoutController?.timeoutMs || 0, provider, "stream");
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    timeout: timeoutController?.timeoutMs,
-                    message: timeoutError.message,
-                });
-                throw timeoutError;
-            }
-            else {
-                logger.error(`[${functionTag}] Error:`, error);
-            }
-            throw error;
-        }
-    }
-    async *createAsyncIterable(body, signal) {
-        const reader = body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        try {
-            while (true) {
-                // Check if aborted
-                if (signal?.aborted) {
-                    throw new Error("AbortError");
-                }
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines) {
-                    if (line.trim() === "") {
-                        continue;
-                    }
-                    if (line.startsWith("data: ")) {
-                        const data = line.slice(6);
-                        if (data.trim() === "[DONE]") {
-                            continue;
-                        }
-                        try {
-                            const chunk = JSON.parse(data);
-                            // Extract text content from different chunk types
-                            if (chunk.type === "content_block_delta" && chunk.delta?.text) {
-                                yield chunk.delta.text;
-                            }
-                        }
-                        catch (parseError) {
-                            logger.warn("[AnthropicProvider.createAsyncIterable] Failed to parse chunk:", parseError);
-                            continue;
-                        }
-                    }
-                }
-            }
+        if (error?.message?.includes("API_KEY_INVALID") ||
+            error?.message?.includes("Invalid API key")) {
+            return new Error("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.");
         }
-        finally {
-            reader.releaseLock();
+        if (error?.message?.includes("rate limit")) {
+            return new Error("Anthropic rate limit exceeded. Please try again later.");
         }
-    }
-    async *generateTextStream(optionsOrPrompt) {
-        logger.debug("[AnthropicProvider.generateTextStream] Starting text streaming");
-        // Parse parameters with backward compatibility
-        const options = typeof optionsOrPrompt === "string"
-            ? { prompt: optionsOrPrompt }
-            : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", } = options;
-        logger.debug(`[AnthropicProvider.generateTextStream] Streaming prompt: "${prompt.substring(0, 100)}..."`);
-        const requestBody = {
-            model: this.getModel(),
-            max_tokens: maxTokens,
-            messages: [
-                {
-                    role: "user",
-                    content: prompt,
-                },
-            ],
-            temperature,
-            system: systemPrompt,
-            stream: true,
+        return new Error(`Anthropic error: ${error?.message || "Unknown error"}`);
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        // Convert StreamOptions to TextGenerationOptions for validation
+        const validationOptions = {
+            prompt: options.input.text,
+            systemPrompt: options.systemPrompt,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
         };
+        this.validateOptions(validationOptions);
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
-            const response = await this.makeRequest("messages", requestBody, true);
-            if (!response.body) {
-                throw new Error("No response body received");
-            }
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = "";
-            try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        break;
-                    }
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    buffer = lines.pop() || "";
-                    for (const line of lines) {
-                        if (line.trim() === "") {
-                            continue;
-                        }
-                        if (line.startsWith("data: ")) {
-                            const data = line.slice(6);
-                            if (data.trim() === "[DONE]") {
-                                continue;
-                            }
-                            try {
-                                const chunk = JSON.parse(data);
-                                // Extract text content from different chunk types
-                                if (chunk.type === "content_block_delta" && chunk.delta?.text) {
-                                    yield {
-                                        content: chunk.delta.text,
-                                        provider: this.name,
-                                        model: this.getModel(),
-                                    };
-                                }
-                            }
-                            catch (parseError) {
-                                logger.warn("[AnthropicProvider.generateTextStream] Failed to parse chunk:", parseError);
-                                continue;
-                            }
-                        }
-                    }
-                }
-            }
-            finally {
-                reader.releaseLock();
-            }
-            logger.debug("[AnthropicProvider.generateTextStream] Streaming completed");
-        }
-        catch (error) {
-            logger.error("[AnthropicProvider.generateTextStream] Error:", error);
-            throw error;
-        }
-    }
-    async testConnection() {
-        logger.debug("[AnthropicProvider.testConnection] Testing connection to Anthropic API");
-        const startTime = Date.now();
-        try {
-            await this.generateText({
-                prompt: "Hello",
-                maxTokens: 5,
+            const result = await streamText({
+                model: this.model,
+                prompt: options.input.text,
+                system: options.systemPrompt || undefined,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                abortSignal: timeoutController?.controller.signal,
             });
-            const responseTime = Date.now() - startTime;
-            logger.debug(`[AnthropicProvider.testConnection] Connection test successful (${responseTime}ms)`);
+            timeoutController?.cleanup();
+            // Transform string stream to content object stream
+            const transformedStream = async function* () {
+                for await (const chunk of result.textStream) {
+                    yield { content: chunk };
+                }
+            };
             return {
-                success: true,
-                responseTime,
+                stream: transformedStream(),
+                provider: this.providerName,
+                model: this.modelName,
             };
         }
         catch (error) {
-            const responseTime = Date.now() - startTime;
-            logger.error(`[AnthropicProvider.testConnection] Connection test failed (${responseTime}ms):`, error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : "Unknown error",
-                responseTime,
-            };
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
         }
     }
-    isConfigured() {
+    async isAvailable() {
         try {
-            this.getApiKey();
+            getAnthropicApiKey();
             return true;
         }
         catch {
             return false;
         }
     }
-    getRequiredConfig() {
-        return ["ANTHROPIC_API_KEY"];
-    }
-    getOptionalConfig() {
-        return ["ANTHROPIC_MODEL", "ANTHROPIC_BASE_URL"];
-    }
-    getModels() {
-        return [
-            "claude-3-5-sonnet-20241022",
-            "claude-3-5-haiku-20241022",
-            "claude-3-opus-20240229",
-            "claude-3-sonnet-20240229",
-            "claude-3-haiku-20240307",
-        ];
-    }
-    supportsStreaming() {
-        return true;
-    }
-    supportsSchema() {
-        return false; // Anthropic doesn't have native JSON schema support like OpenAI
-    }
-    getCapabilities() {
-        return [
-            "text-generation",
-            "streaming",
-            "conversation",
-            "system-prompts",
-            "long-context", // Claude models support up to 200k tokens
-        ];
-    }
-    /**
-     * Alias for generateText() - CLI-SDK consistency
-     */
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
-    /**
-     * Short alias for generateText() - CLI-SDK consistency
-     */
-    async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+    getModel() {
+        return this.model;
     }
 }
+export default AnthropicProvider;

package/dist/lib/providers/azure-openai.d.ts

@@ -0,0 +1,20 @@
+import { BaseProvider } from "../core/base-provider.js";
+import type { AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+export declare class AzureOpenAIProvider extends BaseProvider {
+    private apiKey;
+    private resourceName;
+    private deployment;
+    private apiVersion;
+    private azureProvider;
+    constructor(modelName?: string);
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
+    /**
+     * Returns the Vercel AI SDK model instance for Azure OpenAI
+     */
+    protected getAISDKModel(): any;
+    protected handleProviderError(error: any): Error;
+    protected executeStream(options: StreamOptions, analysisSchema?: any): Promise<StreamResult>;
+}
+export default AzureOpenAIProvider;

package/dist/lib/providers/azure-openai.js

@@ -0,0 +1,89 @@
+import { createAzure } from "@ai-sdk/azure";
+import { streamText } from "ai";
+import { BaseProvider } from "../core/base-provider.js";
+export class AzureOpenAIProvider extends BaseProvider {
+    apiKey;
+    resourceName;
+    deployment;
+    apiVersion;
+    azureProvider;
+    constructor(modelName) {
+        super(modelName, "azure");
+        this.apiKey = process.env.AZURE_OPENAI_API_KEY || "";
+        const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "";
+        this.resourceName = endpoint
+            .replace("https://", "")
+            .replace(/\/+$/, "") // Remove trailing slashes
+            .replace(".openai.azure.com", "");
+        this.deployment =
+            modelName ||
+                process.env.AZURE_OPENAI_DEPLOYMENT ||
+                process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
+                "gpt-4o";
+        this.apiVersion = process.env.AZURE_API_VERSION || "2024-10-01-preview";
+        if (!this.apiKey) {
+            throw new Error("AZURE_OPENAI_API_KEY environment variable is required");
+        }
+        if (!this.resourceName) {
+            throw new Error("AZURE_OPENAI_ENDPOINT environment variable is required");
+        }
+        // Create the Azure provider instance
+        this.azureProvider = createAzure({
+            resourceName: this.resourceName,
+            apiKey: this.apiKey,
+            apiVersion: this.apiVersion,
+        });
+        console.log("Azure Vercel Provider initialized", {
+            deployment: this.deployment,
+            resourceName: this.resourceName,
+            provider: "azure-vercel",
+        });
+    }
+    getProviderName() {
+        return "azure";
+    }
+    getDefaultModel() {
+        return this.deployment;
+    }
+    /**
+     * Returns the Vercel AI SDK model instance for Azure OpenAI
+     */
+    getAISDKModel() {
+        return this.azureProvider(this.deployment);
+    }
+    handleProviderError(error) {
+        if (error?.message?.includes("401")) {
+            return new Error("Invalid Azure OpenAI API key or endpoint.");
+        }
+        return new Error(`Azure OpenAI error: ${error?.message || "Unknown error"}`);
+    }
+    // executeGenerate removed - BaseProvider handles all generation with tools
+    async executeStream(options, analysisSchema) {
+        try {
+            const stream = await streamText({
+                model: this.azureProvider(this.deployment),
+                prompt: options.input?.text || "",
+                maxTokens: options.maxTokens || 1000,
+                temperature: options.temperature || 0.7,
+                system: options.systemPrompt,
+            });
+            return {
+                stream: (async function* () {
+                    for await (const chunk of stream.textStream) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: "azure",
+                model: this.deployment,
+                metadata: {
+                    streamId: `azure-${Date.now()}`,
+                    startTime: Date.now(),
+                },
+            };
+        }
+        catch (error) {
+            throw this.handleProviderError(error);
+        }
+    }
+}
+export default AzureOpenAIProvider;

package/dist/lib/providers/function-calling-provider.d.ts

@@ -3,9 +3,11 @@
  * Integrates MCP tools directly with AI SDK's function calling capabilities
  * This is the missing piece that enables true AI function calling!
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
-import { type GenerateTextResult, type StreamTextResult, type ToolSet, type Schema } from "ai";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
+import { type Schema } from "ai";
+import type { GenerateResult } from "../types/generate-types.js";
 import type { ZodType, ZodTypeDef } from "zod";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
 /**
  * Enhanced provider that enables real function calling with MCP tools
  */
@@ -19,14 +21,19 @@ export declare class FunctionCallingProvider implements AIProvider {
         sessionId?: string;
         userId?: string;
     });
+    /**
+     * PRIMARY METHOD: Stream content using AI (recommended for new code)
+     * Future-ready for multi-modal capabilities with current text focus
+     */
+    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: any): Promise<StreamResult>;
     /**
      * Generate text with real function calling support
      */
-    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>;
     /**
      * Generate text using AI SDK's native function calling
      */
-    private generateTextWithTools;
+    private generateWithTools;
     /**
      * Get the model from the base provider
      * This is a temporary solution - ideally we'd have a getModel() method on AIProvider
@@ -45,17 +52,12 @@ export declare class FunctionCallingProvider implements AIProvider {
      */
     private createFunctionAwareSystemPrompt;
     /**
-     * Stream text with function calling support
-     */
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
-    /**
-     * Alias for generateText() - CLI-SDK consistency
+     * Alias for generate() - CLI-SDK consistency
      */
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
     /**
-     * Short alias for generateText() - CLI-SDK consistency
+     * Short alias for generate() - CLI-SDK consistency
      */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateResult | null>;
 }
 /**
  * Create a function-calling enhanced version of any AI provider