@juspay/neurolink 9.41.0 → 9.42.0

package/dist/lib/services/server/ai/observability/instrumentation.d.ts

@@ -8,7 +8,8 @@
  */
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { trace } from "@opentelemetry/api";
-import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import type { LangfuseConfig } from "../../../../types/observability.js";
 /**
@@ -104,6 +105,11 @@ export declare function getLangfuseSpanProcessor(): LangfuseSpanProcessor | null
  * Get the tracer provider
  */
 export declare function getTracerProvider(): NodeTracerProvider | null;
+/**
+ * Get the logger provider for emitting OTLP log records.
+ * Returns null if OTLP is not configured or LoggerProvider was not created.
+ */
+export declare function getLoggerProvider(): LoggerProvider | null;
 /**
  * Check if OpenTelemetry is initialized
  */

package/dist/lib/services/server/ai/observability/instrumentation.js

@@ -7,8 +7,15 @@
  * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
  */
 import { LangfuseSpanProcessor } from "@langfuse/otel";
-import { trace } from "@opentelemetry/api";
+import { metrics, trace } from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
+import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
+import { BatchSpanProcessor, } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { AsyncLocalStorage } from "async_hooks";
@@ -16,6 +23,8 @@ import { logger } from "../../../../utils/logger.js";
 const LOG_PREFIX = "[OpenTelemetry]";
 const contextStorage = new AsyncLocalStorage();
 let tracerProvider = null;
+let meterProvider = null;
+let loggerProvider = null;
 let langfuseProcessor = null;
 let isInitialized = false;
 let isCredentialsValid = false;
@@ -453,58 +462,179 @@ export function initializeOpenTelemetry(config) {
             return;
         }
     }
-    // THEN: Check enabled for standalone mode
-    if (!config?.enabled) {
-        logger.debug(`${LOG_PREFIX} Langfuse disabled and no external provider, skipping initialization`);
+    const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    const langfuseRequested = config?.enabled === true;
+    const hasLangfuseCreds = !!config.publicKey && !!config.secretKey;
+    // THEN: Check whether we have any standalone observability backend at all.
+    if ((!langfuseRequested || !hasLangfuseCreds) && !otlpEndpoint) {
+        if (langfuseRequested && !hasLangfuseCreds) {
+            logger.warn(`${LOG_PREFIX} Langfuse requested but credentials are missing, and no OTLP endpoint is configured; skipping initialization`, {
+                hasPublicKey: !!config.publicKey,
+                hasSecretKey: !!config.secretKey,
+            });
+        }
+        else {
+            logger.debug(`${LOG_PREFIX} Langfuse disabled and OTLP endpoint missing, skipping initialization`);
+        }
         isInitialized = true;
         return;
     }
-    // Validate credentials for standalone mode
-    if (!config.publicKey || !config.secretKey) {
-        logger.warn(`${LOG_PREFIX} Langfuse enabled but missing credentials, skipping initialization`, {
+    if (langfuseRequested && !hasLangfuseCreds) {
+        logger.warn(`${LOG_PREFIX} Langfuse requested but credentials are missing; continuing with OTLP-only telemetry`, {
             hasPublicKey: !!config.publicKey,
             hasSecretKey: !!config.secretKey,
+            otlpEnabled: !!otlpEndpoint,
         });
-        isInitialized = true;
-        isCredentialsValid = false;
-        return;
     }
     try {
         currentConfig = config;
-        isCredentialsValid = true;
-        // Step 1: Create LangfuseSpanProcessor for standalone mode
-        // shouldExportSpan: export all spans (v5 default filters to gen_ai spans only)
-        langfuseProcessor = new LangfuseSpanProcessor({
-            publicKey: config.publicKey,
-            secretKey: config.secretKey,
-            baseUrl: config.baseUrl || "https://cloud.langfuse.com",
-            environment: config.environment || "dev",
-            release: config.release || "v1.0.0",
-            shouldExportSpan: () => true,
-        });
-        logger.debug(`${LOG_PREFIX} Created LangfuseSpanProcessor`, {
+        isCredentialsValid = hasLangfuseCreds;
+        // Step 1: Create LangfuseSpanProcessor only when Langfuse is explicitly enabled
+        // with real credentials. OTLP-only mode is valid and should not construct one.
+        if (langfuseRequested && hasLangfuseCreds) {
+            // shouldExportSpan: export all spans (v5 default filters to gen_ai spans only)
+            langfuseProcessor = new LangfuseSpanProcessor({
+                publicKey: config.publicKey,
+                secretKey: config.secretKey,
+                baseUrl: config.baseUrl || "https://cloud.langfuse.com",
+                environment: config.environment || "dev",
+                release: config.release || "v1.0.0",
+                shouldExportSpan: () => true,
+            });
+        }
+        else {
+            langfuseProcessor = null;
+        }
+        logger.debug(`${LOG_PREFIX} Standalone observability mode`, {
+            langfuseEnabled: !!langfuseProcessor,
+            otlpEnabled: !!otlpEndpoint,
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
         });
         // Step 2: Create our own TracerProvider (standalone behavior)
+        // Use OTEL_SERVICE_NAME env var if available, otherwise "neurolink"
+        const serviceName = process.env.OTEL_SERVICE_NAME || "neurolink";
         const resource = resourceFromAttributes({
-            [ATTR_SERVICE_NAME]: "neurolink",
+            [ATTR_SERVICE_NAME]: serviceName,
             [ATTR_SERVICE_VERSION]: config.release || "v1.0.0",
             "deployment.environment": config.environment || "dev",
         });
+        // Build span processor list
+        const spanProcessors = [new ContextEnricher()];
+        if (langfuseProcessor) {
+            spanProcessors.push(langfuseProcessor);
+        }
+        // Step 2b: If OTEL_EXPORTER_OTLP_ENDPOINT is set, also export via OTLP HTTP
+        // This allows sending traces to an OpenTelemetry Collector (e.g. for OpenObserve)
+        if (otlpEndpoint) {
+            try {
+                const otlpExporter = new OTLPTraceExporter({
+                    url: `${otlpEndpoint}/v1/traces`,
+                });
+                const otlpBatchProcessor = new BatchSpanProcessor(otlpExporter, {
+                    maxQueueSize: 2048,
+                    maxExportBatchSize: 512,
+                    scheduledDelayMillis: 1000,
+                    exportTimeoutMillis: 30000,
+                });
+                spanProcessors.push(otlpBatchProcessor);
+                logger.info(`${LOG_PREFIX} OTLP trace exporter added`, {
+                    endpoint: `${otlpEndpoint}/v1/traces`,
+                    serviceName,
+                });
+            }
+            catch (otlpError) {
+                logger.warn(`${LOG_PREFIX} Failed to create OTLP exporter (non-fatal)`, {
+                    error: otlpError instanceof Error
+                        ? otlpError.message
+                        : String(otlpError),
+                    endpoint: otlpEndpoint,
+                });
+            }
+        }
         tracerProvider = new NodeTracerProvider({
             resource,
-            spanProcessors: [new ContextEnricher(), langfuseProcessor],
+            spanProcessors,
+        });
+        // Step 4: Register globally with explicit W3C propagator
+        // This ensures traceparent headers from calling SDKs are extracted correctly,
+        // even if another library registers a no-op propagator before us.
+        tracerProvider.register({
+            propagator: new W3CTraceContextPropagator(),
         });
-        // Step 4: Register globally
-        tracerProvider.register();
         usingExternalProvider = false;
         isInitialized = true;
-        logger.info(`${LOG_PREFIX} Initialized with Langfuse span processor`, {
+        // Step 5: If OTLP endpoint is set, also set up MeterProvider for metrics export
+        // This enables TelemetryService's metrics.getMeter() instruments to export via OTLP
+        if (otlpEndpoint) {
+            try {
+                const metricExporter = new OTLPMetricExporter({
+                    url: `${otlpEndpoint}/v1/metrics`,
+                });
+                const metricReader = new PeriodicExportingMetricReader({
+                    exporter: metricExporter,
+                    exportIntervalMillis: 15000, // Export every 15 seconds
+                    exportTimeoutMillis: 10000,
+                });
+                meterProvider = new MeterProvider({
+                    resource,
+                    readers: [metricReader],
+                });
+                // Register globally so TelemetryService's metrics.getMeter() picks it up
+                metrics.setGlobalMeterProvider(meterProvider);
+                logger.info(`${LOG_PREFIX} OTLP metric exporter added — MeterProvider registered globally`, {
+                    endpoint: `${otlpEndpoint}/v1/metrics`,
+                    exportIntervalMs: 15000,
+                    serviceName,
+                    meterProviderType: meterProvider.constructor.name,
+                });
+            }
+            catch (metricsError) {
+                logger.warn(`${LOG_PREFIX} Failed to create OTLP metric exporter (non-fatal)`, {
+                    error: metricsError instanceof Error
+                        ? metricsError.message
+                        : String(metricsError),
+                    endpoint: otlpEndpoint,
+                });
+            }
+            // Step 6: Set up LoggerProvider for OTLP log export
+            // This enables logRequest() to emit structured log records via OTLP
+            try {
+                const logExporter = new OTLPLogExporter({
+                    url: `${otlpEndpoint}/v1/logs`,
+                });
+                const logProcessor = new BatchLogRecordProcessor(logExporter, {
+                    maxQueueSize: 2048,
+                    maxExportBatchSize: 512,
+                    scheduledDelayMillis: 2000,
+                    exportTimeoutMillis: 30000,
+                });
+                loggerProvider = new LoggerProvider({
+                    resource,
+                    processors: [logProcessor],
+                });
+                logger.info(`${LOG_PREFIX} OTLP log exporter added — LoggerProvider created`, {
+                    endpoint: `${otlpEndpoint}/v1/logs`,
+                    serviceName,
+                });
+            }
+            catch (logsError) {
+                logger.warn(`${LOG_PREFIX} Failed to create OTLP log exporter (non-fatal)`, {
+                    error: logsError instanceof Error
+                        ? logsError.message
+                        : String(logsError),
+                    endpoint: otlpEndpoint,
+                });
+            }
+        }
+        logger.info(`${LOG_PREFIX} Observability initialized`, {
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
             release: config.release || "v1.0.0",
             mode: "standalone",
+            langfuseEnabled: !!langfuseProcessor,
+            otlpEnabled: !!otlpEndpoint,
+            serviceName,
         });
     }
     catch (error) {
@@ -540,22 +670,75 @@ export async function flushOpenTelemetry() {
         logger.debug(`${LOG_PREFIX} Not initialized, skipping flush`);
         return;
     }
-    if (!langfuseProcessor) {
-        logger.debug(`${LOG_PREFIX} No processor to flush (Langfuse disabled)`);
-        return;
+    const failures = [];
+    if (langfuseProcessor) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing Langfuse spans...`);
+            await langfuseProcessor.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "langfuse", error });
+            logger.error(`${LOG_PREFIX} Langfuse flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
     }
-    try {
-        logger.info(`${LOG_PREFIX} Flushing pending spans to Langfuse...`);
-        await langfuseProcessor.forceFlush();
-        logger.info(`${LOG_PREFIX} Successfully flushed spans to Langfuse`);
+    else {
+        logger.debug(`${LOG_PREFIX} Langfuse disabled, skipping Langfuse flush`);
     }
-    catch (error) {
-        logger.error(`${LOG_PREFIX} Flush failed`, {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-        throw error;
+    if (tracerProvider && !usingExternalProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP traces...`);
+            await tracerProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "traces", error });
+            logger.error(`${LOG_PREFIX} Trace flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    else {
+        logger.debug(`${LOG_PREFIX} No TracerProvider to flush`);
     }
+    if (meterProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP metrics...`);
+            await meterProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "metrics", error });
+            logger.error(`${LOG_PREFIX} Metric flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    else {
+        logger.debug(`${LOG_PREFIX} No MeterProvider to flush`);
+    }
+    if (loggerProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP logs...`);
+            await loggerProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "logs", error });
+            logger.error(`${LOG_PREFIX} Log flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    else {
+        logger.debug(`${LOG_PREFIX} No LoggerProvider to flush`);
+    }
+    if (failures.length > 0) {
+        throw new Error(`${LOG_PREFIX} Flush failed for: ${failures.map((f) => f.signal).join(", ")}`);
+    }
+    logger.info(`${LOG_PREFIX} Flush complete`);
 }
 /**
  * Shutdown OpenTelemetry and Langfuse span processor
@@ -577,7 +760,17 @@ export async function shutdownOpenTelemetry() {
         if (cachedContextEnricher) {
             await cachedContextEnricher.shutdown();
         }
+        // Shutdown MeterProvider if we created it
+        if (meterProvider) {
+            await meterProvider.shutdown();
+        }
+        // Shutdown LoggerProvider if we created it
+        if (loggerProvider) {
+            await loggerProvider.shutdown();
+        }
         tracerProvider = null;
+        meterProvider = null;
+        loggerProvider = null;
         langfuseProcessor = null;
         cachedContextEnricher = null;
         isInitialized = false;
@@ -603,6 +796,13 @@ export function getLangfuseSpanProcessor() {
 export function getTracerProvider() {
     return tracerProvider;
 }
+/**
+ * Get the logger provider for emitting OTLP log records.
+ * Returns null if OTLP is not configured or LoggerProvider was not created.
+ */
+export function getLoggerProvider() {
+    return loggerProvider;
+}
 /**
  * Check if OpenTelemetry is initialized
  */

package/dist/lib/tasks/backends/bullmqBackend.d.ts

@@ -29,4 +29,5 @@ export declare class BullMQBackend implements TaskBackend {
      */
     private getConnectionConfig;
     private ensureInitialized;
+    private getQueue;
 }

package/dist/lib/tasks/backends/bullmqBackend.js

@@ -62,23 +62,23 @@ 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, {
+            await 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 });
+            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 this.queue.add(task.name, jobData, {
+            await queue.add(task.name, jobData, {
                 jobId: task.id,
                 delay,
             });
@@ -89,18 +89,18 @@ export class BullMQBackend {
         });
     }
     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,5 +185,12 @@ 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;
+    }
 }
 //# sourceMappingURL=bullmqBackend.js.map

package/dist/lib/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/lib/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));
+        const client = this.getClient();
+        await client.hSet(TASKS_HASH, task.id, JSON.stringify(task));
         this.applyRetentionTTL(task);
     }
     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));
+        await client.hSet(TASKS_HASH, taskId, JSON.stringify(updated));
         this.applyRetentionTTL(updated);
         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,6 +156,13 @@ 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.
@@ -171,14 +178,15 @@ export class RedisTaskStore {
         };
         const ttlMs = ttlMap[task.status];
         if (ttlMs) {
+            const client = this.getClient();
             const ttlSeconds = Math.ceil(ttlMs / 1000);
             // Set TTL on associated keys
-            this.client.expire(taskRunsKey(task.id), ttlSeconds).catch((err) => {
+            client.expire(taskRunsKey(task.id), ttlSeconds).catch((err) => {
                 logger.debug("[TaskStore:Redis] Failed to set TTL", {
                     error: String(err),
                 });
             });
-            this.client.expire(taskHistoryKey(task.id), ttlSeconds).catch((err) => {
+            client.expire(taskHistoryKey(task.id), ttlSeconds).catch((err) => {
                 logger.debug("[TaskStore:Redis] Failed to set TTL", {
                     error: String(err),
                 });

package/dist/lib/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?: {