@juspay/neurolink 9.54.5 → 9.54.7

package/dist/types/observability.d.ts

@@ -419,3 +419,84 @@ export type SpanOptions = {
     kind?: import("@opentelemetry/api").SpanKind;
     attributes?: Record<string, string | number | boolean | undefined>;
 };
+/** Trace + parent span IDs used to correlate metric records with spans. */
+export type MetricsTraceContext = {
+    traceId: string;
+    parentSpanId: string;
+};
+/**
+ * Runtime state for the observability exporter circuit breaker.
+ * Prefixed to disambiguate from the richer MCP CircuitBreakerState in mcp.ts.
+ */
+export type ObservabilityCircuitBreakerState = {
+    failures: number;
+    lastFailure: number;
+    state: "closed" | "open" | "half-open";
+};
+/**
+ * Minimal config for the observability exporter circuit breaker.
+ * Prefixed to disambiguate from the richer MCP CircuitBreakerConfig in mcp.ts.
+ */
+export type ObservabilityCircuitBreakerConfig = {
+    failureThreshold: number;
+    resetTimeout: number;
+};
+/** Minimal view of the dynamically-imported @sentry/node module. */
+export type SentryModule = {
+    init: (options: {
+        dsn: string;
+        tracesSampleRate: number;
+        release?: string;
+        environment: string;
+    }) => void;
+    withScope: (callback: (scope: SentryScope) => void) => void;
+    captureException: (error: Error) => void;
+    startInactiveSpan: (options: {
+        name: string;
+        op: string;
+        startTime: number;
+        attributes?: Record<string, unknown>;
+    }) => {
+        end: (timestamp?: number) => void;
+    };
+    flush: (timeout: number) => Promise<boolean>;
+    close: (timeout: number) => Promise<boolean>;
+};
+/** Sentry scope surface used by SentryExporter.withScope callbacks. */
+export type SentryScope = {
+    setTags: (tags: Record<string, string>) => void;
+    setContext: (name: string, context: Record<string, unknown>) => void;
+    setUser: (user: {
+        id: string;
+    }) => void;
+};
+/** Aggregated metrics for a single time window. */
+export type TimeWindowStats = {
+    windowStart: Date;
+    windowEnd: Date;
+    windowDurationMs: number;
+    requestCount: number;
+    errorCount: number;
+    successRate: number;
+    throughput: number;
+    latency: LatencyStats;
+    tokens: TokenUsageStats;
+    costByProvider: Map<string, ProviderCostStats>;
+    costByModel: Map<string, ModelCostStats>;
+};
+/** Configuration for MetricsAggregator. */
+export type MetricsAggregatorConfig = {
+    maxSpansRetained?: number;
+    enableTimeWindows?: boolean;
+    timeWindowMs?: number;
+    maxTimeWindows?: number;
+};
+/**
+ * Per-million-token pricing used by the observability TokenTracker.
+ * Prefixed to disambiguate from the richer providers.ts ModelPricing.
+ */
+export type ObservabilityModelPricing = {
+    inputPricePerMillion: number;
+    outputPricePerMillion: number;
+    cachedInputPricePerMillion?: number;
+};

package/dist/types/processor.d.ts

@@ -823,3 +823,50 @@ export type BatchFileProcessingResult = {
         reason: string;
     }>;
 };
+/** Alias for ExcelJS.CellValue to avoid leaking exceljs types across files. */
+export type CellValue = import("exceljs").CellValue;
+/** Summary of file processing operations. */
+export type FileProcessingSummary = {
+    totalFiles: number;
+    processedFiles: Array<{
+        filename: string;
+        size?: number;
+        type?: string;
+    }>;
+    failedFiles: Array<{
+        filename: string;
+        error: FileProcessingError;
+    }>;
+    skippedFiles: Array<{
+        filename: string;
+        reason: string;
+        suggestedAlternative?: string;
+    }>;
+    warnings: Array<{
+        filename: string;
+        message: string;
+    }>;
+};
+/** Serialized error representation with full context. */
+export type SerializedError = {
+    errorId: string;
+    errorFingerprint: string;
+    errorType: string;
+    message: string;
+    stack?: string;
+    stackFrames?: string[];
+    statusCode?: number;
+    isOperational?: boolean;
+    isRetryable?: boolean;
+    code?: string;
+    metadata?: Record<string, unknown>;
+    cause?: SerializedError;
+    timestamp: string;
+};
+/** Options for error serialization. */
+export type SerializeOptions = {
+    includeStack?: boolean;
+    maxDepth?: number;
+    filterStacks?: boolean;
+    context?: Record<string, unknown>;
+};

package/dist/types/providers.d.ts

@@ -1,7 +1,8 @@
 /**
  * Provider-specific type definitions for NeuroLink
  */
-import type { UnknownRecord, JsonValue } from "./common.js";
+import type { UnknownRecord, JsonValue, StreamingCapability } from "./common.js";
+import type { ProviderError } from "./errors.js";
 import { AIProviderName, AnthropicModels, BedrockModels, GoogleAIModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { Tool } from "ai";
 import type { ValidationSchema } from "./aliases.js";
@@ -443,21 +444,6 @@ export type ProviderCreationError = {
  * Provider factory function type
  */
 export type ProviderFactory = (modelName?: string, providerName?: string, sdk?: unknown) => Promise<unknown>;
-/**
- * Provider constructor type
- */
-export type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: unknown): unknown;
-};
-/**
- * Provider registration entry
- */
-export type ProviderRegistration = {
-    name: string;
-    constructor: ProviderConstructor | ProviderFactory;
-    capabilities?: ProviderCapabilities;
-    defaultConfig?: IndividualProviderConfig;
-};
 /**
  * Configuration options for the provider registry
  */
@@ -1473,3 +1459,121 @@ export type ToolWithLegacyParams = {
     /** Legacy field from AI SDK v3/v4 */
     parameters?: unknown;
 };
+/**
+ * Provider constructor interface - supports both sync constructors and async
+ * factory functions.
+ */
+export type ProviderConstructor = {
+    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string) => Promise<AIProvider>);
+/** Provider registration entry held by ProviderFactory. */
+export type ProviderRegistration = {
+    constructor: ProviderConstructor;
+    defaultModel?: string;
+    aliases?: string[];
+};
+/** Minimal NeuroLink-like instance accepted by the image generation service. */
+export type NeuroLinkInstance = {
+    generate: (options: Record<string, unknown>) => Promise<unknown>;
+};
+/** ProviderError enriched with HTTP response fields from Ollama. */
+export type OllamaHttpError = ProviderError & {
+    statusCode: number;
+    statusText: string;
+    responseBody: string;
+};
+/** Model type detection result. */
+export type ModelDetectionResult = {
+    type: StreamingCapability["modelType"];
+    confidence: number;
+    evidence: string[];
+    suggestedConfig?: Partial<SageMakerModelConfig>;
+};
+/** Endpoint health and metadata information. */
+export type EndpointHealth = {
+    status: "healthy" | "unhealthy" | "unknown";
+    responseTime: number;
+    metadata?: Record<string, unknown>;
+    modelInfo?: {
+        name?: string;
+        version?: string;
+        framework?: string;
+        architecture?: string;
+    };
+};
+/** Configuration object for a detection test wrapper. */
+export type DetectionTestConfig = {
+    test: () => Promise<void>;
+    index: number;
+    testName: string;
+    endpointName: string;
+    semaphore: {
+        acquire(): Promise<void>;
+        release(): void;
+    };
+    incrementRateLimit: () => void;
+    maxRateLimitRetries: number;
+    rateLimitState: {
+        count: number;
+    };
+};
+/** Configuration object for parallel detection test execution. */
+export type ParallelDetectionConfig = {
+    maxConcurrentTests: number;
+    maxRateLimitRetries: number;
+    initialRateLimitCount: number;
+};
+/** Individual SageMaker diagnostic result. */
+export type DiagnosticResult = {
+    name: string;
+    category: "configuration" | "connectivity" | "streaming";
+    status: "pass" | "fail" | "warning";
+    message: string;
+    details?: string;
+    recommendation?: string;
+};
+/** Aggregated SageMaker diagnostic report. */
+export type DiagnosticReport = {
+    overallStatus: "healthy" | "issues" | "critical";
+    results: DiagnosticResult[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        warnings: number;
+    };
+};
+/** SageMaker tool_call item in the OpenAI-compatible payload shape. */
+export type SageMakerOpenAIToolCall = {
+    type: "function";
+    id: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+/**
+ * Event pushed through the Google AI Studio voice session's internal queue
+ * while audio chunks stream back from the Gemini Live API.
+ */
+export type GoogleLiveAudioQueueItem = {
+    type: "audio";
+    audio: import("./stream.js").AudioChunk;
+} | {
+    type: "end";
+} | {
+    type: "error";
+    error: unknown;
+};
+/**
+ * Single part inside a Google Vertex "native" (non-AI-SDK) generateContent
+ * payload — either inline text or an inline base64 data blob.
+ */
+export type VertexNativePart = {
+    text: string;
+} | {
+    inlineData: {
+        mimeType: string;
+        data: string;
+    };
+};

package/dist/types/proxy.d.ts

@@ -13,7 +13,10 @@
  * - src/lib/proxy/accountQuota.ts (quota type)
  * - src/lib/server/routes/claudeProxyRoutes.ts (runtime state, deps)
  */
-import type { Span } from "@opentelemetry/api";
+import type { Counter, Histogram, Span } from "@opentelemetry/api";
+import type { Hono } from "hono";
+import type { Ora } from "ora";
+import type { MCPToolRegistry } from "../mcp/toolRegistry.js";
 import type { ProxyTracer } from "../proxy/proxyTracer.js";
 import type { FallbackEntry, ProxyRoutingConfig, CloakingConfig } from "./subscription.js";
 import type { RouteDeprecation } from "./server.js";
@@ -643,6 +646,10 @@ export type RuntimeAccountState = {
     permanentlyDisabled: boolean;
     lastToken?: string;
     lastRefreshToken?: string;
+    /** Epoch-ms timestamp until which the account should not be used for new
+     *  requests (set after 429 retries are exhausted). Other requests arriving
+     *  during this window will skip the account rather than hammering it again. */
+    coolingUntil?: number;
 };
 /** A passthrough account used in the proxy route handler. */
 export type ProxyPassthroughAccount = {
@@ -737,3 +744,316 @@ export type ProxyPaths = {
     /** Whether this is a dev-mode isolated instance */
     isDev: boolean;
 };
+/** OTel metric instruments used by the proxy tracer. */
+export type ProxyMetrics = {
+    requestsTotal: Counter;
+    requestDuration: Histogram;
+    tokensInput: Counter;
+    tokensOutput: Counter;
+    tokensCacheRead: Counter;
+    tokensCacheCreation: Counter;
+    tokensReasoning: Counter;
+    costTotal: Counter;
+    errorsTotal: Counter;
+    retriesTotal: Counter;
+    modelSubstitutionTotal: Counter;
+    requestBodySize: Histogram;
+    responseBodySize: Histogram;
+    fallbackAttemptsTotal: Counter;
+    fallbackSuccessTotal: Counter;
+    fallbackFailureTotal: Counter;
+};
+/** Context for a proxy request at the root span level. */
+export type ProxyRequestContext = {
+    requestId: string;
+    method: string;
+    path: string;
+    model: string;
+    stream: boolean;
+    toolCount: number;
+    sessionId?: string;
+    userAgent?: string;
+    clientApp?: string;
+};
+/** Context recorded when an account is selected for a proxy request. */
+export type AccountSelectionContext = {
+    strategy: string;
+    accountsTotal: number;
+    accountsHealthy: number;
+    selectedAccount: string;
+    accountType: string;
+    rateLimitBefore5h?: number;
+    rateLimitBefore7d?: number;
+};
+/** Context for a single upstream attempt (one per retry). */
+export type UpstreamAttemptContext = {
+    attempt: number;
+    account: string;
+    polyfillHeaders: boolean;
+    polyfillBody: boolean;
+    upstreamUrl: string;
+};
+/** Token usage and rate-limit utilisation recorded at end of request. */
+export type UsageContext = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    reasoningTokens?: number;
+    rateLimitAfter5h?: number;
+    rateLimitAfter7d?: number;
+};
+/** Where a proxy env file path was sourced from. */
+export type ProxyEnvSource = "cli" | "environment" | "default" | "none";
+/** Result of resolving which proxy env file to load. */
+export type ProxyEnvResolution = {
+    path?: string;
+    source: ProxyEnvSource;
+    required: boolean;
+};
+/** Result of loading the proxy env file. */
+export type ProxyEnvLoadResult = {
+    loaded: boolean;
+    path?: string;
+    source: ProxyEnvSource;
+};
+/** Options controlling proxy env file resolution. */
+export type ProxyEnvOptions = {
+    explicitEnvFile?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+};
+/** Snapshot of proxy-related environment variables captured at startup. */
+export type ProxyEnvironmentSnapshot = {
+    httpsProxy?: string;
+    httpProxy?: string;
+    allProxy?: string;
+    socksProxy?: string;
+    noProxy?: string;
+};
+/** Result of a traffic-quiet check. */
+export type QuietStatus = {
+    isQuiet: boolean;
+    lastActivityAt: Date | null;
+    silenceDurationMs: number;
+};
+/** Accumulated upstream body capture from a raw stream. */
+export type RawStreamCapture = {
+    totalBytes: number;
+    text: string;
+    truncated: boolean;
+};
+/** Transformed stream pair used to capture upstream bodies without buffering. */
+export type RawStreamCaptureResult = {
+    stream: TransformStream<Uint8Array, Uint8Array>;
+    capture: Promise<RawStreamCapture>;
+};
+/** Single captured body/headers entry written to disk by the proxy logger. */
+export type ProxyBodyCaptureEntry = {
+    timestamp: string;
+    requestId: string;
+    phase: string;
+    model: string;
+    stream: boolean;
+    headers?: Record<string, string>;
+    body?: unknown;
+    bodySize?: number;
+    contentType?: string;
+    responseStatus?: number;
+    durationMs?: number;
+    account?: string;
+    accountType?: string;
+    attempt?: number;
+    traceId?: string;
+    spanId?: string;
+    metadata?: Record<string, unknown>;
+};
+/** Persisted artifact produced when a body is stored to disk. */
+export type StoredBodyArtifact = {
+    bodyPath?: string;
+    bodySha256?: string;
+    redactedBodyBytes?: number;
+    storedFileBytes?: number;
+    redactedBody?: string;
+    bodyTruncated?: boolean;
+};
+/** File the proxy logger tracks for rotation and cleanup. */
+export type ManagedLogFile = {
+    path: string;
+    mtime: number;
+    size: number;
+};
+/** Individual content block observed during an SSE stream. */
+export type SSEContentBlock = {
+    index: number;
+    type: "text" | "thinking" | "tool_use" | "tool_result";
+    /** Accumulated text for text blocks. Capped at MAX_BLOCK_CONTENT_BYTES. */
+    text?: string;
+    /** Accumulated thinking content. Capped at MAX_BLOCK_CONTENT_BYTES. */
+    thinking?: string;
+    /** Tool name for tool_use blocks. */
+    toolName?: string;
+    /** Tool call id for tool_use blocks. */
+    toolId?: string;
+    /** Accumulated partial JSON input for tool_use blocks. Capped at MAX_BLOCK_CONTENT_BYTES. */
+    toolInput?: string;
+};
+/** Aggregated telemetry resolved when an SSE stream completes. */
+export type SSETelemetry = {
+    messageId: string;
+    model: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationInputTokens: number;
+        cacheReadInputTokens: number;
+        totalTokens: number;
+    };
+    contentBlocks: SSEContentBlock[];
+    stopReason: string | null;
+    stopSequence: string | null;
+    eventCount: number;
+    streamDurationMs: number;
+    totalBytesReceived: number;
+    events: Array<{
+        type: string;
+        timestamp: number;
+        data: string;
+    }>;
+    rawText?: string;
+};
+/** Mutable accumulator the SSE interceptor uses internally. */
+export type TelemetryAccumulator = {
+    messageId: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens: number;
+    cacheReadInputTokens: number;
+    contentBlocks: SSEContentBlock[];
+    blockByteCounts: Map<number, number>;
+    stopReason: string | null;
+    stopSequence: string | null;
+    eventCount: number;
+    startTime: number;
+    totalBytesReceived: number;
+    events: Array<{
+        type: string;
+        timestamp: number;
+        data: string;
+    }>;
+    rawTextChunks?: string[];
+    rawTextBytes: number;
+    rawTextTruncated: boolean;
+    eventLogTruncated: boolean;
+};
+/** Result of createSSEInterceptor: the pass-through stream and a telemetry promise. */
+export type SSEInterceptorResult = {
+    stream: TransformStream<Uint8Array, Uint8Array>;
+    telemetry: Promise<SSETelemetry>;
+};
+/** Options for createSSEInterceptor. */
+export type SSEInterceptorOptions = {
+    captureRawText?: boolean;
+};
+/** Outcome of a proxy auto-update version check against npm. */
+export type UpdateCheckResult = {
+    currentVersion: string;
+    latestVersion: string;
+    updateAvailable: boolean;
+};
+/** Parsed major.minor.patch components of a semver string. */
+export type SemVer = {
+    major: number;
+    minor: number;
+    patch: number;
+};
+/** Entry describing a version suppressed from auto-update. */
+export type SuppressedVersion = {
+    suppressedAt: string;
+    reason: string;
+};
+/** Persisted state for the proxy auto-update feature. */
+export type UpdateState = {
+    lastCheckAt: string;
+    lastCheckVersion: string;
+    suppressedVersions: Record<string, SuppressedVersion>;
+    lastUpdateAt: string | null;
+    lastUpdateVersion: string | null;
+};
+/** Shape of the dynamically-imported js-yaml module. */
+export type YamlModule = {
+    load(content: string): unknown;
+    default?: {
+        load(content: string): unknown;
+    };
+};
+/** Parsed fields captured from a Claude Code client request body. */
+export type ClaudeSnapshotBody = {
+    metadataUserId?: string;
+    billingHeader?: string;
+    agentBlock?: string;
+    sessionId?: string;
+};
+/** Snapshot of headers and body from a Claude Code request, used for polyfill. */
+export type ClaudeSnapshot = {
+    accountKey: string;
+    capturedAt: string;
+    source: "claude-code";
+    headers: Record<string, string>;
+    body?: ClaudeSnapshotBody;
+};
+/** Parsed shape of a Claude API error body. */
+export type ParsedClaudeError = {
+    errorType?: string;
+    message?: string;
+};
+/** ora spinner instance held by proxy CLI commands, nullable when --quiet. */
+export type ProxySpinner = Ora | null;
+/** Load-balancing strategy used by the proxy across accounts. */
+export type ProxyStartStrategy = "round-robin" | "fill-first";
+/** Alias for the model router's constructor configuration. */
+export type ProxyModelRouterConfig = ProxyRoutingConfig;
+/** Partial proxy config consumed by the start command. */
+export type LoadedProxyConfig = {
+    routing?: Partial<ProxyModelRouterConfig> & {
+        strategy?: ProxyStartStrategy;
+    };
+};
+/**
+ * Handle for a NeuroLink runtime created by the proxy start command.
+ * The `neurolink` field is typed structurally (only the method used by the
+ * proxy layer is exposed) so types/proxy.ts does not depend on the full
+ * NeuroLink class.
+ */
+export type ProxyNeurolinkRuntime = {
+    neurolink: {
+        getToolRegistry(): MCPToolRegistry;
+    };
+    cleanupLogs: (daysToKeep?: number, maxFiles?: number) => void;
+};
+/** Hono app + readiness state created by the proxy start command. */
+export type ProxyStartApp = {
+    app: Hono;
+    readiness: ProxyReadinessState;
+};
+/** Stats shape consumed by the proxy status printer. */
+export type StatusStats = {
+    totalAttempts?: number;
+    totalRequests: number;
+    totalSuccess: number;
+    totalErrors: number;
+    totalRateLimits: number;
+    accounts?: {
+        label: string;
+        type: string;
+        attempts?: number;
+        requests?: number;
+        success?: number;
+        errors?: number;
+        rateLimits?: number;
+        cooling: boolean;
+    }[];
+};
+/** Sub-action of the `proxy telemetry` CLI command. */
+export type ProxyTelemetryAction = "setup" | "start" | "stop" | "status" | "logs" | "import-dashboard";

package/dist/types/rag.d.ts

@@ -1271,3 +1271,25 @@ export type RAGCommandArgs = {
     /** Use Graph RAG */
     graph?: boolean;
 };
+/** Options for the recursive JSON chunk extractor. */
+export type ExtractChunksOptions = {
+    data: unknown;
+    path: string;
+    depth: number;
+    maxDepth: number;
+    maxSize: number;
+    splitKeys: string[];
+    preserveKeys: string[];
+    includeJsonPath: boolean;
+};
+/** Document processing state held by MDocument. */
+export type DocumentState = {
+    content: string;
+    type: DocumentType;
+    metadata: Record<string, unknown>;
+    chunks: Chunk[];
+    embeddings: number[][];
+    history: string[];
+};
+/** Canonical RAG error code. */
+export type RAGErrorCode = "RAG_CHUNKING_ERROR" | "RAG_CHUNKING_INVALID_CONFIG" | "RAG_CHUNKING_STRATEGY_NOT_FOUND" | "RAG_CHUNKING_EMPTY_CONTENT" | "RAG_CHUNKING_SIZE_EXCEEDED" | "RAG_METADATA_EXTRACTION_ERROR" | "RAG_METADATA_EXTRACTION_TIMEOUT" | "RAG_METADATA_SCHEMA_INVALID" | "RAG_METADATA_EXTRACTOR_NOT_FOUND" | "RAG_EMBEDDING_ERROR" | "RAG_EMBEDDING_DIMENSION_MISMATCH" | "RAG_EMBEDDING_RATE_LIMIT" | "RAG_EMBEDDING_PROVIDER_ERROR" | "RAG_VECTOR_QUERY_ERROR" | "RAG_VECTOR_QUERY_TIMEOUT" | "RAG_VECTOR_STORE_UNAVAILABLE" | "RAG_VECTOR_STORE_CONNECTION_ERROR" | "RAG_VECTOR_INDEX_NOT_FOUND" | "RAG_RERANKER_ERROR" | "RAG_RERANKER_NOT_FOUND" | "RAG_RERANKER_API_ERROR" | "RAG_GRAPH_ERROR" | "RAG_GRAPH_TRAVERSAL_ERROR" | "RAG_GRAPH_NODE_NOT_FOUND" | "RAG_PIPELINE_ERROR" | "RAG_PIPELINE_STAGE_FAILED" | "RAG_PIPELINE_PARTIAL_FAILURE" | "RAG_CIRCUIT_BREAKER_OPEN" | "RAG_CIRCUIT_BREAKER_HALF_OPEN_LIMIT" | "RAG_OPERATION_TIMEOUT" | "RAG_RETRY_EXHAUSTED" | "RAG_INVALID_CONFIGURATION";