@juspay/neurolink 9.40.0 → 9.41.0

package/dist/lib/tasks/taskExecutor.js

@@ -0,0 +1,166 @@
+/**
+ * TaskExecutor — Runs a single task execution against NeuroLink.generate().
+ *
+ * Handles:
+ * - Isolated mode: fresh generate() call with no history
+ * - Continuation mode: loads conversation history, appends new exchange
+ * - Retry with exponential backoff for transient errors
+ * - Run result construction and logging
+ */
+import { nanoid } from "nanoid";
+import { logger } from "../utils/logger.js";
+/** Errors that are transient and should be retried */
+const TRANSIENT_PATTERNS = [
+    "rate limit",
+    "rate_limit",
+    "too many requests",
+    "429",
+    "503",
+    "502",
+    "504",
+    "timeout",
+    "econnreset",
+    "econnrefused",
+    "network",
+    "overloaded",
+];
+function isTransientError(error) {
+    const msg = String(error).toLowerCase();
+    return TRANSIENT_PATTERNS.some((p) => msg.includes(p));
+}
+export class TaskExecutor {
+    neurolink;
+    store;
+    constructor(neurolink, store) {
+        this.neurolink = neurolink;
+        this.store = store;
+    }
+    /**
+     * Execute a task once. Called by the backend on each scheduled tick.
+     * Returns the run result (success or error).
+     */
+    async execute(task) {
+        const runId = `run_${nanoid(12)}`;
+        const startTime = Date.now();
+        let lastError;
+        for (let attempt = 1; attempt <= task.retry.maxAttempts; attempt++) {
+            try {
+                const result = await this.executeOnce(task, runId);
+                return result;
+            }
+            catch (err) {
+                lastError = String(err);
+                const willRetry = attempt < task.retry.maxAttempts && isTransientError(err);
+                logger.warn("[TaskExecutor] Execution attempt failed", {
+                    taskId: task.id,
+                    runId,
+                    attempt,
+                    willRetry,
+                    error: lastError,
+                });
+                if (!willRetry) {
+                    break;
+                }
+                // Backoff before retry
+                const backoffIndex = Math.min(attempt - 1, task.retry.backoffMs.length - 1);
+                const delay = task.retry.backoffMs[backoffIndex];
+                await sleep(delay);
+            }
+        }
+        // All retries exhausted or permanent error
+        const errorResult = {
+            taskId: task.id,
+            runId,
+            status: "error",
+            error: lastError,
+            durationMs: Date.now() - startTime,
+            timestamp: new Date().toISOString(),
+        };
+        return errorResult;
+    }
+    // ── Internal ──────────────────────────────────────────
+    async executeOnce(task, runId) {
+        const startTime = Date.now();
+        // Build generate options
+        const generateOptions = {
+            input: { text: task.prompt },
+            ...(task.provider ? { provider: task.provider } : {}),
+            ...(task.model ? { model: task.model } : {}),
+            ...(task.systemPrompt ? { systemPrompt: task.systemPrompt } : {}),
+            ...(task.maxTokens ? { maxTokens: task.maxTokens } : {}),
+            ...(task.temperature !== undefined
+                ? { temperature: task.temperature }
+                : {}),
+            ...(task.timeout ? { timeout: task.timeout } : {}),
+            ...(!task.tools ? { disableTools: true } : {}),
+        };
+        // Thinking level
+        if (task.thinkingLevel) {
+            generateOptions.thinkingConfig = { thinkingLevel: task.thinkingLevel };
+        }
+        // Continuation mode: pass conversation history as proper multi-turn messages
+        if (task.mode === "continuation" && task.sessionId) {
+            const history = await this.store.getHistory(task.id);
+            // Pass history as proper role-based conversation messages
+            if (history.length > 0) {
+                generateOptions.conversationMessages = history.map((entry, i) => ({
+                    id: `${task.sessionId}_${i}`,
+                    role: entry.role,
+                    content: entry.content,
+                    timestamp: entry.timestamp,
+                }));
+            }
+            // Add continuation context to system prompt
+            const runCount = Math.floor(history.length / 2);
+            const continuationHint = runCount > 0
+                ? `This is a continuation task (run ${runCount + 1}). Your previous ${runCount} exchange(s) are provided as conversation history.`
+                : "This is a continuation task. This is the first execution — no prior history exists yet.";
+            generateOptions.systemPrompt = task.systemPrompt
+                ? `${task.systemPrompt}\n\n${continuationHint}`
+                : continuationHint;
+        }
+        // Execute
+        const result = await this.neurolink.generate(generateOptions);
+        // Build run result
+        const runResult = {
+            taskId: task.id,
+            runId,
+            status: "success",
+            output: result.content,
+            toolCalls: result.toolExecutions?.map((te) => ({
+                name: te.name,
+                input: te.input,
+                output: te.output,
+            })),
+            tokensUsed: result.usage
+                ? {
+                    input: result.usage.input ?? 0,
+                    output: result.usage.output ?? 0,
+                }
+                : undefined,
+            durationMs: Date.now() - startTime,
+            timestamp: new Date().toISOString(),
+        };
+        // Continuation mode: append this exchange to history
+        if (task.mode === "continuation" && task.sessionId) {
+            const newEntries = [
+                {
+                    role: "user",
+                    content: task.prompt,
+                    timestamp: new Date(startTime).toISOString(),
+                },
+                {
+                    role: "assistant",
+                    content: result.content,
+                    timestamp: runResult.timestamp,
+                },
+            ];
+            await this.store.appendHistory(task.id, newEntries);
+        }
+        return runResult;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=taskExecutor.js.map

package/dist/lib/tasks/taskManager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * TaskManager — Main orchestrator for scheduled and self-running tasks.
+ *
+ * Manages the full task lifecycle: create, schedule, execute, pause, resume, delete.
+ * Auto-selects TaskStore and TaskBackend based on config.
+ *
+ * Usage:
+ *   const neurolink = new NeuroLink({ tasks: { backend: "bullmq" } });
+ *   await neurolink.tasks.create({ name: "monitor", prompt: "...", schedule: { type: "interval", every: 60000 } });
+ */
+import { type NeuroLinkExecutable, type Task, type TaskDefinition, type TaskManagerConfig, type TaskRunResult, type TaskStatus } from "../types/taskTypes.js";
+export declare class TaskManager {
+    private neurolink;
+    private config;
+    private store;
+    private backend;
+    private executor;
+    private initialized;
+    private initPromise;
+    /** In-memory callback registry (not serializable to store) */
+    private callbacks;
+    /** Emitter reference — set by NeuroLink on integration */
+    private emitter?;
+    constructor(neurolink: NeuroLinkExecutable, config?: TaskManagerConfig);
+    /** Set the event emitter (called by NeuroLink during integration) */
+    setEmitter(emitter: {
+        emit(event: string, ...args: unknown[]): boolean;
+    }): void;
+    private ensureInitialized;
+    private doInitialize;
+    create(definition: TaskDefinition): Promise<Task>;
+    get(taskId: string): Promise<Task | null>;
+    list(filter?: {
+        status?: TaskStatus;
+    }): Promise<Task[]>;
+    update(taskId: string, updates: Partial<TaskDefinition>): Promise<Task>;
+    /** Run a task immediately (outside of its schedule) */
+    run(taskId: string): Promise<TaskRunResult>;
+    pause(taskId: string): Promise<Task>;
+    resume(taskId: string): Promise<Task>;
+    delete(taskId: string): Promise<void>;
+    runs(taskId: string, options?: {
+        limit?: number;
+        status?: string;
+    }): Promise<TaskRunResult[]>;
+    shutdown(): Promise<void>;
+    /** Check if the backend is healthy */
+    isHealthy(): Promise<boolean>;
+    /**
+     * Called by the backend on each scheduled tick.
+     * Executes the task, updates state, fires callbacks/events.
+     */
+    private onTaskTick;
+    /**
+     * Re-schedule all active tasks from store.
+     * Called on initialization to handle process restarts.
+     */
+    private rescheduleActiveTasks;
+    private emit;
+}

package/dist/lib/tasks/taskManager.js

@@ -0,0 +1,393 @@
+/**
+ * TaskManager — Main orchestrator for scheduled and self-running tasks.
+ *
+ * Manages the full task lifecycle: create, schedule, execute, pause, resume, delete.
+ * Auto-selects TaskStore and TaskBackend based on config.
+ *
+ * Usage:
+ *   const neurolink = new NeuroLink({ tasks: { backend: "bullmq" } });
+ *   await neurolink.tasks.create({ name: "monitor", prompt: "...", schedule: { type: "interval", every: 60000 } });
+ */
+import { nanoid } from "nanoid";
+import { logger } from "../utils/logger.js";
+import { TaskBackendRegistry } from "./backends/taskBackendRegistry.js";
+import { TaskError } from "./errors.js";
+import { TaskExecutor } from "./taskExecutor.js";
+import { TASK_DEFAULTS, } from "../types/taskTypes.js";
+export class TaskManager {
+    neurolink;
+    config;
+    store = null;
+    backend = null;
+    executor = null;
+    initialized = false;
+    initPromise = null;
+    /** In-memory callback registry (not serializable to store) */
+    callbacks = new Map();
+    /** Emitter reference — set by NeuroLink on integration */
+    emitter;
+    constructor(neurolink, config) {
+        this.neurolink = neurolink;
+        this.config = { ...config };
+    }
+    /** Set the event emitter (called by NeuroLink during integration) */
+    setEmitter(emitter) {
+        this.emitter = emitter;
+    }
+    // ── Initialization ──────────────────────────────────────
+    async ensureInitialized() {
+        if (this.initialized) {
+            return;
+        }
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this.doInitialize();
+        await this.initPromise;
+    }
+    async doInitialize() {
+        const backendName = this.config.backend ?? TASK_DEFAULTS.backend;
+        // Create store based on backend
+        if (backendName === "bullmq") {
+            const { RedisTaskStore } = await import("./store/redisTaskStore.js");
+            this.store = new RedisTaskStore(this.config);
+        }
+        else {
+            const { FileTaskStore } = await import("./store/fileTaskStore.js");
+            this.store = new FileTaskStore(this.config);
+        }
+        await this.store.initialize();
+        // Create backend
+        this.backend = await TaskBackendRegistry.create(backendName, this.config);
+        await this.backend.initialize();
+        // Create executor
+        this.executor = new TaskExecutor(this.neurolink, this.store);
+        // Re-schedule active tasks from store (handles restarts)
+        await this.rescheduleActiveTasks();
+        this.initialized = true;
+        logger.info("[TaskManager] Initialized", {
+            backend: backendName,
+            store: this.store.type,
+        });
+    }
+    // ── 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();
+        // Enforce maximum task limit to prevent unbounded task creation
+        const maxTasks = this.config.maxTasks ?? TASK_DEFAULTS.maxTasks;
+        const existingTasks = await this.store.list();
+        if (existingTasks.length >= maxTasks) {
+            throw TaskError.create("TASK_LIMIT_REACHED", `Task limit reached (${maxTasks}). Delete existing tasks or increase maxTasks config.`);
+        }
+        const now = new Date().toISOString();
+        const task = {
+            id: `task_${nanoid(12)}`,
+            name: definition.name,
+            prompt: definition.prompt,
+            schedule: definition.schedule,
+            mode: definition.mode ?? TASK_DEFAULTS.mode,
+            status: "active",
+            tools: definition.tools ?? TASK_DEFAULTS.tools,
+            timeout: definition.timeout ?? TASK_DEFAULTS.timeout,
+            retry: {
+                maxAttempts: definition.retry?.maxAttempts ?? TASK_DEFAULTS.retry.maxAttempts,
+                backoffMs: definition.retry?.backoffMs ?? [
+                    ...TASK_DEFAULTS.retry.backoffMs,
+                ],
+            },
+            runCount: 0,
+            createdAt: now,
+            updatedAt: now,
+            // Optional overrides
+            ...(definition.provider ? { provider: definition.provider } : {}),
+            ...(definition.model ? { model: definition.model } : {}),
+            ...(definition.thinkingLevel
+                ? { thinkingLevel: definition.thinkingLevel }
+                : {}),
+            ...(definition.systemPrompt
+                ? { systemPrompt: definition.systemPrompt }
+                : {}),
+            ...(definition.maxTokens ? { maxTokens: definition.maxTokens } : {}),
+            ...(definition.temperature !== undefined
+                ? { temperature: definition.temperature }
+                : {}),
+            ...(definition.maxRuns !== undefined
+                ? { maxRuns: definition.maxRuns }
+                : {}),
+            ...(definition.metadata ? { metadata: definition.metadata } : {}),
+        };
+        // Generate session ID for continuation mode
+        if (task.mode === "continuation") {
+            task.sessionId = `session_${nanoid(12)}`;
+        }
+        // Save to store
+        await this.store.save(task);
+        // Register callbacks (in-memory only)
+        if (definition.onSuccess || definition.onError || definition.onComplete) {
+            this.callbacks.set(task.id, {
+                onSuccess: definition.onSuccess,
+                onError: definition.onError,
+                onComplete: definition.onComplete,
+            });
+        }
+        // Schedule
+        try {
+            await this.backend.schedule(task, (t) => this.onTaskTick(t));
+        }
+        catch (err) {
+            await this.store.delete(task.id);
+            throw err;
+        }
+        this.emit("task:created", task);
+        logger.info("[TaskManager] Task created", {
+            taskId: task.id,
+            name: task.name,
+            schedule: task.schedule.type,
+            mode: task.mode,
+        });
+        return task;
+    }
+    async get(taskId) {
+        await this.ensureInitialized();
+        return this.store.get(taskId);
+    }
+    async list(filter) {
+        await this.ensureInitialized();
+        return this.store.list(filter);
+    }
+    async update(taskId, updates) {
+        await this.ensureInitialized();
+        const existing = await this.store.get(taskId);
+        if (!existing) {
+            throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
+        }
+        // Apply allowed scalar updates via whitelist
+        const ALLOWED_UPDATE_FIELDS = [
+            "name",
+            "prompt",
+            "schedule",
+            "mode",
+            "provider",
+            "model",
+            "systemPrompt",
+            "maxTokens",
+            "temperature",
+            "timeout",
+            "tools",
+            "maxRuns",
+            "metadata",
+            "thinkingLevel",
+        ];
+        const taskUpdates = {};
+        for (const field of ALLOWED_UPDATE_FIELDS) {
+            if (updates[field] !== undefined) {
+                taskUpdates[field] = updates[field];
+            }
+        }
+        // Special-case: mode changes require sessionId handling
+        if (updates.mode !== undefined) {
+            if (updates.mode === "continuation" && !existing.sessionId) {
+                taskUpdates.sessionId = `session_${nanoid(12)}`;
+            }
+            else if (updates.mode !== "continuation") {
+                taskUpdates.sessionId = undefined;
+                await this.store.clearHistory(taskId);
+            }
+        }
+        const updated = await this.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));
+        }
+        return updated;
+    }
+    /** Run a task immediately (outside of its schedule) */
+    async run(taskId) {
+        await this.ensureInitialized();
+        const task = await this.store.get(taskId);
+        if (!task) {
+            throw TaskError.create("TASK_NOT_FOUND", `Task not found: ${taskId}`);
+        }
+        return this.onTaskTick(task);
+    }
+    async pause(taskId) {
+        await this.ensureInitialized();
+        const task = await this.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" });
+        this.emit("task:paused", updated);
+        return updated;
+    }
+    async resume(taskId) {
+        await this.ensureInitialized();
+        const task = await this.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));
+        this.emit("task:resumed", updated);
+        return updated;
+    }
+    async delete(taskId) {
+        await this.ensureInitialized();
+        await this.backend.cancel(taskId);
+        await this.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);
+    }
+    async shutdown() {
+        if (this.backend) {
+            await this.backend.shutdown();
+        }
+        if (this.store) {
+            await this.store.shutdown();
+        }
+        this.callbacks.clear();
+        this.initialized = false;
+        this.initPromise = null;
+        logger.info("[TaskManager] Shut down");
+    }
+    /** Check if the backend is healthy */
+    async isHealthy() {
+        if (!this.backend) {
+            return false;
+        }
+        return this.backend.isHealthy();
+    }
+    // ── Internal ──────────────────────────────────────────
+    /**
+     * Called by the backend on each scheduled tick.
+     * Executes the task, updates state, fires callbacks/events.
+     */
+    async onTaskTick(task) {
+        this.emit("task:started", task);
+        // Re-read latest task state (may have been updated/paused since scheduling)
+        const current = await this.store.get(task.id);
+        if (!current || current.status !== "active") {
+            logger.debug("[TaskManager] Skipping tick for non-active task", {
+                taskId: task.id,
+                status: current?.status,
+            });
+            return {
+                taskId: task.id,
+                runId: "skipped",
+                status: "error",
+                error: "Task is not active",
+                durationMs: 0,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        const result = await this.executor.execute(current);
+        // Log the run
+        await this.store.appendRun(task.id, result);
+        // Update task tracking
+        const updates = {
+            runCount: current.runCount + 1,
+            lastRunAt: result.timestamp,
+        };
+        // Check if task should complete
+        if (current.maxRuns && current.runCount + 1 >= current.maxRuns) {
+            updates.status = "completed";
+            await this.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);
+        }
+        // Mark as failed on permanent error
+        if (result.status === "error" && current.schedule.type === "once") {
+            updates.status = "failed";
+        }
+        await this.store.update(task.id, updates);
+        // Fire callbacks
+        const cbs = this.callbacks.get(task.id);
+        if (cbs) {
+            try {
+                if (result.status === "success" && cbs.onSuccess) {
+                    await cbs.onSuccess(result);
+                }
+                if (result.status === "error" && cbs.onError) {
+                    await cbs.onError({
+                        taskId: task.id,
+                        runId: result.runId,
+                        error: result.error ?? "Unknown error",
+                        attempt: 1, // Executor handles retries internally and returns final result
+                        maxAttempts: current.retry.maxAttempts,
+                        willRetry: false,
+                        timestamp: result.timestamp,
+                    });
+                }
+                if (updates.status === "completed" || updates.status === "failed") {
+                    const finalTask = await this.store.get(task.id);
+                    if (finalTask && cbs.onComplete) {
+                        await cbs.onComplete(finalTask);
+                    }
+                }
+            }
+            catch (cbErr) {
+                logger.error("[TaskManager] Callback error", {
+                    taskId: task.id,
+                    error: String(cbErr),
+                });
+            }
+        }
+        // Emit events
+        if (result.status === "success") {
+            this.emit("task:completed", result);
+        }
+        else {
+            this.emit("task:failed", result);
+        }
+        return result;
+    }
+    /**
+     * Re-schedule all active tasks from store.
+     * Called on initialization to handle process restarts.
+     */
+    async rescheduleActiveTasks() {
+        const activeTasks = await this.store.list({ status: "active" });
+        for (const task of activeTasks) {
+            try {
+                await this.backend.schedule(task, (t) => this.onTaskTick(t));
+                logger.debug("[TaskManager] Re-scheduled task", {
+                    taskId: task.id,
+                    name: task.name,
+                });
+            }
+            catch (err) {
+                logger.error("[TaskManager] Failed to re-schedule task", {
+                    taskId: task.id,
+                    error: String(err),
+                });
+            }
+        }
+        if (activeTasks.length > 0) {
+            logger.info("[TaskManager] Re-scheduled active tasks", {
+                count: activeTasks.length,
+            });
+        }
+    }
+    emit(event, ...args) {
+        this.emitter?.emit(event, ...args);
+    }
+}
+//# sourceMappingURL=taskManager.js.map