@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.151

package/packages/typescript/src/features/orchestrator/services/swarm-event-triage.d.ts

@@ -1,49 +0,0 @@
-/**
- * Event Triage — classifies coordinator events as "routine" or "creative"
- * to route them to the fast small-LLM path or the full Milaidy pipeline.
- *
- * Tier 1 (auto-response rules at PTY worker) already handled before we get here.
- * This module splits the remaining events into:
- * - "routine": simple approvals, permissions, config prompts → small LLM (~1-2s)
- * - "creative": error recovery, design questions, task evaluation → Milaidy (~5-10s)
- *
- * Pure functions — no side effects, same pattern as stall-classifier.ts.
- *
- * @module services/swarm-event-triage
- */
-import { type IAgentRuntime } from "@elizaos/core";
-export type TriageTier = "routine" | "creative";
-export interface TriageContext {
-    /** "blocked" or "turn_complete" */
-    eventType: "blocked" | "turn_complete";
-    /** The blocking prompt text (empty for turn completions). */
-    promptText: string;
-    /** Adapter's promptInfo.type if available. */
-    promptType?: string;
-    /** Recent terminal output (for turn completions). */
-    recentOutput?: string;
-    /** The original task description. */
-    originalTask: string;
-}
-/**
- * Classify an event tier using only heuristics (prompt type + regex).
- * Returns null if inconclusive.
- */
-export declare function classifyByHeuristic(ctx: TriageContext): TriageTier | null;
-/**
- * Build a short classifier prompt for ambiguous events.
- */
-export declare function buildTriagePrompt(ctx: TriageContext): string;
-/**
- * Parse the LLM's triage response. Returns null on failure.
- */
-export declare function parseTriageResponse(llmOutput: string): TriageTier | null;
-/**
- * Main entry point: classify an event as routine or creative.
- *
- * 1. Heuristics (0ms)
- * 2. Small LLM classifier (~500ms-1s) if heuristics are inconclusive
- * 3. Default to "creative" if classifier fails (safe default)
- */
-export declare function classifyEventTier(runtime: IAgentRuntime, ctx: TriageContext, log: (msg: string) => void): Promise<TriageTier>;
-//# sourceMappingURL=swarm-event-triage.d.ts.map

package/packages/typescript/src/features/orchestrator/services/swarm-event-triage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swarm-event-triage.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/swarm-event-triage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAa,MAAM,eAAe,CAAC;AAK9D,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,UAAU,CAAC;AAEhD,MAAM,WAAW,aAAa;IAC7B,mCAAmC;IACnC,SAAS,EAAE,SAAS,GAAG,eAAe,CAAC;IACvC,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,YAAY,EAAE,MAAM,CAAC;CACrB;AAmED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,aAAa,GAAG,UAAU,GAAG,IAAI,CAiCzE;AAID;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAc5D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAaxE;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACtC,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GACxB,OAAO,CAAC,UAAU,CAAC,CA4BrB"}

package/packages/typescript/src/features/orchestrator/services/swarm-event-triage.js

@@ -1,171 +0,0 @@
-/**
- * Event Triage — classifies coordinator events as "routine" or "creative"
- * to route them to the fast small-LLM path or the full Milaidy pipeline.
- *
- * Tier 1 (auto-response rules at PTY worker) already handled before we get here.
- * This module splits the remaining events into:
- * - "routine": simple approvals, permissions, config prompts → small LLM (~1-2s)
- * - "creative": error recovery, design questions, task evaluation → Milaidy (~5-10s)
- *
- * Pure functions — no side effects, same pattern as stall-classifier.ts.
- *
- * @module services/swarm-event-triage
- */
-import { ModelType } from "@elizaos/core";
-import { withTrajectoryContext } from "./trajectory-context.js";
-// ─── Heuristic Sets ───
-/** Prompt types from coding-agent-adapters that are always routine. */
-const ROUTINE_PROMPT_TYPES = new Set([
-    "permission",
-    "config",
-    "tos",
-    "tool_wait",
-]);
-/** Prompt types that always need creative/contextual handling. */
-const CREATIVE_PROMPT_TYPES = new Set(["project_select", "model_select"]);
-/** Regex patterns that indicate routine approval prompts. */
-const ROUTINE_PATTERNS = [
-    /\bAllow\s+tool\b/i,
-    /\(Y\/n\)/,
-    /\(y\/N\)/,
-    /\bTrust\s+(this\s+)?directory\b/i,
-    /\bProceed\?/i,
-    /\boverwrite\?/i,
-    /\bDo you trust\b/i,
-    /\bAllow access\b/i,
-    /\bGrant permission\b/i,
-    /\bAccept\?/i,
-    /\bContinue\?/i,
-    /\bPermit\b.*\?/i,
-    /\bApprove\b.*\?/i,
-];
-/** Regex patterns that indicate creative / contextual decision needed. */
-const CREATIVE_PATTERNS = [
-    /\bWhich approach\b/i,
-    /\bHow should\b/i,
-    /\btests? failing\b/i,
-    /\bchoose between\b/i,
-    /\bpick (one|a|an)\b/i,
-    /\bWhat do you (want|think)\b/i,
-    /\berror recover/i,
-    /\bfailed with\b/i,
-    /\bcompilation error/i,
-    /\bbuild failed\b/i,
-    /\btype error/i,
-    /\bmerge conflict/i,
-];
-/** Turn-complete output patterns that are obviously terminal (routine). */
-const TERMINAL_OUTPUT_PATTERNS = [
-    /All \d+ tests? pass/i,
-    /Tests?:\s+\d+ passed/i,
-    /✓ All checks passed/i,
-    /https:\/\/github\.com\/[^\s]+\/pull\/\d+/,
-    /Successfully created PR/i,
-    /Commit [a-f0-9]{7,40}/i,
-];
-/** Turn-complete output patterns that are obviously intermediate (routine → continue). */
-const INTERMEDIATE_OUTPUT_PATTERNS = [
-    /^Running tests?\.\.\./im,
-    /^Building\.\.\./im,
-    /^Installing dependencies/im,
-];
-// ─── Heuristic Classifier ───
-/**
- * Classify an event tier using only heuristics (prompt type + regex).
- * Returns null if inconclusive.
- */
-export function classifyByHeuristic(ctx) {
-    // 1. Check adapter-provided prompt type
-    if (ctx.promptType) {
-        if (ROUTINE_PROMPT_TYPES.has(ctx.promptType))
-            return "routine";
-        if (CREATIVE_PROMPT_TYPES.has(ctx.promptType))
-            return "creative";
-    }
-    // 2. For blocked events, check prompt text patterns
-    if (ctx.eventType === "blocked" && ctx.promptText) {
-        const hasRoutine = ROUTINE_PATTERNS.some((r) => r.test(ctx.promptText));
-        const hasCreative = CREATIVE_PATTERNS.some((r) => r.test(ctx.promptText));
-        if (hasRoutine && !hasCreative)
-            return "routine";
-        if (hasCreative && !hasRoutine)
-            return "creative";
-        // Both or neither → inconclusive
-        if (hasCreative)
-            return "creative"; // creative wins ties
-    }
-    // 3. For turn completions, check output patterns
-    if (ctx.eventType === "turn_complete" && ctx.recentOutput) {
-        const recentOutput = ctx.recentOutput;
-        const isTerminal = TERMINAL_OUTPUT_PATTERNS.some((r) => r.test(recentOutput));
-        const isIntermediate = INTERMEDIATE_OUTPUT_PATTERNS.some((r) => r.test(recentOutput));
-        if (isTerminal || isIntermediate)
-            return "routine";
-        // For turn completions, bias toward creative — most benefit from task context
-    }
-    return null; // Inconclusive — needs LLM classifier
-}
-// ─── LLM Classifier ───
-/**
- * Build a short classifier prompt for ambiguous events.
- */
-export function buildTriagePrompt(ctx) {
-    const eventDesc = ctx.eventType === "blocked"
-        ? `BLOCKED prompt: "${ctx.promptText.slice(0, 300)}"`
-        : `TURN COMPLETE. Recent output:\n${(ctx.recentOutput ?? "").slice(-500)}`;
-    return (`Classify this task-agent event as "routine" or "creative".\n\n` +
-        `Task: ${ctx.originalTask.slice(0, 200)}\n` +
-        `Event: ${eventDesc}\n\n` +
-        `"routine" = simple approval, permission, config, yes/no, tool consent, obvious pass/fail.\n` +
-        `"creative" = needs task context, error recovery, design choice, ambiguous situation, approach selection.\n\n` +
-        `Respond with ONLY a JSON object: {"tier": "routine"} or {"tier": "creative"}`);
-}
-/**
- * Parse the LLM's triage response. Returns null on failure.
- */
-export function parseTriageResponse(llmOutput) {
-    const matches = llmOutput.matchAll(/\{[\s\S]*?\}/g);
-    for (const match of matches) {
-        try {
-            const parsed = JSON.parse(match[0]);
-            if (parsed.tier === "routine" || parsed.tier === "creative") {
-                return parsed.tier;
-            }
-        }
-        catch {
-            // Try next match
-        }
-    }
-    return null;
-}
-/**
- * Main entry point: classify an event as routine or creative.
- *
- * 1. Heuristics (0ms)
- * 2. Small LLM classifier (~500ms-1s) if heuristics are inconclusive
- * 3. Default to "creative" if classifier fails (safe default)
- */
-export async function classifyEventTier(runtime, ctx, log) {
-    // Step 1: Heuristic classification
-    const heuristicResult = classifyByHeuristic(ctx);
-    if (heuristicResult) {
-        log(`Triage: heuristic → ${heuristicResult}`);
-        return heuristicResult;
-    }
-    // Step 2: Small LLM classifier
-    try {
-        const prompt = buildTriagePrompt(ctx);
-        const result = await withTrajectoryContext(runtime, { source: "orchestrator", decisionType: "event-triage" }, () => runtime.useModel(ModelType.TEXT_SMALL, { prompt }));
-        const tier = parseTriageResponse(result);
-        if (tier) {
-            log(`Triage: LLM → ${tier}`);
-            return tier;
-        }
-        log(`Triage: LLM returned unparseable response — defaulting to creative`);
-    }
-    catch (err) {
-        log(`Triage: LLM classifier failed: ${err} — defaulting to creative`);
-    }
-    // Step 3: Safe default
-    return "creative";
-}

package/packages/typescript/src/features/orchestrator/services/swarm-history.d.ts

@@ -1,27 +0,0 @@
-export type HistoryEntryType = "task_registered" | "task_completed" | "task_stopped" | "task_error" | "key_decision";
-export interface HistoryEntry {
-    timestamp: number;
-    type: HistoryEntryType;
-    sessionId: string;
-    label: string;
-    agentType: string;
-    repo?: string;
-    workdir: string;
-    originalTask?: string;
-    completionSummary?: string;
-    reasoning?: string;
-}
-export declare class SwarmHistory {
-    private filePath;
-    /** In-memory counter to avoid reading the file on every append. */
-    private appendCount;
-    /** Serializes all file mutations. */
-    private mutex;
-    constructor(stateDir?: string);
-    append(entry: HistoryEntry): Promise<void>;
-    readAll(): Promise<HistoryEntry[]>;
-    getLastUsedRepo(): Promise<string | undefined>;
-    /** Called while holding the mutex — no external callers. */
-    private truncateInner;
-}
-//# sourceMappingURL=swarm-history.d.ts.map

package/packages/typescript/src/features/orchestrator/services/swarm-history.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swarm-history.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/swarm-history.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,gBAAgB,GACzB,iBAAiB,GACjB,gBAAgB,GAChB,cAAc,GACd,YAAY,GACZ,cAAc,CAAC;AAElB,MAAM,WAAW,YAAY;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,gBAAgB,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAmCD,qBAAa,YAAY;IACxB,OAAO,CAAC,QAAQ,CAAS;IACzB,mEAAmE;IACnE,OAAO,CAAC,WAAW,CAAK;IACxB,qCAAqC;IACrC,OAAO,CAAC,KAAK,CAAoB;gBAErB,QAAQ,CAAC,EAAE,MAAM;IASvB,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC1C,OAAO,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IA6BlC,eAAe,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAUpD,4DAA4D;YAC9C,aAAa;CAgC3B"}

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

@@ -1,148 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-const MAX_ENTRIES = 150;
-const TRUNCATE_TO = 100;
-/** Maximum file size in bytes before forced truncation (1 MB). */
-const MAX_FILE_SIZE_BYTES = 1_048_576;
-/**
- * Simple async mutex — serializes all file mutations so concurrent
- * append() and truncate() calls don't interleave reads and writes.
- */
-class WriteMutex {
-    queue = [];
-    locked = false;
-    async acquire() {
-        if (!this.locked) {
-            this.locked = true;
-            return;
-        }
-        return new Promise((resolve) => {
-            this.queue.push(resolve);
-        });
-    }
-    release() {
-        const next = this.queue.shift();
-        if (next) {
-            next();
-        }
-        else {
-            this.locked = false;
-        }
-    }
-}
-export class SwarmHistory {
-    filePath;
-    /** In-memory counter to avoid reading the file on every append. */
-    appendCount = 0;
-    /** Serializes all file mutations. */
-    mutex = new WriteMutex();
-    constructor(stateDir) {
-        const dir = stateDir ||
-            process.env.ELIZA_STATE_DIR ||
-            process.env.ELIZA_STATE_DIR ||
-            path.join(os.homedir(), ".eliza");
-        this.filePath = path.join(dir, "swarm-history.jsonl");
-    }
-    async append(entry) {
-        await this.mutex.acquire();
-        try {
-            const dir = path.dirname(this.filePath);
-            await fs.mkdir(dir, { recursive: true });
-            await fs.appendFile(this.filePath, `${JSON.stringify(entry)}\n`, "utf-8");
-            this.appendCount++;
-            // Size-based rotation: truncate if file exceeds 1 MB regardless of line count
-            try {
-                const stat = await fs.stat(this.filePath);
-                if (stat.size > MAX_FILE_SIZE_BYTES) {
-                    await this.truncateInner(TRUNCATE_TO);
-                    return;
-                }
-            }
-            catch {
-                // stat failed — skip size check, fall through to line-count check
-            }
-            // Line-count check after enough appends to potentially exceed MAX_ENTRIES
-            if (this.appendCount >= MAX_ENTRIES - TRUNCATE_TO) {
-                const content = await fs.readFile(this.filePath, "utf-8");
-                const lineCount = content
-                    .split("\n")
-                    .filter((l) => l.trim() !== "").length;
-                if (lineCount > MAX_ENTRIES) {
-                    await this.truncateInner(TRUNCATE_TO);
-                }
-            }
-        }
-        catch (err) {
-            console.error("[swarm-history] append failed:", err);
-            throw err;
-        }
-        finally {
-            this.mutex.release();
-        }
-    }
-    async readAll() {
-        try {
-            const content = await fs.readFile(this.filePath, "utf-8");
-            const entries = [];
-            const lines = content.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-                if (lines[i].trim() === "")
-                    continue;
-                try {
-                    entries.push(JSON.parse(lines[i]));
-                }
-                catch {
-                    console.warn(`[swarm-history] skipping corrupted line at index ${i} (length=${lines[i].length})`);
-                }
-            }
-            return entries;
-        }
-        catch (err) {
-            if (err instanceof Error &&
-                "code" in err &&
-                err.code === "ENOENT") {
-                return [];
-            }
-            console.error("[swarm-history] readAll failed:", err);
-            return [];
-        }
-    }
-    async getLastUsedRepo() {
-        const entries = await this.readAll();
-        for (let i = entries.length - 1; i >= 0; i--) {
-            if (entries[i].repo) {
-                return entries[i].repo;
-            }
-        }
-        return undefined;
-    }
-    /** Called while holding the mutex — no external callers. */
-    async truncateInner(maxEntries) {
-        const entries = await this.readAll();
-        // If readAll returned empty but the file exists, a read error occurred —
-        // don't overwrite the file or we'd erase valid history.
-        if (entries.length === 0) {
-            try {
-                await fs.stat(this.filePath);
-                console.error("[swarm-history] truncate aborted: file exists but readAll returned empty");
-                return;
-            }
-            catch {
-                return;
-            }
-        }
-        // First enforce entry count, then enforce byte budget.
-        // This ensures the file is both under MAX_ENTRIES and MAX_FILE_SIZE_BYTES.
-        let kept = entries.slice(-maxEntries);
-        let content = `${kept.map((e) => JSON.stringify(e)).join("\n")}\n`;
-        // If still over size budget, drop oldest entries until it fits
-        while (Buffer.byteLength(content, "utf-8") > MAX_FILE_SIZE_BYTES &&
-            kept.length > 1) {
-            kept = kept.slice(Math.max(1, Math.floor(kept.length * 0.2)));
-            content = `${kept.map((e) => JSON.stringify(e)).join("\n")}\n`;
-        }
-        await fs.writeFile(this.filePath, content, "utf-8");
-        this.appendCount = 0;
-    }
-}

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

@@ -1,22 +0,0 @@
-/**
- * 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 type { SwarmCoordinatorContext, TaskContext } from "./swarm-coordinator.ts";
-/** How long a session can be idle before the watchdog checks on it (ms). */
-export declare const IDLE_THRESHOLD_MS: number;
-/** Max idle checks before force-escalating a session. */
-export declare const MAX_IDLE_CHECKS = 4;
-/**
- * Scan all active sessions for idle ones. Called periodically by the watchdog timer.
- */
-export declare function scanIdleSessions(ctx: SwarmCoordinatorContext): Promise<void>;
-/**
- * Handle an idle session by asking the LLM to assess its state.
- */
-export declare function handleIdleCheck(ctx: SwarmCoordinatorContext, taskCtx: TaskContext, idleMinutes: number): Promise<void>;
-//# sourceMappingURL=swarm-idle-watchdog.d.ts.map

package/packages/typescript/src/features/orchestrator/services/swarm-idle-watchdog.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swarm-idle-watchdog.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/swarm-idle-watchdog.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EACX,uBAAuB,EACvB,WAAW,EACX,MAAM,wBAAwB,CAAC;AAiBhC,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,QAAgB,CAAC;AAE/C,yDAAyD;AACzD,eAAO,MAAM,eAAe,IAAI,CAAC;AAIjC;;GAEG;AACH,wBAAsB,gBAAgB,CACrC,GAAG,EAAE,uBAAuB,GAC1B,OAAO,CAAC,IAAI,CAAC,CA4Jf;AAED;;GAEG;AACH,wBAAsB,eAAe,CACpC,GAAG,EAAE,uBAAuB,EAC5B,OAAO,EAAE,WAAW,EACpB,WAAW,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAyIf"}