@juspay/neurolink 4.2.0 → 5.1.0

package/dist/providers/mistralAI.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 MistralAI implements AIProvider {
     private modelName;
     private client;
@@ -15,20 +17,21 @@ export declare class MistralAI implements AIProvider {
      */
     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
+     * LEGACY METHOD: Use stream() instead for new code
+     * @deprecated Use stream() method instead
+     */
+    /**
+     * 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
+     * @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?: any): Promise<EnhancedGenerateTextResult | null>;
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateResult | null>;
 }
 export default MistralAI;

package/dist/providers/mistralAI.js

@@ -1,5 +1,5 @@
 import { createMistral } from "@ai-sdk/mistral";
-import { streamText, generateText, Output, } from "ai";
+import { streamText, generateText, Output } from "ai";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
@@ -77,21 +77,31 @@ export class MistralAI {
         return this.client(this.modelName);
     }
     /**
-     * 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
+     * LEGACY METHOD: Use stream() instead for new code
+     * @deprecated Use stream() method instead
      */
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "MistralAI.streamText";
+    /**
+     * 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 = "MistralAI.stream";
         const provider = "mistral";
         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, 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");
+            }
+            // Extract parameters
+            const { prompt = options.input.text, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -120,7 +130,7 @@ export class MistralAI {
                     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.debug(`[${functionTag}] Stream error`, {
                         provider,
                         modelName: this.modelName,
                         error: errorMessage,
@@ -130,7 +140,7 @@ export class MistralAI {
                     });
                 },
                 onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream text finished`, {
+                    logger.debug(`[${functionTag}] Stream finished`, {
                         provider,
                         modelName: this.modelName,
                         finishReason: event.finishReason,
@@ -142,7 +152,7 @@ export class MistralAI {
                 },
                 onChunk: (event) => {
                     chunkCount++;
-                    logger.debug(`[${functionTag}] Stream text chunk`, {
+                    logger.debug(`[${functionTag}] Stream chunk`, {
                         provider,
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
@@ -157,14 +167,29 @@ export class MistralAI {
                 });
             }
             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;
+            logger.debug(`[${functionTag}] Stream request completed`, {
+                provider,
+                modelName: this.modelName,
+            });
+            // Convert to StreamResult format
+            return {
+                stream: (async function* () {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: "mistral",
+                model: this.modelName,
+                metadata: {
+                    streamId: `mistral-${Date.now()}`,
+                    startTime,
+                },
+            };
         }
         catch (err) {
             // Log timeout errors specifically
             if (err instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
+                logger.debug(`[${functionTag}] Timeout error`, {
                     provider,
                     modelName: this.modelName,
                     timeout: err.timeout,
@@ -172,14 +197,11 @@ export class MistralAI {
                 });
             }
             else {
-                logger.error(`[${functionTag}] Exception`, {
+                logger.debug(`[${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,
                 });
             }
             throw err; // Re-throw error to trigger fallback
@@ -189,10 +211,10 @@ export class MistralAI {
      * 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 = "MistralAI.generateText";
+    async generate(optionsOrPrompt, analysisSchema) {
+        const functionTag = "MistralAI.generate";
         const provider = "mistral";
         const startTime = Date.now();
         try {
@@ -256,7 +278,19 @@ export class MistralAI {
                 if (options.enableEvaluation) {
                     result.evaluation = await evaluateResponse(prompt, result.text, options.context);
                 }
-                return result;
+                return {
+                    content: result.text,
+                    provider: "mistral",
+                    model: this.modelName,
+                    usage: result.usage
+                        ? {
+                            inputTokens: result.usage.promptTokens,
+                            outputTokens: result.usage.completionTokens,
+                            totalTokens: result.usage.totalTokens,
+                        }
+                        : undefined,
+                    responseTime: Date.now() - startTime,
+                };
             }
             finally {
                 // Always cleanup timeout
@@ -284,11 +318,8 @@ export class MistralAI {
             throw err; // Re-throw error to trigger fallback
         }
     }
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
     async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+        return this.generate(optionsOrPrompt, analysisSchema);
     }
 }
 export default MistralAI;

package/dist/providers/ollama.d.ts

@@ -10,8 +10,9 @@
  * - Health checking and service validation
  * - Streaming and non-streaming text generation
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
-import type { GenerateTextResult, StreamTextResult, ToolSet } from "ai";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
+import type { GenerateResult } from "../types/generate-types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema } from "ai";
 export declare class Ollama implements AIProvider {
@@ -41,13 +42,13 @@ export declare class Ollama implements AIProvider {
      */
     pullModel(modelName: string): Promise<void>;
     /**
-     * Generate text using Ollama local models
+     * PRIMARY METHOD: Stream content using AI (recommended for new code)
+     * Future-ready for multi-modal capabilities with current text focus
      */
-    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     /**
-     * Generate streaming text using Ollama local models
+     * Generate text using Ollama local models
      */
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateResult | null>;
 }

package/dist/providers/ollama.js

@@ -388,91 +388,139 @@ export class Ollama {
         }
     }
     /**
-     * Generate text using Ollama local models
+     * PRIMARY METHOD: Stream content using AI (recommended for new code)
+     * Future-ready for multi-modal capabilities with current text focus
      */
-    async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "Ollama.generateText";
+    async stream(optionsOrPrompt, analysisSchema) {
+        const functionTag = "Ollama.stream";
         const provider = "ollama";
+        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, timeout, } = 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");
+            }
+            // Extract parameters
+            const { prompt = options.input.text, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             // Convert timeout to milliseconds if provided as string
             const timeoutMs = timeout
                 ? typeof timeout === "string"
-                    ? parseInt(getDefaultTimeout("ollama", "generate").replace(/[^\d]/g, ""))
+                    ? parseInt(getDefaultTimeout("ollama", "stream").replace(/[^\d]/g, ""))
                     : timeout
                 : this.defaultTimeout;
-            logger.debug(`[${functionTag}] Generate request started`, {
+            logger.debug(`[${functionTag}] Stream request started`, {
                 provider,
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                hasSchema: !!finalSchema,
                 timeout: timeoutMs,
             });
             const model = this.getModel(timeoutMs);
-            const generateOptions = {
+            const streamOptions = {
                 model: model,
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
                 maxTokens,
+                onError: (event) => {
+                    const error = event.error;
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const errorStack = error instanceof Error ? error.stack : undefined;
+                    logger.debug(`[${functionTag}] Stream error`, {
+                        provider,
+                        modelName: this.modelName,
+                        error: errorMessage,
+                        stack: errorStack,
+                        promptLength: prompt.length,
+                        chunkCount,
+                    });
+                },
+                onFinish: (event) => {
+                    logger.debug(`[${functionTag}] Stream finished`, {
+                        provider,
+                        modelName: this.modelName,
+                        finishReason: event.finishReason,
+                        usage: event.usage,
+                        totalChunks: chunkCount,
+                        promptLength: prompt.length,
+                        responseLength: event.text?.length || 0,
+                    });
+                },
+                onChunk: (event) => {
+                    chunkCount++;
+                    logger.debug(`[${functionTag}] Stream chunk`, {
+                        provider,
+                        modelName: this.modelName,
+                        chunkNumber: chunkCount,
+                        chunkLength: event.chunk.text?.length || 0,
+                        chunkType: event.chunk.type,
+                    });
+                },
             };
             if (finalSchema) {
-                generateOptions.experimental_output = Output.object({
+                streamOptions.experimental_output = Output.object({
                     schema: finalSchema,
                 });
             }
-            const result = await generateText(generateOptions);
-            if (result.text.includes("model not found")) {
-                throw new Error(`Model '${this.modelName}' not found. Please run 'ollama pull ${this.modelName}'`);
-            }
-            logger.debug(`[${functionTag}] Generate text completed`, {
+            const result = streamText(streamOptions);
+            logger.debug(`[${functionTag}] Stream request completed`, {
                 provider,
                 modelName: this.modelName,
-                usage: result.usage,
-                finishReason: result.finishReason,
-                responseLength: result.text?.length || 0,
             });
-            // Add analytics if enabled
-            if (options.enableAnalytics) {
-                result.analytics = {
+            // Convert to StreamResult format
+            return {
+                stream: (async function* () {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: "ollama",
+                model: this.modelName,
+                metadata: {
+                    streamId: `ollama-${Date.now()}`,
+                    startTime,
+                },
+            };
+        }
+        catch (err) {
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.debug(`[${functionTag}] Timeout error`, {
                     provider,
-                    model: this.modelName,
-                    tokens: result.usage,
-                    responseTime: Date.now() - startTime,
-                    context: options.context,
-                };
+                    modelName: this.modelName,
+                    timeout: err.timeout,
+                    message: err.message,
+                });
             }
-            // Add evaluation if enabled
-            if (options.enableEvaluation) {
-                result.evaluation = await evaluateResponse(prompt, result.text, options.context);
+            else {
+                logger.debug(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    message: "Error in streaming content",
+                    err: String(err),
+                });
             }
-            return result;
-        }
-        catch (err) {
-            logger.debug(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in generating text",
-                err: String(err),
-            });
             throw err; // Re-throw error to trigger fallback
         }
     }
     /**
-     * Generate streaming text using Ollama local models
+     * Generate text using Ollama local models
      */
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "Ollama.streamText";
+    async generate(optionsOrPrompt, analysisSchema) {
+        const functionTag = "Ollama.generate";
         const provider = "ollama";
-        let chunkCount = 0;
+        const startTime = Date.now();
         try {
             // Parse parameters - support both string and options object
             const options = typeof optionsOrPrompt === "string"
@@ -484,85 +532,80 @@ export class Ollama {
             // Convert timeout to milliseconds if provided as string
             const timeoutMs = timeout
                 ? typeof timeout === "string"
-                    ? parseInt(getDefaultTimeout("ollama", "stream").replace(/[^\d]/g, ""))
+                    ? parseInt(getDefaultTimeout("ollama", "generate").replace(/[^\d]/g, ""))
                     : timeout
                 : this.defaultTimeout;
-            logger.debug(`[${functionTag}] Stream request started`, {
+            logger.debug(`[${functionTag}] Generate request started`, {
                 provider,
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
-                hasSchema: !!finalSchema,
                 timeout: timeoutMs,
             });
             const model = this.getModel(timeoutMs);
-            const streamOptions = {
+            const generateOptions = {
                 model: model,
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
                 maxTokens,
-                onError: (event) => {
-                    const error = event.error;
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    const errorStack = error instanceof Error ? error.stack : undefined;
-                    logger.debug(`[${functionTag}] Stream text error`, {
-                        provider,
-                        modelName: this.modelName,
-                        error: errorMessage,
-                        stack: errorStack,
-                        promptLength: prompt.length,
-                        chunkCount,
-                    });
-                },
-                onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream text finished`, {
-                        provider,
-                        modelName: this.modelName,
-                        finishReason: event.finishReason,
-                        usage: event.usage,
-                        totalChunks: chunkCount,
-                        promptLength: prompt.length,
-                        responseLength: event.text?.length || 0,
-                    });
-                },
-                onChunk: (event) => {
-                    chunkCount++;
-                    logger.debug(`[${functionTag}] Stream text chunk`, {
-                        provider,
-                        modelName: this.modelName,
-                        chunkNumber: chunkCount,
-                        chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type,
-                    });
-                },
             };
             if (finalSchema) {
-                streamOptions.experimental_output = Output.object({
+                generateOptions.experimental_output = Output.object({
                     schema: finalSchema,
                 });
             }
-            const result = streamText(streamOptions);
-            return result;
+            const result = await generateText(generateOptions);
+            if (result.text.includes("model not found")) {
+                throw new Error(`Model '${this.modelName}' not found. Please run 'ollama pull ${this.modelName}'`);
+            }
+            logger.debug(`[${functionTag}] Generate text completed`, {
+                provider,
+                modelName: this.modelName,
+                usage: result.usage,
+                finishReason: result.finishReason,
+                responseLength: result.text?.length || 0,
+            });
+            // Add analytics if enabled
+            if (options.enableAnalytics) {
+                result.analytics = {
+                    provider,
+                    model: this.modelName,
+                    tokens: result.usage,
+                    responseTime: Date.now() - startTime,
+                    context: options.context,
+                };
+            }
+            // Add evaluation if enabled
+            if (options.enableEvaluation) {
+                result.evaluation = await evaluateResponse(prompt, result.text, options.context);
+            }
+            return {
+                content: result.text,
+                provider: "ollama",
+                model: this.modelName,
+                usage: result.usage
+                    ? {
+                        inputTokens: result.usage.promptTokens,
+                        outputTokens: result.usage.completionTokens,
+                        totalTokens: result.usage.totalTokens,
+                    }
+                    : undefined,
+                responseTime: Date.now() - startTime,
+            };
         }
         catch (err) {
             logger.debug(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: "Error in streaming text",
+                message: "Error in generating text",
                 err: String(err),
-                promptLength: typeof optionsOrPrompt === "string"
-                    ? optionsOrPrompt.length
-                    : optionsOrPrompt.prompt.length,
             });
             throw err; // Re-throw error to trigger fallback
         }
     }
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
     async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+        return this.generate(optionsOrPrompt, analysisSchema);
     }
 }

package/dist/providers/openAI.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 OpenAI implements AIProvider {
     private modelName;
     private model;
@@ -9,20 +11,17 @@ export declare class OpenAI implements AIProvider {
      * Get the underlying model for function calling
      */
     getModel(): LanguageModelV1;
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
-    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
-     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
-     * @param analysisSchema - Optional schema for output validation
-     * @returns Promise resolving to GenerateTextResult or null
+     * 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
      * @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>;
 }