@juspay/neurolink 5.3.0 → 6.0.0

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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;

package/dist/lib/types/providers.js

@@ -0,0 +1,23 @@
+/**
+ * Provider-specific type definitions for NeuroLink
+ * Replaces 'any' types in provider implementations
+ */
+/**
+ * Type guard for provider error
+ */
+export function isProviderError(error) {
+    return error instanceof Error && "provider" in error;
+}
+/**
+ * Type guard for token usage
+ */
+export function isTokenUsage(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "inputTokens" in value &&
+        "outputTokens" in value &&
+        "totalTokens" in value &&
+        typeof value.inputTokens === "number" &&
+        typeof value.outputTokens === "number" &&
+        typeof value.totalTokens === "number");
+}

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

@@ -1,12 +1,13 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Tool, Schema } from "ai";
 import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
+import type { UnknownRecord, Unknown } from "./common.js";
 /**
  * Interface for tool execution calls
  */
 export interface ToolCall {
     toolName: string;
-    parameters: Record<string, any>;
+    parameters: UnknownRecord;
     id?: string;
 }
 /**
@@ -15,7 +16,7 @@ export interface ToolCall {
 export interface ToolResult {
     toolName: string;
     status: "success" | "failure";
-    output?: any;
+    output?: Unknown;
     error?: string;
     id?: string;
     executionTime?: number;
@@ -48,7 +49,7 @@ export interface StreamOptions {
     maxSteps?: number;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
-    context?: Record<string, any>;
+    context?: UnknownRecord;
     evaluationDomain?: string;
     toolUsageContext?: string;
     conversationHistory?: Array<{

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

@@ -0,0 +1,154 @@
+/**
+ * Tool system type definitions for NeuroLink
+ * Replaces 'any' types in tool registration and execution
+ */
+import { z } from "zod";
+import type { Result, JsonValue, ErrorInfo } from "./common.js";
+/**
+ * Tool parameter schema types
+ */
+export type ToolParameterSchema = z.ZodSchema | Record<string, JsonValue>;
+/**
+ * Standard tool input parameters
+ */
+export interface BaseToolArgs {
+    [key: string]: JsonValue | undefined;
+}
+/**
+ * Tool execution arguments with specific common patterns
+ */
+export interface ToolArgs extends BaseToolArgs {
+    input?: JsonValue;
+    data?: JsonValue;
+    options?: JsonValue;
+}
+/**
+ * Tool execution metadata
+ */
+export interface ToolExecutionMetadata {
+    requestId?: string;
+    startTime?: number;
+    version?: string;
+    [key: string]: JsonValue | undefined;
+}
+/**
+ * Tool execution context
+ */
+export interface ToolContext {
+    sessionId?: string;
+    userId?: string;
+    aiProvider?: string;
+    metadata?: ToolExecutionMetadata;
+}
+/**
+ * Tool execution result metadata
+ */
+export interface ToolResultMetadata {
+    toolName?: string;
+    executionTime?: number;
+    timestamp?: number;
+    source?: string;
+    version?: string;
+    serverId?: string;
+}
+/**
+ * Tool execution result
+ */
+export interface ToolResult<T = JsonValue> extends Result<T, ErrorInfo> {
+    success: boolean;
+    data?: T;
+    error?: ErrorInfo;
+    metadata?: ToolResultMetadata;
+}
+/**
+ * Tool metadata for registration
+ */
+export interface ToolMetadata {
+    category?: string;
+    version?: string;
+    author?: string;
+    tags?: string[];
+    documentation?: string;
+    [key: string]: JsonValue | undefined;
+}
+/**
+ * Tool definition interface
+ */
+export interface ToolDefinition<TArgs = ToolArgs, TResult = JsonValue> {
+    description: string;
+    parameters?: ToolParameterSchema;
+    metadata?: ToolMetadata;
+    execute: (args: TArgs, context?: ToolContext) => Promise<ToolResult<TResult>> | ToolResult<TResult>;
+}
+/**
+ * Simple tool interface (for SDK)
+ */
+export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> {
+    description: string;
+    parameters?: z.ZodSchema;
+    metadata?: ToolMetadata;
+    execute: (args: TArgs, context?: ToolContext) => Promise<TResult> | TResult;
+}
+/**
+ * Tool registry entry
+ */
+export interface ToolRegistryEntry {
+    name: string;
+    description: string;
+    serverId?: string;
+    isImplemented?: boolean;
+    parameters?: ToolParameterSchema;
+    execute?: ToolDefinition["execute"];
+}
+/**
+ * Tool execution information
+ */
+export interface ToolExecution {
+    toolName: string;
+    args: ToolArgs;
+    result: ToolResult;
+    executionTime: number;
+    timestamp: number;
+}
+/**
+ * Available tool information
+ */
+export interface AvailableTool {
+    name: string;
+    description: string;
+    serverId?: string;
+    toolName?: string;
+    parameters?: ToolParameterSchema;
+}
+/**
+ * Tool validation options
+ */
+export interface ToolValidationOptions {
+    customValidator?: (toolName: string, args: ToolArgs) => boolean | Promise<boolean>;
+    validateSchema?: boolean;
+    allowUnknownProperties?: boolean;
+}
+/**
+ * Tool call information (for AI SDK integration)
+ */
+export interface ToolCall {
+    toolName: string;
+    parameters: ToolArgs;
+    id?: string;
+}
+/**
+ * Tool call result (for AI SDK integration)
+ */
+export interface ToolCallResult {
+    id?: string;
+    result: ToolResult;
+    formattedForAI: string;
+}
+/**
+ * Type guard for tool result
+ */
+export declare function isToolResult(value: unknown): value is ToolResult;
+/**
+ * Type guard for tool definition
+ */
+export declare function isToolDefinition(value: unknown): value is ToolDefinition;

package/dist/lib/types/tools.js

@@ -0,0 +1,24 @@
+/**
+ * Tool system type definitions for NeuroLink
+ * Replaces 'any' types in tool registration and execution
+ */
+/**
+ * Type guard for tool result
+ */
+export function isToolResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "success" in value &&
+        typeof value.success === "boolean");
+}
+/**
+ * Type guard for tool definition
+ */
+export function isToolDefinition(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "description" in value &&
+        "execute" in value &&
+        typeof value.description === "string" &&
+        typeof value.execute === "function");
+}

package/dist/lib/utils/logger.d.ts

@@ -4,9 +4,9 @@
  * Provides conditional logging based on NEUROLINK_DEBUG environment variable
  */
 export declare const logger: {
-    debug: (...args: any[]) => void;
-    info: (...args: any[]) => void;
-    warn: (...args: any[]) => void;
-    error: (...args: any[]) => void;
-    always: (...args: any[]) => void;
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    always: (...args: unknown[]) => void;
 };

package/dist/lib/utils/provider-validation.d.ts

@@ -7,6 +7,7 @@
  * - Proper error classification
  * - Rate-limit friendly validation
  */
+import type { UnknownRecord } from "../types/common.js";
 export interface ProviderValidationResult {
     configured: boolean;
     formatValid: boolean;
@@ -15,7 +16,7 @@ export interface ProviderValidationResult {
     error?: string;
     errorType?: "config" | "format" | "auth" | "network" | "quota" | "unknown";
     responseTime?: number;
-    details?: Record<string, any>;
+    details?: UnknownRecord;
 }
 /**
  * Validate API key format for a specific provider