@juspay/neurolink 7.48.1 → 7.50.0

package/dist/types/observability.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Observability Configuration Types
+ * These configs are passed from the parent application (e.g., Lighthouse)
+ * to enable telemetry and observability features in Neurolink SDK
+ */
+/**
+ * Langfuse observability configuration
+ */
+export interface LangfuseConfig {
+    /** Whether Langfuse is enabled */
+    enabled: boolean;
+    /** Langfuse public key */
+    publicKey: string;
+    /**
+     * Langfuse secret key
+     * @sensitive
+     * WARNING: This is a sensitive credential. Handle securely.
+     * Do NOT log, expose, or share this key. Follow best practices for secret management.
+     */
+    secretKey: string;
+    /** Langfuse base URL (default: https://cloud.langfuse.com) */
+    baseUrl?: string;
+    /** Environment name (e.g., dev, staging, prod) */
+    environment?: string;
+    /** Release/version identifier */
+    release?: string;
+}
+/**
+ * OpenTelemetry configuration
+ */
+export interface OpenTelemetryConfig {
+    /** Whether OpenTelemetry is enabled */
+    enabled: boolean;
+    /** OTLP endpoint URL */
+    endpoint?: string;
+    /** Service name for traces */
+    serviceName?: string;
+    /** Service version */
+    serviceVersion?: string;
+}
+/**
+ * Complete observability configuration for Neurolink SDK
+ */
+export interface ObservabilityConfig {
+    /** Langfuse configuration */
+    langfuse?: LangfuseConfig;
+    /** OpenTelemetry configuration */
+    openTelemetry?: OpenTelemetryConfig;
+}

package/dist/types/observability.js

@@ -0,0 +1,6 @@
+/**
+ * Observability Configuration Types
+ * These configs are passed from the parent application (e.g., Lighthouse)
+ * to enable telemetry and observability features in Neurolink SDK
+ */
+export {};

package/dist/types/streamTypes.d.ts

@@ -125,6 +125,8 @@ export interface StreamOptions {
         text: string;
         audio?: AudioInputSpec;
         images?: Array<Buffer | string>;
+        csvFiles?: Array<Buffer | string>;
+        files?: Array<Buffer | string>;
         content?: Array<TextContent | ImageContent>;
     };
     output?: {
@@ -135,6 +137,11 @@ export interface StreamOptions {
             enableProgress?: boolean;
         };
     };
+    csvOptions?: {
+        maxRows?: number;
+        formatStyle?: "raw" | "markdown" | "json";
+        includeHeaders?: boolean;
+    };
     provider?: AIProviderName | string;
     model?: string;
     region?: string;

package/dist/types/tools.d.ts

@@ -4,10 +4,10 @@
  */
 import { z } from "zod";
 import type { Result, JsonValue, ErrorInfo } from "./common.js";
+import type { StandardRecord, ZodUnknownSchema } from "./typeAliases.js";
 /**
  * Commonly used Zod schema type aliases for cleaner type declarations
  */
-import type { ZodUnknownSchema } from "./typeAliases.js";
 export type { ZodUnknownSchema } from "./typeAliases.js";
 export type ZodAnySchema = z.ZodSchema<unknown>;
 export type ZodObjectSchema = z.ZodObject<z.ZodRawShape>;
@@ -19,148 +19,245 @@ export type ToolParameterSchema = ZodUnknownSchema | Record<string, JsonValue>;
 /**
  * Standard tool input parameters
  */
-export interface BaseToolArgs {
+export type BaseToolArgs = {
     [key: string]: JsonValue | undefined;
-}
+};
 /**
  * Tool execution arguments with specific common patterns
  */
-export interface ToolArgs extends BaseToolArgs {
+export type ToolArgs = BaseToolArgs & {
     input?: JsonValue;
     data?: JsonValue;
     options?: JsonValue;
-}
+};
+/**
+ * Generic execution context for MCP operations
+ * Moved from src/lib/mcp/contracts/mcpContract.ts
+ */
+export type ExecutionContext<T = StandardRecord> = {
+    sessionId?: string;
+    userId?: string;
+    config?: T;
+    metadata?: StandardRecord;
+    cacheOptions?: CacheOptions;
+    fallbackOptions?: FallbackOptions;
+    timeoutMs?: number;
+    startTime?: number;
+};
+/**
+ * Cache configuration options
+ * Moved from src/lib/mcp/contracts/mcpContract.ts
+ */
+export type CacheOptions = {
+    enabled?: boolean;
+    ttlMs?: number;
+    strategy?: "memory" | "writeThrough" | "cacheAside";
+};
+/**
+ * Fallback configuration options
+ * Moved from src/lib/mcp/contracts/mcpContract.ts
+ */
+export type FallbackOptions = {
+    enabled?: boolean;
+    maxAttempts?: number;
+    delayMs?: number;
+    circuitBreaker?: boolean;
+};
+/**
+ * Tool information with extensibility
+ * Moved from src/lib/mcp/contracts/mcpContract.ts
+ */
+export type ToolInfo = {
+    name: string;
+    description?: string;
+    category?: string;
+    serverId?: string;
+    inputSchema?: StandardRecord;
+    outputSchema?: StandardRecord;
+    [key: string]: unknown;
+};
+/**
+ * Tool Implementation type for MCP tool registry
+ * Extracted from toolRegistry.ts for centralized type management
+ */
+export type ToolImplementation = {
+    execute: (params: unknown, context?: ExecutionContext) => Promise<unknown> | unknown;
+    description?: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    category?: string;
+    permissions?: string[];
+};
+/**
+ * Tool execution options for enhanced control
+ * Extracted from toolRegistry.ts for centralized type management
+ */
+export type ToolExecutionOptions = {
+    timeout?: number;
+    retries?: number;
+    context?: unknown;
+    preferredSource?: string;
+    fallbackEnabled?: boolean;
+    validateBeforeExecution?: boolean;
+    timeoutMs?: number;
+};
+/**
+ * Tool execution result
+ * Moved from src/lib/mcp/contracts/mcpContract.ts
+ */
+export type ToolExecutionResult<T = unknown> = {
+    result: T;
+    context?: ExecutionContext;
+    performance?: {
+        duration: number;
+        tokensUsed?: number;
+        cost?: number;
+    };
+    validation?: ValidationResult;
+    cached?: boolean;
+    fallback?: boolean;
+};
+/**
+ * Validation result for runtime checks
+ * Moved from src/lib/mcp/contracts/mcpContract.ts
+ */
+export type ValidationResult = {
+    valid: boolean;
+    missing: string[];
+    warnings: string[];
+    recommendations: string[];
+};
 /**
  * Tool execution metadata
  */
-export interface ToolExecutionMetadata {
+export type ToolExecutionMetadata = {
     requestId?: string;
     startTime?: number;
     version?: string;
     [key: string]: JsonValue | undefined;
-}
+};
 /**
  * Tool execution context
  */
-export interface ToolContext {
+export type ToolContext = {
     sessionId?: string;
     userId?: string;
     aiProvider?: string;
     metadata?: ToolExecutionMetadata;
-}
+};
 /**
  * Tool execution result metadata
  */
-export interface ToolResultMetadata {
+export type 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> {
+export type ToolResult<T = JsonValue> = Result<T, ErrorInfo> & {
     success: boolean;
     data?: T;
     error?: ErrorInfo;
     metadata?: ToolResultMetadata;
-}
+};
 /**
  * Tool metadata for registration
  */
-export interface ToolMetadata {
+export type ToolMetadata = {
     category?: string;
     version?: string;
     author?: string;
     tags?: string[];
     documentation?: string;
     [key: string]: JsonValue | undefined;
-}
+};
 /**
- * Tool definition interface
+ * Tool definition type
  */
-export interface ToolDefinition<TArgs = ToolArgs, TResult = JsonValue> {
+export type ToolDefinition<TArgs = ToolArgs, TResult = JsonValue> = {
     description: string;
     parameters?: ToolParameterSchema;
     metadata?: ToolMetadata;
     execute: (params: TArgs, context?: ToolContext) => Promise<ToolResult<TResult>> | ToolResult<TResult>;
-}
+};
 /**
- * Simple tool interface (for SDK)
+ * Simple tool type (for SDK)
  */
-export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> {
+export type SimpleTool<TArgs = ToolArgs, TResult = JsonValue> = {
     description: string;
     parameters?: ZodUnknownSchema;
     metadata?: ToolMetadata;
     execute: (params: TArgs, context?: ToolContext) => Promise<TResult>;
-}
+};
 /**
  * Tool registry entry
  */
-export interface ToolRegistryEntry {
+export type ToolRegistryEntry = {
     name: string;
     description: string;
     serverId?: string;
     isImplemented?: boolean;
     parameters?: ToolParameterSchema;
     execute?: ToolDefinition["execute"];
-}
+};
 /**
  * Tool execution information
  */
-export interface ToolExecution {
+export type ToolExecution = {
     toolName: string;
     params: ToolArgs;
     result: ToolResult;
     executionTime: number;
     timestamp: number;
-}
+};
 /**
  * Available tool information
  */
-export interface AvailableTool {
+export type AvailableTool = {
     name: string;
     description: string;
     serverId?: string;
     toolName?: string;
     parameters?: ToolParameterSchema;
-}
+};
 /**
  * Tool validation options
  */
-export interface ToolValidationOptions {
+export type ToolValidationOptions = {
     customValidator?: (toolName: string, params: ToolArgs) => boolean | Promise<boolean>;
     validateSchema?: boolean;
     allowUnknownProperties?: boolean;
-}
+};
 /**
  * Tool call information (for AI SDK integration)
  */
-export interface ToolCall {
+export type ToolCall = {
     toolName: string;
     parameters: ToolArgs;
     id?: string;
-}
+};
 /**
  * AI SDK Tool Call format (from Vercel AI SDK)
  */
-export interface AiSdkToolCall {
+export type AiSdkToolCall = {
     type: "tool-call";
     toolCallId: string;
     toolName: string;
     params: ToolArgs;
-}
+};
 /**
  * Tool call result (for AI SDK integration)
  */
-export interface ToolCallResult {
+export type ToolCallResult = {
     id?: string;
     result: ToolResult;
     formattedForAI: string;
-}
+};
 /**
  * Type guard for tool result
  */

package/dist/utils/csvProcessor.d.ts

@@ -0,0 +1,68 @@
+/**
+ * CSV Processing Utility
+ * Converts CSV files to LLM-friendly text formats
+ * Uses streaming for memory efficiency with large files
+ */
+import type { FileProcessingResult, CSVProcessorOptions } from "../types/fileTypes.js";
+/**
+ * CSV processor for converting CSV data to LLM-optimized formats
+ *
+ * Supports three output formats:
+ * - raw: Original CSV format with proper escaping (RECOMMENDED for best LLM performance)
+ * - json: JSON array format (best for structured data processing)
+ * - markdown: Markdown table format (best for small datasets <100 rows)
+ *
+ * All formats use csv-parser for reliable parsing, then convert to the target format.
+ *
+ * @example
+ * ```typescript
+ * const csvBuffer = Buffer.from('name,age\nAlice,30\nBob,25');
+ * const result = await CSVProcessor.process(csvBuffer, {
+ *   maxRows: 1000,
+ *   formatStyle: 'raw'
+ * });
+ * console.log(result.content); // CSV string with proper escaping
+ * ```
+ */
+export declare class CSVProcessor {
+    /**
+     * Process CSV Buffer to LLM-friendly format
+     * Content already loaded by FileDetector
+     *
+     * @param content - CSV file as Buffer
+     * @param options - Processing options
+     * @returns Formatted CSV data ready for LLM (JSON or Markdown)
+     */
+    static process(content: Buffer, options?: CSVProcessorOptions): Promise<FileProcessingResult>;
+    /**
+     * Parse CSV string into array of row objects using streaming
+     * Memory-efficient for large files
+     */
+    /**
+     * Parse CSV file from disk using streaming (memory efficient)
+     *
+     * @param filePath - Path to CSV file
+     * @param maxRows - Maximum rows to parse (default: 1000)
+     * @returns Array of row objects
+     */
+    static parseCSVFile(filePath: string, maxRows?: number): Promise<unknown[]>;
+    /**
+     * Parse CSV string to array of row objects
+     * Exposed for use by tools that need direct CSV parsing
+     *
+     * @param csvString - CSV data as string
+     * @param maxRows - Maximum rows to parse (default: 1000)
+     * @returns Array of row objects
+     */
+    static parseCSVString(csvString: string, maxRows?: number): Promise<unknown[]>;
+    /**
+     * Format parsed CSV data for LLM consumption
+     * Only used for JSON and Markdown formats (raw format handled separately)
+     */
+    private static formatForLLM;
+    /**
+     * Format as markdown table
+     * Best for small datasets (<100 rows)
+     */
+    private static toMarkdownTable;
+}