@juspay/neurolink 5.0.0 → 5.2.0

package/dist/types/mcp-types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * MCP Types for In-Memory Server Support
+ * Enables Lighthouse and other integrations to register tools directly
+ */
+/**
+ * In-memory MCP server configuration
+ */
+export interface InMemoryMCPServerConfig {
+    /**
+     * The actual server instance with tools
+     */
+    server: {
+        /**
+         * Server title for display
+         */
+        title?: string;
+        /**
+         * Map of tool name to tool implementation
+         */
+        tools: Map<string, InMemoryToolInfo> | Record<string, InMemoryToolInfo>;
+        /**
+         * Optional server description
+         */
+        description?: string;
+    };
+    /**
+     * Category for grouping tools
+     */
+    category?: string;
+    /**
+     * Metadata about the server
+     */
+    metadata?: {
+        provider?: string;
+        version?: string;
+        author?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * In-memory tool information
+ */
+export interface InMemoryToolInfo {
+    /**
+     * Tool description
+     */
+    description: string;
+    /**
+     * Tool execution function
+     */
+    execute: (params: any) => Promise<InMemoryToolResult> | InMemoryToolResult;
+    /**
+     * Input parameter schema (Zod or JSON Schema)
+     */
+    inputSchema?: any;
+    /**
+     * Whether the tool is implemented (default: true)
+     */
+    isImplemented?: boolean;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Result from in-memory tool execution
+ */
+export interface InMemoryToolResult {
+    /**
+     * Whether execution was successful
+     */
+    success: boolean;
+    /**
+     * Result data if successful
+     */
+    data?: any;
+    /**
+     * Error message if failed
+     */
+    error?: string;
+    /**
+     * Optional metadata about execution
+     */
+    metadata?: {
+        executionTime?: number;
+        toolName?: string;
+        serverId?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * Unified MCP Registry interface
+ */
+export interface UnifiedMCPRegistry {
+    /**
+     * Register an in-memory server
+     */
+    registerInMemoryServer(serverId: string, config: InMemoryMCPServerConfig): Promise<void>;
+    /**
+     * Get all available tools
+     */
+    getAllTools(): Promise<Array<{
+        name: string;
+        serverId: string;
+        description: string;
+        isExternal: boolean;
+    }>>;
+    /**
+     * Execute a tool
+     */
+    executeTool(toolName: string, params: any, context: any): Promise<any>;
+    /**
+     * Check if connected to a server
+     */
+    isConnected(serverId: string): boolean;
+}

package/dist/types/mcp-types.js

@@ -0,0 +1,5 @@
+/**
+ * MCP Types for In-Memory Server Support
+ * Enables Lighthouse and other integrations to register tools directly
+ */
+export {};

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

@@ -0,0 +1,95 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import type { Tool, Schema } from "ai";
+import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
+/**
+ * Interface for tool execution calls
+ */
+export interface ToolCall {
+    toolName: string;
+    parameters: Record<string, any>;
+    id?: string;
+}
+/**
+ * Interface for tool execution results
+ */
+export interface ToolResult {
+    toolName: string;
+    status: "success" | "failure";
+    output?: any;
+    error?: string;
+    id?: string;
+    executionTime?: number;
+}
+/**
+ * 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;
+    maxSteps?: number;
+    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;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+    finishReason?: string;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+    metadata?: {
+        streamId?: string;
+        startTime?: number;
+        totalChunks?: number;
+        estimatedDuration?: number;
+        responseTime?: number;
+        fallback?: boolean;
+    };
+    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/types/universal-provider-options.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Universal Provider Options Interface (Phase 1: Factory Pattern)
+ * Based on TypeScript factory pattern best practices for AI provider abstraction
+ */
+/**
+ * Base configuration interface for all AI providers
+ * Uses Parameter Object Pattern for flexible, extensible configuration
+ */
+export interface UniversalProviderOptions {
+    prompt?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    enableAnalytics?: boolean;
+    enableEvaluation?: boolean;
+    context?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    extensionOptions?: Record<string, unknown>;
+}
+/**
+ * Generic provider options (without providerType)
+ */
+export type GenericProviderOptions = Omit<UniversalProviderOptions, "providerType">;
+/**
+ * Provider-specific configuration extensions
+ * Discriminated union pattern for type-safe provider configs
+ */
+export interface OpenAIProviderOptions extends UniversalProviderOptions {
+    providerType: "openai";
+    organization?: string;
+    seed?: number;
+    topP?: number;
+}
+export interface GoogleAIProviderOptions extends UniversalProviderOptions {
+    providerType: "google-ai";
+    topK?: number;
+    candidateCount?: number;
+    stopSequences?: string[];
+}
+export interface AnthropicProviderOptions extends UniversalProviderOptions {
+    providerType: "anthropic";
+    topK?: number;
+    stopSequences?: string[];
+}
+export interface BedrockProviderOptions extends UniversalProviderOptions {
+    providerType: "bedrock";
+    inferenceProfileArn?: string;
+    region?: string;
+}
+/**
+ * Discriminated union for type-safe provider configuration
+ * Enables compile-time type checking for provider-specific options
+ */
+export type ProviderSpecificOptions = OpenAIProviderOptions | GoogleAIProviderOptions | AnthropicProviderOptions | BedrockProviderOptions;
+/**
+ * Factory configuration interface
+ * Supports both universal and provider-specific parameters
+ */
+export interface ProviderFactoryConfig {
+    providerName: string;
+    modelName?: string;
+    options?: UniversalProviderOptions | ProviderSpecificOptions;
+    enableMCP?: boolean;
+}
+/**
+ * Parameter normalization utilities
+ * Converts between different parameter formats for backward compatibility
+ */
+export declare class ParameterNormalizer {
+    /**
+     * Normalize legacy parameter formats to universal format
+     */
+    static normalizeToUniversal(optionsOrPrompt: UniversalProviderOptions | string): UniversalProviderOptions;
+    /**
+     * Retrieve the provider type if it exists, otherwise return null
+     */
+    private static getProviderType;
+    /**
+     * Extract provider-specific parameters safely
+     */
+    static extractProviderOptions<T extends ProviderSpecificOptions>(options: UniversalProviderOptions | ProviderSpecificOptions, providerType: T["providerType"]): T | GenericProviderOptions;
+    /**
+     * Merge default values with user-provided options
+     */
+    static mergeWithDefaults(options: UniversalProviderOptions, defaults: Partial<UniversalProviderOptions>): UniversalProviderOptions;
+}

package/dist/types/universal-provider-options.js

@@ -0,0 +1,53 @@
+/**
+ * Universal Provider Options Interface (Phase 1: Factory Pattern)
+ * Based on TypeScript factory pattern best practices for AI provider abstraction
+ */
+/**
+ * Parameter normalization utilities
+ * Converts between different parameter formats for backward compatibility
+ */
+export class ParameterNormalizer {
+    /**
+     * Normalize legacy parameter formats to universal format
+     */
+    static normalizeToUniversal(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            return { prompt: optionsOrPrompt };
+        }
+        return optionsOrPrompt;
+    }
+    /**
+     * Retrieve the provider type if it exists, otherwise return null
+     */
+    static getProviderType(options) {
+        return "providerType" in options ? options.providerType : null;
+    }
+    /**
+     * Extract provider-specific parameters safely
+     */
+    static extractProviderOptions(options, providerType) {
+        const currentProviderType = ParameterNormalizer.getProviderType(options);
+        if (currentProviderType === providerType) {
+            return options;
+        }
+        // Handle case where options has providerType but doesn't match
+        if (currentProviderType !== null) {
+            const { providerType: _providerType, ...genericOptions } = options;
+            return genericOptions;
+        }
+        // Options don't have providerType, return as generic
+        return options;
+    }
+    /**
+     * Merge default values with user-provided options
+     */
+    static mergeWithDefaults(options, defaults) {
+        return {
+            ...defaults,
+            ...options,
+            // Merge nested objects
+            context: { ...defaults.context, ...options.context },
+            metadata: { ...defaults.metadata, ...options.metadata },
+        };
+    }
+}

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": "5.0.0",
+  "version": "5.2.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",
@@ -124,10 +124,13 @@
   "dependencies": {
     "@ai-sdk/amazon-bedrock": "^1.0.0",
     "@ai-sdk/anthropic": "^1.2.12",
+    "@ai-sdk/azure": "^1.3.24",
     "@ai-sdk/google": "^1.2.19",
     "@ai-sdk/google-vertex": "^2.2.0",
     "@ai-sdk/mistral": "^1.0.0",
     "@ai-sdk/openai": "^1.0.0",
+    "@ai-sdk/provider": "^1.1.3",
+    "@ai-sdk/provider-utils": "^2.2.8",
     "@google/generative-ai": "^0.24.1",
     "@huggingface/inference": "^2.8.0",
     "@modelcontextprotocol/sdk": "^1.13.0",
@@ -145,25 +148,26 @@
     "@opentelemetry/sdk-metrics": "^1.30.1",
     "@opentelemetry/sdk-node": "^0.54.2",
     "@opentelemetry/semantic-conventions": "^1.34.0",
-    "@types/ws": "^8.18.1",
     "ai": "^4.0.0",
-    "chalk": "^5.3.0",
-    "cors": "^2.8.5",
     "dotenv": "^16.5.0",
-    "express": "^5.1.0",
-    "inquirer": "^9.2.15",
-    "ora": "^7.0.1",
-    "playwright": "^1.52.0",
+    "ollama-ai-provider": "^1.2.0",
     "reconnecting-eventsource": "^1.6.4",
     "undici": "^6.6.2",
     "uuid": "^11.1.0",
     "ws": "^8.18.3",
-    "yargs": "^17.7.2",
     "zod": "^3.22.0",
-    "zod-to-json-schema": "^3.24.5"
+    "zod-to-json-schema": "^3.24.5",
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.15",
+    "ora": "^7.0.1",
+    "yargs": "^17.7.2"
   },
   "devDependencies": {
     "@changesets/cli": "^2.26.2",
+    "@types/ws": "^8.18.1",
+    "@vitest/coverage-v8": "^2.1.9",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
     "@eslint/js": "^9.0.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/commit-analyzer": "^13.0.0",
@@ -183,6 +187,7 @@
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "eslint": "^9.0.0",
+    "playwright": "^1.52.0",
     "prettier": "^3.0.0",
     "publint": "^0.3.2",
     "puppeteer": "^24.10.0",

package/dist/lib/providers/agent-enhanced-provider.d.ts

@@ -1,89 +0,0 @@
-/**
- * Agent-Enhanced Provider for NeuroLink CLI
- * Integrates direct tools with AI providers for true agent functionality
- */
-import { type GenerateTextResult, type StreamTextResult, type ToolSet } from "ai";
-import type { AIProvider, TextGenerationOptions, EnhancedGenerateTextResult, EnhancedStreamTextOptions } from "../core/types.js";
-/**
- * Agent configuration options
- */
-interface AgentConfig {
-    provider: "openai" | "google-ai" | "anthropic";
-    model?: string;
-    toolCategory?: "basic" | "filesystem" | "utility" | "all";
-    maxSteps?: number;
-    enableTools?: boolean;
-    enableMCP?: boolean;
-    mcpInitTimeoutMs?: number;
-    toolExecutionTimeout?: number | string;
-    mcpDiscoveryOptions?: {
-        searchPaths?: string[];
-        configFiles?: string[];
-        autoDiscover?: boolean;
-    };
-}
-/**
- * Agent-Enhanced Provider Class
- * Provides AI generation with tool calling capabilities
- * Now includes MCP tool integration alongside direct tools
- */
-export declare class AgentEnhancedProvider implements AIProvider {
-    private config;
-    private model;
-    private resolvedModelName;
-    private mcpSystem;
-    private mcpInitialized;
-    private mcpInitializing;
-    private mcpInitFailed;
-    constructor(config: AgentConfig);
-    private createModel;
-    /**
-     * Initialize MCP registry with auto-discovery
-     */
-    private initializeMCP;
-    /**
-     * Get combined tools: direct tools + MCP tools
-     */
-    private getCombinedTools;
-    generateText(optionsOrPrompt: TextGenerationOptions | string): Promise<GenerateTextResult<ToolSet, unknown> | null>;
-    streamText(optionsOrPrompt: EnhancedStreamTextOptions | string): Promise<StreamTextResult<ToolSet, unknown> | null>;
-    /**
-     * Determine if we should force tool usage based on prompt patterns
-     */
-    private shouldForceToolUsage;
-    getCapabilities(): string[];
-    getProviderName(): string;
-    getModelName(): string;
-    /**
-     * Test agent functionality
-     */
-    testAgentCapabilities(): Promise<{
-        success: boolean;
-        results: any[];
-    }>;
-    /**
-     * Create agent-enhanced provider factory
-     */
-    static createAgent(config: AgentConfig): AgentEnhancedProvider;
-    /**
-     * Create multiple agent providers for comparison
-     */
-    static createMultiProviderAgents(): Record<string, AgentEnhancedProvider>;
-    /**
-     * Alias for generateText() - CLI-SDK consistency
-     */
-    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
-    /**
-     * Short alias for generateText() - CLI-SDK consistency
-     */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
-}
-/**
- * Helper function to create agent provider
- */
-export declare function createAgentProvider(provider: "openai" | "google-ai" | "anthropic", options?: Partial<AgentConfig>): AgentEnhancedProvider;
-/**
- * Test all available agent providers
- */
-export declare function testAllAgentProviders(): Promise<void>;
-export {};