@juspay/neurolink 4.2.0 → 5.1.0

package/dist/lib/providers/openAI.js

@@ -70,29 +70,29 @@ export class OpenAI {
     getModel() {
         return this.model;
     }
-    async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "OpenAI.streamText";
+    async generate(optionsOrPrompt, analysisSchema) {
+        const functionTag = "OpenAI.generate";
         const provider = "openai";
-        let chunkCount = 0;
+        const startTime = Date.now();
         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;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
-            logger.debug(`[${functionTag}] Stream text started`, {
+            logger.debug(`[${functionTag}] Generate text started`, {
                 provider,
                 modelName: this.modelName,
-                promptLength: prompt.length,
+                promptLength: prompt?.length || 0,
                 temperature,
                 maxTokens,
                 timeout,
             });
             // Create timeout controller if timeout is specified
-            const timeoutController = createTimeoutController(timeout, provider, "stream");
-            const streamOptions = {
+            const timeoutController = createTimeoutController(timeout, provider, "generate");
+            const generateOptions = {
                 model: this.model,
                 prompt: prompt,
                 system: systemPrompt,
@@ -102,50 +102,51 @@ export class OpenAI {
                 ...(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.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);
-            // 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;
+            try {
+                const result = await generateText(generateOptions);
+                // Clean up timeout if successful
+                timeoutController?.cleanup();
+                logger.debug(`[${functionTag}] Generate text completed`, {
+                    provider,
+                    modelName: this.modelName,
+                    usage: result.usage,
+                    finishReason: result.finishReason,
+                    responseLength: result.text?.length || 0,
+                    timeout,
+                });
+                // Add analytics if enabled
+                if (options.enableAnalytics) {
+                    const { createAnalytics } = await import("./analytics-helper.js");
+                    result.analytics = createAnalytics(provider, this.modelName, result, Date.now() - startTime, options.context);
+                }
+                // Add evaluation if enabled
+                if (options.enableEvaluation) {
+                    result.evaluation = await evaluateResponse(prompt, result.text, options.context, options.evaluationDomain, options.toolUsageContext, options.conversationHistory);
+                }
+                return {
+                    content: result.text,
+                    provider: "openai",
+                    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
+                timeoutController?.cleanup();
+            }
         }
         catch (err) {
             // Log timeout errors specifically
@@ -161,36 +162,48 @@ export class OpenAI {
                 logger.debug(`[${functionTag}] Exception`, {
                     provider,
                     modelName: this.modelName,
-                    message: "Error in streaming text",
+                    message: "Error in generating text",
                     err: String(err),
                 });
             }
             throw err; // Re-throw error to trigger fallback
         }
     }
-    async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = "OpenAI.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 = "OpenAI.stream";
         const provider = "openai";
+        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, "generate"), } = 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 to internal 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}] Generate text started`, {
+            logger.debug(`[${functionTag}] Stream request started`, {
                 provider,
                 modelName: this.modelName,
-                promptLength: prompt.length,
+                promptLength: prompt?.length || 0,
                 temperature,
                 maxTokens,
                 timeout,
             });
             // Create timeout controller if timeout is specified
-            const timeoutController = createTimeoutController(timeout, provider, "generate");
-            const generateOptions = {
+            const timeoutController = createTimeoutController(timeout, provider, "stream");
+            const streamOptions = {
                 model: this.model,
                 prompt: prompt,
                 system: systemPrompt,
@@ -200,39 +213,70 @@ export class OpenAI {
                 ...(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.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,
                 });
             }
-            try {
-                const result = await generateText(generateOptions);
-                // Clean up timeout if successful
-                timeoutController?.cleanup();
-                logger.debug(`[${functionTag}] Generate text completed`, {
-                    provider,
-                    modelName: this.modelName,
-                    usage: result.usage,
-                    finishReason: result.finishReason,
-                    responseLength: result.text?.length || 0,
-                    timeout,
-                });
-                // Add analytics if enabled
-                if (options.enableAnalytics) {
-                    const { createAnalytics } = await import("./analytics-helper.js");
-                    result.analytics = createAnalytics(provider, this.modelName, result, Date.now() - startTime, options.context);
-                }
-                // Add evaluation if enabled
-                if (options.enableEvaluation) {
-                    result.evaluation = await evaluateResponse(prompt, result.text, options.context, options.evaluationDomain, options.toolUsageContext, options.conversationHistory);
-                }
-                return result;
-            }
-            finally {
-                // Always cleanup timeout
-                timeoutController?.cleanup();
-            }
+            const result = streamText(streamOptions);
+            logger.debug(`[${functionTag}] Stream request completed`, {
+                provider,
+                modelName: this.modelName,
+            });
+            // Convert to StreamResult format
+            return {
+                stream: result.textStream
+                    ? (async function* () {
+                        for await (const chunk of result.textStream) {
+                            yield { content: chunk };
+                        }
+                    })()
+                    : (async function* () {
+                        yield { content: "" };
+                        throw new Error("No textStream available from AI SDK");
+                    })(),
+                provider: "openai",
+                model: this.modelName,
+                metadata: {
+                    streamId: `openai-${Date.now()}`,
+                    startTime,
+                },
+            };
         }
         catch (err) {
             // Log timeout errors specifically
@@ -248,7 +292,7 @@ export class OpenAI {
                 logger.debug(`[${functionTag}] Exception`, {
                     provider,
                     modelName: this.modelName,
-                    message: "Error in generating text",
+                    message: "Error in streaming content",
                     err: String(err),
                 });
             }
@@ -256,21 +300,12 @@ export class OpenAI {
         }
     }
     /**
-     * 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
-     */
-    async generate(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
-    }
-    /**
-     * 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
      */
     async gen(optionsOrPrompt, analysisSchema) {
-        return this.generateText(optionsOrPrompt, analysisSchema);
+        return this.generate(optionsOrPrompt, analysisSchema);
     }
 }

package/dist/lib/types/generate-types.d.ts

@@ -0,0 +1,79 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import type { Tool, Schema } from "ai";
+import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
+/**
+ * Generate function options interface - Primary method for content generation
+ * Future-ready for multi-modal capabilities while maintaining text focus
+ */
+export interface GenerateOptions {
+    input: {
+        text: string;
+    };
+    output?: {
+        format?: "text" | "structured" | "json";
+    };
+    provider?: AIProviderName | string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+    tools?: Record<string, Tool>;
+    timeout?: number | string;
+    disableTools?: boolean;
+    enableEvaluation?: boolean;
+    enableAnalytics?: boolean;
+    context?: Record<string, any>;
+    evaluationDomain?: string;
+    toolUsageContext?: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+/**
+ * Generate function result interface - Primary output format
+ * Future-ready for multi-modal outputs while maintaining text focus
+ */
+export interface GenerateResult {
+    content: string;
+    outputs?: {
+        text: string;
+    };
+    provider?: string;
+    model?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    responseTime?: number;
+    toolCalls?: Array<{
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, any>;
+    }>;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        name: string;
+        input: Record<string, any>;
+        output: any;
+        duration: number;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, any>;
+    }>;
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+}
+/**
+ * Enhanced provider interface with generate method
+ */
+export interface EnhancedProvider {
+    generate(options: GenerateOptions): Promise<GenerateResult>;
+    getName(): string;
+    isAvailable(): Promise<boolean>;
+}

package/dist/lib/types/generate-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/types/stream-types.d.ts

@@ -0,0 +1,83 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import type { Tool, Schema } from "ai";
+import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
+/**
+ * Stream function options interface - Primary method for streaming content
+ * Future-ready for multi-modal capabilities while maintaining text focus
+ */
+export interface StreamOptions {
+    input: {
+        text: string;
+    };
+    output?: {
+        format?: "text" | "structured" | "json";
+        streaming?: {
+            chunkSize?: number;
+            bufferSize?: number;
+            enableProgress?: boolean;
+        };
+    };
+    provider?: AIProviderName | string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+    tools?: Record<string, Tool>;
+    timeout?: number | string;
+    disableTools?: boolean;
+    enableEvaluation?: boolean;
+    enableAnalytics?: boolean;
+    context?: Record<string, any>;
+    evaluationDomain?: string;
+    toolUsageContext?: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+/**
+ * Stream function result interface - Primary output format for streaming
+ * Future-ready for multi-modal outputs while maintaining text focus
+ */
+export interface StreamResult {
+    stream: AsyncIterable<{
+        content: string;
+    }>;
+    provider?: string;
+    model?: string;
+    metadata?: {
+        streamId?: string;
+        startTime?: number;
+        totalChunks?: number;
+        estimatedDuration?: number;
+    };
+    toolCalls?: Array<{
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, any>;
+    }>;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        name: string;
+        input: Record<string, any>;
+        output: any;
+        duration: number;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+        parameters: Record<string, any>;
+    }>;
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+}
+/**
+ * Enhanced provider interface with stream method
+ */
+export interface EnhancedStreamProvider {
+    stream(options: StreamOptions): Promise<StreamResult>;
+    getName(): string;
+    isAvailable(): Promise<boolean>;
+}

package/dist/lib/types/stream-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/utils/providerUtils-fixed.js

@@ -85,7 +85,7 @@ async function isProviderAvailable(providerName) {
     }
     try {
         const provider = await AIProviderFactory.createProvider(providerName);
-        await provider.generateText({ prompt: "test", maxTokens: 1 });
+        await provider.generate({ prompt: "test", maxTokens: 1 });
         return true;
     }
     catch (error) {

package/dist/lib/utils/streaming-utils.d.ts

@@ -2,7 +2,7 @@
  * Phase 2: Enhanced Streaming Infrastructure
  * Streaming utilities for progress tracking and metadata enhancement
  */
-import type { StreamingProgressData, StreamingMetadata, ProgressCallback, EnhancedStreamTextOptions } from "../core/types.js";
+import type { StreamingProgressData, StreamingMetadata, ProgressCallback } from "../core/types.js";
 export interface UIProgressHandler {
     onProgress: (progress: StreamingProgressData) => void;
     onComplete: (metadata: StreamingMetadata) => void;
@@ -19,6 +19,18 @@ export interface StreamingStats {
 /**
  * Enhanced streaming utilities for progress tracking and metadata
  */
+export interface StreamingConfigOptions {
+    enableProgressTracking?: boolean;
+    progressCallback?: ProgressCallback;
+    includeStreamingMetadata?: boolean;
+    streamingBufferSize?: number;
+    enableStreamingHeaders?: boolean;
+}
+/**
+ * Legacy interface for backward compatibility
+ */
+export interface EnhancedStreamTextOptions extends StreamingConfigOptions {
+}
 export declare class StreamingEnhancer {
     /**
      * Add progress tracking to a readable stream
@@ -42,7 +54,7 @@ export declare class StreamingEnhancer {
     /**
      * Create enhanced streaming configuration
      */
-    static createStreamingConfig(options: EnhancedStreamTextOptions): {
+    static createStreamingConfig(options: StreamingConfigOptions | EnhancedStreamTextOptions): {
         progressTracking: boolean;
         callback?: ProgressCallback;
         metadata: boolean;

package/dist/lib/utils/streaming-utils.js

@@ -2,9 +2,6 @@
  * Phase 2: Enhanced Streaming Infrastructure
  * Streaming utilities for progress tracking and metadata enhancement
  */
-/**
- * Enhanced streaming utilities for progress tracking and metadata
- */
 export class StreamingEnhancer {
     /**
      * Add progress tracking to a readable stream

package/dist/mcp/client.js

@@ -49,11 +49,11 @@ export class NeuroLinkMCPClient extends EventEmitter {
                             return result;
                         }
                         // If it's in Lighthouse format with content array
-                        if (result.content &&
-                            Array.isArray(result.content) &&
-                            result.content[0]?.text) {
+                        if (result.text &&
+                            Array.isArray(result.text) &&
+                            result.text[0]?.text) {
                             try {
-                                const data = JSON.parse(result.content[0].text);
+                                const data = JSON.parse(result.text[0].text);
                                 return {
                                     success: !result.isError,
                                     data,
@@ -69,7 +69,7 @@ export class NeuroLinkMCPClient extends EventEmitter {
                                 // If JSON parsing fails, return the text as-is
                                 return {
                                     success: !result.isError,
-                                    data: { text: result.content[0].text },
+                                    data: { text: result.text[0].text },
                                     metadata: {
                                         toolName,
                                         serverId,

package/dist/mcp/dynamic-orchestrator.js

@@ -199,11 +199,11 @@ export class DynamicOrchestrator extends MCPOrchestrator {
                 .replace("{previousResults}", previousResults || "None yet");
         try {
             // Use AI Core Server to get tool decision
-            const generateTextTool = aiCoreServer.tools["generate-text"];
-            if (!generateTextTool) {
-                throw new Error("generate-text tool not found");
+            const generateTool = aiCoreServer.tools["generate"];
+            if (!generateTool) {
+                throw new Error("generate tool not found");
             }
-            const aiResponse = await generateTextTool.execute({
+            const aiResponse = await generateTool.execute({
                 prompt: "Select the next tool to execute based on the context provided.",
                 systemPrompt,
                 provider: "google-ai", // Use fast model for decisions
@@ -279,11 +279,11 @@ ${executionSummary}
 Provide a clear, concise answer that addresses the user's request based on the tool results.`;
         try {
             // Use AI to generate final summary
-            const generateTextTool = aiCoreServer.tools["generate-text"];
-            if (!generateTextTool) {
-                throw new Error("generate-text tool not found");
+            const generateTool = aiCoreServer.tools["generate"];
+            if (!generateTool) {
+                throw new Error("generate tool not found");
             }
-            const aiResponse = await generateTextTool.execute({
+            const aiResponse = await generateTool.execute({
                 prompt: summaryPrompt,
                 provider: "google-ai",
                 model: "gemini-2.5-pro",

package/dist/mcp/external-client.js

@@ -139,7 +139,7 @@ export class ExternalMCPClient extends EventEmitter {
             // Transform MCP response to NeuroLink format
             const result = {
                 success: !response.isError,
-                data: response.content || response.result || response,
+                data: response.text || response.result || response,
                 metadata: {
                     toolName,
                     serverId: this.config.name,
@@ -150,7 +150,7 @@ export class ExternalMCPClient extends EventEmitter {
                 },
             };
             if (response.isError) {
-                result.error = response.content?.[0]?.text || "Tool execution failed";
+                result.error = response.text?.[0]?.text || "Tool execution failed";
             }
             logger.debug(`[External MCP] Tool ${toolName} executed in ${executionTime}ms`);
             return result;

package/dist/mcp/factory.d.ts

@@ -134,7 +134,7 @@ export interface MCPServerConfig {
  * });
  *
  * aiCoreServer.registerTool({
- *   name: 'generate-text',
+ *   name: 'generate',
  *   description: 'Generate text using AI providers',
  *   execute: async (params, context) => {
  *     // Tool implementation

package/dist/mcp/factory.js

@@ -50,7 +50,7 @@ const ServerConfigSchema = z.object({
  * });
  *
  * aiCoreServer.registerTool({
- *   name: 'generate-text',
+ *   name: 'generate',
  *   description: 'Generate text using AI providers',
  *   execute: async (params, context) => {
  *     // Tool implementation