@juspay/neurolink 4.2.0 → 5.1.0

package/dist/providers/openAI.js

@@ -71,29 +71,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,
@@ -103,50 +103,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
@@ -162,36 +163,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,
@@ -201,39 +214,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
@@ -249,7 +293,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),
                 });
             }
@@ -257,21 +301,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/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/types/generate-types.js

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

package/dist/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/types/stream-types.js

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

package/dist/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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "4.2.0",
+  "version": "5.1.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -71,9 +71,8 @@
     "content:cleanup": "node tools/converted-scripts/cleanup-hash-named-videos.js",
     "content:all": "pnpm run content:screenshots && pnpm run content:videos",
     "// Documentation Automation": "",
-    "docs:sync": "node tools/content/documentation-sync.js",
     "docs:validate": "node tools/content/documentation-sync.js --validate",
-    "docs:generate": "pnpm run docs:sync && pnpm run content:screenshots",
+    "docs:generate": "pnpm run docs:validate && pnpm run content:screenshots",
     "// Development & Monitoring": "",
     "dev:full": "node tools/development/dev-server.js",
     "dev:health": "node tools/development/health-monitor.js",

package/dist/cli/commands/agent-generate.d.ts

@@ -1 +0,0 @@
-export declare function agentGenerateCommand(cli: any): void;

package/dist/cli/commands/agent-generate.js

@@ -1,67 +0,0 @@
-import { AgentEnhancedProvider } from "../../lib/providers/agent-enhanced-provider.js";
-import ora from "ora";
-import chalk from "chalk";
-export function agentGenerateCommand(cli) {
-    cli.command("agent-generate <prompt>", "Generate text with agent capabilities (tool calling)", (yargs) => yargs
-        .positional("prompt", {
-        describe: "The prompt for the agent",
-        type: "string",
-    })
-        .option("provider", {
-        alias: "p",
-        describe: "The AI provider to use",
-        type: "string",
-        choices: ["google-ai", "openai", "anthropic"],
-        default: "google-ai",
-    })
-        .option("model", {
-        alias: "m",
-        describe: "The model to use",
-        type: "string",
-    })
-        .option("toolCategory", {
-        alias: "t",
-        describe: "The category of tools to use",
-        type: "string",
-        choices: ["basic", "filesystem", "utility", "all"],
-        default: "all",
-    }), async (argv) => {
-        const { prompt, provider, model, toolCategory } = argv;
-        const spinner = ora(`Generating response with ${provider} agent...`).start();
-        try {
-            const agentProvider = new AgentEnhancedProvider({
-                provider,
-                model,
-                toolCategory,
-            });
-            const result = await agentProvider.generateText(prompt);
-            if (result) {
-                spinner.succeed("Response generated successfully!");
-                console.log(chalk.green("\nAI Response:"));
-                console.log(result.text);
-                if (result.toolCalls && result.toolCalls.length > 0) {
-                    console.log(chalk.yellow("\nTools Called:"));
-                    for (const call of result.toolCalls) {
-                        console.log(`- ${call.toolName}`);
-                        console.log(`  Args: ${JSON.stringify(call.args)}`);
-                    }
-                }
-                if (result.toolResults && result.toolResults.length > 0) {
-                    console.log(chalk.blue("\nTool Results:"));
-                    for (const toolResult of result.toolResults) {
-                        console.log(`- ${toolResult.toolName}`);
-                        console.log(`  Result: ${JSON.stringify(toolResult.result)}`);
-                    }
-                }
-            }
-            else {
-                spinner.fail("Failed to generate response.");
-            }
-        }
-        catch (error) {
-            spinner.fail("An error occurred during generation.");
-            console.error(chalk.red(error));
-            process.exit(1);
-        }
-    });
-}