@juspay/neurolink 9.41.0 → 9.42.1

package/dist/tasks/backends/bullmqBackend.js

@@ -62,45 +62,51 @@ export class BullMQBackend {
         logger.info("[BullMQ] Backend shut down");
     }
     async schedule(task, executor) {
-        this.ensureInitialized();
+        const queue = this.getQueue();
         this.executors.set(task.id, executor);
-        const jobData = { taskId: task.id, task };
-        const schedule = task.schedule;
-        if (schedule.type === "cron") {
-            await this.queue.upsertJobScheduler(task.id, {
-                pattern: schedule.expression,
-                ...(schedule.timezone ? { tz: schedule.timezone } : {}),
-            }, { name: task.name, data: jobData });
-        }
-        else if (schedule.type === "interval") {
-            await this.queue.upsertJobScheduler(task.id, { every: schedule.every }, { name: task.name, data: jobData });
+        try {
+            const jobData = { taskId: task.id, task };
+            const schedule = task.schedule;
+            if (schedule.type === "cron") {
+                await queue.upsertJobScheduler(task.id, {
+                    pattern: schedule.expression,
+                    ...(schedule.timezone ? { tz: schedule.timezone } : {}),
+                }, { name: task.name, data: jobData });
+            }
+            else if (schedule.type === "interval") {
+                await queue.upsertJobScheduler(task.id, { every: schedule.every }, { name: task.name, data: jobData });
+            }
+            else if (schedule.type === "once") {
+                const at = typeof schedule.at === "string" ? new Date(schedule.at) : schedule.at;
+                const delay = Math.max(0, at.getTime() - Date.now());
+                await queue.add(task.name, jobData, {
+                    jobId: task.id,
+                    delay,
+                });
+            }
         }
-        else if (schedule.type === "once") {
-            const at = typeof schedule.at === "string" ? new Date(schedule.at) : schedule.at;
-            const delay = Math.max(0, at.getTime() - Date.now());
-            await this.queue.add(task.name, jobData, {
-                jobId: task.id,
-                delay,
-            });
+        catch (error) {
+            this.executors.delete(task.id);
+            throw error;
         }
         logger.info("[BullMQ] Task scheduled", {
             taskId: task.id,
-            type: schedule.type,
+            type: task.schedule.type,
         });
     }
     async cancel(taskId) {
-        this.ensureInitialized();
+        const queue = this.getQueue();
         this.executors.delete(taskId);
         // Remove repeatable job scheduler
         try {
-            await this.queue.removeJobScheduler(taskId);
+            await queue.removeJobScheduler(taskId);
         }
         catch {
             // May not be a repeatable job — try removing by job ID
         }
         // Remove delayed/waiting job
         try {
-            const job = await this.queue.getJob(taskId);
+            const job = await queue.getJob(taskId);
             if (job) {
                 await job.remove();
             }
@@ -185,4 +191,11 @@ export class BullMQBackend {
             throw TaskError.create("BACKEND_NOT_INITIALIZED", "[BullMQ] Backend not initialized. Call initialize() first.");
         }
     }
+    getQueue() {
+        this.ensureInitialized();
+        if (!this.queue) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[BullMQ] Queue is unavailable after initialization.");
+        }
+        return this.queue;
+    }
 }

package/dist/tasks/store/redisTaskStore.d.ts

@@ -34,6 +34,7 @@ export declare class RedisTaskStore implements TaskStore {
     getHistory(taskId: string): Promise<ConversationEntry[]>;
     clearHistory(taskId: string): Promise<void>;
     private ensureConnected;
+    private getClient;
     /**
      * Set Redis TTL on terminal-state tasks so they auto-expire.
      * Active and paused tasks never expire.

package/dist/tasks/store/redisTaskStore.js

@@ -61,21 +61,21 @@ export class RedisTaskStore {
     }
     // ── Task CRUD ───────────────────────────────────────────
     async save(task) {
-        this.ensureConnected();
-        await this.client.hSet(TASKS_HASH, task.id, JSON.stringify(task));
-        this.applyRetentionTTL(task);
+        const client = this.getClient();
+        await client.hSet(TASKS_HASH, task.id, JSON.stringify(task));
+        this.applyRetentionTTL(task, client);
     }
     async get(taskId) {
-        this.ensureConnected();
-        const data = await this.client.hGet(TASKS_HASH, taskId);
+        const client = this.getClient();
+        const data = await client.hGet(TASKS_HASH, taskId);
         if (!data) {
             return null;
         }
         return JSON.parse(String(data));
     }
     async list(filter) {
-        this.ensureConnected();
-        const all = await this.client.hGetAll(TASKS_HASH);
+        const client = this.getClient();
+        const all = await client.hGetAll(TASKS_HASH);
         let tasks = Object.values(all).map((v) => JSON.parse(String(v)));
         if (filter?.status) {
             tasks = tasks.filter((t) => t.status === filter.status);
@@ -83,7 +83,7 @@ export class RedisTaskStore {
         return tasks.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
     }
     async update(taskId, updates) {
-        this.ensureConnected();
+        const client = this.getClient();
         const existing = await this.get(taskId);
         if (!existing) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
@@ -94,35 +94,35 @@ export class RedisTaskStore {
             id: existing.id, // ID is immutable
             updatedAt: new Date().toISOString(),
         };
-        await this.client.hSet(TASKS_HASH, taskId, JSON.stringify(updated));
-        this.applyRetentionTTL(updated);
+        await client.hSet(TASKS_HASH, taskId, JSON.stringify(updated));
+        this.applyRetentionTTL(updated, client);
         return updated;
     }
     async delete(taskId) {
-        this.ensureConnected();
+        const client = this.getClient();
         await Promise.all([
-            this.client.hDel(TASKS_HASH, taskId),
-            this.client.del(taskRunsKey(taskId)),
-            this.client.del(taskHistoryKey(taskId)),
+            client.hDel(TASKS_HASH, taskId),
+            client.del(taskRunsKey(taskId)),
+            client.del(taskHistoryKey(taskId)),
         ]);
     }
     // ── Run Logs ──────────────────────────────────────────
     async appendRun(taskId, run) {
-        this.ensureConnected();
+        const client = this.getClient();
         const key = taskRunsKey(taskId);
-        await this.client.lPush(key, JSON.stringify(run));
+        await client.lPush(key, JSON.stringify(run));
         // Trim to keep only the latest maxRunLogs entries
-        await this.client.lTrim(key, 0, this.maxRunLogs - 1);
+        await client.lTrim(key, 0, this.maxRunLogs - 1);
     }
     async getRuns(taskId, options) {
-        this.ensureConnected();
+        const client = this.getClient();
         const limit = options?.limit ?? 20;
         const key = taskRunsKey(taskId);
         // When a status filter is applied, we need to fetch more items than `limit`
         // because post-filter may discard many entries. Fetch all (-1) when filtering,
         // otherwise fetch exactly `limit` items.
         const fetchEnd = options?.status ? -1 : limit - 1;
-        const items = await this.client.lRange(key, 0, fetchEnd);
+        const items = await client.lRange(key, 0, fetchEnd);
         let runs = items.map((v) => JSON.parse(String(v)));
         if (options?.status) {
             runs = runs.filter((r) => r.status === options.status);
@@ -131,24 +131,24 @@ export class RedisTaskStore {
     }
     // ── Continuation History ──────────────────────────────
     async appendHistory(taskId, messages) {
-        this.ensureConnected();
+        const client = this.getClient();
         const key = taskHistoryKey(taskId);
         const serialized = messages.map((m) => JSON.stringify(m));
         if (serialized.length > 0) {
-            await this.client.rPush(key, serialized);
+            await client.rPush(key, serialized);
             // Trim to keep only the most recent entries, preventing unbounded growth
-            await this.client.lTrim(key, -this.maxHistoryEntries, -1);
+            await client.lTrim(key, -this.maxHistoryEntries, -1);
         }
     }
     async getHistory(taskId) {
-        this.ensureConnected();
+        const client = this.getClient();
         const key = taskHistoryKey(taskId);
-        const items = await this.client.lRange(key, 0, -1);
+        const items = await client.lRange(key, 0, -1);
         return items.map((v) => JSON.parse(String(v)));
     }
     async clearHistory(taskId) {
-        this.ensureConnected();
-        await this.client.del(taskHistoryKey(taskId));
+        const client = this.getClient();
+        await client.del(taskHistoryKey(taskId));
     }
     // ── Internal ──────────────────────────────────────────
     ensureConnected() {
@@ -156,11 +156,18 @@ export class RedisTaskStore {
             throw TaskError.create("BACKEND_NOT_INITIALIZED", "[TaskStore:Redis] Not connected. Call initialize() first.");
         }
     }
+    getClient() {
+        this.ensureConnected();
+        if (!this.client) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[TaskStore:Redis] Client is unavailable after initialization.");
+        }
+        return this.client;
+    }
     /**
      * Set Redis TTL on terminal-state tasks so they auto-expire.
      * Active and paused tasks never expire.
      */
-    applyRetentionTTL(task) {
+    applyRetentionTTL(task, client) {
         // We don't set EXPIRE on the hash field directly (Redis doesn't support per-field TTL).
         // Instead, run logs and history keys get TTL. The task hash field itself must be
         // cleaned up via manual deletion or BullMQ's built-in job cleanup.
@@ -170,19 +177,27 @@ export class RedisTaskStore {
             cancelled: this.retentionConfig.cancelledTTL,
         };
         const ttlMs = ttlMap[task.status];
-        if (ttlMs) {
-            const ttlSeconds = Math.ceil(ttlMs / 1000);
-            // Set TTL on associated keys
-            this.client.expire(taskRunsKey(task.id), ttlSeconds).catch((err) => {
-                logger.debug("[TaskStore:Redis] Failed to set TTL", {
-                    error: String(err),
-                });
+        if (!ttlMs || !client.isOpen) {
+            return;
+        }
+        const ttlSeconds = Math.ceil(ttlMs / 1000);
+        // Set TTL on associated keys best-effort. A successful task write should not
+        // be surfaced as a failure just because the retention metadata could not be updated.
+        client.expire(taskRunsKey(task.id), ttlSeconds).catch((err) => {
+            logger.warn("[TaskStore:Redis] Failed to set TTL on task runs key — task data may outlive retention window", {
+                taskId: task.id,
+                key: taskRunsKey(task.id),
+                ttlSeconds,
+                error: String(err),
             });
-            this.client.expire(taskHistoryKey(task.id), ttlSeconds).catch((err) => {
-                logger.debug("[TaskStore:Redis] Failed to set TTL", {
-                    error: String(err),
-                });
+        });
+        client.expire(taskHistoryKey(task.id), ttlSeconds).catch((err) => {
+            logger.warn("[TaskStore:Redis] Failed to set TTL on task history key — task data may outlive retention window", {
+                taskId: task.id,
+                key: taskHistoryKey(task.id),
+                ttlSeconds,
+                error: String(err),
             });
-        }
+        });
     }
 }

package/dist/tasks/taskManager.d.ts

@@ -28,6 +28,9 @@ export declare class TaskManager {
     }): void;
     private ensureInitialized;
     private doInitialize;
+    private getStore;
+    private getBackend;
+    private getExecutor;
     create(definition: TaskDefinition): Promise<Task>;
     get(taskId: string): Promise<Task | null>;
     list(filter?: {
@@ -46,6 +49,8 @@ export declare class TaskManager {
     shutdown(): Promise<void>;
     /** Check if the backend is healthy */
     isHealthy(): Promise<boolean>;
+    private restoreScheduledTask;
+    private rollbackTaskUpdate;
     /**
      * Called by the backend on each scheduled tick.
      * Executes the task, updates state, fires callbacks/events.

package/dist/tasks/taskManager.js

@@ -70,15 +70,35 @@ export class TaskManager {
             store: this.store.type,
         });
     }
+    getStore() {
+        if (!this.store) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[TaskManager] Store not initialized. Call initialize() first.");
+        }
+        return this.store;
+    }
+    getBackend() {
+        if (!this.backend) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[TaskManager] Backend not initialized. Call initialize() first.");
+        }
+        return this.backend;
+    }
+    getExecutor() {
+        if (!this.executor) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[TaskManager] Executor not initialized. Call initialize() first.");
+        }
+        return this.executor;
+    }
     // ── Public API ────────────────────────────────────────
     async create(definition) {
         if (this.config.enabled === false) {
             throw TaskError.create("TASK_DISABLED", "TaskManager is disabled. Set tasks.enabled to true in config.");
         }
         await this.ensureInitialized();
+        const store = this.getStore();
+        const backend = this.getBackend();
         // Enforce maximum task limit to prevent unbounded task creation
         const maxTasks = this.config.maxTasks ?? TASK_DEFAULTS.maxTasks;
-        const existingTasks = await this.store.list();
+        const existingTasks = await store.list();
         if (existingTasks.length >= maxTasks) {
             throw TaskError.create("TASK_LIMIT_REACHED", `Task limit reached (${maxTasks}). Delete existing tasks or increase maxTasks config.`);
         }
@@ -124,7 +144,7 @@ export class TaskManager {
             task.sessionId = `session_${nanoid(12)}`;
         }
         // Save to store
-        await this.store.save(task);
+        await store.save(task);
         // Register callbacks (in-memory only)
         if (definition.onSuccess || definition.onError || definition.onComplete) {
             this.callbacks.set(task.id, {
@@ -135,10 +155,31 @@ export class TaskManager {
         }
         // Schedule
         try {
-            await this.backend.schedule(task, (t) => this.onTaskTick(t));
+            await backend.schedule(task, (t) => this.onTaskTick(t));
         }
         catch (err) {
-            await this.store.delete(task.id);
+            this.callbacks.delete(task.id);
+            try {
+                await store.delete(task.id);
+            }
+            catch (cleanupError) {
+                // Deletion failed — task remains persisted as active. Attempt to mark it
+                // failed so it reaches a terminal state and operators can identify it.
+                logger.error("[TaskManager] Failed to clean up task after schedule error — task may remain persisted as active", {
+                    taskId: task.id,
+                    scheduleError: String(err),
+                    cleanupError: String(cleanupError),
+                });
+                try {
+                    await store.update(task.id, { status: "failed" });
+                }
+                catch (terminalError) {
+                    logger.error("[TaskManager] Failed to force task to terminal state — manual cleanup required", {
+                        taskId: task.id,
+                        error: String(terminalError),
+                    });
+                }
+            }
             throw err;
         }
         this.emit("task:created", task);
@@ -152,15 +193,17 @@ export class TaskManager {
     }
     async get(taskId) {
         await this.ensureInitialized();
-        return this.store.get(taskId);
+        return this.getStore().get(taskId);
     }
     async list(filter) {
         await this.ensureInitialized();
-        return this.store.list(filter);
+        return this.getStore().list(filter);
     }
     async update(taskId, updates) {
         await this.ensureInitialized();
-        const existing = await this.store.get(taskId);
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const existing = await store.get(taskId);
         if (!existing) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
         }
@@ -187,6 +230,7 @@ export class TaskManager {
                 taskUpdates[field] = updates[field];
             }
         }
+        const shouldClearHistory = updates.mode !== undefined && updates.mode !== "continuation";
         // Special-case: mode changes require sessionId handling
         if (updates.mode !== undefined) {
             if (updates.mode === "continuation" && !existing.sessionId) {
@@ -194,21 +238,46 @@ export class TaskManager {
             }
             else if (updates.mode !== "continuation") {
                 taskUpdates.sessionId = undefined;
-                await this.store.clearHistory(taskId);
             }
         }
-        const updated = await this.store.update(taskId, taskUpdates);
+        const updated = await store.update(taskId, taskUpdates);
         // Re-schedule if schedule changed and task is active
         if (updates.schedule && updated.status === "active") {
-            await this.backend.cancel(taskId);
-            await this.backend.schedule(updated, (t) => this.onTaskTick(t));
+            const attemptedSchedule = updated.schedule;
+            await backend.cancel(taskId);
+            try {
+                await backend.schedule(updated, (t) => this.onTaskTick(t));
+            }
+            catch (error) {
+                await this.restoreScheduledTask(existing, "update schedule rollback");
+                await this.rollbackTaskUpdate(taskId, existing, error);
+                throw TaskError.create("SCHEDULE_FAILED", `Failed to update schedule for task ${taskId}`, {
+                    cause: error instanceof Error ? error : undefined,
+                    details: {
+                        taskId,
+                        previousSchedule: existing.schedule,
+                        attemptedSchedule,
+                    },
+                });
+            }
+        }
+        if (shouldClearHistory) {
+            try {
+                await store.clearHistory(taskId);
+            }
+            catch (error) {
+                logger.warn("[TaskManager] Failed to clear task history after mode update", {
+                    taskId,
+                    error: String(error),
+                });
+            }
         }
         return updated;
     }
     /** Run a task immediately (outside of its schedule) */
     async run(taskId) {
         await this.ensureInitialized();
-        const task = await this.store.get(taskId);
+        const task = await this.getStore().get(taskId);
         if (!task) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
         }
@@ -216,42 +285,64 @@ export class TaskManager {
     }
     async pause(taskId) {
         await this.ensureInitialized();
-        const task = await this.store.get(taskId);
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const task = await store.get(taskId);
         if (!task) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
         }
         if (task.status !== "active") {
             throw TaskError.create("INVALID_TASK_STATUS", `Cannot pause task with status: ${task.status}`);
         }
-        await this.backend.pause(taskId);
-        const updated = await this.store.update(taskId, { status: "paused" });
+        await backend.pause(taskId);
+        let updated;
+        try {
+            updated = await store.update(taskId, { status: "paused" });
+        }
+        catch (error) {
+            await this.restoreScheduledTask(task, "pause rollback");
+            throw error;
+        }
         this.emit("task:paused", updated);
         return updated;
     }
     async resume(taskId) {
         await this.ensureInitialized();
-        const task = await this.store.get(taskId);
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const task = await store.get(taskId);
         if (!task) {
             throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
         }
         if (task.status !== "paused") {
             throw TaskError.create("INVALID_TASK_STATUS", `Cannot resume task with status: ${task.status}`);
         }
-        const updated = await this.store.update(taskId, { status: "active" });
-        await this.backend.schedule(updated, (t) => this.onTaskTick(t));
+        const updated = await store.update(taskId, { status: "active" });
+        try {
+            await backend.schedule(updated, (t) => this.onTaskTick(t));
+        }
+        catch (error) {
+            await this.rollbackTaskUpdate(taskId, task, error);
+            throw TaskError.create("SCHEDULE_FAILED", `Failed to resume task ${taskId}`, {
+                cause: error instanceof Error ? error : undefined,
+                details: { taskId, schedule: task.schedule },
+            });
+        }
         this.emit("task:resumed", updated);
         return updated;
     }
     async delete(taskId) {
         await this.ensureInitialized();
-        await this.backend.cancel(taskId);
-        await this.store.delete(taskId);
+        const backend = this.getBackend();
+        const store = this.getStore();
+        await backend.cancel(taskId);
+        await store.delete(taskId);
         this.callbacks.delete(taskId);
         this.emit("task:deleted", taskId);
     }
     async runs(taskId, options) {
         await this.ensureInitialized();
-        return this.store.getRuns(taskId, options);
+        return this.getStore().getRuns(taskId, options);
     }
     async shutdown() {
         if (this.backend) {
@@ -273,14 +364,49 @@ export class TaskManager {
         return this.backend.isHealthy();
     }
     // ── Internal ──────────────────────────────────────────
+    async restoreScheduledTask(task, reason) {
+        if (task.status !== "active") {
+            return;
+        }
+        try {
+            await this.getBackend().schedule(task, (t) => this.onTaskTick(t));
+            logger.warn("[TaskManager] Restored task schedule after rollback", {
+                taskId: task.id,
+                reason,
+            });
+        }
+        catch (restoreError) {
+            logger.error("[TaskManager] Failed to restore task schedule during rollback", {
+                taskId: task.id,
+                reason,
+                error: String(restoreError),
+            });
+        }
+    }
+    async rollbackTaskUpdate(taskId, previousTask, error) {
+        try {
+            return await this.getStore().update(taskId, previousTask);
+        }
+        catch (rollbackError) {
+            logger.error("[TaskManager] Failed to roll back task update — store and in-memory state may be diverged; manual reconciliation required", {
+                taskId,
+                originalError: String(error),
+                rollbackError: String(rollbackError),
+            });
+            throw rollbackError;
+        }
+    }
     /**
      * Called by the backend on each scheduled tick.
      * Executes the task, updates state, fires callbacks/events.
      */
     async onTaskTick(task) {
         this.emit("task:started", task);
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const executor = this.getExecutor();
         // Re-read latest task state (may have been updated/paused since scheduling)
-        const current = await this.store.get(task.id);
+        const current = await store.get(task.id);
         if (!current || current.status !== "active") {
             logger.debug("[TaskManager] Skipping tick for non-active task", {
                 taskId: task.id,
@@ -295,9 +421,9 @@ export class TaskManager {
                 timestamp: new Date().toISOString(),
             };
         }
-        const result = await this.executor.execute(current);
+        const result = await executor.execute(current);
         // Log the run
-        await this.store.appendRun(task.id, result);
+        await store.appendRun(task.id, result);
         // Update task tracking
         const updates = {
             runCount: current.runCount + 1,
@@ -306,18 +432,18 @@ export class TaskManager {
         // Check if task should complete
         if (current.maxRuns && current.runCount + 1 >= current.maxRuns) {
             updates.status = "completed";
-            await this.backend.cancel(task.id);
+            await backend.cancel(task.id);
         }
         // Mark successful once tasks as completed
         if (result.status === "success" && current.schedule.type === "once") {
             updates.status = "completed";
-            await this.backend.cancel(task.id);
+            await backend.cancel(task.id);
         }
         // Mark as failed on permanent error
         if (result.status === "error" && current.schedule.type === "once") {
             updates.status = "failed";
         }
-        await this.store.update(task.id, updates);
+        await store.update(task.id, updates);
         // Fire callbacks
         const cbs = this.callbacks.get(task.id);
         if (cbs) {
@@ -337,7 +463,7 @@ export class TaskManager {
                     });
                 }
                 if (updates.status === "completed" || updates.status === "failed") {
-                    const finalTask = await this.store.get(task.id);
+                    const finalTask = await store.get(task.id);
                     if (finalTask && cbs.onComplete) {
                         await cbs.onComplete(finalTask);
                     }
@@ -364,10 +490,12 @@ export class TaskManager {
      * Called on initialization to handle process restarts.
      */
     async rescheduleActiveTasks() {
-        const activeTasks = await this.store.list({ status: "active" });
+        const store = this.getStore();
+        const backend = this.getBackend();
+        const activeTasks = await store.list({ status: "active" });
         for (const task of activeTasks) {
             try {
-                await this.backend.schedule(task, (t) => this.onTaskTick(t));
+                await backend.schedule(task, (t) => this.onTaskTick(t));
                 logger.debug("[TaskManager] Re-scheduled task", {
                     taskId: task.id,
                     name: task.name,

package/dist/telemetry/index.d.ts

@@ -4,7 +4,8 @@ export { withSpan, withClientSpan, type SpanOptions } from "./withSpan.js";
 export { ATTR } from "./attributes.js";
 /**
  * Initialize telemetry for NeuroLink
- * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
+ * Reuses an existing global TracerProvider when one is already registered,
+ * otherwise bootstraps Neurolink telemetry when an exporter endpoint is configured.
  */
 export declare function initializeTelemetry(): Promise<import("./telemetryService.js").TelemetryService>;
 /**

package/dist/telemetry/index.js

@@ -6,7 +6,8 @@ export { ATTR } from "./attributes.js";
 import { logger } from "../utils/logger.js";
 /**
  * Initialize telemetry for NeuroLink
- * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
+ * Reuses an existing global TracerProvider when one is already registered,
+ * otherwise bootstraps Neurolink telemetry when an exporter endpoint is configured.
  */
 export async function initializeTelemetry() {
     const { TelemetryService } = await import("./telemetryService.js");