@juspay/neurolink 4.2.0 → 5.1.0

package/dist/providers/anthropic.js

@@ -58,8 +58,83 @@ export class AnthropicProvider {
         }
         return response;
     }
-    async generateText(optionsOrPrompt, schema) {
-        const functionTag = "AnthropicProvider.generateText";
+    /**
+     * 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 = "AnthropicProvider.stream";
+        const provider = "anthropic";
+        const startTime = Date.now();
+        logger.debug(`[${functionTag}] Starting content streaming`);
+        // 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");
+        }
+        // Extract parameters
+        const { prompt = options.input.text, 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}`);
+        // Create timeout controller if timeout is specified
+        const timeoutController = createTimeoutController(timeout, provider, "stream");
+        try {
+            const body = {
+                model: this.getModel(),
+                max_tokens: maxTokens,
+                messages: [
+                    ...(systemPrompt
+                        ? [{ role: "assistant", content: systemPrompt }]
+                        : []),
+                    { role: "user", content: prompt },
+                ],
+                temperature,
+                stream: true,
+            };
+            const response = await this.makeRequest("messages", body, true, timeoutController?.controller.signal);
+            const streamIterable = this.createAsyncIterable(response.body, timeoutController?.controller.signal);
+            // Clean up timeout controller
+            timeoutController?.cleanup();
+            logger.debug(`[${functionTag}] Stream initialized successfully`);
+            // Convert to StreamResult format
+            return {
+                stream: (async function* () {
+                    for await (const chunk of streamIterable) {
+                        yield { content: chunk };
+                    }
+                })(),
+                provider: "anthropic",
+                model: this.getModel(),
+                metadata: {
+                    streamId: `anthropic-${Date.now()}`,
+                    startTime,
+                },
+            };
+        }
+        catch (error) {
+            // Always cleanup timeout on error
+            timeoutController?.cleanup();
+            if (error.name === "AbortError" || error.message.includes("timeout")) {
+                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 generate(optionsOrPrompt, schema) {
+        const functionTag = "AnthropicProvider.generate";
         const provider = "anthropic";
         const startTime = Date.now();
         logger.debug(`[${functionTag}] Starting text generation`);
@@ -138,73 +213,10 @@ export class AnthropicProvider {
             throw error;
         }
     }
-    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,
-            };
-        }
-        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;
-        }
-    }
+    /**
+     * LEGACY METHOD: Use stream() instead for new code
+     * @deprecated Use stream() method instead
+     */
     async *createAsyncIterable(body, signal) {
         const reader = body.getReader();
         const decoder = new TextDecoder();
@@ -250,87 +262,11 @@ export class AnthropicProvider {
             reader.releaseLock();
         }
     }
-    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,
-        };
-        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({
+            await this.generate({
                 prompt: "Hello",
                 maxTokens: 5,
             });
@@ -391,15 +327,9 @@ export class AnthropicProvider {
         ];
     }
     /**
-     * Alias for generateText() - CLI-SDK consistency
-     */
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
-    /**
-     * Short alias for generateText() - CLI-SDK consistency
+     * Short alias for generate() - CLI-SDK consistency
      */
     async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+        return this.generate(optionsOrPrompt, analysisSchema);
     }
 }

package/dist/providers/azureOpenAI.d.ts

@@ -4,7 +4,8 @@
  * Enterprise-grade OpenAI integration through Microsoft Azure.
  * Supports all OpenAI models with enhanced security and compliance.
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
 import { AIProviderName } from "../core/types.js";
 export declare class AzureOpenAIProvider implements AIProvider {
     readonly name: AIProviderName;
@@ -18,10 +19,13 @@ export declare class AzureOpenAIProvider implements AIProvider {
     private getDeploymentId;
     private getApiUrl;
     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?: any): Promise<StreamResult>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, schema?: any): Promise<any>;
     private createAsyncIterable;
-    generateTextStream(optionsOrPrompt: StreamTextOptions | string): AsyncGenerator<any, void, unknown>;
     testConnection(): Promise<{
         success: boolean;
         error?: string;
@@ -34,6 +38,5 @@ export declare class AzureOpenAIProvider implements AIProvider {
     supportsStreaming(): boolean;
     supportsSchema(): boolean;
     getCapabilities(): string[];
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateResult | null>;
 }

package/dist/providers/azureOpenAI.js

@@ -69,8 +69,73 @@ export class AzureOpenAIProvider {
         }
         return response;
     }
-    async generateText(optionsOrPrompt, schema) {
-        const functionTag = "AzureOpenAIProvider.generateText";
+    /**
+     * 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 = "AzureOpenAIProvider.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,
+        };
+        // Prepare Azure OpenAI messages
+        const messages = [];
+        if (convertedOptions.systemPrompt) {
+            messages.push({
+                role: "system",
+                content: convertedOptions.systemPrompt,
+            });
+        }
+        messages.push({
+            role: "user",
+            content: convertedOptions.prompt,
+        });
+        const requestBody = {
+            messages,
+            temperature: convertedOptions.temperature ?? 0.7,
+            max_tokens: convertedOptions.maxTokens ?? DEFAULT_MAX_TOKENS,
+            stream: true,
+        };
+        // Create timeout controller if timeout is specified
+        const timeoutController = createTimeoutController(convertedOptions.timeout, this.name, "stream");
+        try {
+            const response = await this.makeRequest(requestBody, true, timeoutController?.controller.signal);
+            // Clean up timeout if successful
+            timeoutController?.cleanup();
+            // Return an async iterable for streaming chunks
+            const streamIterable = this.createAsyncIterable(response.body, timeoutController?.controller.signal);
+            // Compose the StreamResult object
+            return {
+                stream: streamIterable,
+                provider: this.name,
+                model: convertedOptions.model,
+            };
+        }
+        catch (error) {
+            timeoutController?.cleanup();
+            throw error;
+        }
+    }
+    async generate(optionsOrPrompt, schema) {
+        const functionTag = "AzureOpenAIProvider.generate";
         const provider = "azure";
         const startTime = Date.now();
         logger.debug(`[${functionTag}] Starting text generation`);
@@ -159,77 +224,6 @@ export class AzureOpenAIProvider {
             throw error;
         }
     }
-    async streamText(optionsOrPrompt, schema) {
-        const functionTag = "AzureOpenAIProvider.streamText";
-        const provider = "azure";
-        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 a helpful AI assistant.", timeout = getDefaultTimeout(provider, "stream"), } = options;
-        logger.debug(`[${functionTag}] Streaming prompt: "${prompt.substring(0, 100)}...", Timeout: ${timeout}`);
-        const messages = [];
-        if (systemPrompt) {
-            messages.push({
-                role: "system",
-                content: systemPrompt,
-            });
-        }
-        messages.push({
-            role: "user",
-            content: prompt,
-        });
-        const requestBody = {
-            messages,
-            temperature,
-            max_tokens: maxTokens,
-            stream: true,
-        };
-        // Create timeout controller if timeout is specified
-        const timeoutController = createTimeoutController(timeout, provider, "stream");
-        try {
-            const response = await this.makeRequest(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: "stop",
-                // Store timeout controller for external cleanup if needed
-                _timeoutController: timeoutController,
-            };
-        }
-        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();
@@ -260,7 +254,7 @@ export class AzureOpenAIProvider {
                             const chunk = JSON.parse(data);
                             // Extract text content from chunk
                             if (chunk.choices?.[0]?.delta?.content) {
-                                yield chunk.choices[0].delta.content;
+                                yield { content: chunk.choices[0].delta.content };
                             }
                         }
                         catch (parseError) {
@@ -275,91 +269,11 @@ export class AzureOpenAIProvider {
             reader.releaseLock();
         }
     }
-    async *generateTextStream(optionsOrPrompt) {
-        logger.debug("[AzureOpenAIProvider.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 a helpful AI assistant.", } = options;
-        logger.debug(`[AzureOpenAIProvider.generateTextStream] Streaming prompt: "${prompt.substring(0, 100)}..."`);
-        const messages = [];
-        if (systemPrompt) {
-            messages.push({
-                role: "system",
-                content: systemPrompt,
-            });
-        }
-        messages.push({
-            role: "user",
-            content: prompt,
-        });
-        const requestBody = {
-            messages,
-            temperature,
-            max_tokens: maxTokens,
-            stream: true,
-        };
-        try {
-            const response = await this.makeRequest(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 chunk
-                                if (chunk.choices?.[0]?.delta?.content) {
-                                    yield {
-                                        content: chunk.choices[0].delta.content,
-                                        provider: this.name,
-                                        model: chunk.model || this.deploymentId,
-                                    };
-                                }
-                            }
-                            catch (parseError) {
-                                logger.warn("[AzureOpenAIProvider.generateTextStream] Failed to parse chunk:", parseError);
-                                continue;
-                            }
-                        }
-                    }
-                }
-            }
-            finally {
-                reader.releaseLock();
-            }
-            logger.debug("[AzureOpenAIProvider.generateTextStream] Streaming completed");
-        }
-        catch (error) {
-            logger.error("[AzureOpenAIProvider.generateTextStream] Error:", error);
-            throw error;
-        }
-    }
     async testConnection() {
         logger.debug("[AzureOpenAIProvider.testConnection] Testing connection to Azure OpenAI");
         const startTime = Date.now();
         try {
-            await this.generateText({
+            await this.generate({
                 prompt: "Hello",
                 maxTokens: 5,
             });
@@ -428,10 +342,7 @@ export class AzureOpenAIProvider {
             "content-filtering",
         ];
     }
-    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/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