@elizaos/plugin-agent-orchestrator 0.3.12 → 0.3.13

package/dist/api/agent-routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-routes.d.ts","sourceRoot":"","sources":["../../src/api/agent-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AASjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAWhD;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,YAAY,GAChB,OAAO,CAAC,OAAO,CAAC,CAwdlB"}
+{"version":3,"file":"agent-routes.d.ts","sourceRoot":"","sources":["../../src/api/agent-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAajE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiMhD;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,YAAY,GAChB,OAAO,CAAC,OAAO,CAAC,CAuelB"}

package/dist/index.js

@@ -537,6 +537,7 @@ __export(exports_swarm_decision_loop, {
   handleBlocked: () => handleBlocked,
   handleAutonomousDecision: () => handleAutonomousDecision,
   executeDecision: () => executeDecision,
+  clearDeferredTurnCompleteTimers: () => clearDeferredTurnCompleteTimers,
   checkAllTasksComplete: () => checkAllTasksComplete,
   POST_SEND_COOLDOWN_MS: () => POST_SEND_COOLDOWN_MS
 });
@@ -554,6 +555,12 @@ function withTimeout(promise, ms, label) {
     });
   });
 }
+function clearDeferredTurnCompleteTimers() {
+  for (const timer of deferredTurnCompleteTimers.values()) {
+    clearTimeout(timer);
+  }
+  deferredTurnCompleteTimers.clear();
+}
 function toContextSummary(taskCtx) {
   return {
     sessionId: taskCtx.sessionId,
@@ -733,14 +740,23 @@ function checkAllTasksComplete(ctx) {
   };
   if (swarmCompleteCb) {
     ctx.log("checkAllTasksComplete: swarm complete callback is wired — calling synthesis");
-    const taskSummaries = tasks.map((t) => ({
-      sessionId: t.sessionId,
-      label: t.label,
-      agentType: t.agentType,
-      originalTask: t.originalTask,
-      status: t.status,
-      completionSummary: t.completionSummary ?? ""
-    }));
+    const taskSummaries = tasks.map((t) => {
+      const decisions = ctx.sharedDecisions.filter((sd) => sd.agentLabel === t.label).map((sd) => sd.summary);
+      const summaryParts = [];
+      if (decisions.length > 0)
+        summaryParts.push(decisions.join("; "));
+      if (t.completionSummary)
+        summaryParts.push(t.completionSummary);
+      return {
+        sessionId: t.sessionId,
+        label: t.label,
+        agentType: t.agentType,
+        originalTask: t.originalTask,
+        status: t.status,
+        completionSummary: summaryParts.join(`
+`) || ""
+      };
+    });
     withTimeout(Promise.resolve().then(() => swarmCompleteCb({
       tasks: taskSummaries,
       total: tasks.length,
@@ -958,6 +974,8 @@ async function handleBlocked(ctx, sessionId, taskCtx, data) {
   }
 }
 async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
+  if (taskCtx.status !== "active")
+    return;
   if (ctx.inFlightDecisions.has(sessionId)) {
     ctx.log(`Buffering turn-complete for ${sessionId} (in-flight decision running)`);
     ctx.pendingTurnComplete.set(sessionId, data);
@@ -966,10 +984,35 @@ async function handleTurnComplete(ctx, sessionId, taskCtx, data) {
   if (taskCtx.lastInputSentAt) {
     const elapsed = Date.now() - taskCtx.lastInputSentAt;
     if (elapsed < POST_SEND_COOLDOWN_MS) {
+      ctx.pendingTurnComplete.set(sessionId, data);
+      if (!deferredTurnCompleteTimers.has(sessionId)) {
+        const delayMs = POST_SEND_COOLDOWN_MS - elapsed + 50;
+        const timer = setTimeout(() => {
+          deferredTurnCompleteTimers.delete(sessionId);
+          const pendingData = ctx.pendingTurnComplete.get(sessionId);
+          if (!pendingData)
+            return;
+          const currentTask = ctx.tasks.get(sessionId);
+          if (!currentTask || currentTask.status !== "active") {
+            ctx.pendingTurnComplete.delete(sessionId);
+            return;
+          }
+          handleTurnComplete(ctx, sessionId, currentTask, pendingData).catch((err) => {
+            ctx.log(`Deferred turn-complete replay failed for ${sessionId}: ${err}`);
+          });
+        }, delayMs);
+        deferredTurnCompleteTimers.set(sessionId, timer);
+      }
       ctx.log(`Suppressing turn-complete for "${taskCtx.label}" — ` + `${Math.round(elapsed / 1000)}s since last input (cooldown ${POST_SEND_COOLDOWN_MS / 1000}s)`);
       return;
     }
   }
+  const deferredTimer = deferredTurnCompleteTimers.get(sessionId);
+  if (deferredTimer) {
+    clearTimeout(deferredTimer);
+    deferredTurnCompleteTimers.delete(sessionId);
+  }
+  ctx.pendingTurnComplete.delete(sessionId);
   ctx.inFlightDecisions.add(sessionId);
   try {
     ctx.log(`Turn complete for "${taskCtx.label}" — assessing whether task is done`);
@@ -1219,10 +1262,11 @@ async function handleConfirmDecision(ctx, sessionId, taskCtx, promptText, recent
     await drainPendingBlocked(ctx, sessionId);
   }
 }
-var DECISION_CB_TIMEOUT_MS = 30000, MAX_AUTO_RESPONSES = 10, POST_SEND_COOLDOWN_MS = 15000;
+var DECISION_CB_TIMEOUT_MS = 30000, MAX_AUTO_RESPONSES = 10, POST_SEND_COOLDOWN_MS = 15000, deferredTurnCompleteTimers;
 var init_swarm_decision_loop = __esm(() => {
   init_ansi_utils();
   init_swarm_event_triage();
+  deferredTurnCompleteTimers = new Map;
 });
 
 // src/actions/finalize-workspace.ts
@@ -3177,6 +3221,7 @@ async function scanIdleSessions(ctx) {
       if (!session) {
         ctx.log(`Idle watchdog: "${taskCtx.label}" — PTY session no longer exists, marking as stopped`);
         taskCtx.status = "stopped";
+        taskCtx.stoppedAt = now;
         taskCtx.decisions.push({
           timestamp: now,
           event: "idle_watchdog",
@@ -3220,6 +3265,7 @@ async function scanIdleSessions(ctx) {
     if (taskCtx.idleCheckCount >= MAX_IDLE_CHECKS) {
       ctx.log(`Idle watchdog: force-stopping "${taskCtx.label}" after ${MAX_IDLE_CHECKS} checks`);
       taskCtx.status = "stopped";
+      taskCtx.stoppedAt = now;
       taskCtx.decisions.push({
         timestamp: now,
         event: "idle_watchdog",
@@ -3354,6 +3400,7 @@ async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
 var UNREGISTERED_BUFFER_MS = 2000;
 var IDLE_SCAN_INTERVAL_MS = 60 * 1000;
 var PAUSE_TIMEOUT_MS = 30000;
+var STOPPED_RECOVERY_WINDOW_MS = 90000;
 
 class SwarmCoordinator {
   static serviceType = "SWARM_COORDINATOR";
@@ -3454,6 +3501,7 @@ class SwarmCoordinator {
     this.pendingDecisions.clear();
     this.inFlightDecisions.clear();
     this.pendingTurnComplete.clear();
+    clearDeferredTurnCompleteTimers();
     this.lastBlockedPromptFingerprint.clear();
     this.pendingBlocked.clear();
     this.unregisteredBuffer.clear();
@@ -3635,8 +3683,21 @@ class SwarmCoordinator {
       }
       return;
     }
+    let recoveredFromStopped = false;
     if (taskCtx.status === "stopped" || taskCtx.status === "error" || taskCtx.status === "completed") {
-      if (event !== "stopped" && event !== "error") {
+      if (taskCtx.status === "stopped" && event === "task_complete") {
+        const stoppedAt = taskCtx.stoppedAt ?? 0;
+        const ageMs = Date.now() - stoppedAt;
+        if (stoppedAt > 0 && ageMs <= STOPPED_RECOVERY_WINDOW_MS) {
+          this.log(`Recovering "${taskCtx.label}" from stopped on late task_complete (${Math.round(ageMs / 1000)}s old)`);
+          taskCtx.status = "active";
+          recoveredFromStopped = true;
+        } else {
+          this.log(`Ignoring "${event}" for ${taskCtx.label} (status: stopped, age=${Math.round(ageMs / 1000)}s)`);
+          return;
+        }
+      }
+      if (!recoveredFromStopped && event !== "stopped" && event !== "error") {
         this.log(`Ignoring "${event}" for ${taskCtx.label} (status: ${taskCtx.status})`);
         return;
       }
@@ -3687,6 +3748,7 @@ class SwarmCoordinator {
       case "stopped":
         if (taskCtx.status !== "completed" && taskCtx.status !== "error") {
           taskCtx.status = "stopped";
+          taskCtx.stoppedAt = Date.now();
         }
         this.inFlightDecisions.delete(sessionId);
         this.broadcast({
@@ -4774,7 +4836,9 @@ import {
   ModelType as ModelType5
 } from "@elizaos/core";
 // src/services/trajectory-feedback.ts
+import { logger as elizaLogger } from "@elizaos/core";
 var QUERY_TIMEOUT_MS = 5000;
+var SLOW_PATH_BUDGET_MS = 15000;
 function withTimeout2(promise, ms) {
   return Promise.race([
     promise,
@@ -4860,18 +4924,37 @@ async function queryPastExperience(runtime, options = {}) {
     if (!result.trajectories || result.trajectories.length === 0)
       return [];
     const experiences = [];
+    const slowPathDeadline = Date.now() + SLOW_PATH_BUDGET_MS;
     const maxScans = Math.min(result.trajectories.length, maxTrajectories);
     for (let scanIdx = 0;scanIdx < maxScans; scanIdx++) {
       const summary = result.trajectories[scanIdx];
-      const detail = await withTimeout2(logger5.getTrajectoryDetail(summary.id), QUERY_TIMEOUT_MS).catch(() => null);
-      if (!detail?.steps)
-        continue;
-      const metadata = detail.metadata;
+      const metadata = summary.metadata;
+      const metadataInsights = Array.isArray(metadata?.insights) ? metadata.insights.filter((value) => typeof value === "string" && value.trim().length > 0).slice(0, 50) : [];
       const decisionType = metadata?.orchestrator?.decisionType ?? "unknown";
       const taskLabel = metadata?.orchestrator?.taskLabel ?? "";
       const trajectoryRepo = metadata?.orchestrator?.repo;
       if (repo && (!trajectoryRepo || trajectoryRepo !== repo))
         continue;
+      if (metadataInsights.length > 0) {
+        elizaLogger.debug(`[trajectory-feedback] Fast path: ${metadataInsights.length} insight(s) from metadata for ${summary.id}`);
+        for (const insight of metadataInsights) {
+          experiences.push({
+            timestamp: summary.startTime,
+            decisionType,
+            taskLabel,
+            insight
+          });
+        }
+        continue;
+      }
+      if (Date.now() > slowPathDeadline) {
+        elizaLogger.debug(`[trajectory-feedback] Slow path budget exhausted; stopping detail loads`);
+        break;
+      }
+      elizaLogger.debug(`[trajectory-feedback] Slow path: loading full detail for ${summary.id} (no metadata insights)`);
+      const detail = await withTimeout2(logger5.getTrajectoryDetail(summary.id), QUERY_TIMEOUT_MS).catch(() => null);
+      if (!detail?.steps)
+        continue;
       for (const step of detail.steps) {
         if (!step.llmCalls)
           continue;
@@ -4904,7 +4987,7 @@ async function queryPastExperience(runtime, options = {}) {
     }
     return Array.from(seen.values()).sort((a, b) => b.timestamp - a.timestamp).slice(0, maxEntries);
   } catch (err) {
-    console.error("[trajectory-feedback] Failed to query past experience:", err);
+    elizaLogger.error(`[trajectory-feedback] Failed to query past experience: ${err}`);
     return [];
   }
 }
@@ -6593,8 +6676,143 @@ class CodingWorkspaceService {
   }
 }
 // src/api/agent-routes.ts
+import { access, readFile as readFile3, realpath, rm } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import * as os4 from "node:os";
 import * as path6 from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var PREFLIGHT_DONE = new Set;
+var PREFLIGHT_INFLIGHT = new Map;
+function shouldAutoPreflight() {
+  if (process.env.PARALLAX_BENCHMARK_PREFLIGHT_AUTO === "1")
+    return true;
+  return false;
+}
+function isPathInside(parent, candidate) {
+  return candidate === parent || candidate.startsWith(`${parent}${path6.sep}`);
+}
+async function resolveSafeVenvPath(workdir, venvDirRaw) {
+  const venvDir = venvDirRaw.trim();
+  if (!venvDir) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must be non-empty");
+  }
+  if (path6.isAbsolute(venvDir)) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must be relative to workdir");
+  }
+  const normalized = path6.normalize(venvDir);
+  if (normalized === "." || normalized === ".." || normalized.startsWith(`..${path6.sep}`)) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must stay within workdir");
+  }
+  const workdirResolved = path6.resolve(workdir);
+  const workdirReal = await realpath(workdirResolved);
+  const resolved = path6.resolve(workdirReal, normalized);
+  if (!isPathInside(workdirReal, resolved)) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV resolves outside workdir");
+  }
+  if (resolved === workdirReal) {
+    throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV must not resolve to workdir root");
+  }
+  try {
+    const resolvedReal = await realpath(resolved);
+    if (!isPathInside(workdirReal, resolvedReal) || resolvedReal === workdirReal) {
+      throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV resolves outside workdir");
+    }
+  } catch (err) {
+    const maybeErr = err;
+    if (maybeErr?.code !== "ENOENT")
+      throw err;
+    const parentReal = await realpath(path6.dirname(resolved));
+    if (!isPathInside(workdirReal, parentReal)) {
+      throw new Error("PARALLAX_BENCHMARK_PREFLIGHT_VENV parent resolves outside workdir");
+    }
+  }
+  return resolved;
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveRequirementsPath(workdir) {
+  const workdirReal = await realpath(path6.resolve(workdir));
+  const candidates = [
+    path6.join(workdir, "apps", "api", "requirements.txt"),
+    path6.join(workdir, "requirements.txt")
+  ];
+  for (const candidate of candidates) {
+    if (!await fileExists(candidate))
+      continue;
+    try {
+      const candidateReal = await realpath(candidate);
+      if (isPathInside(workdirReal, candidateReal))
+        return candidateReal;
+    } catch {}
+  }
+  return null;
+}
+async function fingerprintRequirementsFile(requirementsPath) {
+  const file = await readFile3(requirementsPath);
+  return createHash("sha256").update(file).digest("hex");
+}
+async function runBenchmarkPreflight(workdir) {
+  if (!shouldAutoPreflight())
+    return;
+  const requirementsPath = await resolveRequirementsPath(workdir);
+  if (!requirementsPath)
+    return;
+  const requirementsFingerprint = await fingerprintRequirementsFile(requirementsPath);
+  const mode = process.env.PARALLAX_BENCHMARK_PREFLIGHT_MODE?.toLowerCase() === "warm" ? "warm" : "cold";
+  const venvDir = process.env.PARALLAX_BENCHMARK_PREFLIGHT_VENV || ".benchmark-venv";
+  const venvPath = await resolveSafeVenvPath(workdir, venvDir);
+  const pythonInVenv = path6.join(venvPath, process.platform === "win32" ? "Scripts" : "bin", process.platform === "win32" ? "python.exe" : "python");
+  const key = `${workdir}::${mode}::${venvPath}::${requirementsFingerprint}`;
+  if (PREFLIGHT_DONE.has(key)) {
+    if (await fileExists(pythonInVenv))
+      return;
+    PREFLIGHT_DONE.delete(key);
+  }
+  const existing = PREFLIGHT_INFLIGHT.get(key);
+  if (existing) {
+    await existing;
+    return;
+  }
+  const run = (async () => {
+    const pythonCommand = process.platform === "win32" ? "python" : "python3";
+    if (mode === "cold") {
+      await rm(venvPath, { recursive: true, force: true });
+    }
+    const hasVenv = await fileExists(pythonInVenv);
+    if (!hasVenv) {
+      await execFileAsync(pythonCommand, ["-m", "venv", venvPath], {
+        cwd: workdir,
+        timeout: 120000,
+        maxBuffer: 8 * 1024 * 1024
+      });
+    }
+    await execFileAsync(pythonInVenv, ["-m", "pip", "install", "--upgrade", "pip"], {
+      cwd: workdir,
+      timeout: 300000,
+      maxBuffer: 8 * 1024 * 1024
+    });
+    await execFileAsync(pythonInVenv, ["-m", "pip", "install", "-r", requirementsPath], {
+      cwd: workdir,
+      timeout: 600000,
+      maxBuffer: 16 * 1024 * 1024
+    });
+    PREFLIGHT_DONE.add(key);
+  })();
+  PREFLIGHT_INFLIGHT.set(key, run);
+  try {
+    await run;
+  } finally {
+    PREFLIGHT_INFLIGHT.delete(key);
+  }
+}
 async function handleAgentRoutes(req, res, pathname, ctx) {
   const method = req.method?.toUpperCase();
   if (method === "GET" && pathname === "/api/coding-agents/preflight") {
@@ -6722,19 +6940,25 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
         metadata
       } = body;
       const workspaceBaseDir = path6.join(os4.homedir(), ".milady", "workspaces");
-      const allowedPrefixes = [
-        path6.resolve(workspaceBaseDir),
-        path6.resolve(process.cwd())
-      ];
+      const workspaceBaseDirResolved = path6.resolve(workspaceBaseDir);
+      const cwdResolved = path6.resolve(process.cwd());
+      const workspaceBaseDirReal = await realpath(workspaceBaseDirResolved).catch(() => workspaceBaseDirResolved);
+      const cwdReal = await realpath(cwdResolved).catch(() => cwdResolved);
+      const allowedPrefixes = [workspaceBaseDirReal, cwdReal];
       let workdir = rawWorkdir;
       if (workdir) {
         const resolved = path6.resolve(workdir);
-        const isAllowed = allowedPrefixes.some((prefix2) => resolved === prefix2 || resolved.startsWith(prefix2 + path6.sep));
+        const resolvedReal = await realpath(resolved).catch(() => null);
+        if (!resolvedReal) {
+          sendError(res, "workdir must exist", 403);
+          return true;
+        }
+        const isAllowed = allowedPrefixes.some((prefix2) => resolvedReal === prefix2 || resolvedReal.startsWith(prefix2 + path6.sep));
         if (!isAllowed) {
           sendError(res, "workdir must be within workspace base directory or cwd", 403);
           return true;
         }
-        workdir = resolved;
+        workdir = resolvedReal;
       }
       const activeSessions = await ctx.ptyService.listSessions();
       const maxSessions = 8;
@@ -6742,6 +6966,13 @@ async function handleAgentRoutes(req, res, pathname, ctx) {
         sendError(res, `Concurrent session limit reached (${maxSessions})`, 429);
         return true;
       }
+      if (workdir) {
+        try {
+          await runBenchmarkPreflight(workdir);
+        } catch (preflightError) {
+          console.warn(`[coding-agent] benchmark preflight failed for ${workdir}:`, preflightError);
+        }
+      }
       const credentials = {
         anthropicKey: ctx.runtime.getSetting("ANTHROPIC_API_KEY"),
         openaiKey: ctx.runtime.getSetting("OPENAI_API_KEY"),
@@ -7468,5 +7699,5 @@ export {
   CodingWorkspaceService
 };
 
-//# debugId=4383E51DF7A1F4A764756E2164756E21
+//# debugId=A818F3DE8DCF48E664756E2164756E21
 //# sourceMappingURL=index.js.map