@juspay/neurolink 4.2.0 → 5.1.0

package/dist/lib/providers/googleVertexAI.js

@@ -294,123 +294,14 @@ export class GoogleVertexAI {
         const vertex = await getVertexInstance();
         return vertex(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
-     */
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "GoogleVertexAI.streamText";
-        const provider = "vertex";
-        let chunkCount = 0;
-        try {
-            // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === "string"
-                ? { prompt: optionsOrPrompt }
-                : optionsOrPrompt;
-            const { prompt, 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`, {
-                provider,
-                modelName: this.modelName,
-                isAnthropic: isAnthropicModel(this.modelName),
-                promptLength: prompt.length,
-                temperature,
-                maxTokens,
-                hasSchema: !!finalSchema,
-                timeout,
-            });
-            const model = await this.getModel();
-            // Create timeout controller if timeout is specified
-            const timeoutController = createTimeoutController(timeout, provider, "stream");
-            const streamOptions = {
-                model: model,
-                prompt: prompt,
-                system: systemPrompt,
-                temperature,
-                maxTokens,
-                // Add abort signal if available
-                ...(timeoutController && {
-                    abortSignal: timeoutController.controller.signal,
-                }),
-                onError: (event) => {
-                    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`, {
-                        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 (analysisSchema) {
-                streamOptions.experimental_output = Output.object({
-                    schema: analysisSchema,
-                });
-            }
-            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;
-        }
-        catch (err) {
-            // Log timeout errors specifically
-            if (err instanceof TimeoutError) {
-                logger.error(`[${functionTag}] Timeout error`, {
-                    provider,
-                    modelName: this.modelName,
-                    isAnthropic: isAnthropicModel(this.modelName),
-                    timeout: err.timeout,
-                    message: err.message,
-                });
-            }
-            else {
-                logger.error(`[${functionTag}] Exception`, {
-                    provider,
-                    modelName: this.modelName,
-                    message: "Error in streaming text",
-                    err: String(err),
-                    promptLength: prompt.length,
-                });
-            }
-            throw err; // Re-throw error to trigger fallback
-        }
-    }
     /**
      * 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 = "GoogleVertexAI.generateText";
+    async generate(optionsOrPrompt, analysisSchema) {
+        const functionTag = "GoogleVertexAI.generate";
         const provider = "vertex";
         const startTime = Date.now();
         try {
@@ -475,7 +366,19 @@ export class GoogleVertexAI {
                 if (options.enableEvaluation) {
                     result.evaluation = await evaluateResponse(prompt, result.text, options.context);
                 }
-                return result;
+                return {
+                    content: result.text,
+                    provider: "vertex",
+                    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
@@ -505,15 +408,140 @@ export class GoogleVertexAI {
         }
     }
     /**
-     * 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
      */
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+    async stream(optionsOrPrompt, analysisSchema) {
+        const functionTag = "GoogleVertexAI.stream";
+        const startTime = Date.now();
+        try {
+            // 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");
+            }
+            logger.debug(`[${functionTag}] Stream request started`, {
+                provider: "vertex",
+                modelName: this.modelName,
+                isAnthropic: isAnthropicModel(this.modelName),
+                promptLength: options.input.text.length,
+                hasSchema: !!analysisSchema,
+            });
+            // 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, timeout = getDefaultTimeout("vertex", "stream"), } = convertedOptions;
+            // Use schema from options or fallback parameter
+            const finalSchema = schema || analysisSchema;
+            logger.debug(`[${functionTag}] Stream request details`, {
+                provider: "vertex",
+                modelName: this.modelName,
+                isAnthropic: isAnthropicModel(this.modelName),
+                promptLength: prompt.length,
+                temperature,
+                maxTokens,
+                hasSchema: !!finalSchema,
+                timeout,
+            });
+            const model = await this.getModel();
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, "vertex", "stream");
+            let chunkCount = 0;
+            const streamOptions = {
+                model: model,
+                prompt: prompt,
+                system: systemPrompt,
+                temperature,
+                maxTokens,
+                // Add abort signal if available
+                ...(timeoutController && {
+                    abortSignal: timeoutController.controller.signal,
+                }),
+                onError: (event) => {
+                    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 error`, {
+                        provider: "vertex",
+                        modelName: this.modelName,
+                        error: errorMessage,
+                        stack: errorStack,
+                        promptLength: prompt.length,
+                        chunkCount,
+                    });
+                },
+                onFinish: (event) => {
+                    logger.debug(`[${functionTag}] Stream finished`, {
+                        provider: "vertex",
+                        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: "vertex",
+                        modelName: this.modelName,
+                        chunkNumber: chunkCount,
+                        chunkLength: event.chunk.text?.length || 0,
+                        chunkType: event.chunk.type,
+                    });
+                },
+            };
+            if (finalSchema) {
+                streamOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
+            }
+            const result = streamText(streamOptions);
+            // Convert to StreamResult format
+            return {
+                stream: (async function* () {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: "vertex",
+                model: this.modelName,
+                metadata: {
+                    streamId: `vertex-${Date.now()}`,
+                    startTime,
+                },
+            };
+        }
+        catch (err) {
+            logger.error(`[${functionTag}] Exception`, {
+                provider: "vertex",
+                modelName: this.modelName,
+                isAnthropic: isAnthropicModel(this.modelName),
+                message: "Error in streaming text",
+                err: String(err),
+            });
+            throw err; // Re-throw error to trigger fallback
+        }
     }
     /**
-     * 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/huggingFace.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 HuggingFace implements AIProvider {
     private modelName;
     private client;
@@ -15,19 +17,16 @@ export declare class HuggingFace 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
+     * 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>;
 }

package/dist/lib/providers/huggingFace.js

@@ -217,21 +217,38 @@ export class HuggingFace {
         return new HuggingFaceLanguageModel(this.modelName, this.client);
     }
     /**
-     * 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 = "HuggingFace.streamText";
+    async stream(optionsOrPrompt, analysisSchema) {
+        const functionTag = "HuggingFace.stream";
         const provider = "huggingface";
         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");
+            }
+            // 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, timeout = getDefaultTimeout(provider, "stream"), } = convertedOptions;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -260,7 +277,7 @@ export class HuggingFace {
                     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,
@@ -270,7 +287,7 @@ export class HuggingFace {
                     });
                 },
                 onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream text finished`, {
+                    logger.debug(`[${functionTag}] Stream finished`, {
                         provider,
                         modelName: this.modelName,
                         finishReason: event.finishReason,
@@ -282,7 +299,7 @@ export class HuggingFace {
                 },
                 onChunk: (event) => {
                     chunkCount++;
-                    logger.debug(`[${functionTag}] Stream text chunk`, {
+                    logger.debug(`[${functionTag}] Stream chunk`, {
                         provider,
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
@@ -297,9 +314,20 @@ export class HuggingFace {
                 });
             }
             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: "huggingface",
+                model: this.modelName,
+                metadata: {
+                    streamId: `huggingface-${Date.now()}`,
+                    startTime,
+                },
+            };
         }
         catch (err) {
             // Log timeout errors specifically
@@ -315,11 +343,11 @@ export class HuggingFace {
                 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
@@ -329,10 +357,10 @@ export class HuggingFace {
      * 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 = "HuggingFace.generateText";
+    async generate(optionsOrPrompt, analysisSchema) {
+        const functionTag = "HuggingFace.generate";
         const provider = "huggingface";
         const startTime = Date.now();
         try {
@@ -396,7 +424,19 @@ export class HuggingFace {
                 if (options.enableEvaluation) {
                     result.evaluation = await evaluateResponse(prompt, result.text, options.context);
                 }
-                return result;
+                return {
+                    content: result.text,
+                    provider: "huggingface",
+                    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
@@ -424,10 +464,7 @@ export class HuggingFace {
             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/lib/providers/mcp-provider.d.ts

@@ -2,9 +2,11 @@
  * NeuroLink MCP-Aware AI Provider
  * Integrates MCP tools with AI providers following Lighthouse's pattern
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
-import type { StreamTextResult, ToolSet, Schema, GenerateTextResult } 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";
 /**
  * MCP-Aware Provider Configuration
  */
@@ -31,8 +33,12 @@ export declare class MCPAwareProvider implements AIProvider {
      * Initialize MCP tools for this session
      */
     private initializeMCP;
-    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    /**
+     * 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(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
     /**
      * Detect if the prompt is requesting tool usage
      */
@@ -52,13 +58,12 @@ export declare class MCPAwareProvider implements AIProvider {
      */
     cleanup(): Promise<void>;
     /**
-     * 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 an MCP-aware provider

package/dist/lib/providers/mcp-provider.js

@@ -83,7 +83,40 @@ export class MCPAwareProvider {
             // Continue without MCP tools if initialization fails
         }
     }
-    async generateText(optionsOrPrompt, analysisSchema) {
+    /**
+     * 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 = "MCPAwareProvider.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 MCP metadata
+        return {
+            ...baseResult,
+            provider: "mcp",
+            model: options.model || "unknown",
+            metadata: {
+                streamId: `mcp-${Date.now()}`,
+                startTime,
+            },
+        };
+    }
+    async generate(optionsOrPrompt, analysisSchema) {
         // Ensure MCP is initialized
         await this.initializeMCP();
         // Parse options
@@ -114,15 +147,19 @@ PARAMS: <json_params>
 
 Otherwise, provide a direct response.`;
             // Generate response with enhanced prompt
-            const response = await this.baseProvider.generateText({
+            const response = await this.baseProvider.generate({
                 ...options,
                 prompt: enhancedPrompt,
             }, analysisSchema);
             if (!response) {
-                return null;
+                return {
+                    content: "No response generated",
+                    provider: "mcp",
+                    model: "unknown",
+                };
             }
             // Check if response includes tool invocation
-            const toolMatch = response.text.match(/TOOL:\s*(\S+)\s*\nPARAMS:\s*({.*})/s);
+            const toolMatch = response.content.match(/TOOL:\s*(\S+)\s*\nPARAMS:\s*({.*})/s);
             if (toolMatch) {
                 const toolName = toolMatch[1];
                 const toolParams = JSON.parse(toolMatch[2]);
@@ -135,12 +172,16 @@ Tool ${toolName} was executed with result:
 ${JSON.stringify(toolResult, null, 2)}
 
 Please provide a response based on this information.`;
-                const finalResponse = await this.baseProvider.generateText({
+                const finalResponse = await this.baseProvider.generate({
                     ...options,
                     prompt: finalPrompt,
                 }, analysisSchema);
                 if (!finalResponse) {
-                    return null;
+                    return {
+                        content: "Tool execution failed",
+                        provider: "mcp",
+                        model: "unknown",
+                    };
                 }
                 // Return response (tool usage is tracked internally)
                 return finalResponse;
@@ -148,12 +189,15 @@ Please provide a response based on this information.`;
             return response;
         }
         // Regular generation without tools
-        return this.baseProvider.generateText(options);
-    }
-    async streamText(optionsOrPrompt, analysisSchema) {
-        // For now, streaming doesn't support tool usage
-        // This matches Lighthouse's approach where MCP is used for non-streaming requests
-        return this.baseProvider.streamText(optionsOrPrompt, analysisSchema);
+        const result = await this.baseProvider.generate(options);
+        if (!result) {
+            return {
+                content: "Base provider returned no result",
+                provider: "mcp",
+                model: "unknown",
+            };
+        }
+        return result;
     }
     /**
      * Detect if the prompt is requesting tool usage
@@ -193,16 +237,13 @@ Please provide a response based on this information.`;
         }
     }
     /**
-     * Alias for generateText() - CLI-SDK consistency
+     * Alias for generate() - 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);
     }
 }
 /**