@juspay/neurolink 4.2.0 → 5.1.0

package/dist/cli/index.js

@@ -21,7 +21,7 @@ import chalk from "chalk";
 import fs from "fs";
 import { addMCPCommands } from "./commands/mcp.js";
 import { addOllamaCommands } from "./commands/ollama.js";
-import { agentGenerateCommand } from "./commands/agent-generate.js";
+import { CLICommandFactory } from "./factories/command-factory.js";
 import { AgentEnhancedProvider } from "../lib/providers/agent-enhanced-provider.js";
 import { logger } from "../lib/utils/logger.js";
 /**
@@ -290,9 +290,9 @@ const cli = yargs(args)
     }
     exitProcess(); // Default exit
 })
-    // Generate Text Command
-    .command(["generate-text [prompt]", "generate [prompt]", "gen [prompt]"], "Generate text using AI providers", (yargsInstance) => yargsInstance
-    .usage("Usage: $0 generate-text [prompt] [options]")
+    // Generate Command (Primary)
+    .command(["generate [prompt]", "gen [prompt]"], "Generate content using AI providers", (yargsInstance) => yargsInstance
+    .usage("Usage: $0 generate [prompt] [options]")
     .positional("prompt", {
     type: "string",
     description: "Text prompt for AI generation (or read from stdin)",
@@ -379,10 +379,10 @@ const cli = yargs(args)
     type: "string",
     description: "JSON context object for custom data",
 })
-    .example('$0 generate-text "Hello world"', "Basic text generation")
-    .example('$0 generate-text "Write a story" --provider openai', "Use specific provider")
-    .example('$0 generate-text "What time is it?"', "Use with natural tool integration (default)")
-    .example('$0 generate-text "Hello world" --disable-tools', "Use without tool integration"), async (argv) => {
+    .example('$0 generate "Hello world"', "Basic content generation")
+    .example('$0 generate "Write a story" --provider openai', "Use specific provider")
+    .example('$0 generate "What time is it?"', "Use with natural tool integration (default)")
+    .example('$0 generate "Hello world" --disable-tools', "Use without tool integration"), async (argv) => {
     // SOLUTION 1: Handle stdin input if no prompt provided
     if (!argv.prompt && !process.stdin.isTTY) {
         // Read from stdin
@@ -430,11 +430,7 @@ const cli = yargs(args)
     if (errors.length > 0) {
         throw new Error(`Parameter validation failed:\n${errors.map((e) => `  • ${e}`).join("\n")}\n\nUse --help for valid parameter ranges.`);
     }
-    // Check if generate-text was used specifically (for deprecation warning)
-    const usedCommand = argv._[0];
-    if (usedCommand === "generate-text" && !argv.quiet) {
-        console.warn(chalk.yellow('⚠️  Warning: "generate-text" is deprecated. Use "generate" or "gen" instead for multimodal support.'));
-    }
+    // Command is now the primary generate method
     let originalConsole = {};
     if (argv.format === "json" && !argv.quiet) {
         // Suppress only if not quiet, as quiet implies no spinners anyway
@@ -470,8 +466,8 @@ const cli = yargs(args)
         }
         if (argv.disableTools === true) {
             // Tools disabled - use standard SDK
-            generatePromise = sdk.generateText({
-                prompt: argv.prompt,
+            generatePromise = sdk.generate({
+                input: { text: argv.prompt },
                 provider: argv.provider === "auto"
                     ? undefined
                     : argv.provider,
@@ -508,7 +504,7 @@ const cli = yargs(args)
                 model: argv.model, // Use specified model or default
                 toolCategory: "all", // Enable all tool categories
             });
-            generatePromise = agentProvider.generateText({
+            generatePromise = agentProvider.generate({
                 prompt: argv.prompt,
                 temperature: argv.temperature,
                 maxTokens: argv.maxTokens, // Respect user's token limit - no artificial caps
@@ -637,7 +633,7 @@ const cli = yargs(args)
     }
 })
     // Stream Text Command
-    .command("stream [prompt]", "Stream text generation in real-time", (yargsInstance) => yargsInstance
+    .command("stream [prompt]", "Stream generation in real-time", (yargsInstance) => yargsInstance
     .usage("Usage: $0 stream [prompt] [options]")
     .positional("prompt", {
     type: "string",
@@ -751,8 +747,8 @@ const cli = yargs(args)
         let stream;
         if (argv.disableTools === true) {
             // Tools disabled - use standard SDK
-            stream = await sdk.generateTextStream({
-                prompt: argv.prompt,
+            stream = await sdk.stream({
+                input: { text: argv.prompt },
                 provider: argv.provider === "auto"
                     ? undefined
                     : argv.provider,
@@ -785,8 +781,8 @@ const cli = yargs(args)
                 toolCategory: "all", // Enable all tool categories
             });
             // Note: AgentEnhancedProvider doesn't support streaming with tools yet
-            // Fall back to generateText for now
-            const result = await agentProvider.generateText({
+            // Fall back to generate for now
+            const result = await agentProvider.generate({
                 prompt: argv.prompt,
                 temperature: argv.temperature,
                 // NEW: Analytics and evaluation support
@@ -795,7 +791,7 @@ const cli = yargs(args)
                 context: contextObj,
             });
             // Simulate streaming by outputting the result
-            const text = result?.text || "";
+            const text = result?.content || "";
             const CHUNK_SIZE = 10;
             const DELAY_MS = 50;
             for (let i = 0; i < text.length; i += CHUNK_SIZE) {
@@ -810,7 +806,7 @@ const cli = yargs(args)
             displayAnalyticsAndEvaluation(result, argv);
             return; // Exit early for agent mode
         }
-        for await (const chunk of stream) {
+        for await (const chunk of stream.stream) {
             process.stdout.write(chunk.content);
             // In debug mode, interleaved logging would appear here
             // (SDK logs are controlled by NEUROLINK_DEBUG set in middleware)
@@ -818,6 +814,8 @@ const cli = yargs(args)
         if (!argv.quiet) {
             process.stdout.write("\n");
         } // Ensure newline after stream
+        // Exit successfully
+        process.exit(0);
     }
     catch (error) {
         handleError(error, "Text streaming");
@@ -912,8 +910,8 @@ const cli = yargs(args)
                 spinner.text = `Processing ${i + 1}/${prompts.length}: ${prompts[i].substring(0, 30)}...`;
             }
             try {
-                const result = await sdk.generateText({
-                    prompt: prompts[i],
+                const result = await sdk.generate({
+                    input: { text: prompts[i] },
                     provider: argv.provider === "auto"
                         ? undefined
                         : argv.provider,
@@ -1075,8 +1073,8 @@ const cli = yargs(args)
             try {
                 const start = Date.now();
                 // Add timeout to prevent hanging
-                const testPromise = sdk.generateText({
-                    prompt: "test",
+                const testPromise = sdk.generate({
+                    input: { text: "test" },
                     provider: p,
                     maxTokens: 1,
                     disableTools: true, // Disable tools for faster status check
@@ -1238,12 +1236,12 @@ const cli = yargs(args)
     .example("$0 completion >> ~/.zshrc", "Add to zsh"), async (argv) => {
     cli.showCompletionScript();
 });
+// Add NEW Generate Command (Primary)
+cli.command(CLICommandFactory.createGenerateCommand());
 // Add MCP Commands
 addMCPCommands(cli);
 // Add Ollama Commands
 addOllamaCommands(cli);
-// Add Agent Generate Command
-agentGenerateCommand(cli);
 // Execute CLI
 (async () => {
     try {

package/dist/cli/utils/interactive-setup.js

@@ -244,7 +244,7 @@ export async function testProviderConnectivity(providers, quiet = false) {
         }
         try {
             const start = Date.now();
-            await sdk.generateText({ prompt: "test", provider, maxTokens: 1 });
+            await sdk.generate({ input: { text: "test" }, provider, maxTokens: 1 });
             const duration = Date.now() - start;
             results.push({ provider, status: "working", responseTime: duration });
             if (spinner) {
@@ -291,7 +291,7 @@ export function displaySetupSummary(result, quiet = false) {
     if (working > 0) {
         console.log(chalk.green("\n✅ Setup completed successfully!"));
         console.log(chalk.yellow("💡 You can now use NeuroLink with your configured providers."));
-        console.log(chalk.gray('   Try: neurolink generate-text "Hello, AI!"'));
+        console.log(chalk.gray('   Try: neurolink generate "Hello, AI!"'));
     }
     else {
         console.log(chalk.red("\n❌ No providers are working."));

package/dist/core/evaluation.d.ts

@@ -47,9 +47,9 @@ export interface UnifiedEvaluationContext {
  * Unified Evaluation Schema (Lighthouse-compatible with extensions)
  */
 export declare const unifiedEvaluationSchema: z.ZodObject<{
-    relevanceScore: z.ZodNumber;
-    accuracyScore: z.ZodNumber;
-    completenessScore: z.ZodNumber;
+    relevance: z.ZodNumber;
+    accuracy: z.ZodNumber;
+    completeness: z.ZodNumber;
     domainAlignment: z.ZodOptional<z.ZodNumber>;
     terminologyAccuracy: z.ZodOptional<z.ZodNumber>;
     toolEffectiveness: z.ZodOptional<z.ZodNumber>;
@@ -58,9 +58,9 @@ export declare const unifiedEvaluationSchema: z.ZodObject<{
     suggestedImprovements: z.ZodOptional<z.ZodString>;
     alertSeverity: z.ZodEnum<["low", "medium", "high", "none"]>;
 }, "strip", z.ZodTypeAny, {
-    relevanceScore: number;
-    accuracyScore: number;
-    completenessScore: number;
+    relevance: number;
+    accuracy: number;
+    completeness: number;
     isOffTopic: boolean;
     reasoning: string;
     alertSeverity: "low" | "medium" | "high" | "none";
@@ -69,9 +69,9 @@ export declare const unifiedEvaluationSchema: z.ZodObject<{
     toolEffectiveness?: number | undefined;
     suggestedImprovements?: string | undefined;
 }, {
-    relevanceScore: number;
-    accuracyScore: number;
-    completenessScore: number;
+    relevance: number;
+    accuracy: number;
+    completeness: number;
     isOffTopic: boolean;
     reasoning: string;
     alertSeverity: "low" | "medium" | "high" | "none";

package/dist/core/evaluation.js

@@ -16,17 +16,17 @@ import { z } from "zod";
  */
 export const unifiedEvaluationSchema = z.object({
     // Core evaluation scores
-    relevanceScore: z
+    relevance: z
         .number()
         .min(0)
         .max(10)
         .describe("Score (0-10) for how well the response addresses query intent and aligns with domain/role. 10 is most relevant."),
-    accuracyScore: z
+    accuracy: z
         .number()
         .min(0)
         .max(10)
         .describe("Score (0-10) for factual correctness against data, tool outputs, and domain knowledge. 10 is most accurate."),
-    completenessScore: z
+    completeness: z
         .number()
         .min(0)
         .max(10)
@@ -113,8 +113,8 @@ export async function performUnifiedEvaluation(context) {
             }
             catch (structuredError) {
                 logger.warn(`[${functionTag}] Structured evaluation failed, using fallback`, { structuredError });
-                // Fallback to legacy generateText
-                const result = await evaluationModel.generateText({
+                // Fallback to legacy generate
+                const result = await evaluationModel.generate({
                     prompt: evaluationPrompt + "\n\nRespond with valid JSON only.",
                     temperature: 0.1,
                     maxTokens: 1000,
@@ -302,9 +302,9 @@ function processStructuredEvaluationResult(result, modelConfig, evaluationTime,
     const overall = Math.round(allScores.reduce((sum, score) => sum + score, 0) / allScores.length);
     return {
         // Core scores
-        relevanceScore: Math.max(0, Math.min(10, Math.round(result.relevanceScore || 0))),
-        accuracyScore: Math.max(0, Math.min(10, Math.round(result.accuracyScore || 0))),
-        completenessScore: Math.max(0, Math.min(10, Math.round(result.completenessScore || 0))),
+        relevance: Math.max(0, Math.min(10, Math.round(result.relevanceScore || 0))),
+        accuracy: Math.max(0, Math.min(10, Math.round(result.accuracyScore || 0))),
+        completeness: Math.max(0, Math.min(10, Math.round(result.completenessScore || 0))),
         overall: Math.max(0, Math.min(10, overall)),
         // Enhanced insights
         isOffTopic: result.isOffTopic || false,
@@ -372,9 +372,9 @@ function parseUnifiedEvaluationResult(evaluationText, modelConfig, evaluationTim
             ? parseInt(completenessMatch[1] || completenessMatch[2] || completenessMatch[3], 10)
             : 8; // Default fallback score
         return {
-            relevanceScore: Math.max(0, Math.min(10, relevance)),
-            accuracyScore: Math.max(0, Math.min(10, accuracy)),
-            completenessScore: Math.max(0, Math.min(10, completeness)),
+            relevance: Math.max(0, Math.min(10, relevance)),
+            accuracy: Math.max(0, Math.min(10, accuracy)),
+            completeness: Math.max(0, Math.min(10, completeness)),
             overall: Math.round((relevance + accuracy + completeness) / 3),
             isOffTopic: false,
             alertSeverity: "none",
@@ -400,9 +400,9 @@ function parseUnifiedEvaluationResult(evaluationText, modelConfig, evaluationTim
  */
 function getDefaultUnifiedEvaluation(reason, evaluationTime, context) {
     return {
-        relevanceScore: 0,
-        accuracyScore: 0,
-        completenessScore: 0,
+        relevance: 0,
+        accuracy: 0,
+        completeness: 0,
         overall: 0,
         isOffTopic: false,
         alertSeverity: "high",

package/dist/core/types.d.ts

@@ -1,5 +1,32 @@
 import type { ZodType, ZodTypeDef } from "zod";
-import type { StreamTextResult, ToolSet, Schema, GenerateTextResult, Tool } from "ai";
+import type { Schema, Tool } from "ai";
+import type { GenerateResult } from "../types/generate-types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+export interface TextGenerationResult {
+    content: string;
+    provider?: string;
+    model?: string;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+    };
+    responseTime?: number;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        toolName: string;
+        executionTime: number;
+        success: boolean;
+        serverId?: string;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+        server: string;
+        category?: string;
+    }>;
+}
 /**
  * Supported AI Provider Names
  */
@@ -12,7 +39,8 @@ export declare enum AIProviderName {
     GOOGLE_AI = "google-ai",
     HUGGINGFACE = "huggingface",
     OLLAMA = "ollama",
-    MISTRAL = "mistral"
+    MISTRAL = "mistral",
+    AUTO = "auto"
 }
 /**
  * Supported Models for Amazon Bedrock
@@ -73,28 +101,7 @@ export interface StreamingOptions {
  */
 export interface TextGenerationOptions {
     prompt: string;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    systemPrompt?: string;
-    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
-    tools?: Record<string, Tool>;
-    timeout?: number | string;
-    enableEvaluation?: boolean;
-    enableAnalytics?: boolean;
-    context?: Record<string, any>;
-    evaluationDomain?: string;
-    toolUsageContext?: string;
-    conversationHistory?: Array<{
-        role: string;
-        content: string;
-    }>;
-}
-/**
- * Stream text options interface
- */
-export interface StreamTextOptions {
-    prompt: string;
+    provider?: AIProviderName;
     model?: string;
     temperature?: number;
     maxTokens?: number;
@@ -133,10 +140,13 @@ export interface AnalyticsData {
  * Updated to match Lighthouse's exact evaluation interface for consistency
  */
 export interface EvaluationData {
-    relevanceScore: number;
-    accuracyScore: number;
-    completenessScore: number;
+    relevance: number;
+    accuracy: number;
+    completeness: number;
     overall: number;
+    domainAlignment?: number;
+    terminologyAccuracy?: number;
+    toolEffectiveness?: number;
     isOffTopic: boolean;
     alertSeverity: "low" | "medium" | "high" | "none";
     reasoning: string;
@@ -207,11 +217,7 @@ export interface ProviderModelConfig {
 /**
  * Enhanced result interfaces with optional analytics/evaluation
  */
-export interface EnhancedGenerateTextResult extends GenerateTextResult<ToolSet, unknown> {
-    analytics?: AnalyticsData;
-    evaluation?: EvaluationData;
-}
-export interface EnhancedStreamTextResult extends StreamTextResult<ToolSet, unknown> {
+export interface EnhancedGenerateResult extends GenerateResult {
     analytics?: AnalyticsData;
     evaluation?: EvaluationData;
 }
@@ -240,26 +246,13 @@ export interface StreamingMetadata {
     modelUsed: string;
 }
 export type ProgressCallback = (progress: StreamingProgressData) => void;
-export interface EnhancedStreamTextOptions extends StreamTextOptions {
-    enableProgressTracking?: boolean;
-    progressCallback?: ProgressCallback;
-    includeStreamingMetadata?: boolean;
-    streamingBufferSize?: number;
-    enableStreamingHeaders?: boolean;
-    customStreamingConfig?: {
-        chunkDelayMs?: number;
-        maxConcurrentChunks?: number;
-        compressionEnabled?: boolean;
-    };
-}
 /**
  * AI Provider interface with flexible parameter support
  */
 export interface AIProvider {
-    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedStreamTextResult | null>;
-    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
-    generate(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<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<EnhancedGenerateResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
 }
 /**
  * Provider attempt result for iteration tracking

package/dist/core/types.js

@@ -12,6 +12,7 @@ export var AIProviderName;
     AIProviderName["HUGGINGFACE"] = "huggingface";
     AIProviderName["OLLAMA"] = "ollama";
     AIProviderName["MISTRAL"] = "mistral";
+    AIProviderName["AUTO"] = "auto";
 })(AIProviderName || (AIProviderName = {}));
 /**
  * Supported Models for Amazon Bedrock

package/dist/factories/compatibility-factory.d.ts

@@ -0,0 +1,20 @@
+import type { GenerateOptions, GenerateResult } from "../types/generate-types.js";
+import type { TextGenerationOptions } from "../core/types.js";
+/**
+ * Compatibility conversion factory for seamless migration
+ * between generateText and generate functions
+ */
+export declare class CompatibilityConversionFactory {
+    /**
+     * Convert TextGenerationOptions to GenerateOptions
+     */
+    static convertTextToGenerate(options: TextGenerationOptions): GenerateOptions;
+    /**
+     * Convert GenerateResult to legacy TextGenerationResult format
+     */
+    static convertGenerateToText(result: GenerateResult): any;
+    /**
+     * Convert GenerateOptions to TextGenerationOptions
+     */
+    static convertGenerateToText_Options(options: GenerateOptions): TextGenerationOptions;
+}

package/dist/factories/compatibility-factory.js

@@ -0,0 +1,69 @@
+/**
+ * Compatibility conversion factory for seamless migration
+ * between generateText and generate functions
+ */
+export class CompatibilityConversionFactory {
+    /**
+     * Convert TextGenerationOptions to GenerateOptions
+     */
+    static convertTextToGenerate(options) {
+        const { prompt, ...rest } = options;
+        return {
+            input: { text: prompt },
+            output: { format: "text" },
+            provider: rest.provider,
+            model: rest.model,
+            temperature: rest.temperature,
+            maxTokens: rest.maxTokens,
+            systemPrompt: rest.systemPrompt,
+            schema: rest.schema,
+            tools: rest.tools,
+            timeout: rest.timeout,
+            enableEvaluation: rest.enableEvaluation,
+            enableAnalytics: rest.enableAnalytics,
+            context: rest.context,
+            evaluationDomain: rest.evaluationDomain,
+            toolUsageContext: rest.toolUsageContext,
+            conversationHistory: rest.conversationHistory,
+        };
+    }
+    /**
+     * Convert GenerateResult to legacy TextGenerationResult format
+     */
+    static convertGenerateToText(result) {
+        return {
+            content: result.content,
+            provider: result.provider,
+            model: result.model,
+            usage: result.usage,
+            responseTime: result.responseTime,
+            toolsUsed: result.toolsUsed,
+            toolExecutions: result.toolExecutions,
+            enhancedWithTools: result.enhancedWithTools,
+            availableTools: result.availableTools,
+            analytics: result.analytics,
+            evaluation: result.evaluation,
+        };
+    }
+    /**
+     * Convert GenerateOptions to TextGenerationOptions
+     */
+    static convertGenerateToText_Options(options) {
+        return {
+            prompt: options.input.text,
+            model: options.model,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            systemPrompt: options.systemPrompt,
+            schema: options.schema,
+            tools: options.tools,
+            timeout: options.timeout,
+            enableEvaluation: options.enableEvaluation,
+            enableAnalytics: options.enableAnalytics,
+            context: options.context,
+            evaluationDomain: options.evaluationDomain,
+            toolUsageContext: options.toolUsageContext,
+            conversationHistory: options.conversationHistory,
+        };
+    }
+}

package/dist/factories/provider-generate-factory.d.ts

@@ -0,0 +1,20 @@
+import type { EnhancedProvider } from "../types/generate-types.js";
+import type { AIProvider } from "../core/types.js";
+/**
+ * Factory for enhancing providers with generate() capability using Proxy pattern
+ * Maintains 100% backward compatibility while adding new generate method
+ */
+export declare class ProviderGenerateFactory {
+    /**
+     * Enhance any provider with generate() method using TypeScript Proxy
+     */
+    static enhanceProvider<T extends AIProvider>(provider: T): T & EnhancedProvider;
+    /**
+     * Create the generate() method that internally uses generateText for performance parity
+     */
+    private static createGenerateMethod;
+    /**
+     * Enhance all providers from a registry
+     */
+    static enhanceAllProviders(providers: Map<string, AIProvider>): Map<string, AIProvider & EnhancedProvider>;
+}

package/dist/factories/provider-generate-factory.js

@@ -0,0 +1,87 @@
+import { CompatibilityConversionFactory } from "./compatibility-factory.js";
+/**
+ * Factory for enhancing providers with generate() capability using Proxy pattern
+ * Maintains 100% backward compatibility while adding new generate method
+ */
+export class ProviderGenerateFactory {
+    /**
+     * Enhance any provider with generate() method using TypeScript Proxy
+     */
+    static enhanceProvider(provider) {
+        return new Proxy(provider, {
+            get(target, prop, receiver) {
+                if (prop === "generate") {
+                    return ProviderGenerateFactory.createGenerateMethod(target);
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+            has(target, prop) {
+                if (prop === "generate") {
+                    return true;
+                }
+                return Reflect.has(target, prop);
+            },
+        });
+    }
+    /**
+     * Create the generate() method that internally uses generateText for performance parity
+     */
+    static createGenerateMethod(provider) {
+        return async (options) => {
+            // Validate input
+            if (!options.input?.text) {
+                throw new Error("Generate options must include input.text");
+            }
+            // Convert GenerateOptions to TextGenerationOptions
+            const textOptions = CompatibilityConversionFactory.convertGenerateToText_Options(options);
+            try {
+                // Use existing generate method for identical performance
+                const textResult = await provider.generate(textOptions);
+                // Convert back to GenerateResult format with type safety
+                const generateResult = {
+                    content: textResult?.content || "",
+                    outputs: { text: textResult?.content || "" },
+                    provider: textResult?.provider,
+                    model: textResult?.model,
+                    usage: textResult?.usage
+                        ? {
+                            inputTokens: textResult.usage?.promptTokens || 0,
+                            outputTokens: textResult.usage?.completionTokens || 0,
+                            totalTokens: textResult.usage?.totalTokens || 0,
+                        }
+                        : undefined,
+                    responseTime: textResult?.responseTime,
+                    toolsUsed: textResult?.toolsUsed,
+                    toolExecutions: textResult?.toolExecutions?.map((te) => ({
+                        name: te.toolName || te.name || "",
+                        input: te.input || {},
+                        output: te.output || te.result,
+                        duration: te.executionTime || te.duration || 0,
+                    })),
+                    enhancedWithTools: textResult?.enhancedWithTools,
+                    availableTools: textResult?.availableTools?.map((at) => ({
+                        name: at.name || "",
+                        description: at.description || "",
+                        parameters: at.parameters || {},
+                    })),
+                    analytics: textResult?.analytics,
+                    evaluation: textResult?.evaluation,
+                };
+                return generateResult;
+            }
+            catch (error) {
+                throw new Error(`Generate method failed: ${error}`);
+            }
+        };
+    }
+    /**
+     * Enhance all providers from a registry
+     */
+    static enhanceAllProviders(providers) {
+        const enhancedProviders = new Map();
+        for (const [name, provider] of providers) {
+            enhancedProviders.set(name, this.enhanceProvider(provider));
+        }
+        return enhancedProviders;
+    }
+}

package/dist/index.d.ts

@@ -9,13 +9,15 @@
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
 export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, ProviderAttempt, SupportedModelName, } from "./core/types.js";
+export type { GenerateOptions, GenerateResult, EnhancedProvider, } from "./types/generate-types.js";
+export { CompatibilityConversionFactory } from "./factories/compatibility-factory.js";
+export { ProviderGenerateFactory } from "./factories/provider-generate-factory.js";
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
 export { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, } from "./providers/index.js";
 export type { ProviderName } from "./providers/index.js";
 export { PROVIDERS, AVAILABLE_PROVIDERS } from "./providers/index.js";
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { NeuroLink } from "./neurolink.js";
-export type { TextGenerationOptions, StreamTextOptions, TextGenerationResult, } from "./neurolink.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function
@@ -25,7 +27,7 @@ export declare const VERSION = "1.0.0";
  * import { createAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createAIProvider('bedrock');
- * const result = await provider.streamText('Hello, AI!');
+ * const result = await provider.stream({ input: { text: 'Hello, AI!' } });
  * ```
  */
 export declare function createAIProvider(providerName?: string, modelName?: string): Promise<import("./core/types.js").AIProvider>;