@elizaos/agent 0.25.8 → 2.0.0-alpha.144

package/packages/typescript/src/features/orchestrator/services/swarm-idle-watchdog.js

@@ -0,0 +1,265 @@
+/**
+ * Swarm Coordinator — Idle Watchdog
+ *
+ * Extracted from swarm-coordinator.ts for modularity.
+ * Scans active sessions for idle ones and asks the LLM to assess their state.
+ *
+ * @module services/swarm-idle-watchdog
+ */
+import { ModelType } from "@elizaos/core";
+import { cleanForChat, stripAnsi } from "./ansi-utils.js";
+import { buildIdleCheckPrompt, parseCoordinationResponse, } from "./swarm-coordinator-prompts.js";
+import { checkAllTasksComplete, executeDecision, } from "./swarm-decision-loop.js";
+import { withTrajectoryContext } from "./trajectory-context.js";
+// ─── Constants ───
+/** How long a session can be idle before the watchdog checks on it (ms). */
+export const IDLE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+/** Max idle checks before force-escalating a session. */
+export const MAX_IDLE_CHECKS = 4;
+// ─── Idle Watchdog ───
+/**
+ * Scan all active sessions for idle ones. Called periodically by the watchdog timer.
+ */
+export async function scanIdleSessions(ctx) {
+    const now = Date.now();
+    for (const taskCtx of ctx.tasks.values()) {
+        if (taskCtx.status !== "active" && taskCtx.status !== "tool_running") {
+            continue;
+        }
+        // Liveness check: if the PTY session no longer exists in the worker
+        // (e.g. parent process was SIGKILL'd and restarted), mark it dead.
+        if (ctx.ptyService) {
+            const session = ctx.ptyService.getSession(taskCtx.sessionId);
+            if (!session) {
+                ctx.log(`Idle watchdog: "${taskCtx.label}" — PTY session no longer exists, marking as stopped`);
+                taskCtx.status = "stopped";
+                taskCtx.stoppedAt = now;
+                await ctx.recordDecision(taskCtx, {
+                    timestamp: now,
+                    event: "idle_watchdog",
+                    promptText: "PTY session no longer exists",
+                    decision: "stopped",
+                    reasoning: "Underlying PTY process is gone (likely killed during restart)",
+                });
+                ctx.broadcast({
+                    type: "stopped",
+                    sessionId: taskCtx.sessionId,
+                    timestamp: now,
+                    data: { reason: "pty_session_gone" },
+                });
+                ctx.sendChatMessage(`[${taskCtx.label}] Session lost — the agent process is no longer running (likely killed during a restart).`, "coding-agent");
+                checkAllTasksComplete(ctx);
+                continue;
+            }
+        }
+        const idleMs = now - taskCtx.lastActivityAt;
+        if (idleMs < IDLE_THRESHOLD_MS)
+            continue;
+        // Skip if already checking this session
+        if (ctx.inFlightDecisions.has(taskCtx.sessionId))
+            continue;
+        // Check if PTY output has changed since last scan — if data is flowing,
+        // the session is active even without named events (e.g. loading spinners).
+        // Compare stripped output to ignore TUI cursor movements and redraws
+        // that would otherwise fool the watchdog into thinking the session is active.
+        if (ctx.ptyService) {
+            try {
+                const rawOutput = await ctx.ptyService.getSessionOutput(taskCtx.sessionId, 20);
+                const currentOutput = stripAnsi(rawOutput).trim();
+                const lastSeen = ctx.lastSeenOutput.get(taskCtx.sessionId) ?? "";
+                ctx.lastSeenOutput.set(taskCtx.sessionId, currentOutput);
+                if (currentOutput !== lastSeen) {
+                    // Output changed — session is producing data, reset idle state
+                    taskCtx.lastActivityAt = now;
+                    taskCtx.idleCheckCount = 0;
+                    ctx.log(`Idle watchdog: "${taskCtx.label}" has fresh PTY output — not idle`);
+                    continue;
+                }
+            }
+            catch {
+                // Can't read output — proceed with idle check
+            }
+            // Even if the visible 20-line tail didn't change, trust the adapter's
+            // own "I am busy" signal. TUIs like Codex redraw their status row
+            // ("Working (Xs • esc to interrupt)") in place via cursor positioning,
+            // so consecutive ANSI-stripped tails can collapse to identical text
+            // even while the model is actively reasoning for minutes. The adapter's
+            // detectLoading() runs against the full buffer and is the source of
+            // truth for "is the agent processing right now".
+            try {
+                const isLoading = await ctx.ptyService.isSessionLoading(taskCtx.sessionId);
+                if (isLoading) {
+                    taskCtx.lastActivityAt = now;
+                    taskCtx.idleCheckCount = 0;
+                    ctx.log(`Idle watchdog: "${taskCtx.label}" adapter reports loading — not idle`);
+                    continue;
+                }
+            }
+            catch {
+                // Fall through to the LLM idle check if we can't query the adapter.
+            }
+        }
+        taskCtx.idleCheckCount++;
+        const idleMinutes = Math.round(idleMs / 60_000);
+        ctx.log(`Idle watchdog: "${taskCtx.label}" idle for ${idleMinutes}m (check ${taskCtx.idleCheckCount}/${MAX_IDLE_CHECKS})`);
+        if (taskCtx.idleCheckCount >= MAX_IDLE_CHECKS) {
+            // Force-stop — too many idle checks with no resolution
+            ctx.log(`Idle watchdog: force-stopping "${taskCtx.label}" after ${MAX_IDLE_CHECKS} checks`);
+            taskCtx.status = "stopped";
+            taskCtx.stoppedAt = now;
+            await ctx.recordDecision(taskCtx, {
+                timestamp: now,
+                event: "idle_watchdog",
+                promptText: `Session idle for ${idleMinutes} minutes`,
+                decision: "stopped",
+                reasoning: `Force-stopped after ${MAX_IDLE_CHECKS} idle checks with no activity`,
+            });
+            ctx.broadcast({
+                type: "stopped",
+                sessionId: taskCtx.sessionId,
+                timestamp: now,
+                data: {
+                    reason: "idle_watchdog_max_checks",
+                    idleMinutes,
+                    idleCheckCount: taskCtx.idleCheckCount,
+                },
+            });
+            ctx.sendChatMessage(`[${taskCtx.label}] Session stopped — idle for ${idleMinutes} minutes with no progress.`, "coding-agent");
+            // Force-kill the PTY session — idle timeout means nothing to save.
+            if (ctx.ptyService) {
+                try {
+                    await ctx.ptyService.stopSession(taskCtx.sessionId, /* force */ true);
+                }
+                catch (err) {
+                    ctx.log(`Idle watchdog: failed to stop session ${taskCtx.sessionId}: ${err}`);
+                    taskCtx.status = "error";
+                    await ctx.syncTaskContext(taskCtx);
+                    ctx.broadcast({
+                        type: "error",
+                        sessionId: taskCtx.sessionId,
+                        timestamp: now,
+                        data: { message: `Failed to stop idle session: ${err}` },
+                    });
+                }
+            }
+            // Check if all tasks are now done
+            checkAllTasksComplete(ctx);
+            continue;
+        }
+        // Ask the LLM what's going on
+        await handleIdleCheck(ctx, taskCtx, idleMinutes);
+    }
+}
+/**
+ * Handle an idle session by asking the LLM to assess its state.
+ */
+export async function handleIdleCheck(ctx, taskCtx, idleMinutes) {
+    const sessionId = taskCtx.sessionId;
+    ctx.inFlightDecisions.add(sessionId);
+    try {
+        let recentOutput = "";
+        if (ctx.ptyService) {
+            try {
+                const raw = await ctx.ptyService.getSessionOutput(sessionId, 50);
+                recentOutput = cleanForChat(raw);
+            }
+            catch {
+                recentOutput = "";
+            }
+        }
+        const contextSummary = {
+            sessionId,
+            agentType: taskCtx.agentType,
+            label: taskCtx.label,
+            originalTask: taskCtx.originalTask,
+            workdir: taskCtx.workdir,
+        };
+        const decisionHistory = taskCtx.decisions
+            .filter((d) => d.decision !== "auto_resolved")
+            .slice(-5)
+            .map((d) => ({
+            event: d.event,
+            promptText: d.promptText,
+            action: d.decision,
+            response: d.response,
+            reasoning: d.reasoning,
+        }));
+        const siblings = [];
+        for (const [sid, task] of ctx.tasks) {
+            if (sid === sessionId)
+                continue;
+            siblings.push({
+                label: task.label,
+                agentType: task.agentType,
+                originalTask: task.originalTask,
+                status: task.status,
+            });
+        }
+        const prompt = buildIdleCheckPrompt(contextSummary, recentOutput, idleMinutes, taskCtx.idleCheckCount, MAX_IDLE_CHECKS, decisionHistory, siblings, ctx.sharedDecisions, ctx.getSwarmContext());
+        let decision = null;
+        try {
+            const result = await withTrajectoryContext(ctx.runtime, {
+                source: "orchestrator",
+                decisionType: "idle-check",
+                sessionId,
+                taskLabel: taskCtx.label,
+                repo: taskCtx.repo,
+                workdir: taskCtx.workdir,
+                originalTask: taskCtx.originalTask,
+            }, () => ctx.runtime.useModel(ModelType.TEXT_SMALL, { prompt }));
+            decision = parseCoordinationResponse(result);
+        }
+        catch (err) {
+            ctx.log(`Idle check LLM call failed: ${err}`);
+        }
+        if (!decision) {
+            ctx.log(`Idle check for "${taskCtx.label}": LLM returned invalid response — escalating`);
+            ctx.sendChatMessage(`[${taskCtx.label}] Session idle for ${idleMinutes}m — couldn't determine status. Needs your attention.`, "coding-agent");
+            return;
+        }
+        // Record the decision
+        await ctx.recordDecision(taskCtx, {
+            timestamp: Date.now(),
+            event: "idle_watchdog",
+            promptText: `Session idle for ${idleMinutes} minutes`,
+            decision: decision.action,
+            response: decision.action === "respond"
+                ? decision.useKeys
+                    ? `keys:${decision.keys?.join(",")}`
+                    : decision.response
+                : undefined,
+            reasoning: decision.reasoning,
+        });
+        ctx.broadcast({
+            type: "idle_check_decision",
+            sessionId,
+            timestamp: Date.now(),
+            data: {
+                action: decision.action,
+                idleMinutes,
+                idleCheckNumber: taskCtx.idleCheckCount,
+                reasoning: decision.reasoning,
+            },
+        });
+        // Send chat message
+        if (decision.action === "complete") {
+            // executeDecision handles chat + stop for "complete"
+        }
+        else if (decision.action === "respond") {
+            const actionDesc = decision.useKeys
+                ? `Sent keys: ${decision.keys?.join(", ")}`
+                : `Nudged: ${decision.response ?? ""}`;
+            ctx.log(`[${taskCtx.label}] Idle for ${idleMinutes}m — ${actionDesc}`);
+        }
+        else if (decision.action === "escalate") {
+            ctx.sendChatMessage(`[${taskCtx.label}] Idle for ${idleMinutes}m — needs your attention: ${decision.reasoning}`, "coding-agent");
+        }
+        else if (decision.action === "ignore") {
+            ctx.log(`Idle check for "${taskCtx.label}": LLM says still working — ${decision.reasoning}`);
+        }
+        await executeDecision(ctx, sessionId, decision);
+    }
+    finally {
+        ctx.inFlightDecisions.delete(sessionId);
+    }
+}

package/packages/typescript/src/features/orchestrator/services/task-acceptance.d.ts

@@ -0,0 +1,8 @@
+import { type IAgentRuntime } from "@elizaos/core";
+import type { CreateTaskThreadInput } from "./task-registry.ts";
+export interface TaskAcceptanceCriteriaResult {
+    criteria: string[];
+    source: "provided" | "model" | "baseline";
+}
+export declare function deriveTaskAcceptanceCriteria(runtime: IAgentRuntime, input: CreateTaskThreadInput): Promise<TaskAcceptanceCriteriaResult>;
+//# sourceMappingURL=task-acceptance.d.ts.map

package/packages/typescript/src/features/orchestrator/services/task-acceptance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-acceptance.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/task-acceptance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE,MAAM,WAAW,4BAA4B;IAC5C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC;CAC1C;AAiGD,wBAAsB,4BAA4B,CACjD,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,qBAAqB,GAC1B,OAAO,CAAC,4BAA4B,CAAC,CAgCvC"}

package/packages/typescript/src/features/orchestrator/services/task-acceptance.js

@@ -0,0 +1,114 @@
+import { ModelType } from "@elizaos/core";
+const MAX_CRITERIA = 7;
+function trimCriterion(value) {
+    return value
+        .replace(/^[\s*-]+/, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function uniqueCriteria(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values.map(trimCriterion)) {
+        if (!value)
+            continue;
+        const key = value.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(value);
+        if (result.length >= MAX_CRITERIA)
+            break;
+    }
+    return result;
+}
+function parseJsonCriteria(raw) {
+    const trimmed = raw.trim();
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+    const candidate = (fenced?.[1] ?? trimmed).trim();
+    const parsed = JSON.parse(candidate);
+    if (!Array.isArray(parsed))
+        return [];
+    return uniqueCriteria(parsed.filter((entry) => typeof entry === "string"));
+}
+function plannedSubtasks(input) {
+    const subtasks = input.currentPlan
+        ?.subtasks;
+    if (!Array.isArray(subtasks))
+        return [];
+    return uniqueCriteria(subtasks.filter((entry) => typeof entry === "string"));
+}
+function getRepo(input) {
+    const repo = input.metadata?.repo;
+    if (typeof repo !== "string")
+        return null;
+    const trimmed = repo.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildBaselineAcceptanceCriteria(input) {
+    const criteria = [];
+    const subtasks = plannedSubtasks(input);
+    criteria.push(`Address the full request: ${input.originalRequest}`);
+    for (const subtask of subtasks.slice(0, 3)) {
+        criteria.push(`Complete this planned subtask: ${subtask}`);
+    }
+    if (input.kind === "coding" || getRepo(input)) {
+        criteria.push("Run the relevant checks for the changed code, or record the exact blocker.");
+    }
+    criteria.push("Capture concrete completion evidence in the task record.");
+    criteria.push("Do not claim completion while any blocker or missing verification remains.");
+    return uniqueCriteria(criteria).slice(0, MAX_CRITERIA);
+}
+function buildAcceptancePrompt(input) {
+    const subtasks = plannedSubtasks(input);
+    const planBlock = subtasks.length > 0
+        ? subtasks.map((task) => `- ${task}`).join("\n")
+        : "- none";
+    return [
+        "Generate task completion criteria for an orchestrated agent task.",
+        "Return strict JSON only: an array of 3 to 7 measurable strings.",
+        "Each criterion must be observable and suitable for completion validation.",
+        "Avoid generic wording like 'do a good job'.",
+        "",
+        `Title: ${input.title}`,
+        `Kind: ${input.kind ?? "coding"}`,
+        `Original request: ${input.originalRequest}`,
+        `Repository: ${getRepo(input) ?? "none"}`,
+        "Planned subtasks:",
+        planBlock,
+        "",
+        "Prefer criteria about completed work, verification, evidence, and unresolved blockers.",
+    ].join("\n");
+}
+export async function deriveTaskAcceptanceCriteria(runtime, input) {
+    const provided = uniqueCriteria(input.acceptanceCriteria ?? []);
+    if (provided.length > 0) {
+        return {
+            criteria: provided,
+            source: "provided",
+        };
+    }
+    try {
+        const raw = await runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt: buildAcceptancePrompt(input),
+            temperature: 0.1,
+            stream: false,
+        });
+        if (typeof raw === "string") {
+            const parsed = parseJsonCriteria(raw);
+            if (parsed.length >= 3) {
+                return {
+                    criteria: parsed,
+                    source: "model",
+                };
+            }
+        }
+    }
+    catch {
+        // Fall back to baseline criteria when the model is unavailable or invalid.
+    }
+    return {
+        criteria: buildBaselineAcceptanceCriteria(input),
+        source: "baseline",
+    };
+}

package/packages/typescript/src/features/orchestrator/services/task-agent-auth.d.ts

@@ -0,0 +1,68 @@
+import { spawn as spawnChildProcess } from "node:child_process";
+import type { IAgentRuntime } from "@elizaos/core";
+import type { PreflightResult } from "coding-agent-adapters";
+import type { SupportedTaskAgentAdapter } from "./task-agent-frameworks.ts";
+export type TaskAgentAuthStatusValue = "authenticated" | "unauthenticated" | "unknown";
+export interface TaskAgentAuthStatus {
+    status: TaskAgentAuthStatusValue;
+    method?: string;
+    detail?: string;
+    loginHint?: string;
+}
+export interface TaskAgentAuthLaunchResult {
+    launched: boolean;
+    url?: string;
+    deviceCode?: string;
+    instructions?: string;
+    browserOpened?: boolean;
+    browserClicked?: boolean;
+    browserDetail?: string;
+    recoveryTarget?: "same_session" | "replacement_session";
+    replacementSessionId?: string;
+    replacementFramework?: string;
+}
+export interface TaskAgentAuthFlowHandle {
+    agentType: SupportedTaskAgentAdapter;
+    startedAt: number;
+    completion: Promise<{
+        code: number | null;
+        signal: NodeJS.Signals | null;
+    }>;
+    snapshot: () => TaskAgentAuthLaunchResult;
+    stop: () => void;
+}
+type ExecFileFn = (file: string, args: string[], options?: {
+    encoding?: BufferEncoding;
+    env?: NodeJS.ProcessEnv;
+    timeout?: number;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+type SpawnFn = typeof spawnChildProcess;
+type FetchFn = typeof fetch;
+interface TaskAgentAuthDeps {
+    execFile: ExecFileFn;
+    fetch: FetchFn;
+    spawn: SpawnFn;
+}
+interface TaskAgentAuthOptions {
+    deps?: Partial<TaskAgentAuthDeps>;
+    env?: NodeJS.ProcessEnv;
+    runtime?: IAgentRuntime;
+}
+export declare function normalizeTaskAgentAdapterId(value: string | undefined): SupportedTaskAgentAdapter | null;
+export declare function getTaskAgentLoginHint(agentType: SupportedTaskAgentAdapter): string | undefined;
+export declare function probeTaskAgentAuth(agentType: SupportedTaskAgentAdapter, options?: TaskAgentAuthOptions): Promise<TaskAgentAuthStatus>;
+export declare function launchTaskAgentAuthFlow(agentType: SupportedTaskAgentAdapter, options?: TaskAgentAuthOptions): Promise<{
+    handle: TaskAgentAuthFlowHandle | null;
+    result: TaskAgentAuthLaunchResult;
+}>;
+export declare function assistTaskAgentBrowserLogin(agentType: SupportedTaskAgentAdapter, rawUrl: string, options?: TaskAgentAuthOptions): Promise<{
+    opened: boolean;
+    clicked: boolean;
+    detail?: string;
+}>;
+export declare function augmentTaskAgentPreflightResults(results: PreflightResult[], options?: TaskAgentAuthOptions): Promise<PreflightResult[]>;
+export {};
+//# sourceMappingURL=task-agent-auth.d.ts.map

package/packages/typescript/src/features/orchestrator/services/task-agent-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-agent-auth.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/task-agent-auth.ts"],"names":[],"mappings":"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"}