@juspay/neurolink 9.41.0 → 9.42.0

package/dist/lib/auth/sessionManager.js

@@ -1,4 +1,5 @@
 // src/lib/auth/sessionManager.ts
+import { withTimeout } from "../utils/async/withTimeout.js";
 import { logger } from "../utils/logger.js";
 /** Mask an identifier for safe logging: show first 4 chars + "***" */
 function maskId(id) {
@@ -7,6 +8,7 @@ function maskId(id) {
     }
     return `${id.slice(0, 4)}***`;
 }
+const REDIS_CONNECT_TIMEOUT_MS = 5000;
 /**
  * In-memory session storage
  *
@@ -31,10 +33,12 @@ export class MemorySessionStorage {
     async set(session) {
         this.sessions.set(session.id, session);
         // Track user's sessions
-        if (!this.userSessions.has(session.user.id)) {
-            this.userSessions.set(session.user.id, new Set());
+        let sessionIds = this.userSessions.get(session.user.id);
+        if (!sessionIds) {
+            sessionIds = new Set();
+            this.userSessions.set(session.user.id, sessionIds);
         }
-        this.userSessions.get(session.user.id).add(session.id);
+        sessionIds.add(session.id);
     }
     async delete(sessionId) {
         const session = this.sessions.get(sessionId);
@@ -84,7 +88,7 @@ export class MemorySessionStorage {
  * Redis session storage
  *
  * Distributed session storage using Redis. Suitable for multi-instance
- * deployments. Requires ioredis or similar Redis client.
+ * deployments. Requires the "redis" (node-redis) package.
  *
  * Note: Redis client must be provided or configured via environment.
  */
@@ -111,16 +115,25 @@ export class RedisSessionStorage {
     async createClient() {
         try {
             // Use variable indirection to prevent TypeScript from resolving the module at compile time
-            const moduleName = "ioredis";
-            const ioredis = await import(/* @vite-ignore */ moduleName);
-            const Redis = ioredis.default || ioredis.Redis;
-            this.client = new Redis(this.redisUrl);
-            return this.client;
+            const moduleName = "redis";
+            const redisModule = (await import(
+            /* @vite-ignore */ moduleName));
+            const client = redisModule.createClient({
+                url: this.redisUrl,
+            });
+            client.on("error", (err) => {
+                logger.error("Redis session client error:", err.message);
+            });
+            await withTimeout(client.connect(), REDIS_CONNECT_TIMEOUT_MS, `Redis session client connect timed out after ${REDIS_CONNECT_TIMEOUT_MS}ms`);
+            this.client = client;
+            return client;
         }
-        catch {
+        catch (error) {
             this.initPromise = null;
-            logger.error('Redis client (ioredis) not available. Install ioredis package and ensure Redis is reachable when using storage: "redis".');
-            throw new Error("Redis client not available");
+            logger.error('Redis client not available. Ensure the "redis" package is installed and Redis is reachable when using storage: "redis".');
+            throw error instanceof Error
+                ? error
+                : new Error("Redis client not available");
         }
     }
     sessionKey(sessionId) {
@@ -136,6 +149,13 @@ export class RedisSessionStorage {
             if (!data) {
                 return null;
             }
+            if (typeof data !== "string") {
+                logger.warn("Unexpected Redis session payload type", {
+                    sessionId: maskId(sessionId),
+                    type: typeof data,
+                });
+                return null;
+            }
             const session = JSON.parse(data);
             // Parse dates
             session.createdAt = new Date(session.createdAt);
@@ -143,7 +163,7 @@ export class RedisSessionStorage {
                 session.expiresAt = new Date(session.expiresAt);
             }
             // Check expiration
-            if (new Date() > session.expiresAt) {
+            if (session.expiresAt && new Date() > session.expiresAt) {
                 await this.delete(sessionId);
                 return null;
             }
@@ -162,9 +182,9 @@ export class RedisSessionStorage {
                 ? Math.max(1, Math.floor((session.expiresAt.getTime() - Date.now()) / 1000))
                 : this.ttl;
             // Store session
-            await client.setex(this.sessionKey(session.id), ttlSeconds, JSON.stringify(session));
+            await client.setEx(this.sessionKey(session.id), ttlSeconds, JSON.stringify(session));
             // Track user's sessions
-            await client.sadd(this.userSessionsKey(session.user.id), session.id);
+            await client.sAdd(this.userSessionsKey(session.user.id), session.id);
             await client.expire(this.userSessionsKey(session.user.id), this.ttl);
         }
         catch (error) {
@@ -180,13 +200,21 @@ export class RedisSessionStorage {
             // recursion for expired sessions.
             const data = await client.get(this.sessionKey(sessionId));
             if (data) {
-                try {
-                    const session = JSON.parse(data);
-                    await client.srem(this.userSessionsKey(session.user.id), sessionId);
+                if (typeof data !== "string") {
+                    logger.warn("Unexpected Redis session payload type during delete", {
+                        sessionId: maskId(sessionId),
+                        type: typeof data,
+                    });
                 }
-                catch {
-                    // If parsing fails, we still delete the key below
-                    logger.warn(`Failed to parse session data for cleanup: ${maskId(sessionId)}`);
+                else {
+                    try {
+                        const session = JSON.parse(data);
+                        await client.sRem(this.userSessionsKey(session.user.id), sessionId);
+                    }
+                    catch {
+                        // If parsing fails, we still delete the key below
+                        logger.warn(`Failed to parse session data for cleanup: ${maskId(sessionId)}`);
+                    }
                 }
             }
             await client.del(this.sessionKey(sessionId));
@@ -198,7 +226,7 @@ export class RedisSessionStorage {
     async getUserSessions(userId) {
         try {
             const client = await this.getClient();
-            const sessionIds = await client.smembers(this.userSessionsKey(userId));
+            const sessionIds = await client.sMembers(this.userSessionsKey(userId));
             const sessions = [];
             for (const sessionId of sessionIds) {
                 const session = await this.get(sessionId);
@@ -216,7 +244,7 @@ export class RedisSessionStorage {
     async deleteUserSessions(userId) {
         try {
             const client = await this.getClient();
-            const sessionIds = await client.smembers(this.userSessionsKey(userId));
+            const sessionIds = await client.sMembers(this.userSessionsKey(userId));
             for (const sessionId of sessionIds) {
                 await client.del(this.sessionKey(sessionId));
             }
@@ -232,10 +260,13 @@ export class RedisSessionStorage {
             // Use SCAN instead of KEYS to avoid blocking Redis in production
             let cursor = "0";
             do {
-                const [nextCursor, keys] = await client.scan(cursor, "MATCH", `${this.prefix}*`, "COUNT", "100");
-                cursor = nextCursor;
-                if (keys.length > 0) {
-                    await client.del(...keys);
+                const result = await client.scan(cursor, {
+                    MATCH: `${this.prefix}*`,
+                    COUNT: 100,
+                });
+                cursor = result.cursor;
+                if (result.keys.length > 0) {
+                    await client.del(result.keys);
                 }
             } while (cursor !== "0");
         }

package/dist/lib/client/aiSdkAdapter.js

@@ -186,6 +186,9 @@ export class NeuroLinkLanguageModel {
                 // Drain anything already buffered.
                 while (buffer.length > 0) {
                     const chunk = buffer.shift();
+                    if (!chunk) {
+                        break;
+                    }
                     yield chunk;
                     if (chunk.type === "finish") {
                         return;

package/dist/lib/client/streamingClient.js

@@ -251,10 +251,12 @@ export class SSEClient {
      * Register event handler
      */
     on(event, callback) {
-        if (!this.eventHandlers.has(event)) {
-            this.eventHandlers.set(event, new Set());
+        let handlers = this.eventHandlers.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this.eventHandlers.set(event, handlers);
         }
-        this.eventHandlers.get(event).add(callback);
+        handlers.add(callback);
     }
     /**
      * Remove event handler
@@ -315,7 +317,11 @@ export class SSEClient {
             });
             while (!done && !error) {
                 if (events.length > 0) {
-                    yield events.shift();
+                    const nextEvent = events.shift();
+                    if (!nextEvent) {
+                        continue;
+                    }
+                    yield nextEvent;
                 }
                 else {
                     await new Promise((resolve) => {
@@ -325,7 +331,11 @@ export class SSEClient {
             }
             // Yield remaining events
             while (events.length > 0) {
-                yield events.shift();
+                const nextEvent = events.shift();
+                if (!nextEvent) {
+                    continue;
+                }
+                yield nextEvent;
             }
             if (error) {
                 throw error;
@@ -545,10 +555,12 @@ export class WebSocketStreamingClient {
      * Register event handler
      */
     on(event, callback) {
-        if (!this.eventHandlers.has(event)) {
-            this.eventHandlers.set(event, new Set());
+        let handlers = this.eventHandlers.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this.eventHandlers.set(event, handlers);
         }
-        this.eventHandlers.get(event).add(callback);
+        handlers.add(callback);
     }
     /**
      * Remove event handler
@@ -591,7 +603,11 @@ export class WebSocketStreamingClient {
         try {
             while (!disconnected) {
                 if (messageQueue.length > 0) {
-                    yield messageQueue.shift();
+                    const nextMessage = messageQueue.shift();
+                    if (nextMessage === undefined) {
+                        continue;
+                    }
+                    yield nextMessage;
                 }
                 else {
                     await new Promise((resolve) => {
@@ -601,7 +617,11 @@ export class WebSocketStreamingClient {
             }
             // Yield remaining messages
             while (messageQueue.length > 0) {
-                yield messageQueue.shift();
+                const nextMessage = messageQueue.shift();
+                if (nextMessage === undefined) {
+                    continue;
+                }
+                yield nextMessage;
             }
         }
         finally {

package/dist/lib/core/modules/GenerationHandler.js

@@ -95,6 +95,7 @@ export class GenerationHandler {
                 };
             }
         }
+        const prepareStep = options.prepareStep;
         return await generateText({
             model,
             messages,
@@ -103,8 +104,8 @@ export class GenerationHandler {
             stopWhen: stepCountIs(options.maxSteps ?? DEFAULT_MAX_STEPS),
             ...(shouldUseTools &&
                 options.toolChoice && { toolChoice: options.toolChoice }),
-            ...(options.prepareStep && {
-                experimental_prepareStep: ((stepOptions) => options.prepareStep({
+            ...(prepareStep && {
+                experimental_prepareStep: ((stepOptions) => prepareStep({
                     ...stepOptions,
                     maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS,
                 })),

package/dist/lib/core/redisConversationMemoryManager.js

@@ -16,6 +16,7 @@ import { runWithCurrentLangfuseContext } from "../services/server/ai/observabili
 import { logger } from "../utils/logger.js";
 import { createRedisClient, deserializeConversation, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
 const redisTracer = tracers.redis;
+const REDIS_TIMEOUT_MS = 5000;
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -130,13 +131,14 @@ export class RedisConversationMemoryManager {
         if (!this.redisClient) {
             return undefined;
         }
+        const redisClient = this.redisClient;
         return redisTracer.startActiveSpan("neurolink.memory.getSession", { kind: SpanKind.CLIENT, attributes: { "session.id": sessionId } }, async (span) => {
             if (userId) {
                 span.setAttribute("user.id", userId);
             }
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const conversationData = await this.redisClient.get(redisKey);
+                const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
                 const conversation = deserializeConversation(conversationData || null);
                 if (!conversation) {
                     span.setAttribute("session.found", false);
@@ -630,6 +632,7 @@ export class RedisConversationMemoryManager {
             logger.warn("[RedisConversationMemoryManager] Redis client not available in buildContextMessages");
             return [];
         }
+        const redisClient = this.redisClient;
         // NLK-GAP-012: Add span for buildContext CRUD operation
         return redisTracer.startActiveSpan("neurolink.memory.buildContext", {
             kind: SpanKind.CLIENT,
@@ -645,7 +648,7 @@ export class RedisConversationMemoryManager {
                     method: "buildContextMessages",
                 });
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const conversationData = await this.redisClient.get(redisKey);
+                const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
                 const conversation = deserializeConversation(conversationData || null);
                 if (!conversation) {
                     span.setAttribute("session.found", false);
@@ -1080,6 +1083,7 @@ User message: "${userMessage}"`;
         if (!this.redisClient) {
             return false;
         }
+        const redisClient = this.redisClient;
         // NLK-GAP-012: Add span for clearSession CRUD operation
         return redisTracer.startActiveSpan("neurolink.memory.clear", {
             kind: SpanKind.CLIENT,
@@ -1090,7 +1094,7 @@ User message: "${userMessage}"`;
         }, async (span) => {
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const result = await this.redisClient.del(redisKey);
+                const result = await withTimeout(redisClient.del(redisKey), REDIS_TIMEOUT_MS);
                 if (Number(result) > 0) {
                     // Remove session from user's session set
                     if (userId) {

package/dist/lib/evaluation/BatchEvaluator.js

@@ -6,6 +6,9 @@ import { Evaluator } from "./index.js";
 import { createBatchEvaluationError, isRetryableEvaluationError, } from "./errors/EvaluationError.js";
 import { logger } from "../utils/logger.js";
 import { NeuroLinkFeatureError } from "../core/infrastructure/index.js";
+function hasEvaluationData(result) {
+    return result.success && result.data !== undefined;
+}
 /**
  * BatchEvaluator - Performs evaluation on multiple items in parallel.
  * Supports configurable concurrency, retry logic, and progress tracking.
@@ -201,7 +204,7 @@ export class BatchEvaluator {
             }
         }
         // Calculate summary statistics
-        const successfulResults = results.filter((r) => r.success && r.data);
+        const successfulResults = results.filter(hasEvaluationData);
         const scores = successfulResults.map((r) => r.data.overall);
         const passingScores = successfulResults.filter((r) => r.data.overall >=
             (autoEvalConfig.threshold || this.config.threshold || 7));

package/dist/lib/evaluation/hooks/observabilityHooks.js

@@ -41,10 +41,12 @@ export class ObservabilityHooks {
      * Register an event handler
      */
     on(event, handler) {
-        if (!this._handlers.has(event)) {
-            this._handlers.set(event, new Set());
+        let handlers = this._handlers.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this._handlers.set(event, handlers);
         }
-        this._handlers.get(event).add(handler);
+        handlers.add(handler);
         // Return unsubscribe function
         return () => {
             this._handlers.get(event)?.delete(handler);

package/dist/lib/evaluation/pipeline/evaluationPipeline.d.ts

@@ -12,9 +12,9 @@ export type PipelineExecutionOptions = {
     correlationId?: string;
     /** Custom timeout override */
     timeout?: number;
-    /** Skip specific scorers */
+    /** Skip specific scorers. Mutually exclusive with onlyScorers. */
     skipScorers?: string[];
-    /** Only run specific scorers */
+    /** Only run specific scorers. Mutually exclusive with skipScorers. */
     onlyScorers?: string[];
     /** Additional metadata to attach */
     metadata?: JsonObject;
@@ -59,6 +59,7 @@ export declare class EvaluationPipeline {
      * Execute the pipeline on input
      */
     execute(input: ScorerInput, options?: PipelineExecutionOptions): Promise<PipelineResult>;
+    private _validateExecutionOptions;
     /**
      * Get scorers to run based on options
      */

package/dist/lib/evaluation/pipeline/evaluationPipeline.js

@@ -91,6 +91,7 @@ export class EvaluationPipeline {
         if (!this._initialized) {
             await this.initialize();
         }
+        this._validateExecutionOptions(options);
         const startTime = Date.now();
         const correlationId = options?.correlationId ?? `pipeline-${Date.now()}`;
         logger.debug(`Executing pipeline: ${this._config.name ?? "unnamed"}`, {
@@ -173,16 +174,25 @@ export class EvaluationPipeline {
             skippedScorers,
         };
     }
+    _validateExecutionOptions(options) {
+        const hasOnlyScorers = !!options?.onlyScorers && options.onlyScorers.length > 0;
+        const hasSkipScorers = !!options?.skipScorers && options.skipScorers.length > 0;
+        if (hasOnlyScorers && hasSkipScorers) {
+            throw new Error("Cannot specify both 'onlyScorers' and 'skipScorers' options");
+        }
+    }
     /**
      * Get scorers to run based on options
      */
     _getScorersToRun(options) {
         const allScorers = Array.from(this._scorers.entries());
-        if (options?.onlyScorers && options.onlyScorers.length > 0) {
-            return allScorers.filter(([id]) => options.onlyScorers.includes(id));
+        const onlyScorers = options?.onlyScorers;
+        const skipScorers = options?.skipScorers;
+        if (onlyScorers && onlyScorers.length > 0) {
+            return allScorers.filter(([id]) => onlyScorers.includes(id));
         }
-        if (options?.skipScorers && options.skipScorers.length > 0) {
-            return allScorers.filter(([id]) => !options.skipScorers.includes(id));
+        if (skipScorers && skipScorers.length > 0) {
+            return allScorers.filter(([id]) => !skipScorers.includes(id));
         }
         return allScorers;
     }
@@ -191,11 +201,13 @@ export class EvaluationPipeline {
      */
     _getSkippedScorers(options) {
         const allIds = Array.from(this._scorers.keys());
-        if (options?.onlyScorers && options.onlyScorers.length > 0) {
-            return allIds.filter((id) => !options.onlyScorers.includes(id));
+        const onlyScorers = options?.onlyScorers;
+        const skipScorers = options?.skipScorers;
+        if (onlyScorers && onlyScorers.length > 0) {
+            return allIds.filter((id) => !onlyScorers.includes(id));
         }
-        if (options?.skipScorers && options.skipScorers.length > 0) {
-            return options.skipScorers.filter((id) => allIds.includes(id));
+        if (skipScorers && skipScorers.length > 0) {
+            return skipScorers.filter((id) => allIds.includes(id));
         }
         return [];
     }

package/dist/lib/evaluation/pipeline/strategies/batchStrategy.js

@@ -2,6 +2,9 @@
  * @file Batch Strategy
  * Batch processing for evaluation pipelines
  */
+function hasPipelineResult(result) {
+    return !result.error && result.result !== undefined;
+}
 /**
  * Default batch configuration
  */
@@ -66,7 +69,7 @@ export class BatchStrategy {
         }
         // Calculate summary
         const totalDuration = Date.now() - startTime;
-        const successfulResults = results.filter((r) => !r.error && r.result);
+        const successfulResults = results.filter(hasPipelineResult);
         const scores = successfulResults.map((r) => r.result.overallScore);
         const passed = successfulResults.filter((r) => r.result.passed);
         return {
@@ -192,7 +195,7 @@ export async function* streamBatchEvaluation(pipeline, inputs, config) {
             durations.push(result.duration);
             // If continueOnError is false and this result has an error, abort and return summary
             if (result.error && batchConfig.continueOnError === false) {
-                const successfulResults = results.filter((r) => !r.error && r.result);
+                const successfulResults = results.filter(hasPipelineResult);
                 const earlyScores = successfulResults.map((r) => r.result.overallScore);
                 const earlyPassed = successfulResults.filter((r) => r.result.passed);
                 return {
@@ -219,7 +222,7 @@ export async function* streamBatchEvaluation(pipeline, inputs, config) {
         }
     }
     // Return summary
-    const successfulResults = results.filter((r) => !r.error && r.result);
+    const successfulResults = results.filter(hasPipelineResult);
     const scores = successfulResults.map((r) => r.result.overallScore);
     const passed = successfulResults.filter((r) => r.result.passed);
     return {

package/dist/lib/evaluation/pipeline/strategies/samplingStrategy.js

@@ -17,6 +17,12 @@ export const DEFAULT_SAMPLING_CONFIG = {
         maxRate: 1.0,
     },
 };
+const DEFAULT_ADAPTIVE_CONFIG = {
+    enabled: false,
+    qualityThreshold: 0.7,
+    minRate: 0.1,
+    maxRate: 1.0,
+};
 /**
  * Sampling strategy for evaluation
  */
@@ -27,9 +33,10 @@ export class SamplingStrategy {
     _maxRecentScores = 100;
     constructor(config = {}) {
         const clamp01 = (v) => Math.max(0, Math.min(1, v));
+        const defaultAdaptive = DEFAULT_SAMPLING_CONFIG.adaptive ?? DEFAULT_ADAPTIVE_CONFIG;
         const rawRate = config.rate ?? DEFAULT_SAMPLING_CONFIG.rate;
-        const rawMinRate = config.adaptive?.minRate ?? DEFAULT_SAMPLING_CONFIG.adaptive.minRate;
-        const rawMaxRate = config.adaptive?.maxRate ?? DEFAULT_SAMPLING_CONFIG.adaptive.maxRate;
+        const rawMinRate = config.adaptive?.minRate ?? defaultAdaptive.minRate;
+        const rawMaxRate = config.adaptive?.maxRate ?? defaultAdaptive.maxRate;
         const minRate = clamp01(Math.min(rawMinRate, rawMaxRate));
         const maxRate = clamp01(Math.max(rawMinRate, rawMaxRate));
         this._config = {
@@ -41,9 +48,8 @@ export class SamplingStrategy {
                 ...(config.alwaysEvaluate ?? {}),
             },
             adaptive: {
-                enabled: config.adaptive?.enabled ?? DEFAULT_SAMPLING_CONFIG.adaptive.enabled,
-                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ??
-                    DEFAULT_SAMPLING_CONFIG.adaptive.qualityThreshold),
+                enabled: config.adaptive?.enabled ?? defaultAdaptive.enabled,
+                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ?? defaultAdaptive.qualityThreshold),
                 minRate,
                 maxRate,
             },
@@ -156,9 +162,12 @@ export class SamplingStrategy {
      */
     configure(config) {
         const clamp01 = (v) => Math.max(0, Math.min(1, v));
+        const currentAdaptive = this._config.adaptive ??
+            DEFAULT_SAMPLING_CONFIG.adaptive ??
+            DEFAULT_ADAPTIVE_CONFIG;
         const rawRate = config.rate ?? this._config.rate;
-        const rawMinRate = config.adaptive?.minRate ?? this._config.adaptive.minRate;
-        const rawMaxRate = config.adaptive?.maxRate ?? this._config.adaptive.maxRate;
+        const rawMinRate = config.adaptive?.minRate ?? currentAdaptive.minRate;
+        const rawMaxRate = config.adaptive?.maxRate ?? currentAdaptive.maxRate;
         const minRate = clamp01(Math.min(rawMinRate, rawMaxRate));
         const maxRate = clamp01(Math.max(rawMinRate, rawMaxRate));
         this._config = {
@@ -170,9 +179,8 @@ export class SamplingStrategy {
                 ...(config.alwaysEvaluate ?? {}),
             },
             adaptive: {
-                enabled: config.adaptive?.enabled ?? this._config.adaptive.enabled,
-                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ??
-                    this._config.adaptive.qualityThreshold),
+                enabled: config.adaptive?.enabled ?? currentAdaptive.enabled,
+                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ?? currentAdaptive.qualityThreshold),
                 minRate,
                 maxRate,
             },

package/dist/lib/neurolink.d.ts

@@ -13,8 +13,9 @@ import type { MCPToolAnnotations } from "./mcp/toolAnnotations.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
 import type { MetricsSummary, TraceView } from "./observability/metricsAggregator.js";
 import type { SpanData } from "./observability/types/spanTypes.js";
-import type { JsonObject, NeuroLinkEvents, TypedEventEmitter } from "./types/common.js";
+import { TaskManager } from "./tasks/taskManager.js";
 import type { AuthenticatedContext, MastraAuthProvider } from "./types/authTypes.js";
+import type { JsonObject, NeuroLinkEvents, TypedEventEmitter } from "./types/common.js";
 import type { MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig } from "./types/configTypes.js";
 import type { ChatMessage } from "./types/conversation.js";
 import type { ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo } from "./types/externalMcp.js";
@@ -25,7 +26,6 @@ import type { ObservabilityConfig } from "./types/observability.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
 import type { ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions } from "./types/tools.js";
 import type { BatchOperationResult } from "./types/typeAliases.js";
-import { TaskManager } from "./tasks/taskManager.js";
 export declare class NeuroLink {
     private mcpInitialized;
     private mcpSkipped;
@@ -1909,6 +1909,7 @@ export declare class NeuroLink {
      * @param config - Auth provider or configuration to create one
      */
     setAuthProvider(config: NeuroLinkAuthConfig): Promise<void>;
+    private initializeAuthProviderFromConfig;
     /**
      * Get the currently configured authentication provider
      */