@juspay/neurolink 9.54.3 → 9.54.5

package/dist/lib/types/{mcpTypes.js → mcp.js}

@@ -3,4 +3,4 @@
  * Enables various integrations to register tools directly
  */
 export {};
-//# sourceMappingURL=mcpTypes.js.map
+//# sourceMappingURL=mcp.js.map

package/dist/lib/types/{mcpOutputTypes.js → mcpOutput.js}

@@ -6,4 +6,4 @@
  * @module types/mcpOutputTypes
  */
 export {};
-//# sourceMappingURL=mcpOutputTypes.js.map
+//# sourceMappingURL=mcpOutput.js.map

package/dist/lib/types/{middlewareTypes.d.ts → middleware.d.ts}

@@ -1,7 +1,6 @@
 import type { LanguageModelMiddleware } from "ai";
 import type { JsonValue } from "../types/common.js";
-import type { EvaluationData } from "./evaluation.js";
-import type { GetPromptFunction } from "./evaluationTypes.js";
+import type { EvaluationData, GetPromptFunction } from "./evaluation.js";
 /**
  * Metadata type for NeuroLink middleware
  * Provides additional information about middleware without affecting execution

package/dist/lib/types/middleware.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=middleware.js.map

package/dist/lib/types/{modelTypes.d.ts → model.d.ts}

@@ -5,7 +5,7 @@
 import { z } from "zod";
 import type { JsonValue } from "./common.js";
 import { AIProviderName } from "../constants/enums.js";
-import type { TaskType } from "./taskClassificationTypes.js";
+import type { TaskType } from "./taskClassification.js";
 /**
  * Model performance tier definition
  */

package/dist/lib/types/{modelTypes.js → model.js}

@@ -29,4 +29,4 @@ export const ModelRegistrySchema = z.object({
     aliases: z.record(z.string(), z.string()).optional(),
     defaults: z.record(z.string(), z.string()).optional(),
 });
-//# sourceMappingURL=modelTypes.js.map
+//# sourceMappingURL=model.js.map

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

@@ -4,6 +4,7 @@
  * to enable telemetry and observability features in Neurolink SDK
  */
 import type { AttributeValue } from "@opentelemetry/api";
+import type { SpanData } from "./span.js";
 /**
  * Trace name format for Langfuse traces
  *
@@ -177,7 +178,7 @@ export type RetryPolicy = {
     /** Policy name for identification */
     readonly name: string;
     /** Decide whether to retry */
-    shouldRetry(context: import("../observability/retryPolicy.js").RetryContext): import("../observability/retryPolicy.js").RetryDecision;
+    shouldRetry(context: RetryContext): RetryDecision;
     /** Maximum attempts allowed */
     readonly maxAttempts: number;
     /** Maximum total time allowed for retries */
@@ -190,7 +191,7 @@ export type Sampler = {
     /** Sampler name for identification */
     readonly name: string;
     /** Determine if a span should be sampled */
-    shouldSample(span: import("../observability/types/spanTypes.js").SpanData): boolean;
+    shouldSample(span: SpanData): boolean;
     /** Get sampling decision description */
     getDescription(): string;
 };
@@ -201,9 +202,220 @@ export type SpanProcessor = {
     /** Processor name for identification */
     readonly name: string;
     /** Process a span before export, returns null to drop the span */
-    process(span: import("../observability/types/spanTypes.js").SpanData): import("../observability/types/spanTypes.js").SpanData | null;
+    process(span: SpanData): SpanData | null;
     /** Optional async processing (for external lookups, etc.) */
-    processAsync?(span: import("../observability/types/spanTypes.js").SpanData): Promise<import("../observability/types/spanTypes.js").SpanData | null>;
+    processAsync?(span: SpanData): Promise<SpanData | null>;
     /** Shutdown the processor (cleanup resources) */
     shutdown?(): Promise<void>;
 };
+/**
+ * Hierarchical trace view grouping related spans
+ */
+export type TraceView = {
+    /** Trace identifier shared by all spans in this trace */
+    traceId: string;
+    /** The root/parent span of this trace */
+    rootSpan: SpanData;
+    /** Child spans linked to the root */
+    childSpans: SpanData[];
+    /** Total duration from first to last span */
+    totalDurationMs: number;
+    /** Total number of spans in this trace */
+    spanCount: number;
+    /** Overall trace status */
+    status: "ok" | "error" | "partial";
+};
+/**
+ * Extended context for Langfuse spans.
+ * Supports all Langfuse trace attributes for rich observability.
+ */
+export type LangfuseContext = {
+    userId?: string | null;
+    sessionId?: string | null;
+    /** Conversation/thread identifier for grouping related traces */
+    conversationId?: string | null;
+    /** Request identifier for correlating with application logs */
+    requestId?: string | null;
+    /** Custom trace name for better organization in Langfuse UI */
+    traceName?: string | null;
+    /** Custom metadata to attach to spans */
+    metadata?: Record<string, unknown> | null;
+    /**
+     * Explicit operation name (e.g., "ai.streamText", "chat", "embeddings").
+     * If set, overrides auto-detection from the span name.
+     */
+    operationName?: string | null;
+    /**
+     * Override global autoDetectOperationName setting for this context.
+     * When undefined, uses the global setting (defaults to true).
+     */
+    autoDetectOperationName?: boolean;
+    /**
+     * Custom attributes to set on all spans within this context.
+     * These attributes are propagated to every span created within the
+     * AsyncLocalStorage context.
+     */
+    customAttributes?: Record<string, string | number | boolean>;
+};
+/**
+ * Latency statistics with percentile calculations
+ */
+export type LatencyStats = {
+    /** Minimum latency in milliseconds */
+    min: number;
+    /** Maximum latency in milliseconds */
+    max: number;
+    /** Mean/average latency in milliseconds */
+    mean: number;
+    /** Median latency (p50) in milliseconds */
+    median: number;
+    /** 50th percentile latency in milliseconds */
+    p50: number;
+    /** 75th percentile latency in milliseconds */
+    p75: number;
+    /** 90th percentile latency in milliseconds */
+    p90: number;
+    /** 95th percentile latency in milliseconds */
+    p95: number;
+    /** 99th percentile latency in milliseconds */
+    p99: number;
+    /** Standard deviation in milliseconds */
+    stdDev: number;
+    /** Total number of samples */
+    count: number;
+};
+/**
+ * Cost breakdown by provider
+ */
+export type ProviderCostStats = {
+    provider: string;
+    totalCost: number;
+    requestCount: number;
+    avgCostPerRequest: number;
+    inputCost: number;
+    outputCost: number;
+};
+/**
+ * Cost breakdown by model
+ */
+export type ModelCostStats = {
+    model: string;
+    provider: string;
+    totalCost: number;
+    requestCount: number;
+    avgCostPerRequest: number;
+    inputTokens: number;
+    outputTokens: number;
+    inputCost: number;
+    outputCost: number;
+};
+/**
+ * Aggregated metrics summary
+ */
+export type MetricsSummary = {
+    /** Total number of spans tracked */
+    totalSpans: number;
+    /** Number of successful spans */
+    successfulSpans: number;
+    /** Number of failed spans */
+    failedSpans: number;
+    /** Overall success rate (0-1) */
+    successRate: number;
+    /** Latency statistics */
+    latency: LatencyStats;
+    /** Token usage statistics */
+    tokens: TokenUsageStats;
+    /** Cost by provider */
+    costByProvider: ProviderCostStats[];
+    /** Cost by model */
+    costByModel: ModelCostStats[];
+    /** Total cost across all providers */
+    totalCost: number;
+    /** Span count by type */
+    spansByType: Record<string, number>;
+    /** Timestamp of first span */
+    firstSpanTime?: Date;
+    /** Timestamp of last span */
+    lastSpanTime?: Date;
+    /** Tracking duration in milliseconds */
+    trackingDurationMs?: number;
+};
+/**
+ * Result of a retry decision
+ */
+export type RetryDecision = {
+    /** Whether to retry */
+    shouldRetry: boolean;
+    /** Delay before retry in milliseconds */
+    delayMs: number;
+    /** Reason for the decision */
+    reason: string;
+};
+/**
+ * Context for retry decision making
+ */
+export type RetryContext = {
+    /** Current attempt number (0-indexed) */
+    attempt: number;
+    /** The error that triggered the retry */
+    error: Error;
+    /** Total elapsed time since first attempt */
+    elapsedMs: number;
+    /** Operation name for logging */
+    operationName: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Token usage statistics by provider
+ */
+export type ProviderTokenStats = {
+    provider: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cost: number;
+    requestCount: number;
+};
+/**
+ * Token usage statistics by model
+ */
+export type ModelTokenStats = {
+    model: string;
+    provider: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cost: number;
+    requestCount: number;
+    avgTokensPerRequest: number;
+};
+/**
+ * Aggregated token usage statistics
+ */
+export type TokenUsageStats = {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    reasoningTokens: number;
+    totalCost: number;
+    byProvider: Map<string, ProviderTokenStats>;
+    byModel: Map<string, ModelTokenStats>;
+    bySpanType: Map<string, number>;
+};
+export type HealthMetrics = {
+    timestamp: number;
+    memoryUsage: NodeJS.MemoryUsage;
+    uptime: number;
+    activeConnections: number;
+    errorRate: number;
+    averageResponseTime: number;
+};
+export type SpanOptions = {
+    name: string;
+    tracer: import("@opentelemetry/api").Tracer;
+    kind?: import("@opentelemetry/api").SpanKind;
+    attributes?: Record<string, string | number | boolean | undefined>;
+};

package/dist/{types/pptTypes.d.ts → lib/types/ppt.d.ts}

@@ -11,7 +11,6 @@
  * - PPTError: Error handling (follows VideoError pattern)
  */
 import type { NeuroLink } from "../neurolink.js";
-import { NeuroLinkError } from "../utils/errorHandling.js";
 import type { ImageWithAltText } from "./content.js";
 import type { AIProvider } from "./providers.js";
 export type ThemeOption = "modern" | "corporate" | "creative" | "minimal" | "dark";
@@ -99,33 +98,6 @@ export type PPTGenerationResult = {
         fileSize?: number;
     };
 };
-/**
- * PPT generation error codes
- * Following the VIDEO_ERROR_CODES pattern
- */
-export declare const PPT_ERROR_CODES: {
-    /** Content planning AI call failed */
-    readonly PLANNING_FAILED: "PPT_PLANNING_FAILED";
-    /** AI returned invalid/unparseable response */
-    readonly INVALID_AI_RESPONSE: "PPT_INVALID_AI_RESPONSE";
-    /** Image generation for slide failed */
-    readonly IMAGE_GENERATION_FAILED: "PPT_IMAGE_GENERATION_FAILED";
-    /** PPTX file assembly failed */
-    readonly ASSEMBLY_FAILED: "PPT_ASSEMBLY_FAILED";
-    /** File system write failed */
-    readonly FILE_WRITE_FAILED: "PPT_FILE_WRITE_FAILED";
-    /** Invalid input options */
-    readonly INVALID_INPUT: "PPT_INVALID_INPUT";
-    /** Generation timeout */
-    readonly TIMEOUT: "PPT_TIMEOUT";
-};
-/**
- * PPT generation error class
- * Extends NeuroLinkError for consistent error handling (follows VideoError pattern)
- */
-export declare class PPTError extends NeuroLinkError {
-    constructor(message: string, code: string, context?: Record<string, unknown>, originalError?: Error);
-}
 /**
  * Slide types (35 total)
  * Defines the purpose/content type of a slide

package/dist/lib/types/ppt.js

@@ -0,0 +1,37 @@
+/**
+ * PPT Generation Types
+ *
+ * All types for presentation generation - both external API types and internal pipeline types.
+ * Used by the content planner, slide generator, and orchestrator.
+ *
+ * Architecture:
+ * - PPTOutputOptions / PPTGenerationResult: External API types (GenerateOptions.output.ppt)
+ * - SlideSchema / ContentPlan: Content planning pipeline types
+ * - CompleteSlide / PPTGenerationContext: Generation context types
+ * - PPTError: Error handling (follows VideoError pattern)
+ */
+// ============================================================================
+// VALIDATION CONSTANTS
+// ============================================================================
+/** Minimum number of slides allowed */
+export const MIN_SLIDES = 5;
+/** Maximum number of slides allowed */
+export const MAX_SLIDES = 50;
+/** Slide dimensions in inches by aspect ratio */
+export const SLIDE_DIMENSIONS = {
+    "16:9": { width: 10, height: 5.625 },
+    "4:3": { width: 10, height: 7.5 },
+};
+/**
+ * Validate a hex color string (6 hex characters, no # prefix).
+ */
+export function isValidHexColor(color) {
+    return /^[0-9A-Fa-f]{6}$/.test(color);
+}
+/**
+ * Normalize a hex color by stripping leading # if present.
+ */
+export function normalizeHexColor(color) {
+    return color.startsWith("#") ? color.slice(1) : color;
+}
+//# sourceMappingURL=ppt.js.map

package/dist/lib/{processors/base/types.d.ts → types/processor.d.ts}

@@ -6,7 +6,7 @@
  *
  * @module processors/base/types
  */
-import type { FileErrorCode } from "../errors/FileErrorCode.js";
+import type { FileErrorCode } from "../processors/errors/FileErrorCode.js";
 /**
  * Generic file information - provider agnostic.
  * Replaces Slack-specific SlackFileInfo with a universal interface.
@@ -96,7 +96,7 @@ export type FileProcessingError = {
  * Generic result type for internal operations.
  * Used for validation and download operations that don't return ProcessedFileBase.
  */
-export type OperationResult<T = void> = {
+export type ProcessorOperationResult<T = void> = {
     /** Whether the operation was successful */
     success: boolean;
     /** Operation result data (present when success is true) */
@@ -118,7 +118,7 @@ export type OperationResult<T = void> = {
  * }
  * ```
  */
-export type FileProcessingResult<T extends ProcessedFileBase = ProcessedFileBase> = {
+export type ProcessorFileProcessingResult<T extends ProcessedFileBase = ProcessedFileBase> = {
     /** Whether the processing was successful */
     success: boolean;
     /** Processed file data (present when success is true) */
@@ -130,7 +130,7 @@ export type FileProcessingResult<T extends ProcessedFileBase = ProcessedFileBase
  * Configuration for retry behavior on transient failures.
  * Implements exponential backoff with optional custom retry predicate.
  */
-export type RetryConfig = {
+export type ProcessorRetryConfig = {
     /** Maximum number of retry attempts */
     maxRetries: number;
     /** Base delay between retries in milliseconds */
@@ -150,13 +150,13 @@ export type ProcessOptions = {
     /** Override default timeout (in milliseconds) */
     timeout?: number;
     /** Retry configuration for transient failures */
-    retryConfig?: RetryConfig;
+    retryConfig?: ProcessorRetryConfig;
 };
 /**
  * Default retry configuration for file downloads.
  * Uses exponential backoff: 1s, 2s, 4s (capped at maxDelayMs)
  */
-export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+export declare const DEFAULT_RETRY_CONFIG: ProcessorRetryConfig;
 /** Default timeout for text file downloads (30 seconds) */
 export declare const DEFAULT_TEXT_TIMEOUT_MS = 30000;
 /** Default maximum size for text files (10 MB) */
@@ -389,7 +389,7 @@ export type ProcessorInfo = {
  * Error message template with user-friendly messaging and retry information.
  * Re-exported from errors module for convenience.
  */
-export type { ErrorMessageTemplate, FileErrorCode, } from "../errors/FileErrorCode.js";
+export { FileErrorCode } from "../processors/errors/FileErrorCode.js";
 /**
  * Processed SVG result.
  * Extends ProcessedFileBase with SVG-specific fields.
@@ -597,3 +597,229 @@ export type ProcessedRtf = ProcessedFileBase & {
  * Type guard function signature for JSON parsing.
  */
 export type JsonTypeGuard<T> = (parsed: unknown) => parsed is T;
+/**
+ * Registration entry for a file processor.
+ */
+export type ProcessorRegistration<T extends ProcessedFileBase = ProcessedFileBase> = {
+    name: string;
+    priority: number;
+    processor: import("../processors/base/index.js").BaseFileProcessor<T>;
+    isSupported: (mimetype: string, filename: string) => boolean;
+    description?: string;
+    aliases?: string[];
+};
+/**
+ * Processed audio file result.
+ * Extends ProcessedFileBase with audio-specific metadata, tags, and transcript info.
+ */
+export type ProcessedAudio = ProcessedFileBase & {
+    /** LLM-friendly text representation of the audio file metadata and tags */
+    textContent: string;
+    /** Audio stream metadata (codec, duration, bitrate, etc.) */
+    metadata: {
+        duration: number;
+        durationFormatted: string;
+        codec: string;
+        codecProfile?: string;
+        bitrate?: number;
+        sampleRate?: number;
+        channels?: number;
+        bitsPerSample?: number;
+        lossless: boolean;
+        fileSize: number;
+    };
+    /** Extracted ID3/Vorbis/APE tags */
+    tags: {
+        title?: string;
+        artist?: string;
+        album?: string;
+        year?: number;
+        genre?: string[];
+        track?: {
+            no: number | null;
+            of: number | null;
+        };
+        comment?: string;
+        composer?: string;
+    };
+    transcript?: string;
+    hasTranscript: boolean;
+    transcriptionProvider?: string;
+    coverArt?: Buffer;
+};
+/**
+ * Processed video result.
+ * Extends ProcessedFileBase with video-specific fields including metadata,
+ * extracted keyframes, subtitle text, and a pre-formatted textContent block
+ * suitable for sending to an LLM.
+ */
+export type ProcessedVideo = ProcessedFileBase & {
+    textContent: string;
+    keyframes: Buffer[];
+    metadata: {
+        duration: number;
+        durationFormatted: string;
+        width: number;
+        height: number;
+        codec: string;
+        fps: number;
+        bitrate: number;
+        audioCodec?: string;
+        audioChannels?: number;
+        audioSampleRate?: number;
+        subtitleTracks: number;
+        fileSize: number;
+    };
+    subtitleText?: string;
+    hasKeyframes: boolean;
+    frameCount: number;
+};
+/**
+ * Supported archive format identifiers.
+ */
+export type ArchiveFormat = "zip" | "tar" | "tar.gz" | "tar.bz2" | "gz" | "rar" | "7z";
+/**
+ * Metadata about an individual entry within an archive.
+ */
+export type ArchiveEntry = {
+    name: string;
+    uncompressedSize: number;
+    compressedSize: number;
+    isDirectory: boolean;
+};
+/**
+ * Processed archive result.
+ * Extends ProcessedFileBase with archive-specific metadata, entry listing,
+ * and any security warnings encountered during processing.
+ */
+export type ProcessedArchive = ProcessedFileBase & {
+    textContent: string;
+    archiveMetadata: {
+        format: ArchiveFormat;
+        totalEntries: number;
+        totalUncompressedSize: number;
+        totalCompressedSize: number;
+    };
+    entries: ArchiveEntry[];
+    securityWarnings: string[];
+};
+/**
+ * Options for CLI file processing
+ */
+export type CliFileProcessingOptions = {
+    /** Verbose output - shows processing details */
+    verbose?: boolean;
+    /** Processor to use (bypasses auto-detection) */
+    processor?: string;
+    /** Output format: json, text, or raw */
+    outputFormat?: "json" | "text" | "raw";
+};
+/**
+ * Result of CLI file processing
+ */
+export type CliProcessingResult = {
+    /** Whether processing succeeded */
+    success: boolean;
+    /** Name of the processor that was used */
+    processorUsed: string | null;
+    /** Formatted output string */
+    output: string;
+    /** Error message if processing failed */
+    error?: string;
+};
+/**
+ * Information about a supported file type
+ */
+export type SupportedFileTypeInfo = {
+    /** Processor name */
+    name: string;
+    /** Priority (lower = processed first) */
+    priority: number;
+    /** Supported file extensions */
+    extensions: string[];
+    /** Supported MIME types */
+    mimeTypes: string[];
+    /** Optional description */
+    description?: string;
+};
+/**
+ * Error message template with user-friendly messaging and retry information.
+ */
+export type ProcessorErrorMessageTemplate = {
+    /** Technical error message */
+    message: string;
+    /** User-friendly error message */
+    userMessage: string;
+    /** Suggested action to resolve the error */
+    suggestedAction: string;
+    /** Whether this error is potentially retryable */
+    retryable: boolean;
+};
+/**
+ * Options for processing files through the registry.
+ * Extends base ProcessOptions with registry-specific options.
+ *
+ * @example
+ * ```typescript
+ * const options: FileProcessingOptions = {
+ *   // Base options
+ *   authHeaders: { Authorization: "Bearer token" },
+ *   timeout: 60000,
+ *
+ *   // Registry-specific options
+ *   preferredProcessor: "pdf",      // Use specific processor
+ *   allowFallback: true,            // Allow fallback if no processor found
+ *   maxFiles: 50,                   // Limit batch processing
+ * };
+ * ```
+ */
+export type FileProcessingOptions = ProcessOptions & {
+    /** Preferred processor name (bypasses auto-detection) */
+    preferredProcessor?: string;
+    /** Whether to fall back to default processing if no processor found */
+    allowFallback?: boolean;
+    /** Maximum number of files to process (default: 100) */
+    maxFiles?: number;
+};
+/**
+ * Result of processing multiple files through the registry.
+ * Categorizes files into successful, failed, and skipped.
+ *
+ * @example
+ * ```typescript
+ * const result = await processBatchWithRegistry(files);
+ *
+ * // Handle successful files
+ * for (const { fileInfo, processorName, result } of result.successful) {
+ *   console.log(`${fileInfo.name}: processed by ${processorName}`);
+ * }
+ *
+ * // Handle failed files
+ * for (const { fileInfo, error } of result.failed) {
+ *   console.error(`${fileInfo.name}: ${error}`);
+ * }
+ *
+ * // Handle skipped files
+ * for (const { fileInfo, reason } of result.skipped) {
+ *   console.warn(`${fileInfo.name}: ${reason}`);
+ * }
+ * ```
+ */
+export type BatchFileProcessingResult = {
+    /** Successfully processed files */
+    successful: Array<{
+        fileInfo: FileInfo;
+        processorName: string;
+        result: ProcessorFileProcessingResult<ProcessedFileBase>;
+    }>;
+    /** Files that failed to process */
+    failed: Array<{
+        fileInfo: FileInfo;
+        error: string;
+    }>;
+    /** Files that were skipped (no processor found or over limit) */
+    skipped: Array<{
+        fileInfo: FileInfo;
+        reason: string;
+    }>;
+};

package/dist/lib/{processors/base/types.js → types/processor.js}

@@ -80,4 +80,12 @@ export const PROCESSOR_PRIORITIES = {
     /** Archive files */
     ARCHIVE: 180,
 };
-//# sourceMappingURL=types.js.map
+// =============================================================================
+// ERROR MESSAGE TEMPLATE
+// =============================================================================
+/**
+ * Error message template with user-friendly messaging and retry information.
+ * Re-exported from errors module for convenience.
+ */
+export { FileErrorCode } from "../processors/errors/FileErrorCode.js";
+//# sourceMappingURL=processor.js.map