@juspay/neurolink 4.2.0 → 5.1.0

package/dist/lib/providers/agent-enhanced-provider.js

@@ -2,12 +2,11 @@
  * Agent-Enhanced Provider for NeuroLink CLI
  * Integrates direct tools with AI providers for true agent functionality
  */
-import { generateText, streamText, } from "ai";
+import { generateText as aiGenerate } from "ai";
 import { google } from "@ai-sdk/google";
 import { openai } from "@ai-sdk/openai";
 import { anthropic } from "@ai-sdk/anthropic";
 import { getToolsForCategory, } from "../agent/direct-tools.js";
-import { StreamingEnhancer, StreamingMonitor, } from "../utils/streaming-utils.js";
 import { UnifiedMCPSystem } from "../mcp/unified-mcp.js";
 import { mcpLogger } from "../mcp/logging.js";
 import { parseTimeout } from "../utils/timeout.js";
@@ -258,7 +257,37 @@ export class AgentEnhancedProvider {
         }
         return { ...directTools, ...mcpTools };
     }
-    async generateText(optionsOrPrompt) {
+    /**
+     * 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 = "AgentEnhancedProvider.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");
+        }
+        // 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,
+        };
+        // Use stream method to get streaming result
+        return await this.stream(options);
+    }
+    async generate(optionsOrPrompt) {
         const startTime = Date.now();
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
@@ -284,7 +313,7 @@ export class AgentEnhancedProvider {
                 }
             }
             // The AI SDK with maxSteps automatically handles tool calling and result integration
-            const result = await generateText({
+            const result = await aiGenerate({
                 model: this.model,
                 prompt: systemPrompt
                     ? `System: ${systemPrompt}\n\nUser: ${prompt}`
@@ -345,9 +374,21 @@ export class AgentEnhancedProvider {
                     });
                     // Return result with the formatted text
                     return {
-                        ...result,
-                        text: finalText,
-                        finishReason: "stop",
+                        content: finalText,
+                        provider: this.getProviderName(),
+                        model: this.getModelName(),
+                        usage: result.usage
+                            ? {
+                                inputTokens: result.usage.promptTokens,
+                                outputTokens: result.usage.completionTokens,
+                                totalTokens: result.usage.totalTokens,
+                            }
+                            : undefined,
+                        responseTime: 0,
+                        toolsUsed: [],
+                        toolExecutions: [],
+                        enhancedWithTools: false,
+                        availableTools: [],
                     };
                 }
                 catch (error) {
@@ -357,9 +398,21 @@ export class AgentEnhancedProvider {
                     // Fallback: return raw tool results
                     const fallbackText = `Tool execution completed. Raw results: ${JSON.stringify(result.toolResults, null, 2)}`;
                     return {
-                        ...result,
-                        text: fallbackText,
-                        finishReason: "stop",
+                        content: fallbackText,
+                        provider: this.getProviderName(),
+                        model: this.getModelName(),
+                        usage: result.usage
+                            ? {
+                                inputTokens: result.usage.promptTokens,
+                                outputTokens: result.usage.completionTokens,
+                                totalTokens: result.usage.totalTokens,
+                            }
+                            : undefined,
+                        responseTime: 0,
+                        toolsUsed: [],
+                        toolExecutions: [],
+                        enhancedWithTools: false,
+                        availableTools: [],
                     };
                 }
             }
@@ -372,85 +425,26 @@ export class AgentEnhancedProvider {
                 result.evaluation = await evaluateResponse(prompt, result.text, options.context);
             }
             // Return the full result - the AI SDK has already handled tool execution and integration
-            return result;
-        }
-        catch (error) {
-            console.error("[AgentEnhancedProvider] generateText error:", error);
-            throw error;
-        }
-    }
-    async streamText(optionsOrPrompt) {
-        const options = typeof optionsOrPrompt === "string"
-            ? { prompt: optionsOrPrompt }
-            : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, timeout, 
-        // Phase 2: Enhanced streaming options
-        enableProgressTracking, progressCallback, includeStreamingMetadata, streamingBufferSize, enableStreamingHeaders, customStreamingConfig, } = options;
-        // Phase 2.1: Setup streaming enhancements
-        const streamId = `agent_stream_${Date.now()}`;
-        const streamingConfig = StreamingEnhancer.createStreamingConfig(options);
-        if (enableProgressTracking) {
-            StreamingMonitor.registerStream(streamId);
-        }
-        // Get combined tools (direct + MCP) if enabled
-        const tools = this.config.enableTools ? await this.getCombinedTools() : {};
-        try {
-            // Parse timeout if provided
-            let abortSignal;
-            if (timeout) {
-                const timeoutMs = typeof timeout === "string" ? parseTimeout(timeout) : timeout;
-                if (timeoutMs !== undefined) {
-                    abortSignal = AbortSignal.timeout(timeoutMs);
-                }
-            }
-            const result = await streamText({
-                model: this.model,
-                prompt: systemPrompt
-                    ? `System: ${systemPrompt}\n\nUser: ${prompt}`
-                    : prompt,
-                tools,
-                maxSteps: this.config.maxSteps,
-                temperature,
-                maxTokens,
-                toolChoice: this.shouldForceToolUsage(prompt) ? "required" : "auto",
-                abortSignal, // Pass abort signal for timeout support
-            });
-            // Phase 2.1: Apply streaming enhancements if enabled
-            if (streamingConfig.progressTracking && result.textStream) {
-                const enhancedCallback = streamingConfig.callback
-                    ? (progress) => {
-                        StreamingMonitor.updateStream(streamId, progress);
-                        streamingConfig.callback(progress);
-                        if (progress.phase === "complete") {
-                            StreamingMonitor.completeStream(streamId);
-                        }
+            return {
+                content: result.text,
+                provider: this.getProviderName(),
+                model: this.getModelName(),
+                usage: result.usage
+                    ? {
+                        inputTokens: result.usage.promptTokens,
+                        outputTokens: result.usage.completionTokens,
+                        totalTokens: result.usage.totalTokens,
                     }
-                    : undefined;
-                // Enhance the stream with progress tracking
-                const enhancedStream = StreamingEnhancer.addProgressTracking(result.textStream, enhancedCallback, { streamId, bufferSize: streamingConfig.bufferSize });
-                // Return enhanced result with tracking
-                return {
-                    ...result,
-                    textStream: enhancedStream,
-                    // Phase 2.1: Add streaming metadata
-                    streamingMetadata: streamingConfig.metadata
-                        ? {
-                            streamId,
-                            provider: this.getProviderName(),
-                            model: this.getModelName(),
-                            enabledFeatures: {
-                                progressTracking: true,
-                                metadata: streamingConfig.metadata,
-                                headers: streamingConfig.headers,
-                            },
-                        }
-                        : undefined,
-                };
-            }
-            return result;
+                    : undefined,
+                responseTime: 0,
+                toolsUsed: [],
+                toolExecutions: [],
+                enhancedWithTools: false,
+                availableTools: [],
+            };
         }
         catch (error) {
-            console.error("[AgentEnhancedProvider] streamText error:", error);
+            console.error("[AgentEnhancedProvider] generate error:", error);
             throw error;
         }
     }
@@ -500,12 +494,12 @@ export class AgentEnhancedProvider {
         for (const prompt of testPrompts) {
             try {
                 logger.debug(`Testing: "${prompt}"`);
-                const result = await this.generateText(prompt);
+                const result = await this.generate(prompt);
                 if (!result) {
                     results.push({
                         prompt,
                         success: false,
-                        error: "No result returned from generateText",
+                        error: "No result returned from generate",
                     });
                     logger.warn(`❌ No result returned`);
                     continue;
@@ -519,9 +513,9 @@ export class AgentEnhancedProvider {
                     prompt,
                     success,
                     toolsCalled,
-                    response: result.text.substring(0, 100) + "...",
+                    response: result.content.substring(0, 100) + "...",
                 });
-                logger.debug(`✅ Tools called: ${toolsCalled}, Response: ${result.text.substring(0, 50)}...`);
+                logger.debug(`✅ Tools called: ${toolsCalled}, Response: ${result.content.substring(0, 50)}...`);
             }
             catch (error) {
                 results.push({
@@ -565,16 +559,13 @@ export class AgentEnhancedProvider {
         return providers;
     }
     /**
-     * Alias for generateText() - CLI-SDK consistency
+     * Alias for generate() - CLI-SDK consistency
      */
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt);
-    }
     /**
-     * Short alias for generateText() - CLI-SDK consistency
+     * Short alias for generate() - CLI-SDK consistency
      */
     async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt);
+        return this.generate(optionsOrPrompt);
     }
 }
 /**

package/dist/lib/providers/amazonBedrock.d.ts

@@ -1,19 +1,28 @@
 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 AmazonBedrock implements AIProvider {
     private modelName;
     private model;
     private bedrock;
     constructor(modelName?: string | null);
-    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>;
     /**
-     * Alias for generateText() - CLI-SDK consistency
+     * LEGACY METHOD: Use stream() instead for new code
+     * @deprecated Use stream() method instead
      */
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
     /**
-     * Short 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
      */
-    gen(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>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
+    /**
+     * Alias for generate() - CLI-SDK consistency
+     */
+    /**
+     * Short alias for generate() - CLI-SDK consistency
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
 }

package/dist/lib/providers/amazonBedrock.js

@@ -123,22 +123,38 @@ export class AmazonBedrock {
             throw err;
         }
     }
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "AmazonBedrock.streamText";
+    /**
+     * 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
+     */
+    async stream(optionsOrPrompt, analysisSchema) {
+        const functionTag = "AmazonBedrock.stream";
         const provider = "bedrock";
         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 prompt and other 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`, {
                 provider,
                 modelName: this.modelName,
-                promptLength: prompt.length,
+                promptLength: prompt?.length || 0,
                 temperature,
                 maxTokens,
                 timeout,
@@ -159,10 +175,9 @@ export class AmazonBedrock {
                     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,
-                        region: getAWSRegion(),
                         error: errorMessage,
                         stack: errorStack,
                         promptLength: prompt.length,
@@ -170,10 +185,9 @@ export class AmazonBedrock {
                     });
                 },
                 onFinish: (event) => {
-                    logger.debug(`[${functionTag}] Stream text finished`, {
+                    logger.debug(`[${functionTag}] Stream finished`, {
                         provider,
                         modelName: this.modelName,
-                        region: getAWSRegion(),
                         finishReason: event.finishReason,
                         usage: event.usage,
                         totalChunks: chunkCount,
@@ -183,7 +197,7 @@ export class AmazonBedrock {
                 },
                 onChunk: (event) => {
                     chunkCount++;
-                    logger.debug(`[${functionTag}] Stream text chunk`, {
+                    logger.debug(`[${functionTag}] Stream chunk`, {
                         provider,
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
@@ -197,42 +211,49 @@ export class AmazonBedrock {
                     schema: finalSchema,
                 });
             }
-            // Direct streamText call - let the real error bubble up
             const result = streamText(streamOptions);
-            logger.debug(`[${functionTag}] Stream text call successful`, {
+            logger.debug(`[${functionTag}] Stream request completed`, {
                 provider,
                 modelName: this.modelName,
-                promptLength: prompt.length,
             });
-            // 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: "bedrock",
+                model: this.modelName,
+                metadata: {
+                    streamId: `bedrock-${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,
-                    region: getAWSRegion(),
                     timeout: err.timeout,
                     message: err.message,
                 });
             }
             else {
-                logger.error(`[${functionTag}] Exception`, {
+                logger.debug(`[${functionTag}] Exception`, {
                     provider,
                     modelName: this.modelName,
-                    region: getAWSRegion(),
-                    message: "Error in streaming text",
+                    message: "Error in streaming content",
                     err: String(err),
                 });
             }
             throw err; // Re-throw error to trigger fallback
         }
     }
-    async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "AmazonBedrock.generateText";
+    async generate(optionsOrPrompt, analysisSchema) {
+        const functionTag = "AmazonBedrock.generate";
         const provider = "bedrock";
         const startTime = Date.now();
         try {
@@ -290,7 +311,19 @@ export class AmazonBedrock {
                 if (options.enableEvaluation) {
                     result.evaluation = await evaluateResponse(prompt, result.text, options.context);
                 }
-                return result;
+                return {
+                    content: result.text,
+                    provider: "bedrock",
+                    model: this.modelName || "claude-3-sonnet",
+                    usage: result.usage
+                        ? {
+                            inputTokens: result.usage.promptTokens,
+                            outputTokens: result.usage.completionTokens,
+                            totalTokens: result.usage.totalTokens,
+                        }
+                        : undefined,
+                    responseTime: 0,
+                };
             }
             finally {
                 // Always cleanup timeout
@@ -320,15 +353,12 @@ export class AmazonBedrock {
         }
     }
     /**
-     * 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);
     }
 }

package/dist/lib/providers/anthropic.d.ts

@@ -4,9 +4,10 @@
  * 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 type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema } from "ai";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
 import { AIProviderName } from "../core/types.js";
 export declare class AnthropicProvider implements AIProvider {
     readonly name: AIProviderName;
@@ -17,10 +18,17 @@ export declare class AnthropicProvider implements AIProvider {
     private getApiKey;
     private getModel;
     private makeRequest;
-    generateText(optionsOrPrompt: TextGenerationOptions | string, schema?: any): Promise<any>;
-    streamText(optionsOrPrompt: StreamTextOptions | string, schema?: any): Promise<any>;
+    /**
+     * 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?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, schema?: any): Promise<any>;
+    /**
+     * LEGACY METHOD: Use stream() instead for new code
+     * @deprecated Use stream() method instead
+     */
     private createAsyncIterable;
-    generateTextStream(optionsOrPrompt: StreamTextOptions | string): AsyncGenerator<any, void, unknown>;
     testConnection(): Promise<{
         success: boolean;
         error?: string;
@@ -34,11 +42,7 @@ export declare class AnthropicProvider implements AIProvider {
     supportsSchema(): boolean;
     getCapabilities(): string[];
     /**
-     * Alias for generateText() - CLI-SDK consistency
-     */
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
-    /**
-     * 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>;
 }