@juspay/neurolink 9.51.4 → 9.53.0

package/dist/tasks/autoresearchTaskExecutor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Autoresearch task executor — bridges TaskManager with the
+ * autoresearch experiment loop.
+ *
+ * Each tick:
+ * 1. Loads/creates a ResearchWorker for the task's tag
+ * 2. Gets the phase-appropriate tool filter
+ * 3. Calls NeuroLink.generate() with research tools + prompt
+ * 4. Advances phase based on which tools the AI called
+ * 5. Returns a TaskRunResult
+ *
+ * Workers are cached by tag to avoid re-initialization on each tick.
+ * Forwards the NeuroLink emitter to each worker for lifecycle events.
+ */
+import type { AutoresearchEmitter } from "../types/autoresearchTypes.js";
+import type { NeuroLinkExecutable, Task, TaskRunResult } from "../types/taskTypes.js";
+/**
+ * Clear all cached workers. Called by TaskManager.shutdown().
+ */
+export declare function clearWorkerCache(): void;
+/**
+ * Execute one autoresearch tick for a task.
+ *
+ * Returns a TaskRunResult-shaped object.
+ * If the task is missing autoresearch config, returns an error result
+ * instead of throwing (so the scheduler can record the failure).
+ *
+ * @param emitter - Optional emitter to forward autoresearch lifecycle events
+ */
+export declare function executeAutoresearchTick(task: Task & {
+    autoresearch?: unknown;
+}, neurolink: NeuroLinkExecutable, emitter?: AutoresearchEmitter): Promise<TaskRunResult>;

package/dist/tasks/autoresearchTaskExecutor.js

@@ -0,0 +1,302 @@
+/**
+ * Autoresearch task executor — bridges TaskManager with the
+ * autoresearch experiment loop.
+ *
+ * Each tick:
+ * 1. Loads/creates a ResearchWorker for the task's tag
+ * 2. Gets the phase-appropriate tool filter
+ * 3. Calls NeuroLink.generate() with research tools + prompt
+ * 4. Advances phase based on which tools the AI called
+ * 5. Returns a TaskRunResult
+ *
+ * Workers are cached by tag to avoid re-initialization on each tick.
+ * Forwards the NeuroLink emitter to each worker for lifecycle events.
+ */
+import { ResearchWorker } from "../autoresearch/worker.js";
+import { withTimeout } from "../utils/errorHandling.js";
+import { logger } from "../utils/logger.js";
+// ── Worker cache ────────────────────────────────────────
+const workerCache = new Map();
+/**
+ * Clear all cached workers. Called by TaskManager.shutdown().
+ */
+export function clearWorkerCache() {
+    workerCache.clear();
+    logger.debug("[AutoresearchExecutor] Worker cache cleared");
+}
+// ── Phase advancement ──────────────────────────────────
+/**
+ * Determine the next phase based on which tools the AI called.
+ *
+ * The worker path (`runExperimentCycle`) drives phases internally.
+ * The task path must replicate that advancement here. The mapping:
+ *
+ *   bootstrap → (get_context called) → propose
+ *   propose   → (read_file called)   → edit
+ *   edit      → (write_candidate)    → commit
+ *   commit    → (commit_candidate)   → run
+ *   run       → (run_experiment)     → evaluate
+ *   evaluate  → (parse_log)          → record
+ *   record    → (record called)      → accept_or_revert
+ *   accept_or_revert → (accept/revert) → propose
+ *
+ * Returns null if no advancement is indicated (e.g. no recognised tools called).
+ */
+function inferNextPhase(currentPhase, calledTools) {
+    if (calledTools.length === 0) {
+        return null;
+    }
+    // Compute phase advancement per-tool against the running accumulated phase
+    function phaseAfterTool(toolName, phase) {
+        switch (toolName) {
+            case "research_get_context":
+                return phase === "bootstrap" || phase === "propose" ? "propose" : phase;
+            case "research_read_file":
+                return phase === "propose" ? "edit" : phase;
+            case "research_write_candidate":
+                return "commit";
+            case "research_commit_candidate":
+                return "run";
+            case "research_run_experiment":
+                return "evaluate";
+            case "research_parse_log":
+                return "record";
+            case "research_record":
+                return "accept_or_revert";
+            case "research_accept":
+                return "propose";
+            case "research_revert":
+                return "propose";
+            default:
+                return phase; // informational tools don't advance
+        }
+    }
+    // Walk the called tools in order, accumulating phase progression
+    let nextPhase = currentPhase;
+    for (const toolName of calledTools) {
+        nextPhase = phaseAfterTool(toolName, nextPhase);
+    }
+    return nextPhase !== currentPhase ? nextPhase : null;
+}
+/**
+ * Get or create a ResearchWorker for the given task.
+ * When an emitter is provided, it is injected into the worker
+ * so that autoresearch:* events flow through the central event bus.
+ */
+async function getOrCreateWorker(task, emitter) {
+    const tag = `task-${task.id}`;
+    const cached = workerCache.get(tag);
+    if (cached) {
+        // Re-inject emitter in case it changed (e.g. after re-initialization)
+        if (emitter) {
+            cached.setEmitter(emitter);
+        }
+        // Attempt to resume existing state
+        try {
+            await cached.resume();
+            return cached;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            // Only re-initialize if state is genuinely missing; surface other errors
+            if (msg.includes("STATE_NOT_FOUND") || msg.includes("No state file")) {
+                workerCache.delete(tag);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    // Validated at caller (line 184 returns early if missing)
+    const config = task.autoresearch;
+    const worker = new ResearchWorker({
+        repoPath: config.repoPath,
+        mutablePaths: config.mutablePaths,
+        runCommand: config.runCommand,
+        metric: config.metric,
+        ...(config.immutablePaths ? { immutablePaths: config.immutablePaths } : {}),
+        ...(config.timeoutMs ? { timeoutMs: config.timeoutMs } : {}),
+        ...(config.provider ? { provider: config.provider } : {}),
+        ...(config.model ? { model: config.model } : {}),
+        ...(config.thinkingLevel ? { thinkingLevel: config.thinkingLevel } : {}),
+        ...(config.maxExperiments ? { maxExperiments: config.maxExperiments } : {}),
+        // Forward artifact layout fields so scheduled runs match standalone config
+        ...(config.programPath ? { programPath: config.programPath } : {}),
+        ...(config.resultsPath ? { resultsPath: config.resultsPath } : {}),
+        ...(config.statePath ? { statePath: config.statePath } : {}),
+        ...(config.logPath ? { logPath: config.logPath } : {}),
+        ...(config.branchPrefix ? { branchPrefix: config.branchPrefix } : {}),
+        ...(config.memoryMetric ? { memoryMetric: config.memoryMetric } : {}),
+    });
+    // Inject emitter before initialization so init events are captured
+    if (emitter) {
+        worker.setEmitter(emitter);
+    }
+    // Try resuming existing state first; only initialize if state is genuinely missing
+    try {
+        await worker.resume();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("STATE_NOT_FOUND") || msg.includes("No state file")) {
+            await worker.initialize(tag);
+        }
+        else {
+            throw err;
+        }
+    }
+    workerCache.set(tag, worker);
+    return worker;
+}
+/**
+ * Execute one autoresearch tick for a task.
+ *
+ * Returns a TaskRunResult-shaped object.
+ * If the task is missing autoresearch config, returns an error result
+ * instead of throwing (so the scheduler can record the failure).
+ *
+ * @param emitter - Optional emitter to forward autoresearch lifecycle events
+ */
+export async function executeAutoresearchTick(task, neurolink, emitter) {
+    const startTime = Date.now();
+    const runId = `ar_${Date.now()}`;
+    // Validate config presence
+    if (!task.autoresearch) {
+        return {
+            taskId: task.id,
+            runId,
+            status: "error",
+            error: `Task ${task.id} has type=autoresearch but no autoresearch config`,
+            durationMs: Date.now() - startTime,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    try {
+        const worker = await getOrCreateWorker(task, emitter);
+        // Get phase-appropriate tools and filter
+        const tools = worker.getTools();
+        const toolFilter = await worker.getToolFilterForCurrentPhase();
+        const systemPrompt = await worker.getSystemPrompt();
+        const cyclePrompt = await worker.getCyclePrompt();
+        // Register research tools on NeuroLink if it supports registerTool
+        const sdk = neurolink;
+        if (typeof sdk.registerTool === "function") {
+            for (const [name, tool] of Object.entries(tools)) {
+                sdk.registerTool(name, tool);
+            }
+        }
+        // Get the current phase's forced tool (if any)
+        const phasePolicy = await worker.getPhaseToolPolicy();
+        // Extract provider/model from autoresearch config
+        const arConfig = task.autoresearch;
+        // Create an AbortController so the tick respects the task timeout.
+        // Each tick should complete within a bounded time; 20 tool-call steps
+        // is enough for one explore→write→experiment→record cycle.
+        const tickTimeoutMs = (task.timeout ?? 120_000);
+        const abortController = new AbortController();
+        const abortTimer = setTimeout(() => abortController.abort(), tickTimeoutMs);
+        // Call generate
+        const generateOptions = {
+            input: { text: cyclePrompt },
+            systemPrompt,
+            tools: true,
+            skipToolPromptInjection: true,
+            maxSteps: 20, // Bound tool-call steps per tick to avoid runaway loops
+            abortSignal: abortController.signal,
+            // Forward provider/model from autoresearch config
+            ...(arConfig?.provider ? { provider: arConfig.provider } : {}),
+            ...(arConfig?.model ? { model: arConfig.model } : {}),
+            ...(arConfig?.thinkingLevel || task.thinkingLevel
+                ? {
+                    thinkingConfig: {
+                        thinkingLevel: arConfig?.thinkingLevel ?? task.thinkingLevel,
+                    },
+                }
+                : {}),
+            ...(task.timeout ? { timeout: task.timeout } : {}),
+            // Phase tool restrictions
+            toolFilter,
+            // Use prepareStep to force tool only on first step, not all steps
+            ...(phasePolicy.forcedTool
+                ? {
+                    prepareStep: ({ stepNumber }) => {
+                        if (stepNumber === 0) {
+                            return {
+                                toolChoice: {
+                                    type: "tool",
+                                    toolName: phasePolicy.forcedTool,
+                                },
+                            };
+                        }
+                        return {};
+                    },
+                }
+                : {}),
+            // Observability
+            requestId: runId,
+            ...(task.metadata?.maxBudgetUsd
+                ? { maxBudgetUsd: task.metadata.maxBudgetUsd }
+                : {}),
+        };
+        let result;
+        try {
+            result = await withTimeout(neurolink.generate(generateOptions), tickTimeoutMs, new Error(`Autoresearch tick exceeded ${tickTimeoutMs}ms timeout`));
+        }
+        finally {
+            clearTimeout(abortTimer);
+        }
+        // ── Phase advancement ──────────────────────────────
+        // The deterministic worker path (runExperimentCycle) advances
+        // phases internally.  The task path must do it here, based on
+        // which tools the AI actually called this tick.
+        const calledTools = (result.toolExecutions ?? [])
+            .map((te) => {
+            const t = te;
+            return typeof t.name === "string" ? t.name : "";
+        })
+            .filter(Boolean);
+        const currentState = await worker.getState();
+        const currentPhase = currentState?.currentPhase ?? "bootstrap";
+        const nextPhase = inferNextPhase(currentPhase, calledTools);
+        if (nextPhase) {
+            await worker.advancePhase(nextPhase);
+            logger.debug("[AutoresearchExecutor] Phase advanced", {
+                from: currentPhase,
+                to: nextPhase,
+                calledTools,
+            });
+        }
+        return {
+            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(),
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.error("[AutoresearchExecutor] Tick failed", {
+            taskId: task.id,
+            runId,
+            error: msg,
+        });
+        return {
+            taskId: task.id,
+            runId,
+            status: "error",
+            error: msg,
+            durationMs: Date.now() - startTime,
+            timestamp: new Date().toISOString(),
+        };
+    }
+}

package/dist/tasks/errors.d.ts

@@ -12,6 +12,7 @@ export declare const TaskErrorCodes: {
     readonly TASK_LIMIT_REACHED: "TASK-005";
     readonly TASK_DISABLED: "TASK-006";
     readonly SCHEDULE_FAILED: "TASK-007";
+    readonly TASK_VALIDATION_FAILED: "TASK-008";
 };
 export declare const TaskError: {
     codes: {
@@ -22,8 +23,9 @@ export declare const TaskError: {
         readonly TASK_LIMIT_REACHED: "TASK-005";
         readonly TASK_DISABLED: "TASK-006";
         readonly SCHEDULE_FAILED: "TASK-007";
+        readonly TASK_VALIDATION_FAILED: "TASK-008";
     };
-    create: (code: "TASK_NOT_FOUND" | "BACKEND_NOT_INITIALIZED" | "BACKEND_UNKNOWN" | "INVALID_TASK_STATUS" | "TASK_LIMIT_REACHED" | "TASK_DISABLED" | "SCHEDULE_FAILED", message: string, options?: {
+    create: (code: "TASK_NOT_FOUND" | "BACKEND_NOT_INITIALIZED" | "BACKEND_UNKNOWN" | "INVALID_TASK_STATUS" | "TASK_LIMIT_REACHED" | "TASK_DISABLED" | "SCHEDULE_FAILED" | "TASK_VALIDATION_FAILED", message: string, options?: {
         retryable?: boolean;
         details?: Record<string, unknown>;
         cause?: Error;

package/dist/tasks/errors.js

@@ -13,5 +13,6 @@ export const TaskErrorCodes = {
     TASK_LIMIT_REACHED: "TASK-005",
     TASK_DISABLED: "TASK-006",
     SCHEDULE_FAILED: "TASK-007",
+    TASK_VALIDATION_FAILED: "TASK-008",
 };
 export const TaskError = createErrorFactory("Task", TaskErrorCodes);

package/dist/tasks/taskExecutor.d.ts

@@ -7,11 +7,13 @@
  * - Retry with exponential backoff for transient errors
  * - Run result construction and logging
  */
-import type { TaskStore, Task, TaskRunResult, NeuroLinkExecutable } from "../types/taskTypes.js";
+import type { AutoresearchEmitter } from "../types/autoresearchTypes.js";
+import type { NeuroLinkExecutable, Task, TaskRunResult, TaskStore } from "../types/taskTypes.js";
 export declare class TaskExecutor {
     private neurolink;
     private store;
-    constructor(neurolink: NeuroLinkExecutable, store: TaskStore);
+    private emitter?;
+    constructor(neurolink: NeuroLinkExecutable, store: TaskStore, emitter?: AutoresearchEmitter | undefined);
     /**
      * Execute a task once. Called by the backend on each scheduled tick.
      * Returns the run result (success or error).

package/dist/tasks/taskExecutor.js

@@ -9,6 +9,7 @@
  */
 import { nanoid } from "nanoid";
 import { logger } from "../utils/logger.js";
+import { executeAutoresearchTick } from "./autoresearchTaskExecutor.js";
 /** Errors that are transient and should be retried */
 const TRANSIENT_PATTERNS = [
     "rate limit",
@@ -31,9 +32,11 @@ function isTransientError(error) {
 export class TaskExecutor {
     neurolink;
     store;
-    constructor(neurolink, store) {
+    emitter;
+    constructor(neurolink, store, emitter) {
         this.neurolink = neurolink;
         this.store = store;
+        this.emitter = emitter;
     }
     /**
      * Execute a task once. Called by the backend on each scheduled tick.
@@ -80,6 +83,10 @@ export class TaskExecutor {
     }
     // ── Internal ──────────────────────────────────────────
     async executeOnce(task, runId) {
+        // ── Autoresearch routing ──
+        if (task.type === "autoresearch") {
+            return executeAutoresearchTick(task, this.neurolink, this.emitter);
+        }
         const startTime = Date.now();
         // Build generate options
         const generateOptions = {

package/dist/tasks/taskManager.js

@@ -9,11 +9,12 @@
  *   await neurolink.tasks.create({ name: "monitor", prompt: "...", schedule: { type: "interval", every: 60000 } });
  */
 import { nanoid } from "nanoid";
+import { TASK_DEFAULTS, } from "../types/taskTypes.js";
 import { logger } from "../utils/logger.js";
+import { clearWorkerCache } from "./autoresearchTaskExecutor.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;
@@ -60,8 +61,8 @@ export class TaskManager {
         // Create backend
         this.backend = await TaskBackendRegistry.create(backendName, this.config);
         await this.backend.initialize();
-        // Create executor
-        this.executor = new TaskExecutor(this.neurolink, this.store);
+        // Create executor (pass emitter for autoresearch lifecycle events)
+        this.executor = new TaskExecutor(this.neurolink, this.store, this.emitter);
         // Re-schedule active tasks from store (handles restarts)
         await this.rescheduleActiveTasks();
         this.initialized = true;
@@ -103,12 +104,31 @@ export class TaskManager {
             throw TaskError.create("TASK_LIMIT_REACHED", `Task limit reached (${maxTasks}). Delete existing tasks or increase maxTasks config.`);
         }
         const now = new Date().toISOString();
+        // Autoresearch validation
+        const taskType = definition.type ?? "standard";
+        if (taskType === "autoresearch") {
+            const ar = definition.autoresearch;
+            if (!ar) {
+                throw TaskError.create("TASK_VALIDATION_FAILED", 'Tasks with type "autoresearch" require an autoresearch config.');
+            }
+            if (!ar.repoPath ||
+                !ar.runCommand ||
+                !ar.mutablePaths?.length ||
+                !ar.metric) {
+                throw TaskError.create("TASK_VALIDATION_FAILED", "Autoresearch config must include repoPath, runCommand, mutablePaths (non-empty), and metric.");
+            }
+        }
+        // Reject autoresearch config on non-autoresearch tasks
+        if (definition.autoresearch && taskType !== "autoresearch") {
+            throw TaskError.create("TASK_VALIDATION_FAILED", 'Tasks with autoresearch config must have type "autoresearch".');
+        }
         const task = {
             id: `task_${nanoid(12)}`,
             name: definition.name,
             prompt: definition.prompt,
             schedule: definition.schedule,
             mode: definition.mode ?? TASK_DEFAULTS.mode,
+            type: taskType,
             status: "active",
             tools: definition.tools ?? TASK_DEFAULTS.tools,
             timeout: definition.timeout ?? TASK_DEFAULTS.timeout,
@@ -138,6 +158,9 @@ export class TaskManager {
                 ? { maxRuns: definition.maxRuns }
                 : {}),
             ...(definition.metadata ? { metadata: definition.metadata } : {}),
+            ...(definition.autoresearch
+                ? { autoresearch: definition.autoresearch }
+                : {}),
         };
         // Generate session ID for continuation mode
         if (task.mode === "continuation") {
@@ -352,6 +375,7 @@ export class TaskManager {
             await this.store.shutdown();
         }
         this.callbacks.clear();
+        clearWorkerCache();
         this.initialized = false;
         this.initPromise = null;
         logger.info("[TaskManager] Shut down");

package/dist/tasks/tools/taskTools.d.ts

@@ -58,7 +58,7 @@ export declare function createTaskTools(manager: TaskManager): {
         schedule?: undefined;
     }>;
     listTasks: import("ai").Tool<{
-        status?: "failed" | "pending" | "active" | "paused" | "completed" | "cancelled" | undefined;
+        status?: "failed" | "pending" | "completed" | "cancelled" | "active" | "paused" | undefined;
     }, {
         success: boolean;
         count: number;

package/dist/telemetry/attributes.d.ts

@@ -87,4 +87,19 @@ export declare const ATTR: {
     readonly CONTEXT_TOKENS_AFTER: "context.tokens_after";
     readonly MW_COUNT: "middleware.count";
     readonly MW_NAMES: "middleware.names";
+    readonly AR_TAG: "autoresearch.tag";
+    readonly AR_BRANCH: "autoresearch.branch";
+    readonly AR_PHASE: "autoresearch.phase";
+    readonly AR_PHASE_FROM: "autoresearch.phase_from";
+    readonly AR_PHASE_TO: "autoresearch.phase_to";
+    readonly AR_RUN_COUNT: "autoresearch.run_count";
+    readonly AR_KEEP_COUNT: "autoresearch.keep_count";
+    readonly AR_STATUS: "autoresearch.status";
+    readonly AR_METRIC: "autoresearch.metric";
+    readonly AR_BEST_METRIC: "autoresearch.best_metric";
+    readonly AR_DIRECTION: "autoresearch.metric_direction";
+    readonly AR_COMMIT: "autoresearch.commit";
+    readonly AR_DURATION_MS: "autoresearch.duration_ms";
+    readonly AR_DESCRIPTION: "autoresearch.description";
+    readonly AR_ERROR_CODE: "autoresearch.error_code";
 };

package/dist/telemetry/attributes.js

@@ -97,4 +97,20 @@ export const ATTR = {
     // Middleware
     MW_COUNT: "middleware.count",
     MW_NAMES: "middleware.names",
+    // Autoresearch
+    AR_TAG: "autoresearch.tag",
+    AR_BRANCH: "autoresearch.branch",
+    AR_PHASE: "autoresearch.phase",
+    AR_PHASE_FROM: "autoresearch.phase_from",
+    AR_PHASE_TO: "autoresearch.phase_to",
+    AR_RUN_COUNT: "autoresearch.run_count",
+    AR_KEEP_COUNT: "autoresearch.keep_count",
+    AR_STATUS: "autoresearch.status",
+    AR_METRIC: "autoresearch.metric",
+    AR_BEST_METRIC: "autoresearch.best_metric",
+    AR_DIRECTION: "autoresearch.metric_direction",
+    AR_COMMIT: "autoresearch.commit",
+    AR_DURATION_MS: "autoresearch.duration_ms",
+    AR_DESCRIPTION: "autoresearch.description",
+    AR_ERROR_CODE: "autoresearch.error_code",
 };

package/dist/telemetry/tracers.d.ts

@@ -13,4 +13,5 @@ export declare const tracers: {
     readonly middleware: import("@opentelemetry/api").Tracer;
     readonly processor: import("@opentelemetry/api").Tracer;
     readonly file: import("@opentelemetry/api").Tracer;
+    readonly autoresearch: import("@opentelemetry/api").Tracer;
 };

package/dist/telemetry/tracers.js

@@ -14,4 +14,5 @@ export const tracers = {
     middleware: trace.getTracer("neurolink.middleware"),
     processor: trace.getTracer("neurolink.processor"),
     file: trace.getTracer("neurolink.file"),
+    autoresearch: trace.getTracer("neurolink.autoresearch"),
 };