@juspay/neurolink 9.39.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.
@@ -181,6 +197,10 @@ export declare class NeuroLink {
     private registerMemoryRetrievalTools;
     /** Format memory context for prompt inclusion */
     private formatMemoryContext;
+    /**
+     * Format memory context from multiple users into a labeled block.
+     */
+    private formatMultiUserMemoryContext;
     /**
      * Determine whether memory should be read (retrieved) for this call.
      * Respects both the global memory SDK config and per-call overrides.
@@ -192,13 +212,14 @@ export declare class NeuroLink {
      */
     private shouldWriteMemory;
     /**
-     * Retrieve condensed memory for a user.
+     * Retrieve condensed memory for a user (and optionally additional users).
      * Returns the input text enhanced with memory context, or unchanged if no memory.
      */
     private retrieveMemory;
     /**
      * Store a conversation turn in memory (non-blocking).
      * Calls add(userId, content) which internally condenses old + new via LLM.
+     * Supports additional users with per-user prompt and maxWords overrides.
      */
     private storeMemoryInBackground;
     /**

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.
@@ -823,6 +896,20 @@ export class NeuroLink {
 
 ${memoryContext}
 
+Current user's request: ${currentInput}`;
+    }
+    /**
+     * Format memory context from multiple users into a labeled block.
+     */
+    formatMultiUserMemoryContext(memories, currentInput) {
+        const memoryBlocks = [];
+        for (const [label, memory] of memories) {
+            memoryBlocks.push(`[${label}]\n${memory}`);
+        }
+        return `Context from previous conversations:
+
+${memoryBlocks.join("\n\n")}
+
 Current user's request: ${currentInput}`;
     }
     /**
@@ -863,32 +950,71 @@ Current user's request: ${currentInput}`;
         return true;
     }
     /**
-     * Retrieve condensed memory for a user.
+     * Retrieve condensed memory for a user (and optionally additional users).
      * Returns the input text enhanced with memory context, or unchanged if no memory.
      */
-    async retrieveMemory(inputText, userId) {
+    async retrieveMemory(inputText, userId, additionalUsers) {
         const client = this.ensureMemoryReady();
         if (!client) {
             return inputText;
         }
-        const memory = await client.get(userId);
-        if (!memory) {
+        // Collect all user IDs to read (primary + additional users with read !== false)
+        const readableAdditional = (additionalUsers || []).filter((u) => u.read !== false);
+        if (readableAdditional.length === 0) {
+            // Single user — use original fast path
+            const memory = await client.get(userId);
+            if (!memory) {
+                return inputText;
+            }
+            return this.formatMemoryContext(memory, inputText);
+        }
+        // Multi-user: fetch all memories in parallel
+        // Build entries with labels for formatting
+        const entries = [
+            { id: userId, label: "User" },
+            ...readableAdditional.map((u) => ({
+                id: u.userId,
+                label: u.label || u.userId,
+            })),
+        ];
+        const results = await Promise.all(entries.map(async (entry) => {
+            const memory = await client.get(entry.id);
+            return { ...entry, memory };
+        }));
+        const memories = new Map();
+        for (const { label, memory } of results) {
+            if (memory) {
+                memories.set(label, memory);
+            }
+        }
+        if (memories.size === 0) {
             return inputText;
         }
-        return this.formatMemoryContext(memory, inputText);
+        return this.formatMultiUserMemoryContext(memories, inputText);
     }
     /**
      * Store a conversation turn in memory (non-blocking).
      * Calls add(userId, content) which internally condenses old + new via LLM.
+     * Supports additional users with per-user prompt and maxWords overrides.
      */
-    storeMemoryInBackground(originalPrompt, responseContent, userId) {
+    storeMemoryInBackground(originalPrompt, responseContent, userId, additionalUsers) {
         setImmediate(async () => {
             try {
                 const client = this.ensureMemoryReady();
-                if (client) {
-                    const content = `User: ${originalPrompt}\nAssistant: ${responseContent}`;
-                    await client.add(userId, content);
+                if (!client) {
+                    return;
                 }
+                const content = `User: ${originalPrompt}\nAssistant: ${responseContent}`;
+                // Collect all users to write: primary + additional users with write !== false
+                const writeOps = [client.add(userId, content)];
+                const writableAdditional = (additionalUsers || []).filter((u) => u.write !== false);
+                for (const user of writableAdditional) {
+                    const addOptions = user.prompt || user.maxWords
+                        ? { prompt: user.prompt, maxWords: user.maxWords }
+                        : undefined;
+                    writeOps.push(client.add(user.userId, content, addOptions));
+                }
+                await Promise.all(writeOps);
             }
             catch (error) {
                 logger.warn("Memory storage failed:", error);
@@ -1853,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 {
@@ -2428,6 +2566,17 @@ Current user's request: ${currentInput}`;
                                 });
                             }
                         }
+                        // Memory retrieval for generate path
+                        if (this.shouldReadMemory(options.memory, options.context?.userId) &&
+                            options.context?.userId) {
+                            try {
+                                options.input.text = await this.retrieveMemory(options.input.text, options.context.userId, options.memory?.additionalUsers);
+                                logger.debug("Memory retrieval successful (generate)");
+                            }
+                            catch (error) {
+                                logger.warn("Memory retrieval failed (generate):", error);
+                            }
+                        }
                         // 🔧 CRITICAL FIX: Convert to TextGenerationOptions while preserving the input object for multimodal support
                         const baseOptions = {
                             prompt: options.input.text,
@@ -2457,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
@@ -2613,7 +2764,7 @@ Current user's request: ${currentInput}`;
         // Memory storage
         if (this.shouldWriteMemory(options.memory, options.context?.userId, generateResult.content) &&
             options.context?.userId) {
-            this.storeMemoryInBackground(originalPrompt ?? "", generateResult.content.trim(), options.context.userId);
+            this.storeMemoryInBackground(originalPrompt ?? "", generateResult.content.trim(), options.context.userId, options.memory?.additionalUsers);
         }
     }
     /**
@@ -2681,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,
@@ -2772,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,
@@ -4411,7 +4578,7 @@ Current user's request: ${currentInput}`;
         if (this.shouldReadMemory(options.memory, options.context?.userId) &&
             options.context?.userId) {
             try {
-                options.input.text = await this.retrieveMemory(options.input.text, options.context.userId);
+                options.input.text = await this.retrieveMemory(options.input.text, options.context.userId, options.memory?.additionalUsers);
                 logger.debug("Memory retrieval successful");
             }
             catch (error) {
@@ -4724,7 +4891,7 @@ Current user's request: ${currentInput}`;
             }
         }
         if (this.shouldWriteMemory(enhancedOptions.memory, enhancedOptions.context?.userId, accumulatedContent)) {
-            this.storeMemoryInBackground(originalPrompt ?? "", accumulatedContent.trim(), enhancedOptions.context?.userId);
+            this.storeMemoryInBackground(originalPrompt ?? "", accumulatedContent.trim(), enhancedOptions.context?.userId, enhancedOptions.memory?.additionalUsers);
         }
     }
     /**
@@ -4982,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 = "";
@@ -8332,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;
+}