@juspay/neurolink 1.5.0 → 1.5.2

package/dist/lib/core/factory.js

@@ -0,0 +1,162 @@
+import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio } from '../providers/index.js';
+import { getBestProvider } from '../utils/providerUtils.js';
+import { logger } from '../utils/logger.js';
+const componentIdentifier = 'aiProviderFactory';
+/**
+ * Factory for creating AI provider instances with centralized configuration
+ */
+export class AIProviderFactory {
+    /**
+     * Create a provider instance for the specified provider type
+     * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')
+     * @param modelName - Optional model name override
+     * @returns AIProvider instance
+     */
+    static createProvider(providerName, modelName) {
+        const functionTag = 'AIProviderFactory.createProvider';
+        logger.debug(`[${functionTag}] Provider creation started`, {
+            providerName,
+            modelName: modelName || 'default'
+        });
+        try {
+            let provider;
+            switch (providerName.toLowerCase()) {
+                case 'vertex':
+                case 'google':
+                case 'gemini':
+                    provider = new GoogleVertexAI(modelName);
+                    break;
+                case 'bedrock':
+                case 'amazon':
+                case 'aws':
+                    provider = new AmazonBedrock(modelName);
+                    break;
+                case 'openai':
+                case 'gpt':
+                    provider = new OpenAI(modelName);
+                    break;
+                case 'anthropic':
+                case 'claude':
+                    provider = new AnthropicProvider();
+                    break;
+                case 'azure':
+                case 'azure-openai':
+                    provider = new AzureOpenAIProvider();
+                    break;
+                case 'google-ai':
+                case 'google-studio':
+                    provider = new GoogleAIStudio(modelName);
+                    break;
+                default:
+                    throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai, anthropic, azure, google-ai`);
+            }
+            logger.debug(`[${functionTag}] Provider creation succeeded`, {
+                providerName,
+                modelName: modelName || 'default',
+                providerType: provider.constructor.name
+            });
+            return provider;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug(`[${functionTag}] Provider creation failed`, {
+                providerName,
+                modelName: modelName || 'default',
+                error: errorMessage
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create a provider instance with specific provider enum and model
+     * @param provider - Provider enum value
+     * @param model - Specific model enum value
+     * @returns AIProvider instance
+     */
+    static createProviderWithModel(provider, model) {
+        const functionTag = 'AIProviderFactory.createProviderWithModel';
+        logger.debug(`[${functionTag}] Provider model creation started`, {
+            provider,
+            model
+        });
+        try {
+            const providerInstance = this.createProvider(provider, model);
+            logger.debug(`[${functionTag}] Provider model creation succeeded`, {
+                provider,
+                model,
+                providerType: providerInstance.constructor.name
+            });
+            return providerInstance;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug(`[${functionTag}] Provider model creation failed`, {
+                provider,
+                model,
+                error: errorMessage
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create the best available provider automatically
+     * @param requestedProvider - Optional preferred provider
+     * @param modelName - Optional model name override
+     * @returns AIProvider instance
+     */
+    static createBestProvider(requestedProvider, modelName) {
+        const functionTag = 'AIProviderFactory.createBestProvider';
+        try {
+            const bestProvider = getBestProvider(requestedProvider);
+            logger.debug(`[${functionTag}] Best provider selected`, {
+                requestedProvider: requestedProvider || 'auto',
+                selectedProvider: bestProvider,
+                modelName: modelName || 'default'
+            });
+            return this.createProvider(bestProvider, modelName);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug(`[${functionTag}] Best provider selection failed`, {
+                requestedProvider: requestedProvider || 'auto',
+                error: errorMessage
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create primary and fallback provider instances
+     * @param primaryProvider - Primary provider name
+     * @param fallbackProvider - Fallback provider name
+     * @param modelName - Optional model name override
+     * @returns Object with primary and fallback providers
+     */
+    static createProviderWithFallback(primaryProvider, fallbackProvider, modelName) {
+        const functionTag = 'AIProviderFactory.createProviderWithFallback';
+        logger.debug(`[${functionTag}] Fallback provider setup started`, {
+            primaryProvider,
+            fallbackProvider,
+            modelName: modelName || 'default'
+        });
+        try {
+            const primary = this.createProvider(primaryProvider, modelName);
+            const fallback = this.createProvider(fallbackProvider, modelName);
+            logger.debug(`[${functionTag}] Fallback provider setup succeeded`, {
+                primaryProvider,
+                fallbackProvider,
+                modelName: modelName || 'default'
+            });
+            return { primary, fallback };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug(`[${functionTag}] Fallback provider setup failed`, {
+                primaryProvider,
+                fallbackProvider,
+                error: errorMessage
+            });
+            throw error;
+        }
+    }
+}
+export { componentIdentifier };

package/dist/lib/core/types.d.ts

@@ -0,0 +1,111 @@
+import type { ZodType, ZodTypeDef } from 'zod';
+import type { StreamTextResult, ToolSet, Schema, GenerateTextResult } from 'ai';
+/**
+ * Supported AI Provider Names
+ */
+export declare enum AIProviderName {
+    BEDROCK = "bedrock",
+    OPENAI = "openai",
+    VERTEX = "vertex",
+    ANTHROPIC = "anthropic",
+    AZURE = "azure",
+    GOOGLE_AI = "google-ai"
+}
+/**
+ * Supported Models for Amazon Bedrock
+ */
+export declare enum BedrockModels {
+    CLAUDE_3_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0",
+    CLAUDE_3_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0",
+    CLAUDE_3_5_SONNET = "anthropic.claude-3-5-sonnet-20240620-v1:0",
+    CLAUDE_3_7_SONNET = "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+}
+/**
+ * Supported Models for OpenAI
+ */
+export declare enum OpenAIModels {
+    GPT_4 = "gpt-4",
+    GPT_4_TURBO = "gpt-4-turbo",
+    GPT_4O = "gpt-4o",
+    GPT_4O_MINI = "gpt-4o-mini",
+    GPT_3_5_TURBO = "gpt-3.5-turbo"
+}
+/**
+ * Supported Models for Google Vertex AI
+ */
+export declare enum VertexModels {
+    CLAUDE_4_0_SONNET = "claude-sonnet-4@20250514",
+    GEMINI_2_5_FLASH = "gemini-2.5-flash-preview-05-20"
+}
+/**
+ * Supported Models for Google AI Studio
+ */
+export declare enum GoogleAIModels {
+    GEMINI_1_5_PRO_LATEST = "gemini-1.5-pro-latest",
+    GEMINI_1_5_FLASH_LATEST = "gemini-1.5-flash-latest",
+    GEMINI_2_0_FLASH_EXP = "gemini-2.0-flash-exp",
+    GEMINI_1_0_PRO = "gemini-1.0-pro"
+}
+/**
+ * Union type of all supported model names
+ */
+export type SupportedModelName = BedrockModels | OpenAIModels | VertexModels | GoogleAIModels;
+/**
+ * Provider configuration specifying provider and its available models
+ */
+export interface ProviderConfig {
+    provider: AIProviderName;
+    models: SupportedModelName[];
+}
+/**
+ * Options for AI requests with unified provider configuration
+ */
+export interface StreamingOptions {
+    providers: ProviderConfig[];
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}
+/**
+ * Text generation options interface
+ */
+export interface TextGenerationOptions {
+    prompt: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+}
+/**
+ * Stream text options interface
+ */
+export interface StreamTextOptions {
+    prompt: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+}
+/**
+ * AI Provider interface with flexible parameter support
+ */
+export interface AIProvider {
+    streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+}
+/**
+ * Provider attempt result for iteration tracking
+ */
+export interface ProviderAttempt {
+    provider: AIProviderName;
+    model: SupportedModelName;
+    success: boolean;
+    error?: string;
+    stack?: string;
+}
+/**
+ * Default provider configurations
+ */
+export declare const DEFAULT_PROVIDER_CONFIGS: ProviderConfig[];

package/dist/lib/core/types.js

@@ -0,0 +1,68 @@
+/**
+ * Supported AI Provider Names
+ */
+export var AIProviderName;
+(function (AIProviderName) {
+    AIProviderName["BEDROCK"] = "bedrock";
+    AIProviderName["OPENAI"] = "openai";
+    AIProviderName["VERTEX"] = "vertex";
+    AIProviderName["ANTHROPIC"] = "anthropic";
+    AIProviderName["AZURE"] = "azure";
+    AIProviderName["GOOGLE_AI"] = "google-ai";
+})(AIProviderName || (AIProviderName = {}));
+/**
+ * Supported Models for Amazon Bedrock
+ */
+export var BedrockModels;
+(function (BedrockModels) {
+    BedrockModels["CLAUDE_3_SONNET"] = "anthropic.claude-3-sonnet-20240229-v1:0";
+    BedrockModels["CLAUDE_3_HAIKU"] = "anthropic.claude-3-haiku-20240307-v1:0";
+    BedrockModels["CLAUDE_3_5_SONNET"] = "anthropic.claude-3-5-sonnet-20240620-v1:0";
+    BedrockModels["CLAUDE_3_7_SONNET"] = "arn:aws:bedrock:us-east-2:225681119357:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0";
+})(BedrockModels || (BedrockModels = {}));
+/**
+ * Supported Models for OpenAI
+ */
+export var OpenAIModels;
+(function (OpenAIModels) {
+    OpenAIModels["GPT_4"] = "gpt-4";
+    OpenAIModels["GPT_4_TURBO"] = "gpt-4-turbo";
+    OpenAIModels["GPT_4O"] = "gpt-4o";
+    OpenAIModels["GPT_4O_MINI"] = "gpt-4o-mini";
+    OpenAIModels["GPT_3_5_TURBO"] = "gpt-3.5-turbo";
+})(OpenAIModels || (OpenAIModels = {}));
+/**
+ * Supported Models for Google Vertex AI
+ */
+export var VertexModels;
+(function (VertexModels) {
+    VertexModels["CLAUDE_4_0_SONNET"] = "claude-sonnet-4@20250514";
+    VertexModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash-preview-05-20";
+})(VertexModels || (VertexModels = {}));
+/**
+ * Supported Models for Google AI Studio
+ */
+export var GoogleAIModels;
+(function (GoogleAIModels) {
+    GoogleAIModels["GEMINI_1_5_PRO_LATEST"] = "gemini-1.5-pro-latest";
+    GoogleAIModels["GEMINI_1_5_FLASH_LATEST"] = "gemini-1.5-flash-latest";
+    GoogleAIModels["GEMINI_2_0_FLASH_EXP"] = "gemini-2.0-flash-exp";
+    GoogleAIModels["GEMINI_1_0_PRO"] = "gemini-1.0-pro";
+})(GoogleAIModels || (GoogleAIModels = {}));
+/**
+ * Default provider configurations
+ */
+export const DEFAULT_PROVIDER_CONFIGS = [
+    {
+        provider: AIProviderName.BEDROCK,
+        models: [BedrockModels.CLAUDE_3_7_SONNET, BedrockModels.CLAUDE_3_5_SONNET]
+    },
+    {
+        provider: AIProviderName.VERTEX,
+        models: [VertexModels.CLAUDE_4_0_SONNET, VertexModels.GEMINI_2_5_FLASH]
+    },
+    {
+        provider: AIProviderName.OPENAI,
+        models: [OpenAIModels.GPT_4O, OpenAIModels.GPT_4O_MINI]
+    }
+];

package/dist/lib/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * NeuroLink AI Toolkit
+ *
+ * A unified AI provider interface with support for multiple providers,
+ * automatic fallback, streaming, and tool integration.
+ *
+ * Extracted from lighthouse project's proven AI functionality.
+ */
+import { AIProviderFactory } from './core/factory.js';
+export { AIProviderFactory };
+export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, ProviderAttempt, SupportedModelName } from './core/types.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
+ *
+ * @example
+ * ```typescript
+ * import { createAIProvider } from 'neurolink';
+ *
+ * const provider = createAIProvider('bedrock');
+ * const result = await provider.streamText('Hello, AI!');
+ * ```
+ */
+export declare function createAIProvider(providerName?: string, modelName?: string): import("./index.js").AIProvider;
+/**
+ * Create provider with automatic fallback
+ *
+ * @example
+ * ```typescript
+ * import { createAIProviderWithFallback } from 'neurolink';
+ *
+ * const { primary, fallback } = createAIProviderWithFallback('bedrock', 'vertex');
+ * ```
+ */
+export declare function createAIProviderWithFallback(primaryProvider?: string, fallbackProvider?: string, modelName?: string): {
+    primary: import("./index.js").AIProvider;
+    fallback: import("./index.js").AIProvider;
+};
+/**
+ * Create the best available provider based on configuration
+ *
+ * @example
+ * ```typescript
+ * import { createBestAIProvider } from 'neurolink';
+ *
+ * const provider = createBestAIProvider();
+ * ```
+ */
+export declare function createBestAIProvider(requestedProvider?: string, modelName?: string): import("./index.js").AIProvider;

package/dist/lib/index.js

@@ -0,0 +1,62 @@
+/**
+ * NeuroLink AI Toolkit
+ *
+ * A unified AI provider interface with support for multiple providers,
+ * automatic fallback, streaming, and tool integration.
+ *
+ * Extracted from lighthouse project's proven AI functionality.
+ */
+// Core exports
+import { AIProviderFactory } from './core/factory.js';
+export { AIProviderFactory };
+// Model enums
+export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS } from './core/types.js';
+// Provider exports
+export { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider } from './providers/index.js';
+export { PROVIDERS, AVAILABLE_PROVIDERS } from './providers/index.js';
+// Utility exports
+export { getBestProvider, getAvailableProviders, isValidProvider } from './utils/providerUtils.js';
+// Main NeuroLink wrapper class
+export { NeuroLink } from './neurolink.js';
+// Version
+export const VERSION = '1.0.0';
+/**
+ * Quick start factory function
+ *
+ * @example
+ * ```typescript
+ * import { createAIProvider } from 'neurolink';
+ *
+ * const provider = createAIProvider('bedrock');
+ * const result = await provider.streamText('Hello, AI!');
+ * ```
+ */
+export function createAIProvider(providerName, modelName) {
+    return AIProviderFactory.createProvider(providerName || 'bedrock', modelName);
+}
+/**
+ * Create provider with automatic fallback
+ *
+ * @example
+ * ```typescript
+ * import { createAIProviderWithFallback } from 'neurolink';
+ *
+ * const { primary, fallback } = createAIProviderWithFallback('bedrock', 'vertex');
+ * ```
+ */
+export function createAIProviderWithFallback(primaryProvider, fallbackProvider, modelName) {
+    return AIProviderFactory.createProviderWithFallback(primaryProvider || 'bedrock', fallbackProvider || 'vertex', modelName);
+}
+/**
+ * Create the best available provider based on configuration
+ *
+ * @example
+ * ```typescript
+ * import { createBestAIProvider } from 'neurolink';
+ *
+ * const provider = createBestAIProvider();
+ * ```
+ */
+export function createBestAIProvider(requestedProvider, modelName) {
+    return AIProviderFactory.createBestProvider(requestedProvider, modelName);
+}

package/dist/lib/mcp/context-manager.d.ts

@@ -0,0 +1,164 @@
+/**
+ * NeuroLink MCP Context Management System
+ * Unified context creation and management for all tool executions
+ * Ensures rich context flows through tool chain with session tracking
+ */
+import type { NeuroLinkExecutionContext } from './factory.js';
+/**
+ * Context creation request interface
+ */
+export interface ContextRequest {
+    sessionId?: string;
+    userId?: string;
+    aiProvider?: string;
+    modelId?: string;
+    temperature?: number;
+    maxTokens?: number;
+    organizationId?: string;
+    projectId?: string;
+    environmentType?: 'development' | 'staging' | 'production';
+    frameworkType?: 'react' | 'vue' | 'svelte' | 'next' | 'nuxt' | 'sveltekit';
+    permissions?: string[];
+    securityLevel?: 'public' | 'private' | 'organization';
+    [key: string]: any;
+}
+/**
+ * Context manager for creating and managing execution contexts
+ * Provides rich context for all tool executions with session tracking
+ */
+export declare class ContextManager {
+    private sessionCounter;
+    private activeContexts;
+    /**
+     * Create a new execution context with rich information
+     *
+     * @param request Context creation request with optional fields
+     * @returns Complete execution context ready for tool chain
+     */
+    createContext(request?: ContextRequest): NeuroLinkExecutionContext;
+    /**
+     * Add a tool to the execution chain
+     *
+     * @param context Execution context to modify
+     * @param toolName Name of the tool being executed
+     */
+    addToToolChain(context: NeuroLinkExecutionContext, toolName: string): void;
+    /**
+     * Get the current tool chain for a context
+     *
+     * @param context Execution context
+     * @returns Array of tool names in execution order
+     */
+    getToolChain(context: NeuroLinkExecutionContext): string[];
+    /**
+     * Set parent tool for nested tool execution
+     *
+     * @param context Execution context to modify
+     * @param parentToolId ID of the parent tool
+     */
+    setParentTool(context: NeuroLinkExecutionContext, parentToolId: string): void;
+    /**
+     * Create child context for nested tool execution
+     *
+     * @param parentContext Parent execution context
+     * @param childToolName Name of the child tool
+     * @returns New child context with inherited properties
+     */
+    createChildContext(parentContext: NeuroLinkExecutionContext, childToolName: string): NeuroLinkExecutionContext;
+    /**
+     * Get context by session ID
+     *
+     * @param sessionId Session identifier
+     * @returns Execution context or undefined if not found
+     */
+    getContext(sessionId: string): NeuroLinkExecutionContext | undefined;
+    /**
+     * Update context with new information
+     *
+     * @param sessionId Session identifier
+     * @param updates Partial context updates
+     */
+    updateContext(sessionId: string, updates: Partial<NeuroLinkExecutionContext>): void;
+    /**
+     * Remove context from active tracking
+     *
+     * @param sessionId Session identifier
+     */
+    removeContext(sessionId: string): void;
+    /**
+     * Get all active contexts (for debugging/monitoring)
+     *
+     * @returns Array of all active contexts
+     */
+    getActiveContexts(): NeuroLinkExecutionContext[];
+    /**
+     * Clear all active contexts
+     */
+    clearAllContexts(): void;
+    /**
+     * Get context statistics
+     *
+     * @returns Context usage statistics
+     */
+    getStats(): {
+        activeContexts: number;
+        totalSessionsCreated: number;
+        averageToolChainLength: number;
+    };
+    /**
+     * Generate unique session ID
+     *
+     * @returns Unique session identifier
+     */
+    private generateSessionId;
+    /**
+     * Extract custom fields from request (excluding known fields)
+     *
+     * @param request Context creation request
+     * @returns Custom fields object
+     */
+    private extractCustomFields;
+}
+/**
+ * Default context manager instance
+ * Can be used across the application for consistent context management
+ */
+export declare const defaultContextManager: ContextManager;
+/**
+ * Utility function to create context with defaults
+ *
+ * @param request Optional context request
+ * @returns Execution context with sensible defaults
+ */
+export declare function createExecutionContext(request?: ContextRequest): NeuroLinkExecutionContext;
+/**
+ * Utility function to add tool to default context manager
+ *
+ * @param context Execution context
+ * @param toolName Tool name to add
+ */
+export declare function addToolToChain(context: NeuroLinkExecutionContext, toolName: string): void;
+/**
+ * Context validation utilities
+ */
+export declare class ContextValidator {
+    /**
+     * Validate context has required fields for tool execution
+     *
+     * @param context Execution context to validate
+     * @returns Validation result with details
+     */
+    static validateContext(context: NeuroLinkExecutionContext): {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Validate context permissions for tool execution
+     *
+     * @param context Execution context
+     * @param requiredPermissions Permissions required by tool
+     * @returns Whether context has required permissions
+     */
+    static hasPermissions(context: NeuroLinkExecutionContext, requiredPermissions: string[]): boolean;
+}