@juspay/neurolink 9.40.0 → 9.41.0

package/dist/cli/parser.js

@@ -15,6 +15,7 @@ import { ObservabilityCommandFactory } from "./commands/observability.js";
 import { TelemetryCommandFactory } from "./commands/telemetry.js";
 import { proxyStartCommand, proxyStatusCommand, proxySetupCommand, proxyGuardCommand, proxyInstallCommand, proxyUninstallCommand, } from "./commands/proxy.js";
 import { EvaluateCommandFactory } from "./commands/evaluate.js";
+import { TaskCommandFactory } from "./commands/task.js";
 // Enhanced CLI with Professional UX
 export function initializeCliParser() {
     return (yargs(hideBin(process.argv))
@@ -199,6 +200,8 @@ export function initializeCliParser() {
         handler: () => { },
     })
         // Evaluate Command Group - Using EvaluateCommandFactory
-        .command(EvaluateCommandFactory.createEvaluateCommand())); // Close the main return statement
+        .command(EvaluateCommandFactory.createEvaluateCommand())
+        // Task Command Group - Scheduled and self-running tasks
+        .command(TaskCommandFactory.createTaskCommands())); // Close the main return statement
 }
 //# sourceMappingURL=parser.js.map

package/dist/lib/neurolink.d.ts

@@ -25,11 +25,14 @@ 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;
     private mcpInitPromise;
     private emitter;
+    private _taskManager?;
+    private _taskManagerConfig?;
     private toolRegistry;
     private autoDiscoveredServerInfos;
     private externalServerManager;
@@ -148,6 +151,13 @@ export declare class NeuroLink {
      */
     private get _metricsTraceContext();
     constructor(config?: NeurolinkConstructorConfig);
+    /**
+     * TaskManager — scheduled and self-running tasks.
+     * Lazy-initialized on first access. Configurable via constructor `tasks` option.
+     * The actual async initialization (Redis connect, backend start) happens
+     * lazily inside TaskManager on first operation.
+     */
+    get tasks(): TaskManager;
     /**
      * Initialize provider registry with security settings
      */
@@ -173,6 +183,12 @@ export declare class NeuroLink {
      * and registers them as direct tools so they're available to LLMs.
      */
     private registerFileTools;
+    /**
+     * Register task management tools bound to a TaskManager instance.
+     * Follows the same factory + registry pattern as registerFileTools().
+     * Called when TaskManager is created (eagerly or lazily via the `tasks` getter).
+     */
+    private registerTaskTools;
     /**
      * Register memory retrieval tools that allow the AI to access
      * conversation history, including full tool outputs.

package/dist/lib/neurolink.js

@@ -75,6 +75,8 @@ import { isNonNullObject } from "./utils/typeUtils.js";
 import { resolveModel } from "./utils/modelAliasResolver.js";
 import { getWorkflow } from "./workflow/core/workflowRegistry.js";
 import { runWorkflow } from "./workflow/core/workflowRunner.js";
+import { TaskManager } from "./tasks/taskManager.js";
+import { createTaskTools } from "./tasks/tools/taskTools.js";
 /**
  * NL-002: Classify MCP error messages into categories for AI disambiguation.
  * Returns a human-readable error category based on error message content.
@@ -187,6 +189,9 @@ export class NeuroLink {
     mcpSkipped = false;
     mcpInitPromise = null;
     emitter = new EventEmitter();
+    // TaskManager — lazy-initialized on first access via `this.tasks`
+    _taskManager;
+    _taskManagerConfig;
     toolRegistry;
     autoDiscoveredServerInfos = [];
     // External MCP server management
@@ -459,6 +464,28 @@ export class NeuroLink {
         if (config?.auth) {
             this.pendingAuthConfig = config.auth;
         }
+        // Store task config for lazy initialization
+        this._taskManagerConfig = config?.tasks;
+        // Eagerly create TaskManager and register tools if config is provided
+        if (this._taskManagerConfig) {
+            this._taskManager = new TaskManager(this, this._taskManagerConfig);
+            this._taskManager.setEmitter(this.emitter);
+            this.registerTaskTools(this._taskManager);
+        }
+    }
+    /**
+     * TaskManager — scheduled and self-running tasks.
+     * Lazy-initialized on first access. Configurable via constructor `tasks` option.
+     * The actual async initialization (Redis connect, backend start) happens
+     * lazily inside TaskManager on first operation.
+     */
+    get tasks() {
+        if (!this._taskManager) {
+            this._taskManager = new TaskManager(this, this._taskManagerConfig);
+            this._taskManager.setEmitter(this.emitter);
+            this.registerTaskTools(this._taskManager);
+        }
+        return this._taskManager;
     }
     /**
      * Initialize provider registry with security settings
@@ -716,6 +743,52 @@ export class NeuroLink {
             logger.debug(`[NeuroLink] Registered ${Object.keys(fileTools).length} file reference tools`);
         });
     }
+    /**
+     * Register task management tools bound to a TaskManager instance.
+     * Follows the same factory + registry pattern as registerFileTools().
+     * Called when TaskManager is created (eagerly or lazily via the `tasks` getter).
+     */
+    registerTaskTools(manager) {
+        const taskTools = createTaskTools(manager);
+        for (const [toolName, toolDef] of Object.entries(taskTools)) {
+            const toolId = `direct.${toolName}`;
+            const toolInfo = {
+                name: toolName,
+                description: toolDef.description || `Task tool: ${toolName}`,
+                inputSchema: {},
+                serverId: "direct",
+                category: "built-in",
+            };
+            // registerTool is async but its core logic is synchronous (Map.set).
+            // We fire-and-forget here but tools are available immediately after
+            // the synchronous validation + map insertion completes.
+            void this.toolRegistry.registerTool(toolId, toolInfo, {
+                execute: async (params) => {
+                    try {
+                        const result = await toolDef.execute(params, {
+                            toolCallId: "task-tool",
+                            messages: [],
+                        });
+                        return {
+                            success: true,
+                            data: result,
+                            metadata: { toolName, serverId: "direct", executionTime: 0 },
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            metadata: { toolName, serverId: "direct", executionTime: 0 },
+                        };
+                    }
+                },
+                description: toolDef.description,
+                inputSchema: {},
+            });
+        }
+        logger.debug(`[NeuroLink] Registered ${Object.keys(taskTools).length} task tools`);
+    }
     /**
      * Register memory retrieval tools that allow the AI to access
      * conversation history, including full tool outputs.
@@ -1906,6 +1979,18 @@ Current user's request: ${currentInput}`;
                     logger.warn("[NeuroLink] MCP servers shutdown failed:", error);
                 }
             }
+            // Shutdown TaskManager
+            if (this._taskManager) {
+                try {
+                    await withTimeout(this._taskManager.shutdown(), 5000, new Error("TaskManager shutdown timed out"));
+                }
+                catch (error) {
+                    logger.warn("[NeuroLink] TaskManager shutdown error:", error);
+                }
+                finally {
+                    this._taskManager = undefined;
+                }
+            }
             // Close conversation memory manager (release Redis connections, etc.)
             if (this.conversationMemory?.close) {
                 try {
@@ -2521,6 +2606,8 @@ Current user's request: ${currentInput}`;
                             abortSignal: options.abortSignal,
                             skipToolPromptInjection: options.skipToolPromptInjection,
                             middleware: options.middleware,
+                            // Pass through conversation messages for task continuation and external callers
+                            conversationMessages: options.conversationMessages,
                         };
                         // Auto-map top-level sessionId/userId to context for convenience
                         // Tests and users may pass sessionId/userId as top-level options
@@ -2745,7 +2832,15 @@ Current user's request: ${currentInput}`;
         // Execute workflow
         const workflowResult = await runWorkflow(workflowConfig, {
             prompt: options.input.text,
-            conversationHistory: options.conversationHistory,
+            conversationHistory: options.conversationMessages
+                ?.filter((m) => m.role === "user" || m.role === "assistant")
+                .map((m) => ({
+                role: m.role,
+                content: typeof m.content === "string"
+                    ? m.content
+                    : JSON.stringify(m.content),
+            })) ??
+                options.conversationHistory,
             timeout: options.timeout,
             verbose: false,
             metadata: options.context,
@@ -2836,7 +2931,15 @@ Current user's request: ${currentInput}`;
         // Execute workflow with progressive streaming
         const workflowStream = runWorkflowWithStreaming(workflowConfig, {
             prompt: options.input.text,
-            conversationHistory: options.conversationHistory,
+            conversationHistory: options.conversationMessages
+                ?.filter((m) => m.role === "user" || m.role === "assistant")
+                .map((m) => ({
+                role: m.role,
+                content: typeof m.content === "string"
+                    ? m.content
+                    : JSON.stringify(m.content),
+            })) ??
+                options.conversationHistory,
             timeout: options.timeout,
             verbose: false,
             metadata: options.context,
@@ -5046,6 +5149,7 @@ Current user's request: ${currentInput}`;
             model: options.model,
             temperature: options.temperature,
             maxTokens: options.maxTokens,
+            conversationMessages: options.conversationMessages,
         });
         // Create a wrapper around the fallback stream that accumulates content
         let fallbackAccumulatedContent = "";
@@ -8396,6 +8500,19 @@ Current user's request: ${currentInput}`;
                 cleanupErrors.push(err);
                 logger.warn("[NeuroLink] Error clearing caches:", error);
             }
+            // 5b. Shutdown TaskManager
+            if (this._taskManager) {
+                try {
+                    logger.debug("[NeuroLink] Shutting down TaskManager...");
+                    await withTimeout(this._taskManager.shutdown(), 5000, new Error("TaskManager shutdown timed out"));
+                }
+                catch (error) {
+                    logger.warn("[NeuroLink] TaskManager shutdown error:", error);
+                }
+                finally {
+                    this._taskManager = undefined;
+                }
+            }
             // 6. Reset initialization flags
             try {
                 logger.debug("[NeuroLink] Resetting initialization state...");

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

@@ -0,0 +1,32 @@
+/**
+ * BullMQ Backend — Production-grade task scheduling via Redis.
+ *
+ * - Cron tasks → BullMQ repeatable jobs with cron pattern
+ * - Interval tasks → BullMQ repeatable jobs with `every` option
+ * - One-shot tasks → BullMQ delayed jobs
+ * - Survives process restarts (Redis-persisted)
+ */
+import { type Task, type TaskBackend, type TaskExecutorFn, type TaskManagerConfig } from "../../types/taskTypes.js";
+export declare class BullMQBackend implements TaskBackend {
+    readonly name = "bullmq";
+    private queue;
+    private worker;
+    private executors;
+    private config;
+    constructor(config: TaskManagerConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    schedule(task: Task, executor: TaskExecutorFn): Promise<void>;
+    cancel(taskId: string): Promise<void>;
+    pause(taskId: string): Promise<void>;
+    resume(taskId: string): Promise<void>;
+    isHealthy(): Promise<boolean>;
+    /**
+     * Returns a connection options object for BullMQ / ioredis.
+     * When a URL is provided we parse it fully, preserving TLS (`rediss://`),
+     * ACL username, password, db index, and any query-string parameters so
+     * nothing is silently dropped.
+     */
+    private getConnectionConfig;
+    private ensureInitialized;
+}

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

@@ -0,0 +1,189 @@
+/**
+ * BullMQ Backend — Production-grade task scheduling via Redis.
+ *
+ * - Cron tasks → BullMQ repeatable jobs with cron pattern
+ * - Interval tasks → BullMQ repeatable jobs with `every` option
+ * - One-shot tasks → BullMQ delayed jobs
+ * - Survives process restarts (Redis-persisted)
+ */
+import { Queue, Worker } from "bullmq";
+import { logger } from "../../utils/logger.js";
+import { TaskError } from "../errors.js";
+import { TASK_DEFAULTS, } from "../../types/taskTypes.js";
+const QUEUE_NAME = "neurolink-tasks";
+export class BullMQBackend {
+    name = "bullmq";
+    queue = null;
+    worker = null;
+    executors = new Map();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async initialize() {
+        const connection = this.getConnectionConfig();
+        this.queue = new Queue(QUEUE_NAME, { connection });
+        this.worker = new Worker(QUEUE_NAME, async (job) => {
+            const taskId = job.data.taskId;
+            const task = job.data.task;
+            const executor = this.executors.get(taskId);
+            if (!executor) {
+                logger.warn("[BullMQ] No executor found for task", { taskId });
+                return;
+            }
+            logger.info("[BullMQ] Executing task", { taskId, name: task.name });
+            const result = await executor(task);
+            return result;
+        }, {
+            connection,
+            concurrency: this.config.maxConcurrentRuns ?? TASK_DEFAULTS.maxConcurrentRuns,
+        });
+        this.worker.on("failed", (job, err) => {
+            logger.error("[BullMQ] Job failed", {
+                taskId: job?.data?.taskId,
+                error: String(err),
+            });
+        });
+        this.worker.on("error", (err) => {
+            logger.error("[BullMQ] Worker error", { error: String(err) });
+        });
+        logger.info("[BullMQ] Backend initialized");
+    }
+    async shutdown() {
+        if (this.worker) {
+            await this.worker.close();
+            this.worker = null;
+        }
+        if (this.queue) {
+            await this.queue.close();
+            this.queue = null;
+        }
+        this.executors.clear();
+        logger.info("[BullMQ] Backend shut down");
+    }
+    async schedule(task, executor) {
+        this.ensureInitialized();
+        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 });
+        }
+        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,
+            });
+        }
+        logger.info("[BullMQ] Task scheduled", {
+            taskId: task.id,
+            type: schedule.type,
+        });
+    }
+    async cancel(taskId) {
+        this.ensureInitialized();
+        this.executors.delete(taskId);
+        // Remove repeatable job scheduler
+        try {
+            await this.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);
+            if (job) {
+                await job.remove();
+            }
+        }
+        catch {
+            // Job may already be processed/removed
+        }
+        logger.info("[BullMQ] Task cancelled", { taskId });
+    }
+    async pause(taskId) {
+        // BullMQ doesn't have per-job pause, so we fully cancel the job scheduler
+        // and executor. This is intentionally destructive — cancel() removes both
+        // the executor from the map and the job/scheduler from Redis.
+        //
+        // Resume flow (orchestrated by TaskManager):
+        //   1. TaskManager.resume() updates task status to "active" in the store
+        //   2. TaskManager.resume() calls backend.schedule(task, newExecutor)
+        //   3. schedule() re-registers the executor and creates a new job/scheduler
+        //
+        // Because TaskManager always supplies a fresh executor on schedule(),
+        // there is no need to preserve the old executor here.
+        await this.cancel(taskId);
+        logger.info("[BullMQ] Task paused (cancelled pending jobs; TaskManager will re-schedule on resume)", { taskId });
+    }
+    async resume(taskId) {
+        // No-op: BullMQ resume is handled by TaskManager calling schedule() after
+        // this method returns. See TaskManager.resume() which calls:
+        //   backend.schedule(updatedTask, executor)
+        // That call re-registers the executor and creates the job/scheduler in Redis.
+        logger.info("[BullMQ] Task resume requested (awaiting re-schedule from TaskManager)", { taskId });
+    }
+    async isHealthy() {
+        if (!this.queue) {
+            return false;
+        }
+        try {
+            // Check if the queue can reach Redis
+            await this.queue.getJobCounts();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ── Internal ──────────────────────────────────────────
+    /**
+     * Returns a connection options object for BullMQ / ioredis.
+     * When a URL is provided we parse it fully, preserving TLS (`rediss://`),
+     * ACL username, password, db index, and any query-string parameters so
+     * nothing is silently dropped.
+     */
+    getConnectionConfig() {
+        const redis = this.config.redis ?? {};
+        if (redis.url) {
+            const parsed = new URL(redis.url);
+            const opts = {
+                host: parsed.hostname || "localhost",
+                port: Number(parsed.port) || 6379,
+                db: parsed.pathname ? Number(parsed.pathname.slice(1)) || 0 : 0,
+            };
+            if (parsed.password) {
+                opts.password = decodeURIComponent(parsed.password);
+            }
+            if (parsed.username) {
+                opts.username = decodeURIComponent(parsed.username);
+            }
+            // rediss:// scheme → enable TLS
+            if (parsed.protocol === "rediss:") {
+                opts.tls = {};
+            }
+            return opts;
+        }
+        return {
+            host: redis.host ?? TASK_DEFAULTS.redis.host,
+            port: redis.port ?? TASK_DEFAULTS.redis.port,
+            ...(redis.password ? { password: redis.password } : {}),
+            db: redis.db ?? 0,
+        };
+    }
+    ensureInitialized() {
+        if (!this.queue) {
+            throw TaskError.create("BACKEND_NOT_INITIALIZED", "[BullMQ] Backend not initialized. Call initialize() first.");
+        }
+    }
+}
+//# sourceMappingURL=bullmqBackend.js.map

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

@@ -0,0 +1,27 @@
+/**
+ * NodeTimeout Backend — Development/zero-dependency task scheduling.
+ *
+ * - Cron tasks → parsed with `croner`, scheduled via setTimeout chains
+ * - Interval tasks → setInterval
+ * - One-shot tasks → setTimeout
+ * - All timers are in-process — lost on restart
+ */
+import { type Task, type TaskBackend, type TaskExecutorFn, type TaskManagerConfig } from "../../types/taskTypes.js";
+export declare class NodeTimeoutBackend implements TaskBackend {
+    readonly name = "node-timeout";
+    private scheduled;
+    private paused;
+    private disposed;
+    private activeRuns;
+    private maxConcurrentRuns;
+    constructor(config: TaskManagerConfig);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    schedule(task: Task, executor: TaskExecutorFn): Promise<void>;
+    cancel(taskId: string): Promise<void>;
+    pause(taskId: string): Promise<void>;
+    resume(taskId: string): Promise<void>;
+    isHealthy(): Promise<boolean>;
+    private executeTask;
+    private clearEntry;
+}

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

@@ -0,0 +1,141 @@
+/**
+ * NodeTimeout Backend — Development/zero-dependency task scheduling.
+ *
+ * - Cron tasks → parsed with `croner`, scheduled via setTimeout chains
+ * - Interval tasks → setInterval
+ * - One-shot tasks → setTimeout
+ * - All timers are in-process — lost on restart
+ */
+import { Cron } from "croner";
+import { logger } from "../../utils/logger.js";
+import { TASK_DEFAULTS, } from "../../types/taskTypes.js";
+export class NodeTimeoutBackend {
+    name = "node-timeout";
+    scheduled = new Map();
+    paused = new Map();
+    disposed = false;
+    activeRuns = 0;
+    maxConcurrentRuns;
+    constructor(config) {
+        this.maxConcurrentRuns =
+            config.maxConcurrentRuns ?? TASK_DEFAULTS.maxConcurrentRuns;
+    }
+    async initialize() {
+        logger.info("[NodeTimeout] Backend initialized");
+    }
+    async shutdown() {
+        this.disposed = true;
+        for (const entry of this.scheduled.values()) {
+            this.clearEntry(entry);
+        }
+        this.scheduled.clear();
+        this.paused.clear();
+        logger.info("[NodeTimeout] Backend shut down");
+    }
+    async schedule(task, executor) {
+        // Cancel existing schedule for this task if any
+        await this.cancel(task.id);
+        const entry = { taskId: task.id, executor, task };
+        const schedule = task.schedule;
+        if (schedule.type === "cron") {
+            entry.cronJob = new Cron(schedule.expression, {
+                timezone: schedule.timezone,
+                catch: (err) => {
+                    logger.error("[NodeTimeout] Cron execution error", {
+                        taskId: task.id,
+                        error: String(err),
+                    });
+                },
+            }, () => {
+                this.executeTask(entry);
+            });
+        }
+        else if (schedule.type === "interval") {
+            // Wait for the first interval tick before executing
+            entry.intervalId = setInterval(() => {
+                this.executeTask(entry);
+            }, schedule.every);
+        }
+        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());
+            entry.timeoutId = setTimeout(() => {
+                this.executeTask(entry);
+                this.scheduled.delete(task.id);
+            }, delay);
+        }
+        this.scheduled.set(task.id, entry);
+        logger.info("[NodeTimeout] Task scheduled", {
+            taskId: task.id,
+            type: schedule.type,
+        });
+    }
+    async cancel(taskId) {
+        const entry = this.scheduled.get(taskId);
+        if (entry) {
+            this.clearEntry(entry);
+            this.scheduled.delete(taskId);
+        }
+        this.paused.delete(taskId);
+        logger.debug("[NodeTimeout] Task cancelled", { taskId });
+    }
+    async pause(taskId) {
+        const entry = this.scheduled.get(taskId);
+        if (!entry) {
+            return;
+        }
+        this.clearEntry(entry);
+        this.scheduled.delete(taskId);
+        // Save the entry so we can re-schedule on resume
+        this.paused.set(taskId, entry);
+        logger.info("[NodeTimeout] Task paused", { taskId });
+    }
+    async resume(taskId) {
+        const entry = this.paused.get(taskId);
+        if (!entry) {
+            return;
+        }
+        this.paused.delete(taskId);
+        // Re-schedule with the saved task and executor
+        await this.schedule(entry.task, entry.executor);
+        logger.info("[NodeTimeout] Task resumed", { taskId });
+    }
+    async isHealthy() {
+        return !this.disposed;
+    }
+    // ── Internal ──────────────────────────────────────────
+    executeTask(entry) {
+        if (this.activeRuns >= this.maxConcurrentRuns) {
+            logger.warn("[NodeTimeout] Max concurrent runs reached, skipping tick", {
+                taskId: entry.taskId,
+                activeRuns: this.activeRuns,
+                maxConcurrentRuns: this.maxConcurrentRuns,
+            });
+            return;
+        }
+        this.activeRuns++;
+        entry
+            .executor(entry.task)
+            .catch((err) => {
+            logger.error("[NodeTimeout] Task execution failed", {
+                taskId: entry.taskId,
+                error: String(err),
+            });
+        })
+            .finally(() => {
+            this.activeRuns--;
+        });
+    }
+    clearEntry(entry) {
+        if (entry.cronJob) {
+            entry.cronJob.stop();
+        }
+        if (entry.intervalId !== undefined) {
+            clearInterval(entry.intervalId);
+        }
+        if (entry.timeoutId !== undefined) {
+            clearTimeout(entry.timeoutId);
+        }
+    }
+}
+//# sourceMappingURL=nodeTimeoutBackend.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * TaskBackendRegistry — registration point for all task backend implementations.
+ * Follows the same pattern as ProviderRegistry: dynamic imports, lazy registration.
+ */
+import type { TaskBackendName, TaskBackendFactoryFn, TaskManagerConfig, TaskBackend } from "../../types/taskTypes.js";
+export declare class TaskBackendRegistry {
+    private static factories;
+    private static registered;
+    /**
+     * Register a backend factory function.
+     * Can be called externally to add custom backends (e.g., "pg-boss").
+     */
+    static register(name: string, factory: TaskBackendFactoryFn): void;
+    /**
+     * Register the built-in backends (BullMQ, NodeTimeout).
+     * Idempotent — safe to call multiple times.
+     */
+    static registerDefaults(): void;
+    /**
+     * Create a backend instance by name.
+     */
+    static create(name: TaskBackendName | string, config: TaskManagerConfig): Promise<TaskBackend>;
+    /**
+     * Check if a backend is registered.
+     */
+    static has(name: string): boolean;
+    /**
+     * List all registered backend names.
+     */
+    static getAvailable(): string[];
+}