@juspay/neurolink 5.3.0 → 6.1.0

package/dist/services/websocket/websocket-server.js

@@ -1,6 +1,7 @@
 import { WebSocketServer, WebSocket } from "ws";
 import { EventEmitter } from "events";
 import { randomUUID } from "crypto";
+import { IncomingMessage } from "http";
 import { logger } from "../../utils/logger.js";
 export class NeuroLinkWebSocketServer extends EventEmitter {
     wss;
@@ -44,7 +45,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         }
         const connectionId = randomUUID();
         const userAgent = request.headers["user-agent"];
-        const ipAddress = request.socket.remoteAddress;
+        const ipAddress = request.socket?.remoteAddress;
         // Store connection
         this.connections.set(connectionId, ws);
         this.connectionInfo.set(connectionId, {

package/dist/telemetry/telemetry-service.js

@@ -1,5 +1,5 @@
 import { NodeSDK } from "@opentelemetry/sdk-node";
-import { metrics, trace } from "@opentelemetry/api";
+import { metrics, trace, } from "@opentelemetry/api";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";

package/dist/types/cli.d.ts

@@ -0,0 +1,247 @@
+/**
+ * CLI-specific type definitions for NeuroLink
+ * Replaces 'any' types in CLI commands and arguments
+ */
+import type { UnknownRecord, JsonValue } from "./common.js";
+import type { AnalyticsData, EvaluationData, TokenUsage } from "./providers.js";
+import type { ToolCall, ToolResult } from "./tools.js";
+/**
+ * Base command arguments interface
+ */
+export interface BaseCommandArgs {
+    /** Enable debug output */
+    debug?: boolean;
+    /** Output format */
+    format?: "text" | "json" | "table";
+    /** Verbose output */
+    verbose?: boolean;
+    /** Quiet mode */
+    quiet?: boolean;
+}
+/**
+ * Generate command arguments
+ */
+export interface GenerateCommandArgs extends BaseCommandArgs {
+    /** Input text or prompt */
+    input?: string;
+    /** AI provider to use */
+    provider?: string;
+    /** Model name */
+    model?: string;
+    /** System prompt */
+    system?: string;
+    /** Temperature setting */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Enable analytics */
+    analytics?: boolean;
+    /** Enable evaluation */
+    evaluation?: boolean;
+    /** Context data */
+    context?: string;
+    /** Disable tools */
+    disableTools?: boolean;
+    /** Maximum steps for multi-turn */
+    maxSteps?: number;
+    /** Output file */
+    output?: string;
+}
+/**
+ * Stream command arguments
+ */
+export interface StreamCommandArgs extends BaseCommandArgs {
+    /** Input text or prompt */
+    input?: string;
+    /** AI provider to use */
+    provider?: string;
+    /** Model name */
+    model?: string;
+    /** System prompt */
+    system?: string;
+    /** Temperature setting */
+    temperature?: number;
+    /** Maximum tokens */
+    maxTokens?: number;
+    /** Disable tools */
+    disableTools?: boolean;
+}
+/**
+ * MCP command arguments
+ */
+export interface MCPCommandArgs extends BaseCommandArgs {
+    /** MCP server name */
+    server?: string;
+    /** Tool name to execute */
+    tool?: string;
+    /** Tool parameters as JSON string */
+    params?: string;
+    /** List available tools */
+    list?: boolean;
+    /** Discover MCP servers */
+    discover?: boolean;
+    /** Show server information */
+    info?: boolean;
+}
+/**
+ * Ollama command arguments
+ */
+export interface OllamaCommandArgs extends BaseCommandArgs {
+    /** Ollama model name */
+    model?: string;
+    /** List available models */
+    list?: boolean;
+    /** Pull a model */
+    pull?: boolean;
+    /** Remove a model */
+    remove?: boolean;
+    /** Show model information */
+    show?: boolean;
+}
+/**
+ * Provider status command arguments
+ */
+export interface ProviderStatusArgs extends BaseCommandArgs {
+    /** Specific provider to check */
+    provider?: string;
+    /** Check all providers */
+    all?: boolean;
+}
+/**
+ * CLI command result
+ */
+export interface CommandResult {
+    /** Command success status */
+    success: boolean;
+    /** Result data */
+    data?: unknown;
+    /** Error message if failed */
+    error?: string;
+    /** Output content */
+    content?: string;
+    /** Execution metadata */
+    metadata?: {
+        executionTime?: number;
+        timestamp?: number;
+        command?: string;
+    };
+}
+/**
+ * Generate command result
+ */
+export interface GenerateResult extends CommandResult {
+    content: string;
+    provider?: string;
+    model?: string;
+    usage?: TokenUsage;
+    responseTime?: number;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+    toolsUsed?: string[];
+    toolExecutions?: Array<{
+        toolName: string;
+        args: UnknownRecord;
+        result: unknown;
+        executionTime: number;
+    }>;
+    enhancedWithTools?: boolean;
+    availableTools?: Array<{
+        name: string;
+        description: string;
+    }>;
+}
+/**
+ * Stream result chunk
+ */
+export interface StreamChunk {
+    content?: string;
+    delta?: string;
+    done?: boolean;
+    metadata?: UnknownRecord;
+}
+/**
+ * CLI output formatting options
+ */
+export interface OutputOptions {
+    format: "text" | "json" | "table";
+    pretty?: boolean;
+    color?: boolean;
+    compact?: boolean;
+}
+/**
+ * Command handler function type
+ */
+export type CommandHandler<TArgs = BaseCommandArgs, TResult = CommandResult> = (args: TArgs) => Promise<TResult>;
+/**
+ * Command definition
+ */
+export interface CommandDefinition<TArgs = BaseCommandArgs> {
+    name: string;
+    description: string;
+    aliases?: string[];
+    args?: {
+        [K in keyof TArgs]: {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required?: boolean;
+            default?: TArgs[K];
+        };
+    };
+    handler: CommandHandler<TArgs>;
+}
+/**
+ * CLI context
+ */
+export interface CLIContext {
+    cwd: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    exitCode?: number;
+}
+/**
+ * Color mapping for CLI output
+ */
+export interface ColorMap {
+    [severity: string]: {
+        color: string;
+        symbol?: string;
+    };
+}
+/**
+ * Display severity colors (for evaluation display)
+ */
+export interface SeverityColors {
+    [key: string]: {
+        color: string;
+        symbol: string;
+    };
+}
+/**
+ * JSON output structure
+ */
+export interface JSONOutput {
+    success: boolean;
+    data?: JsonValue;
+    error?: string;
+    metadata?: {
+        timestamp: number;
+        command: string;
+        version?: string;
+    };
+}
+/**
+ * Console override for quiet mode
+ */
+export interface ConsoleOverride {
+    [method: string]: (() => void) | undefined;
+}
+/**
+ * Type guard for generate result
+ */
+export declare function isGenerateResult(value: unknown): value is GenerateResult;
+/**
+ * Type guard for command result
+ */
+export declare function isCommandResult(value: unknown): value is CommandResult;

package/dist/types/cli.js

@@ -0,0 +1,22 @@
+/**
+ * CLI-specific type definitions for NeuroLink
+ * Replaces 'any' types in CLI commands and arguments
+ */
+/**
+ * Type guard for generate result
+ */
+export function isGenerateResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "content" in value &&
+        typeof value.content === "string");
+}
+/**
+ * Type guard for command result
+ */
+export function isCommandResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "success" in value &&
+        typeof value.success === "boolean");
+}

package/dist/types/common.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Common utility types for NeuroLink
+ * These types provide type-safe alternatives to 'any' usage
+ */
+/**
+ * Type-safe unknown value - use instead of 'any' when type is truly unknown
+ */
+export type Unknown = unknown;
+/**
+ * Type-safe record for metadata and configuration objects
+ */
+export type UnknownRecord = Record<string, unknown>;
+/**
+ * Type-safe array of unknown items
+ */
+export type UnknownArray = unknown[];
+/**
+ * JSON-serializable value type
+ */
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export interface JsonArray extends Array<JsonValue> {
+}
+/**
+ * Type-safe error handling
+ */
+export interface ErrorInfo {
+    message: string;
+    code?: string | number;
+    stack?: string;
+    cause?: unknown;
+}
+/**
+ * Generic success/error result type
+ */
+export interface Result<T = unknown, E = ErrorInfo> {
+    success: boolean;
+    data?: T;
+    error?: E;
+}
+/**
+ * Function parameter type for dynamic functions
+ */
+export interface FunctionParameters {
+    [key: string]: unknown;
+}
+/**
+ * Generic async function type
+ */
+export type AsyncFunction<TParams = FunctionParameters, TResult = unknown> = (params: TParams) => Promise<TResult>;
+/**
+ * Sync function type
+ */
+export type SyncFunction<TParams = FunctionParameters, TResult = unknown> = (params: TParams) => TResult;
+/**
+ * Union of async and sync functions
+ */
+export type AnyFunction<TParams = FunctionParameters, TResult = unknown> = AsyncFunction<TParams, TResult> | SyncFunction<TParams, TResult>;
+/**
+ * Type guard to check if value is Error
+ */
+export declare function isError(value: unknown): value is Error;
+/**
+ * Type guard to check if value is ErrorInfo
+ */
+export declare function isErrorInfo(value: unknown): value is ErrorInfo;
+/**
+ * Safe error message extraction
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Safe error conversion
+ */
+export declare function toErrorInfo(error: unknown): ErrorInfo;

package/dist/types/common.js

@@ -0,0 +1,52 @@
+/**
+ * Common utility types for NeuroLink
+ * These types provide type-safe alternatives to 'any' usage
+ */
+/**
+ * Type guard to check if value is Error
+ */
+export function isError(value) {
+    return value instanceof Error;
+}
+/**
+ * Type guard to check if value is ErrorInfo
+ */
+export function isErrorInfo(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "message" in value &&
+        typeof value.message === "string");
+}
+/**
+ * Safe error message extraction
+ */
+export function getErrorMessage(error) {
+    if (isError(error)) {
+        return error.message;
+    }
+    if (isErrorInfo(error)) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return String(error);
+}
+/**
+ * Safe error conversion
+ */
+export function toErrorInfo(error) {
+    if (isError(error)) {
+        return {
+            message: error.message,
+            stack: error.stack,
+            code: error.code,
+        };
+    }
+    if (isErrorInfo(error)) {
+        return error;
+    }
+    return {
+        message: getErrorMessage(error),
+    };
+}

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

@@ -23,7 +23,7 @@ export interface GenerateOptions {
     disableTools?: boolean;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
     evaluationDomain?: string;
     toolUsageContext?: string;
     conversationHistory?: Array<{
@@ -51,21 +51,21 @@ export interface GenerateResult {
     toolCalls?: Array<{
         toolCallId: string;
         toolName: string;
-        args: Record<string, any>;
+        args: Record<string, unknown>;
     }>;
-    toolResults?: any[];
+    toolResults?: unknown[];
     toolsUsed?: string[];
     toolExecutions?: Array<{
         name: string;
-        input: Record<string, any>;
-        output: any;
+        input: Record<string, unknown>;
+        output: unknown;
         duration: number;
     }>;
     enhancedWithTools?: boolean;
     availableTools?: Array<{
         name: string;
         description: string;
-        parameters: Record<string, any>;
+        parameters: Record<string, unknown>;
     }>;
     analytics?: AnalyticsData;
     evaluation?: EvaluationData;

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Centralized type exports for NeuroLink
+ * Provides type-safe alternatives to 'any' usage throughout the codebase
+ */
+export * from "./common.js";
+export * from "./tools.js";
+export * from "./providers.js";
+export * from "./cli.js";
+export type { Unknown, UnknownRecord, UnknownArray, JsonValue, JsonObject, JsonArray, ErrorInfo, Result, FunctionParameters, } from "./common.js";
+export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, AvailableTool, ToolExecution, } from "./tools.js";
+export type { AISDKModel, ProviderError, TokenUsage, AnalyticsData, EvaluationData, ProviderConfig, } from "./providers.js";
+export type { BaseCommandArgs, GenerateCommandArgs, CommandResult, GenerateResult, StreamChunk, } from "./cli.js";

package/dist/types/index.js

@@ -0,0 +1,12 @@
+/**
+ * Centralized type exports for NeuroLink
+ * Provides type-safe alternatives to 'any' usage throughout the codebase
+ */
+// Common utility types
+export * from "./common.js";
+// Tool system types
+export * from "./tools.js";
+// Provider types
+export * from "./providers.js";
+// CLI types
+export * from "./cli.js";

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

@@ -34,7 +34,7 @@ export interface InMemoryMCPServerConfig {
         provider?: string;
         version?: string;
         author?: string;
-        [key: string]: any;
+        [key: string]: unknown;
     };
 }
 /**
@@ -48,11 +48,11 @@ export interface InMemoryToolInfo {
     /**
      * Tool execution function
      */
-    execute: (params: any) => Promise<InMemoryToolResult> | InMemoryToolResult;
+    execute: (params: unknown) => Promise<InMemoryToolResult> | InMemoryToolResult;
     /**
      * Input parameter schema (Zod or JSON Schema)
      */
-    inputSchema?: any;
+    inputSchema?: unknown;
     /**
      * Whether the tool is implemented (default: true)
      */
@@ -60,7 +60,7 @@ export interface InMemoryToolInfo {
     /**
      * Optional metadata
      */
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
 }
 /**
  * Result from in-memory tool execution
@@ -73,7 +73,7 @@ export interface InMemoryToolResult {
     /**
      * Result data if successful
      */
-    data?: any;
+    data?: unknown;
     /**
      * Error message if failed
      */
@@ -85,7 +85,7 @@ export interface InMemoryToolResult {
         executionTime?: number;
         toolName?: string;
         serverId?: string;
-        [key: string]: any;
+        [key: string]: unknown;
     };
 }
 /**
@@ -108,7 +108,7 @@ export interface UnifiedMCPRegistry {
     /**
      * Execute a tool
      */
-    executeTool(toolName: string, params: any, context: any): Promise<any>;
+    executeTool(toolName: string, params: unknown, context: unknown): Promise<unknown>;
     /**
      * Check if connected to a server
      */

package/dist/types/providers.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Provider-specific type definitions for NeuroLink
+ * Replaces 'any' types in provider implementations
+ */
+import type { UnknownRecord, JsonValue } from "./common.js";
+/**
+ * Generic AI SDK model interface
+ */
+export interface AISDKModel {
+    [key: string]: unknown;
+}
+/**
+ * Provider error information
+ */
+export interface ProviderError extends Error {
+    code?: string | number;
+    statusCode?: number;
+    provider?: string;
+    originalError?: unknown;
+}
+/**
+ * Token usage information
+ */
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+/**
+ * Analytics data structure
+ */
+export interface AnalyticsData {
+    provider: string;
+    model: string;
+    requestDuration: number;
+    tokenUsage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    timestamp: number;
+    context?: JsonValue;
+    [key: string]: JsonValue | undefined;
+}
+/**
+ * Evaluation data structure
+ */
+export interface EvaluationData {
+    relevance?: number;
+    accuracy?: number;
+    completeness?: number;
+    coherence?: number;
+    overall?: number;
+    feedback?: string;
+    [key: string]: JsonValue | undefined;
+}
+/**
+ * Provider capabilities
+ */
+export interface ProviderCapabilities {
+    supportsStreaming: boolean;
+    supportsTools: boolean;
+    supportsImages: boolean;
+    supportsAudio: boolean;
+    maxTokens?: number;
+    supportedModels: string[];
+}
+/**
+ * Provider configuration
+ */
+export interface ProviderConfig {
+    apiKey?: string;
+    baseURL?: string;
+    timeout?: number;
+    retries?: number;
+    model?: string;
+    [key: string]: unknown;
+}
+/**
+ * Amazon Bedrock specific types
+ */
+export declare namespace BedrockTypes {
+    interface Client {
+        send(command: unknown): Promise<unknown>;
+        config: {
+            region?: string;
+            credentials?: unknown;
+        };
+    }
+    interface InvokeModelCommand {
+        input: {
+            modelId: string;
+            body: string;
+            contentType?: string;
+        };
+    }
+}
+/**
+ * Mistral specific types
+ */
+export declare namespace MistralTypes {
+    interface Client {
+        chat?: {
+            complete?: (options: unknown) => Promise<unknown>;
+            stream?: (options: unknown) => AsyncIterable<unknown>;
+        };
+    }
+}
+/**
+ * OpenTelemetry specific types (for telemetry service)
+ */
+export declare namespace TelemetryTypes {
+    interface Meter {
+        createCounter(name: string, options?: unknown): Counter;
+        createHistogram(name: string, options?: unknown): Histogram;
+    }
+    interface Tracer {
+        startSpan(name: string, options?: unknown): Span;
+    }
+    interface Counter {
+        add(value: number, attributes?: UnknownRecord): void;
+    }
+    interface Histogram {
+        record(value: number, attributes?: UnknownRecord): void;
+    }
+    interface Span {
+        end(): void;
+        setStatus(status: unknown): void;
+        recordException(exception: unknown): void;
+    }
+}
+/**
+ * Provider factory function type
+ */
+export type ProviderFactory = (modelName?: string, providerName?: string, sdk?: unknown) => Promise<unknown>;
+/**
+ * Provider constructor type
+ */
+export interface ProviderConstructor {
+    new (modelName?: string, providerName?: string, sdk?: unknown): unknown;
+}
+/**
+ * Provider registration entry
+ */
+export interface ProviderRegistration {
+    name: string;
+    constructor: ProviderConstructor | ProviderFactory;
+    capabilities?: ProviderCapabilities;
+    defaultConfig?: ProviderConfig;
+}
+/**
+ * Type guard for provider error
+ */
+export declare function isProviderError(error: unknown): error is ProviderError;
+/**
+ * Type guard for token usage
+ */
+export declare function isTokenUsage(value: unknown): value is TokenUsage;