@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/types/agentNetwork.js

@@ -1,8 +0,0 @@
-/**
- * Agent Network Types for Multi-Agent Orchestration
- *
- * These types define the core abstractions for NeuroLink's multi-agent system,
- * enabling intelligent routing, agent collaboration, and hierarchical networks.
- */
-export {};
-//# sourceMappingURL=agentNetwork.js.map

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

@@ -1,368 +0,0 @@
-/**
- * Comprehensive Type Alias Library
- * Centralizes commonly used complex types to improve readability and maintainability
- */
-import type { ZodTypeAny } from "zod";
-import type { JsonValue, Result, AsyncFunction } from "./common.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import type { Schema } from "./tools.js";
-/**
- * Type alias for complex Zod schema type to improve readability
- * Used across providers and validation systems
- * Using ZodTypeAny to prevent infinite type recursion in zod-to-json-schema
- */
-export type ZodUnknownSchema = ZodTypeAny;
-/**
- * Bridges Zod 4 schema types to the zod-to-json-schema library which still
- * types against Zod 3 (`zod/v3`). Zod 4 schemas are structurally compatible
- * at runtime but not assignable at the type level, so call sites must cast
- * through `unknown` to this type at the third-party boundary.
- */
-export type ZodToJsonSchemaInput = Parameters<typeof zodToJsonSchema>[0];
-/**
- * Dialects accepted by Zod 4's native `z.toJSONSchema(schema, { target })`.
- * Note the `.` in `"openapi-3.0"`: this differs from the `zod-to-json-schema`
- * package's `"openApi3"` form. The schemaConversion helper maps between the
- * two so internal call sites can use a single `"openApi3"` identifier.
- */
-export type Zod4NativeTarget = "draft-07" | "openapi-3.0";
-/**
- * Subset of Zod 4's `ToJSONSchemaParams` we forward through. Kept minimal so
- * the type stays stable even if Zod 4 grows the surface in future releases.
- */
-export type Zod4NativeParams = {
-    target?: Zod4NativeTarget;
-};
-/**
- * Union type for schema validation (Zod or AI SDK schema)
- * Commonly used in provider interfaces and validation functions
- */
-export type ValidationSchema = ZodUnknownSchema | Schema<unknown>;
-/**
- * Optional validation schema type
- * Used in optional schema parameters across the codebase
- */
-export type OptionalValidationSchema = ValidationSchema | undefined;
-/**
- * Standard unknown record type for flexible object structures
- * Most commonly used record type across the codebase
- */
-export type StandardRecord = Record<string, unknown>;
-/**
- * String-valued record for configuration and metadata
- * Common in environment variables and config objects
- */
-export type StringRecord = Record<string, string>;
-/**
- * Number-valued record for metrics and counters
- * Used in performance monitoring and statistics
- */
-export type NumberRecord = Record<string, number>;
-/**
- * Boolean-valued record for feature flags and settings
- * Common in configuration and capability objects
- */
-export type BooleanRecord = Record<string, boolean>;
-/**
- * Mixed primitive record for configuration objects
- * Allows string, number, boolean values
- */
-export type PrimitiveRecord = Record<string, string | number | boolean>;
-/**
- * JSON-safe record type for API communication
- * Ensures values are JSON-serializable
- */
-export type JsonRecord = Record<string, JsonValue>;
-/**
- * Optional record types for flexible parameters
- */
-export type OptionalStandardRecord = StandardRecord | undefined;
-export type OptionalStringRecord = StringRecord | undefined;
-export type OptionalJsonRecord = JsonRecord | undefined;
-/**
- * Tool execution function with context
- * Standard pattern for MCP tool execution
- */
-export type ToolExecutionFunction<TParams = unknown, TResult = unknown> = (params: TParams, context?: StandardRecord) => Promise<TResult>;
-/**
- * Event handler function type
- * Common in event-driven architectures
- */
-export type EventHandler<TEvent = unknown> = (event: TEvent) => void | Promise<void>;
-/**
- * Async event handler function type
- */
-export type AsyncEventHandler<TEvent = unknown> = (event: TEvent) => Promise<void>;
-/**
- * Validation function type
- * Common pattern for input validation
- */
-export type ValidationFunction<T = unknown> = (value: T) => boolean;
-/**
- * Transformation function type
- * Common in data processing pipelines
- */
-export type TransformFunction<TInput = unknown, TOutput = unknown> = (input: TInput) => TOutput;
-/**
- * Async transformation function type
- */
-export type AsyncTransformFunction<TInput = unknown, TOutput = unknown> = (input: TInput) => Promise<TOutput>;
-/**
- * Array of standard records
- * Common in data collections
- */
-export type RecordArray = StandardRecord[];
-/**
- * String array type
- * Very common for lists of identifiers, names, etc.
- */
-export type StringArray = string[];
-/**
- * Number array type
- * Common for metrics, coordinates, etc.
- */
-export type NumberArray = number[];
-/**
- * Optional array types
- */
-export type OptionalStringArray = StringArray | undefined;
-export type OptionalRecordArray = RecordArray | undefined;
-/**
- * API response structure
- * Standard response format across providers
- */
-export type ApiResponse<TData = unknown> = {
-    success: boolean;
-    data?: TData;
-    error?: string;
-    metadata?: StandardRecord;
-};
-/**
- * Async API response type
- */
-export type AsyncApiResponse<TData = unknown> = Promise<ApiResponse<TData>>;
-/**
- * Paginated response structure
- * Common in list APIs
- */
-export type PaginatedResponse<TData = unknown> = ApiResponse<TData> & {
-    pagination?: {
-        page: number;
-        limit: number;
-        total: number;
-        hasNext: boolean;
-    };
-};
-/**
- * Basic execution context
- * Minimal context for tool execution
- */
-export type BasicContext = {
-    sessionId?: string;
-    userId?: string;
-    timestamp?: number;
-};
-/**
- * Enhanced execution context
- * Extended context with additional metadata
- */
-export type EnhancedContext = BasicContext & {
-    requestId?: string;
-    metadata?: StandardRecord;
-    timeout?: number;
-};
-/**
- * Standard error structure
- * Consistent error format across the codebase
- */
-export type StandardError = {
-    message: string;
-    code?: string;
-    details?: StandardRecord;
-    stack?: string;
-};
-/**
- * Async result type
- */
-export type AsyncResult<TData = unknown, TError = StandardError> = Promise<Result<TData, TError>>;
-/**
- * Operation result with metadata
- * Enhanced result type with additional context
- */
-export type OperationResult<TData = unknown> = Result<TData> & {
-    duration?: number;
-    metadata?: StandardRecord;
-};
-/**
- * Nullable type alias
- * Common pattern for optional values
- */
-export type Nullable<T> = T | null;
-/**
- * Optional type alias (more explicit than T | undefined)
- */
-export type Optional<T> = T | undefined;
-/**
- * Maybe type (combines null and undefined)
- */
-export type Maybe<T> = T | null | undefined;
-/**
- * Non-empty string type
- * Useful for validated string inputs
- */
-export type NonEmptyString = string & {
-    readonly __brand: unique symbol;
-};
-/**
- * Positive number type
- * Useful for validated numeric inputs
- */
-export type PositiveNumber = number & {
-    readonly __brand: unique symbol;
-};
-/**
- * Timestamp type (number representing milliseconds since epoch)
- */
-export type Timestamp = number & {
-    readonly __brand: unique symbol;
-};
-/**
- * ID type for entity identifiers
- */
-export type EntityId = string & {
-    readonly __brand: unique symbol;
-};
-/**
- * Feature flag configuration
- * Common structure for feature toggles
- */
-export type FeatureConfig = BooleanRecord & {
-    enabled?: boolean;
-    metadata?: StandardRecord;
-};
-/**
- * Service configuration
- * Standard structure for service settings
- */
-export type ServiceConfig = {
-    enabled?: boolean;
-    timeout?: number;
-    retries?: number;
-    endpoint?: string;
-    apiKey?: string;
-    metadata?: StandardRecord;
-};
-/**
- * Simple success/error result (different from generic OperationResult)
- * Used for basic operation feedback without data payload
- */
-export type SimpleResult = {
-    success: boolean;
-    error?: string;
-};
-/**
- * Connectivity test result for providers
- * Standard format for testing provider connections
- */
-export type ConnectivityResult = {
-    success: boolean;
-    error?: string;
-};
-/**
- * Connection result with latency information
- * Used for detailed connection testing with performance metrics
- */
-export type ConnectionResult = {
-    connected: boolean;
-    latency?: number;
-    error?: string;
-};
-/**
- * Provider pair result for fallback configurations
- * Used when creating primary/fallback provider setups
- */
-export type ProviderPairResult<T = unknown> = {
-    primary: T;
-    fallback: T;
-};
-/**
- * Tool execution result with enhanced prompt
- * Common pattern in tool orchestration scenarios
- */
-export type OrchestrationResult = {
-    toolResults: unknown[];
-    enhancedPrompt: string;
-};
-/**
- * Batch operation result with count and errors
- * Standard pattern for operations that process multiple items
- */
-export type BatchOperationResult = {
-    success: boolean;
-    error?: string;
-    toolCount?: number;
-};
-/**
- * Server loading result with detailed feedback
- * Used when loading multiple servers with error tracking
- */
-export type ServerLoadResult = {
-    serversLoaded: number;
-    errors: string[];
-};
-/**
- * Transport connection result for MCP operations
- * Standard format for MCP transport establishment
- * Note: Using proper types instead of unknown to fix TypeScript compilation
- */
-export type TransportResult = {
-    transport: unknown;
-    process?: unknown;
-};
-/**
- * Transport result with required process (for stdio transport)
- * Used when process is guaranteed to be present
- */
-export type TransportWithProcessResult = {
-    transport: unknown;
-    process: unknown;
-};
-/**
- * Transport result without process (for network transports)
- * Used for SSE and WebSocket transports that don't spawn processes
- */
-export type NetworkTransportResult = {
-    transport: unknown;
-};
-/**
- * Re-export commonly used types from other modules
- * Provides one-stop shop for type imports
- */
-export type { JsonValue, JsonObject } from "./common.js";
-/**
- * Type guard for checking if value is a StandardRecord
- *
- * @param value - Value to check
- * @returns True if value is a non-null object (but not an array)
- *
- * @example
- * ```typescript
- * if (isStandardRecord(data)) {
- *   // TypeScript now knows data is Record<string, unknown>
- *   console.log(data.someProperty);
- * }
- * ```
- */
-export declare function isStandardRecord(value: unknown): value is StandardRecord;
-/**
- * Type guard for checking if value is a JsonRecord
- */
-export declare function isJsonRecord(value: unknown): value is JsonRecord;
-/**
- * Type guard for checking if value is a StringArray
- */
-export declare function isStringArray(value: unknown): value is StringArray;
-/**
- * Type guard for checking if value is an AsyncFunction
- */
-export declare function isAsyncFunction(value: unknown): value is AsyncFunction;

package/dist/lib/types/aliases.js

@@ -1,50 +0,0 @@
-/**
- * Comprehensive Type Alias Library
- * Centralizes commonly used complex types to improve readability and maintainability
- */
-import { zodToJsonSchema } from "zod-to-json-schema";
-// ============================================================================
-// TYPE GUARDS AND UTILITIES
-// ============================================================================
-/**
- * Type guard for checking if value is a StandardRecord
- *
- * @param value - Value to check
- * @returns True if value is a non-null object (but not an array)
- *
- * @example
- * ```typescript
- * if (isStandardRecord(data)) {
- *   // TypeScript now knows data is Record<string, unknown>
- *   console.log(data.someProperty);
- * }
- * ```
- */
-export function isStandardRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Type guard for checking if value is a JsonRecord
- */
-export function isJsonRecord(value) {
-    return (isStandardRecord(value) &&
-        Object.values(value).every((val) => val === null ||
-            typeof val === "string" ||
-            typeof val === "number" ||
-            typeof val === "boolean" ||
-            Array.isArray(val) ||
-            isJsonRecord(val)));
-}
-/**
- * Type guard for checking if value is a StringArray
- */
-export function isStringArray(value) {
-    return (Array.isArray(value) && value.every((item) => typeof item === "string"));
-}
-/**
- * Type guard for checking if value is an AsyncFunction
- */
-export function isAsyncFunction(value) {
-    return typeof value === "function";
-}
-//# sourceMappingURL=aliases.js.map

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

@@ -1,215 +0,0 @@
-/**
- * Analytics-related type definitions for NeuroLink
- * Comprehensive usage tracking, performance metrics, and cost analysis types
- */
-import type { JsonValue, UnknownRecord } from "./common.js";
-import type { ClaudeLimitSnapshot } from "./subscription.js";
-/**
- * Token usage information (consolidated from multiple sources)
- */
-export type TokenUsage = {
-    input: number;
-    output: number;
-    total: number;
-    cacheCreationTokens?: number;
-    cacheReadTokens?: number;
-    reasoning?: number;
-    cacheSavingsPercent?: number;
-};
-/**
- * Error info type for analytics
- */
-export type AnalyticsErrorInfo = {
-    message: string;
-    code?: string | number;
-    stack?: string;
-    details?: UnknownRecord;
-};
-/**
- * Analytics data structure (consolidated from core analytics)
- */
-export type AnalyticsData = {
-    provider: string;
-    model?: string;
-    tokenUsage: TokenUsage;
-    requestDuration: number;
-    timestamp: string;
-    cost?: number;
-    context?: JsonValue;
-    /** Number of agentic steps (model calls) the turn used. */
-    stepsUsed?: number;
-    /** Number of external tool calls the turn made (final_result excluded). */
-    toolCallCount?: number;
-    /** Why the turn ended — see GenerateStopReason. */
-    stopReason?: string;
-    /** Wall-clock duration of the turn in milliseconds. */
-    elapsedMs?: number;
-    /** Verbatim provider finish/stop reason for the terminal model call. */
-    rawFinishReason?: string;
-    /**
-     * Account limit state observed on this request — subscription window
-     * headroom, reset times, and (via the NeuroLink Claude proxy) which account
-     * served it and how much the pool has left. Present for Anthropic traffic
-     * whose response carried rate-limit headers.
-     */
-    limits?: ClaudeLimitSnapshot;
-};
-/**
- * Stream Analytics Data - Enhanced for performance tracking
- */
-export type StreamAnalyticsData = {
-    /** Tool execution results with timing */
-    toolResults?: Promise<Array<unknown>>;
-    /** Tool calls made during stream */
-    toolCalls?: Promise<Array<unknown>>;
-    /** Stream performance metrics */
-    performance?: {
-        startTime: number;
-        endTime?: number;
-        chunkCount: number;
-        avgChunkSize: number;
-        totalBytes: number;
-    };
-    /** Provider analytics */
-    providerAnalytics?: AnalyticsData;
-};
-export type PerformanceMetrics = {
-    startTime: number;
-    endTime?: number;
-    duration?: number;
-    memoryStart: NodeJS.MemoryUsage;
-    memoryEnd?: NodeJS.MemoryUsage;
-    memoryDelta?: {
-        rss: number;
-        heapTotal: number;
-        heapUsed: number;
-        external: number;
-    };
-};
-export type TimeRangeOption = {
-    start: Date;
-    end: Date;
-};
-/**
- * Quality score subset captured on an analytics telemetry record.
- */
-export type AnalyticsQualityScore = {
-    overall: number;
-    relevance: number;
-    accuracy: number;
-    completeness: number;
-    reasoning?: string;
-};
-/**
- * Single request lifecycle record for advanced analytics aggregation.
- */
-export type TelemetryRecord = {
-    id: string;
-    provider: string;
-    model: string;
-    userId?: string;
-    teamId?: string;
-    department?: string;
-    timestamp: number;
-    latency: number;
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    cost: number;
-    isError: boolean;
-    errorMessage?: string;
-    qualityScore?: AnalyticsQualityScore;
-};
-/**
- * Pluggable storage backend for analytics telemetry records.
- */
-export type AnalyticsStorage = {
-    /** Save a telemetry record */
-    saveRecord(record: TelemetryRecord): Promise<void>;
-    /** Retrieve all records */
-    getRecords(): Promise<TelemetryRecord[]>;
-    /** Clear storage */
-    clear(): Promise<void>;
-};
-/**
- * Options for the bounded in-memory analytics storage backend.
- */
-export type InMemoryAnalyticsStorageOptions = {
-    /** Maximum records to retain. Oldest records are evicted when exceeded. */
-    maxRecords?: number;
-};
-export type ProviderMetricsOptions = {
-    providers?: string[];
-    timeRange?: TimeRangeOption | string;
-    metrics?: string[];
-};
-export type ProviderMetricItem = {
-    name: string;
-    averageLatency: number;
-    averageResponseTime: number;
-    totalTokens: number;
-    inputTokens: number;
-    outputTokens: number;
-    errorRate: number;
-    successRate: number;
-    costPerToken: number;
-    totalCost: number;
-    requestCount: number;
-};
-export type ProviderMetricsResult = {
-    averageLatency: number;
-    averageResponseTime: number;
-    totalTokens: number;
-    inputTokens: number;
-    outputTokens: number;
-    errorRate: number;
-    successRate: number;
-    costPerToken: number;
-    totalCost: number;
-    requestCount: number;
-    providers: ProviderMetricItem[];
-};
-export type CostAnalysisOptions = {
-    timeRange?: TimeRangeOption | string;
-    groupBy?: string | string[];
-    includeProjections?: boolean;
-};
-export type CostGroupItem = {
-    groupKey: string;
-    provider?: string;
-    model?: string;
-    userId?: string;
-    totalCost: number;
-    costPerToken: number;
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    requestCount: number;
-};
-export type CostAnalysisResult = {
-    totalCost: number;
-    totalTokens: number;
-    inputTokens: number;
-    outputTokens: number;
-    requestCount: number;
-    groups: Record<string, CostGroupItem>;
-    providers: CostGroupItem[];
-    projections?: {
-        nextMonth: number;
-        nextQuarter: number;
-    };
-};
-export type TeamAnalyticsOptions = {
-    teamId?: string;
-    departments?: string[];
-    metrics?: string[];
-    timeRange?: TimeRangeOption | string;
-};
-export type TeamAnalyticsResult = {
-    totalRequests: number;
-    uniqueUsers: number;
-    providersUsed: string[];
-    costBreakdownByProvider: Record<string, number>;
-    costBreakdownByUser: Record<string, number>;
-    qualityScores?: AnalyticsQualityScore;
-};

package/dist/lib/types/analytics.js

@@ -1,6 +0,0 @@
-/**
- * Analytics-related type definitions for NeuroLink
- * Comprehensive usage tracking, performance metrics, and cost analysis types
- */
-export {};
-//# sourceMappingURL=analytics.js.map