aether-mcp-server 2.0.0

package/dist/agent.js

@@ -0,0 +1,1046 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aetherNavigationAgent = exports.aetherTools = exports.activeTasks = void 0;
+exports.getTaskEventLog = getTaskEventLog;
+exports.updateScratchpad = updateScratchpad;
+exports.saveTaskState = saveTaskState;
+exports.restoreUnfinishedTasks = restoreUnfinishedTasks;
+exports.recordExtensionFailure = recordExtensionFailure;
+exports.recordExtensionSuccess = recordExtensionSuccess;
+exports.isCircuitBreakerOpen = isCircuitBreakerOpen;
+exports.getCircuitBreakerStatus = getCircuitBreakerStatus;
+exports.purgeCompletedTasks = purgeCompletedTasks;
+exports.delegateToBrowser = delegateToBrowser;
+const langgraph_1 = require("@langchain/langgraph");
+const google_genai_1 = require("@langchain/google-genai");
+const messages_1 = require("@langchain/core/messages");
+const tools_1 = require("@langchain/core/tools");
+const prebuilt_1 = require("@langchain/langgraph/prebuilt");
+const zod_1 = require("zod");
+const dotenv = __importStar(require("dotenv"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ws_server_1 = require("./ws-server");
+dotenv.config();
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+const MAX_CONSECUTIVE_ERRORS = 5; // Force-fail a task after this many back-to-back tool errors
+const TASK_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes max per task
+const RETRY_DELAYS_MS = [1000, 2000, 4000, 8000, 16000]; // Exponential backoff for tool retries
+const MAX_TOOL_RETRIES = 5;
+const LLM_RETRY_DELAYS_MS = [2000, 4000, 8000]; // Exponential backoff for LLM API calls
+const MAX_LLM_RETRIES = 3;
+const MAX_EVENT_LOG_TOTAL = 5000; // Global cap on EVENT_LOG size (all tasks combined)
+const MAX_ACTIVE_TASKS = 100; // Prevent unbounded memory growth
+const COMPLETED_TASK_TTL_MS = 5 * 60 * 1000; // 5 minutes before completed tasks are purged
+const CIRCUIT_BREAKER_THRESHOLD = 10; // Consecutive extension failures before circuit opens
+const CIRCUIT_BREAKER_COOLDOWN_MS = 60 * 1000; // 1 minute cooldown before circuit half-opens
+const EVENT_LOG = [];
+const MAX_EVENT_LOG_SIZE = 500; // Keep last N events per task
+function emitAgentEvent(event) {
+    // Trim old events if log is too large
+    const eventsForTask = EVENT_LOG.filter(e => e.taskId === event.taskId);
+    if (eventsForTask.length > MAX_EVENT_LOG_SIZE) {
+        const toRemove = eventsForTask.length - MAX_EVENT_LOG_SIZE;
+        let removed = 0;
+        for (let i = EVENT_LOG.length - 1; i >= 0 && removed < toRemove; i--) {
+            if (EVENT_LOG[i].taskId === event.taskId) {
+                EVENT_LOG.splice(i, 1);
+                removed++;
+            }
+        }
+    }
+    EVENT_LOG.push(event);
+    // Also emit to the taskEvents bus for SSE consumers
+    ws_server_1.taskEvents.emit("agent_event", event);
+}
+function getTaskEventLog(taskId) {
+    return EVENT_LOG.filter(e => e.taskId === taskId);
+}
+// ============================================================================
+// GLOBAL TASK TRACKER & SCRATCHPAD LOGGER
+// ============================================================================
+exports.activeTasks = new Map();
+const SCRATCHPAD_DIR = path.join(process.cwd(), "..", ".aether_tasks");
+if (!fs.existsSync(SCRATCHPAD_DIR)) {
+    fs.mkdirSync(SCRATCHPAD_DIR, { recursive: true });
+}
+// Async scratchpad write — does not block the event loop
+async function updateScratchpad(taskId, content, append = true) {
+    const filePath = path.join(SCRATCHPAD_DIR, `${taskId}.md`);
+    const timestamp = new Date().toISOString();
+    const formattedContent = `\n## [${timestamp}]\n${content}\n`;
+    try {
+        if (append) {
+            await fs.promises.appendFile(filePath, formattedContent, "utf-8");
+        }
+        else {
+            await fs.promises.writeFile(filePath, `# Task: ${taskId}\n${formattedContent}`, "utf-8");
+        }
+    }
+    catch (err) {
+        console.error(`[Agent] Scratchpad write error for task ${taskId}: ${err.message}`);
+    }
+}
+async function saveTaskState(taskId, objective, status, extra) {
+    const filePath = path.join(SCRATCHPAD_DIR, `${taskId}.state.json`);
+    let existing = {};
+    try {
+        existing = JSON.parse(await fs.promises.readFile(filePath, "utf-8"));
+    }
+    catch { /* file doesn't exist yet — that's fine */ }
+    const state = {
+        taskId,
+        objective: existing.objective ?? objective,
+        status,
+        startedAt: existing.startedAt ?? new Date().toISOString(),
+        errorCount: extra?.errorCount ?? existing.errorCount ?? 0,
+        stepCount: extra?.stepCount ?? existing.stepCount ?? 0,
+        ...(status !== "running" ? { finishedAt: new Date().toISOString() } : {}),
+    };
+    try {
+        await fs.promises.writeFile(filePath, JSON.stringify(state, null, 2), "utf-8");
+    }
+    catch (err) {
+        console.error(`[Agent] Failed to persist task state for ${taskId}: ${err.message}`);
+    }
+}
+/**
+ * Called at server startup — restores any tasks that were "running" when the
+ * server previously crashed so that status checks return a meaningful message.
+ */
+async function restoreUnfinishedTasks() {
+    let files = [];
+    try {
+        files = await fs.promises.readdir(SCRATCHPAD_DIR);
+    }
+    catch {
+        return;
+    }
+    for (const file of files) {
+        if (!file.endsWith(".state.json"))
+            continue;
+        try {
+            const raw = await fs.promises.readFile(path.join(SCRATCHPAD_DIR, file), "utf-8");
+            const state = JSON.parse(raw);
+            if (state.status === "running") {
+                console.error(`[Agent] Restored crashed task: ${state.taskId}`);
+                exports.activeTasks.set(state.taskId, {
+                    objective: state.objective,
+                    status: "Crashed (server restarted)",
+                    lastObservation: "Server was restarted while this task was in progress.",
+                    shouldInterrupt: false,
+                    startedAt: Date.now() - 60000, // Approximate
+                    stepCount: state.stepCount || 0,
+                    consecutiveErrors: 0,
+                    toolCallHistory: [],
+                });
+                await saveTaskState(state.taskId, state.objective, "crashed");
+            }
+        }
+        catch (e) {
+            console.error(`[Agent] Could not restore state from ${file}: ${e.message}`);
+        }
+    }
+}
+// Helper: emit a task event and update activeTasks.status atomically
+function emitTaskUpdate(taskId, status, extra = {}) {
+    const task = exports.activeTasks.get(taskId);
+    if (task) {
+        task.status = status;
+        // Track step count if provided
+        if (extra.stepCount !== undefined)
+            task.stepCount = extra.stepCount;
+        if (extra.consecutiveErrors !== undefined)
+            task.consecutiveErrors = extra.consecutiveErrors;
+    }
+    ws_server_1.taskEvents.emit("task_update", { taskId, status, timestamp: Date.now(), ...extra });
+    emitAgentEvent({
+        taskId,
+        timestamp: new Date().toISOString(),
+        eventType: "state_change",
+        data: { status, ...extra },
+    });
+}
+// ============================================================================
+// TIMEOUT WRAPPER WITH RETRY
+// ============================================================================
+async function withTimeout(promise, ms = 30000, label = "Action") {
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms. The browser might be hanging.`)), ms);
+    });
+    return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timer));
+}
+/**
+ * Retry wrapper with exponential backoff for flaky tool calls.
+ */
+async function withRetry(fn, taskId, toolName, maxRetries = MAX_TOOL_RETRIES) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            emitAgentEvent({
+                taskId,
+                timestamp: new Date().toISOString(),
+                eventType: "tool_retry",
+                data: { tool: toolName, attempt: attempt + 1, error: err.message },
+            });
+            if (attempt < maxRetries) {
+                const delay = RETRY_DELAYS_MS[attempt] ?? RETRY_DELAYS_MS[RETRY_DELAYS_MS.length - 1];
+                void updateScratchpad(taskId, `⚠️ ${toolName} failed (attempt ${attempt + 1}/${maxRetries + 1}). Retrying in ${delay}ms...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError;
+}
+const circuitBreaker = {
+    state: "closed",
+    failureCount: 0,
+    lastFailureAt: 0,
+    lastStateChangeAt: Date.now(),
+};
+function recordExtensionFailure() {
+    circuitBreaker.failureCount++;
+    circuitBreaker.lastFailureAt = Date.now();
+    if (circuitBreaker.failureCount >= CIRCUIT_BREAKER_THRESHOLD && circuitBreaker.state !== "open") {
+        circuitBreaker.state = "open";
+        circuitBreaker.lastStateChangeAt = Date.now();
+        console.error(`[Agent] Circuit breaker OPENED after ${circuitBreaker.failureCount} consecutive extension failures`);
+        emitAgentEvent({
+            taskId: "system",
+            timestamp: new Date().toISOString(),
+            eventType: "critical_error",
+            data: { circuitBreaker: "opened", failureCount: circuitBreaker.failureCount },
+        });
+    }
+}
+function recordExtensionSuccess() {
+    if (circuitBreaker.state === "half-open") {
+        circuitBreaker.state = "closed";
+        circuitBreaker.failureCount = 0;
+        circuitBreaker.lastStateChangeAt = Date.now();
+        console.error("[Agent] Circuit breaker CLOSED after successful extension call");
+    }
+    else if (circuitBreaker.state === "closed") {
+        circuitBreaker.failureCount = 0;
+    }
+}
+function isCircuitBreakerOpen() {
+    if (circuitBreaker.state === "open") {
+        // Check if cooldown has elapsed — if so, half-open to allow a test call
+        const elapsed = Date.now() - circuitBreaker.lastStateChangeAt;
+        if (elapsed >= CIRCUIT_BREAKER_COOLDOWN_MS) {
+            circuitBreaker.state = "half-open";
+            circuitBreaker.lastStateChangeAt = Date.now();
+            console.error("[Agent] Circuit breaker HALF-OPEN — allowing test call");
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+function getCircuitBreakerStatus() {
+    return `${circuitBreaker.state} (failures: ${circuitBreaker.failureCount})`;
+}
+// ============================================================================
+// MEMORY MANAGEMENT — purge old completed tasks and trim event log
+// ============================================================================
+/**
+ * Purge completed tasks that have exceeded their TTL to prevent memory leaks.
+ * Call this periodically (e.g., every 60 seconds).
+ */
+function purgeCompletedTasks() {
+    const now = Date.now();
+    for (const [taskId, task] of exports.activeTasks.entries()) {
+        const isTerminalStatus = ["success", "failed", "crashed", "interrupted", "timeout"].includes(task.status)
+            || task.status.startsWith("Crashed");
+        if (isTerminalStatus && (now - task.startedAt) > COMPLETED_TASK_TTL_MS) {
+            exports.activeTasks.delete(taskId);
+        }
+    }
+    // Update health endpoint with current count
+    (0, ws_server_1.setActiveTaskCount)(exports.activeTasks.size);
+    // Also trim EVENT_LOG if it exceeds global cap
+    while (EVENT_LOG.length > MAX_EVENT_LOG_TOTAL) {
+        EVENT_LOG.shift();
+    }
+}
+// Start periodic purge timer
+const purgeInterval = setInterval(purgeCompletedTasks, 60_000);
+// Prevent the interval from keeping the process alive if everything else exits
+if (typeof purgeInterval.unref === "function") {
+    purgeInterval.unref();
+}
+// ============================================================================
+// LLM API RETRY — resilient LLM invocation
+// ============================================================================
+async function invokeLLMWithRetry(messages, taskId) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= MAX_LLM_RETRIES; attempt++) {
+        try {
+            emitAgentEvent({
+                taskId,
+                timestamp: new Date().toISOString(),
+                eventType: "llm_call",
+                data: { attempt: attempt + 1, messageCount: messages.length },
+            });
+            const response = await llm.invoke(messages);
+            emitAgentEvent({
+                taskId,
+                timestamp: new Date().toISOString(),
+                eventType: "llm_response",
+                data: { toolCalls: response.tool_calls?.length ?? 0 },
+            });
+            return response;
+        }
+        catch (err) {
+            lastError = err;
+            emitAgentEvent({
+                taskId,
+                timestamp: new Date().toISOString(),
+                eventType: "tool_retry",
+                data: { tool: "llm_invoke", attempt: attempt + 1, error: err.message },
+            });
+            if (attempt < MAX_LLM_RETRIES) {
+                const delay = LLM_RETRY_DELAYS_MS[attempt] ?? LLM_RETRY_DELAYS_MS[LLM_RETRY_DELAYS_MS.length - 1];
+                void updateScratchpad(taskId, `⚠️ LLM API call failed (attempt ${attempt + 1}/${MAX_LLM_RETRIES + 1}). Retrying in ${delay}ms...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw lastError;
+}
+const graphState = {
+    messages: { value: (x, y) => x.concat(y), default: () => [] },
+    objective: { value: (x, y) => y ?? x, default: () => "" },
+    taskId: { value: (x, y) => y ?? x, default: () => `task-${Date.now()}` },
+    parentId: { value: (x, y) => y ?? x, default: () => undefined },
+    finalResult: { value: (x, y) => y ?? x, default: () => null },
+    status: { value: (x, y) => y ?? x, default: () => "pending" },
+    errorCount: { value: (x, y) => y !== undefined ? y : x, default: () => 0 },
+    stepCount: { value: (x, y) => y !== undefined ? y : x, default: () => 0 },
+};
+// ============================================================================
+// 2. SYSTEM PROMPT
+// ============================================================================
+const AETHER_SYSTEM_PROMPT = `You are the Aether Navigation Agent — an elite browser automation specialist with Total Browser Command.
+Your mission: Achieve the user's objective with maximum reliability and efficiency.
+
+═══════════════════════════════════════════════════════════
+🧠 CORE OPERATING PRINCIPLES
+═══════════════════════════════════════════════════════════
+
+1. NEVER GIVE UP — Every obstacle is a puzzle, not a dead end.
+   - If a selector fails → try a different selector
+   - If an element ID is stale → call get_state to refresh
+   - If a page won't load → try navigate again, or check URL
+   - If all DOM methods fail → use coordinate clicking
+   - If coordinates fail → try scrolling first, then retry
+
+2. ALWAYS KNOW YOUR STATE — Never act blind.
+   - Call get_state BEFORE any interaction if you're uncertain about the current page
+   - After navigation, ALWAYS call get_state to confirm you arrived at the right page
+   - After clicking, call get_state to verify the click had the expected effect
+   - If get_state returns unexpected results, re-orient before proceeding
+
+3. BE METHODICAL — Rushing causes mistakes.
+   - Break complex objectives into small, verifiable steps
+   - Verify each step succeeded before moving to the next
+   - Save intermediate findings with write_to_scratchpad
+   - If a multi-step flow breaks, use get_state to diagnose where you are
+
+═══════════════════════════════════════════════════════════
+🎯 INTERACTION HIERARCHY (use in order)
+═══════════════════════════════════════════════════════════
+
+TIER 1 — Aether IDs (Most Reliable):
+   - Elements marked with @ID (e.g., @12, @45) are the most precise handles
+   - Use: act(action="click", elementId="@12")
+   - These are stable across page re-renders
+
+TIER 2 — Semantic Selectors:
+   - CSS selectors: act(action="click", selector="button[type='submit']")
+   - Text-based: act(action="click", selector="button:has-text('Sign In')")
+   - Attribute-based: act(action="type", selector="input[name='email']", value="test@test.com")
+
+TIER 3 — Coordinate Clicking:
+   - Use computer_20241022 for pixel-perfect clicks when DOM methods fail
+   - Get coordinates from get_state interactive elements list
+   - Always scroll the element into view first if needed
+
+TIER 4 — JavaScript Injection:
+   - Use execute_script for complex DOM manipulation
+   - Use cdp_command for protocol-level browser control
+   - This is your escape hatch for anything the other tools can't handle
+
+═══════════════════════════════════════════════════════════
+⚡ CRITICAL RULES
+═══════════════════════════════════════════════════════════
+
+✅ DO:
+   - Call get_state first to understand the current page
+   - Pass taskId to EVERY tool call for proper tracking
+   - Use write_to_scratchpad to save important findings
+   - Handle popups, cookies banners, and overlays immediately
+   - Wait for page to settle after navigation (use act(action="wait"))
+   - Verify each action succeeded before proceeding
+   - Try alternative approaches when something fails
+
+❌ DON'T:
+   - Don't assume the page state — always verify with get_state
+   - Don't repeat the same failing action more than once
+   - Don't skip steps in a multi-step flow
+   - Don't forget to call complete_task when done
+   - Don't hallucinate element IDs — only use IDs from get_state output
+   - Don't proceed if the page clearly shows an error
+
+═══════════════════════════════════════════════════════════
+🔄 ERROR RECOVERY PROTOCOL
+═══════════════════════════════════════════════════════════
+
+When any tool returns an error:
+1. READ the error message carefully
+2. CALL get_state to understand current browser state
+3. IDENTIFY what went wrong (element not found? page changed? timeout?)
+4. CHOOSE an alternative approach from the interaction hierarchy
+5. RETRY with the new approach
+6. If all tiers fail, use execute_script as a last resort
+
+═══════════════════════════════════════════════════════════
+📋 TASK COMPLETION
+═══════════════════════════════════════════════════════════
+
+When the objective is FULLY achieved:
+1. Save the result with write_to_scratchpad if needed
+2. Call complete_task with:
+   - success: true
+   - result: The final answer, data, or confirmation message
+   - taskId: Your current task ID
+3. The result should be concise but complete — include all information the user needs
+
+If the objective CANNOT be achieved after exhausting all approaches:
+1. Document what you tried and what failed in write_to_scratchpad
+2. Call complete_task with:
+   - success: false
+   - result: Detailed explanation of what went wrong and what was attempted
+
+═══════════════════════════════════════════════════════════
+
+Remember: You are in control. Think step by step. Verify your assumptions. 
+Never give up — there is always another path.`;
+// ============================================================================
+// 3. AETHER NATIVE TOOLS
+// ============================================================================
+/**
+ * Helper: track tool call in the task tracker and emit events
+ */
+function trackToolCall(taskId, toolName) {
+    const task = exports.activeTasks.get(taskId);
+    if (task) {
+        task.stepCount++;
+        task.toolCallHistory.push({ tool: toolName, result: "success", timestamp: Date.now() });
+        // Keep only last 50 tool calls
+        if (task.toolCallHistory.length > 50) {
+            task.toolCallHistory = task.toolCallHistory.slice(-50);
+        }
+    }
+}
+function trackToolError(taskId, toolName, error) {
+    const task = exports.activeTasks.get(taskId);
+    if (task) {
+        task.consecutiveErrors++;
+        task.stepCount++;
+        task.toolCallHistory.push({ tool: toolName, result: "error", timestamp: Date.now() });
+        if (task.toolCallHistory.length > 50) {
+            task.toolCallHistory = task.toolCallHistory.slice(-50);
+        }
+    }
+    // Update circuit breaker
+    recordExtensionFailure();
+    emitAgentEvent({
+        taskId,
+        timestamp: new Date().toISOString(),
+        eventType: "tool_error",
+        data: { tool: toolName, error, consecutiveErrors: exports.activeTasks.get(taskId)?.consecutiveErrors ?? 0 },
+    });
+}
+function trackToolSuccess(taskId, toolName) {
+    const task = exports.activeTasks.get(taskId);
+    if (task) {
+        task.consecutiveErrors = 0; // Reset on success
+    }
+    // Update circuit breaker
+    recordExtensionSuccess();
+    emitAgentEvent({
+        taskId,
+        timestamp: new Date().toISOString(),
+        eventType: "tool_result",
+        data: { tool: toolName, success: true },
+    });
+}
+/**
+ * Helper: check if extension is connected before attempting commands
+ */
+function checkExtensionConnection(taskId) {
+    if (!(0, ws_server_1.isExtensionConnected)()) {
+        trackToolError(taskId, "connection_check", "Extension not connected");
+        return { connected: false, error: "Browser extension is not connected. Ensure the extension is loaded and active." };
+    }
+    return { connected: true };
+}
+const actTool = (0, tools_1.tool)(async (input) => {
+    const taskId = input.taskId || "unknown";
+    const action = input.action;
+    const a = input;
+    const eid = a.elementId ? String(a.elementId).replace('@', '') : undefined;
+    // Connection check
+    const conn = checkExtensionConnection(taskId);
+    if (!conn.connected)
+        return `Error: ${conn.error}`;
+    void updateScratchpad(taskId, `▶️ ACT: ${action} | Target: ${input.elementId || input.selector || input.value || 'N/A'}`);
+    emitAgentEvent({ taskId, timestamp: new Date().toISOString(), eventType: "tool_call", data: { tool: "act", action, target: input.elementId || input.selector || 'coordinate' } });
+    try {
+        const execution = async () => {
+            if (action === "click") {
+                if (eid)
+                    return await (0, ws_server_1.sendCommandToExtension)("click_element", { id: eid, text: a.value });
+                if (a.selector)
+                    return await (0, ws_server_1.sendCommandToExtension)("click_element_by_selector", { selector: a.selector });
+                if (a.coordinate) {
+                    const [x, y] = String(a.coordinate).split(',').map(Number);
+                    return await (0, ws_server_1.sendCommandToExtension)("click", { x, y });
+                }
+                return await (0, ws_server_1.sendCommandToExtension)(action, a);
+            }
+            if (action === "type") {
+                if (eid || a.selector)
+                    await (0, ws_server_1.sendCommandToExtension)(eid ? "click_element" : "click_element_by_selector", { id: eid, selector: a.selector });
+                return await (0, ws_server_1.sendCommandToExtension)("type", { text: a.value || a.text });
+            }
+            if (action === "navigate") {
+                return await (0, ws_server_1.sendCommandToExtension)("navigate", { url: a.value });
+            }
+            return await (0, ws_server_1.sendCommandToExtension)(action, a);
+        };
+        const resultMsg = await withTimeout(execution(), 30000, `act(${action})`);
+        const obs = `Success: ${typeof resultMsg === 'string' ? resultMsg : JSON.stringify(resultMsg)}`;
+        void updateScratchpad(taskId, `✅ ${obs}`);
+        trackToolCall(taskId, "act");
+        trackToolSuccess(taskId, "act");
+        return obs;
+    }
+    catch (err) {
+        const errorMsg = `Error: ${err.message}. Try an alternative method.`;
+        void updateScratchpad(taskId, `❌ ${errorMsg}`);
+        trackToolError(taskId, "act", err.message);
+        return errorMsg;
+    }
+}, {
+    name: "act",
+    description: "Perform precise, high-speed actions in the browser.",
+    schema: zod_1.z.object({
+        action: zod_1.z.enum([
+            "navigate", "click", "type", "fill", "select", "check",
+            "hover", "scroll", "wait", "screenshot",
+            "new_tab", "switch_tab", "close_tab", "drag_and_drop", "upload_file", "get_logs",
+            "get_tree", "get_dom_tree", "configure", "print_pdf", "emulate_network",
+            "get_cookies", "set_cookie", "clear_cache", "set_geolocation", "set_timezone", "get_performance_metrics",
+            "start_screencast", "stop_screencast", "record_session",
+            "mock_network_request", "generate_artifact", "highlight_elements",
+            "assert", "start_tracing", "stop_tracing", "target_auto_attach", "enable_domain", "pause", "resume",
+            "screenshot_region", "verify_ui_state"
+        ]),
+        selector: zod_1.z.string().optional(),
+        elementId: zod_1.z.string().optional(),
+        value: zod_1.z.string().optional(),
+        assertionType: zod_1.z.string().optional(),
+        coordinate: zod_1.z.string().optional(),
+        tabId: zod_1.z.number().optional(),
+        taskId: zod_1.z.string().optional().describe("Always pass the current taskId here"),
+    }),
+});
+const getStateTool = (0, tools_1.tool)(async (input) => {
+    const taskId = input.taskId || "unknown";
+    // Connection check
+    const conn = checkExtensionConnection(taskId);
+    if (!conn.connected)
+        return `Error: ${conn.error}`;
+    emitAgentEvent({ taskId, timestamp: new Date().toISOString(), eventType: "tool_call", data: { tool: "get_state" } });
+    try {
+        const result = await withTimeout((0, ws_server_1.sendCommandToExtension)("get_state", { screenshot: false }), 30000, "get_state");
+        if (!result) {
+            trackToolError(taskId, "get_state", "Received empty state");
+            return "Error: Received empty state from extension";
+        }
+        const elementsSummary = result.interactiveElements
+            ? result.interactiveElements.map((el) => `[@${el.id}] ${el.tagName} "${el.text}" ${el.type ? 'type=' + el.type : ''}`).join("\n")
+            : "No elements found";
+        const obs = `Title: ${result.title}\nURL: ${result.url}\nInteractive Elements:\n${elementsSummary}`;
+        void updateScratchpad(taskId, `📍 Get State: ${result.title} | ${result.interactiveElements?.length || 0} elements`);
+        trackToolCall(taskId, "get_state");
+        trackToolSuccess(taskId, "get_state");
+        return obs;
+    }
+    catch (err) {
+        trackToolError(taskId, "get_state", err.message);
+        return `Error getting state: ${err.message}`;
+    }
+}, {
+    name: "get_state",
+    description: "Capture the current browser state including interactive elements.",
+    schema: zod_1.z.object({ taskId: zod_1.z.string().optional() }),
+});
+const executeScriptTool = (0, tools_1.tool)(async (input) => {
+    const taskId = input.taskId || "unknown";
+    // Connection check
+    const conn = checkExtensionConnection(taskId);
+    if (!conn.connected)
+        return `Error: ${conn.error}`;
+    emitAgentEvent({ taskId, timestamp: new Date().toISOString(), eventType: "tool_call", data: { tool: "execute_script" } });
+    void updateScratchpad(taskId, `⚙️ Executing JS...`);
+    try {
+        const result = await withTimeout((0, ws_server_1.sendCommandToExtension)("evaluate", { script: String(input.script) }), 30000, "execute_script");
+        trackToolCall(taskId, "execute_script");
+        trackToolSuccess(taskId, "execute_script");
+        return `Result: ${JSON.stringify(result)}`;
+    }
+    catch (err) {
+        trackToolError(taskId, "execute_script", err.message);
+        return `Script Error: ${err.message}`;
+    }
+}, {
+    name: "execute_script",
+    description: "Execute JS in the browser context.",
+    schema: zod_1.z.object({
+        script: zod_1.z.string(),
+        taskId: zod_1.z.string().optional()
+    }),
+});
+const cdpCommandTool = (0, tools_1.tool)(async (input) => {
+    const taskId = input.taskId || "unknown";
+    // Connection check
+    const conn = checkExtensionConnection(taskId);
+    if (!conn.connected)
+        return `Error: ${conn.error}`;
+    emitAgentEvent({ taskId, timestamp: new Date().toISOString(), eventType: "tool_call", data: { tool: "cdp_command", command: input.command } });
+    void updateScratchpad(taskId, `🔧 CDP: ${input.command}`);
+    try {
+        const result = await withTimeout((0, ws_server_1.sendCommandToExtension)("cdp_command", { command: input.command, args: input.args || {} }), 30000, "cdp_command");
+        trackToolCall(taskId, "cdp_command");
+        trackToolSuccess(taskId, "cdp_command");
+        return `CDP Result: ${JSON.stringify(result)}`;
+    }
+    catch (err) {
+        trackToolError(taskId, "cdp_command", err.message);
+        return `CDP Error: ${err.message}`;
+    }
+}, {
+    name: "cdp_command",
+    description: "Execute raw Chrome DevTools Protocol command.",
+    schema: zod_1.z.object({
+        command: zod_1.z.string(),
+        args: zod_1.z.record(zod_1.z.any()).optional(),
+        taskId: zod_1.z.string().optional()
+    }),
+});
+const computerTool = (0, tools_1.tool)(async (input) => {
+    const taskId = input.taskId || "unknown";
+    // Connection check
+    const conn = checkExtensionConnection(taskId);
+    if (!conn.connected)
+        return `Error: ${conn.error}`;
+    emitAgentEvent({ taskId, timestamp: new Date().toISOString(), eventType: "tool_call", data: { tool: "computer_20241022", action: input.action } });
+    void updateScratchpad(taskId, `🖱️ Computer: ${input.action}`);
+    try {
+        const a = input;
+        let resultMsg = "";
+        if (a.action === "left_click" && a.coordinate) {
+            await withTimeout((0, ws_server_1.sendCommandToExtension)("click", { x: a.coordinate[0], y: a.coordinate[1], button: "left", clickCount: 1 }), 30000, "computer_click");
+            resultMsg = `Left clicked at [${a.coordinate}]`;
+        }
+        else if (a.action === "right_click" && a.coordinate) {
+            await withTimeout((0, ws_server_1.sendCommandToExtension)("click", { x: a.coordinate[0], y: a.coordinate[1], button: "right", clickCount: 1 }), 30000, "computer_right_click");
+            resultMsg = `Right clicked at [${a.coordinate}]`;
+        }
+        else if (a.action === "double_click" && a.coordinate) {
+            await withTimeout((0, ws_server_1.sendCommandToExtension)("double_click", { x: a.coordinate[0], y: a.coordinate[1] }), 30000, "computer_double_click");
+            resultMsg = `Double clicked at [${a.coordinate}]`;
+        }
+        else if (a.action === "middle_click" && a.coordinate) {
+            await withTimeout((0, ws_server_1.sendCommandToExtension)("click", { x: a.coordinate[0], y: a.coordinate[1], button: "middle", clickCount: 1 }), 30000, "computer_middle_click");
+            resultMsg = `Middle clicked at [${a.coordinate}]`;
+        }
+        else if (a.action === "mouse_move" && a.coordinate) {
+            await withTimeout((0, ws_server_1.sendCommandToExtension)("mouse_move", { x: a.coordinate[0], y: a.coordinate[1] }), 30000, "computer_mouse_move");
+            resultMsg = `Moved mouse to [${a.coordinate}]`;
+        }
+        else if (a.action === "left_click_drag" && a.coordinate && a.start_coordinate) {
+            await withTimeout((0, ws_server_1.sendCommandToExtension)("drag", {
+                startX: a.start_coordinate[0], startY: a.start_coordinate[1],
+                endX: a.coordinate[0], endY: a.coordinate[1]
+            }), 30000, "computer_drag");
+            resultMsg = `Dragged from [${a.start_coordinate}] to [${a.coordinate}]`;
+        }
+        else if (a.action === "type" && a.text) {
+            await withTimeout((0, ws_server_1.sendCommandToExtension)("type", { text: a.text }), 30000, "computer_type");
+            resultMsg = `Typed: ${a.text}`;
+        }
+        else if (a.action === "key" && a.text) {
+            await withTimeout((0, ws_server_1.sendCommandToExtension)("type", { text: a.text }), 30000, "computer_key");
+            resultMsg = `Key pressed: ${a.text}`;
+        }
+        else if (a.action === "screenshot") {
+            const data = await withTimeout((0, ws_server_1.sendCommandToExtension)("screenshot_region", { x: 0, y: 0, width: 1920, height: 1080 }), 30000, "computer_screenshot");
+            resultMsg = data ? `Screenshot taken (${String(data).length} chars)` : "Screenshot taken";
+        }
+        else if (a.action === "cursor_position") {
+            resultMsg = "Cursor position tracking not available via CDP; use get_state to read DOM positions.";
+        }
+        else {
+            resultMsg = `Action '${a.action}' requires a coordinate or text parameter. Check your input.`;
+        }
+        trackToolCall(taskId, "computer_20241022");
+        trackToolSuccess(taskId, "computer_20241022");
+        return resultMsg;
+    }
+    catch (err) {
+        trackToolError(taskId, "computer_20241022", err.message);
+        return `Computer Tool Error: ${err.message}`;
+    }
+}, {
+    name: "computer_20241022",
+    description: "Native Anthropic Computer Use API implementation for zero-shot browser control via X,Y coordinates.",
+    schema: zod_1.z.object({
+        action: zod_1.z.enum([
+            "key", "type", "mouse_move", "left_click",
+            "left_click_drag", "right_click", "middle_click",
+            "double_click", "screenshot", "cursor_position"
+        ]),
+        coordinate: zod_1.z.array(zod_1.z.number()).optional().describe("Target [x, y] coordinate. For left_click_drag, this is the END coordinate."),
+        start_coordinate: zod_1.z.array(zod_1.z.number()).optional().describe("For left_click_drag only: the START [x, y] coordinate."),
+        text: zod_1.z.string().optional().describe("Text to type or key name to press (e.g. 'Return', 'ctrl+c')."),
+        taskId: zod_1.z.string().optional()
+    }),
+});
+const writeScratchpadTool = (0, tools_1.tool)(async (input) => {
+    const taskId = input.taskId || "unknown";
+    await updateScratchpad(taskId, `### AGENT NOTES\n${input.notes}`);
+    trackToolCall(taskId, "write_to_scratchpad");
+    trackToolSuccess(taskId, "write_to_scratchpad");
+    return "Notes saved to scratchpad.";
+}, {
+    name: "write_to_scratchpad",
+    description: "Use this to save partial data, notes, or findings while navigating complex multi-step tasks so you don't forget them.",
+    schema: zod_1.z.object({
+        notes: zod_1.z.string().describe("The information you want to save."),
+        taskId: zod_1.z.string().optional(),
+    }),
+});
+const completeTaskTool = (0, tools_1.tool)(async (input) => {
+    const taskId = input.taskId || "unknown";
+    await updateScratchpad(taskId, `### TASK COMPLETED\nSuccess: ${input.success}\nResult payload has been saved.`);
+    emitAgentEvent({
+        taskId,
+        timestamp: new Date().toISOString(),
+        eventType: "completion",
+        data: { success: input.success, result: input.result },
+    });
+    trackToolCall(taskId, "complete_task");
+    trackToolSuccess(taskId, "complete_task");
+    return "Payload saved successfully. Stop execution.";
+}, {
+    name: "complete_task",
+    description: "Call this tool when the objective has been successfully achieved to pass data back.",
+    schema: zod_1.z.object({
+        result: zod_1.z.any().describe("The final extracted data, confirmation message, or state summary to return."),
+        success: zod_1.z.boolean(),
+        taskId: zod_1.z.string().optional(),
+    }),
+});
+exports.aetherTools = [
+    actTool,
+    getStateTool,
+    executeScriptTool,
+    cdpCommandTool,
+    computerTool,
+    writeScratchpadTool,
+    completeTaskTool
+];
+// ============================================================================
+// 4. LLM & GRAPH ROUTING
+// ============================================================================
+const llm = new google_genai_1.ChatGoogleGenerativeAI({
+    model: process.env.MODEL_NAME || "gemini-3-flash-preview",
+    apiKey: process.env.OPENAI_API_KEY,
+    temperature: 0,
+}).bindTools(exports.aetherTools);
+async function callModel(state) {
+    const taskState = exports.activeTasks.get(state.taskId);
+    // --- Interrupt check ---
+    if (taskState?.shouldInterrupt) {
+        void updateScratchpad(state.taskId, "⚠️ Task interrupted by Orchestrator.");
+        emitTaskUpdate(state.taskId, "interrupted");
+        return { status: "interrupted" };
+    }
+    // --- Error budget: count consecutive tool errors from previous round ---
+    const prevToolMessages = state.messages.filter((m) => m instanceof messages_1.ToolMessage || m._getType?.() === "tool");
+    const recentErrors = prevToolMessages.slice(-MAX_CONSECUTIVE_ERRORS).filter(m => /^(Error|Script Error|CDP Error|Computer Tool Error):/.test(String(m.content))).length;
+    const newErrorCount = (recentErrors > 0) ? 1 : 0; // incremental delta for accumulator
+    if (state.errorCount >= MAX_CONSECUTIVE_ERRORS || recentErrors >= MAX_CONSECUTIVE_ERRORS) {
+        const msg = `## MAX ERRORS REACHED (${state.errorCount + newErrorCount}/${MAX_CONSECUTIVE_ERRORS})\nForcing task to failed state to prevent infinite retry loop.`;
+        void updateScratchpad(state.taskId, msg);
+        emitTaskUpdate(state.taskId, "failed", { reason: "max_errors" });
+        return { status: "failed", errorCount: newErrorCount };
+    }
+    // --- Build messages ---
+    const isFirstRun = state.messages.length === 0;
+    const initialMessages = [];
+    if (isFirstRun) {
+        initialMessages.push(new messages_1.SystemMessage(AETHER_SYSTEM_PROMPT));
+        initialMessages.push(new messages_1.HumanMessage(`# OBJECTIVE
+${state.objective}
+
+# CONTEXT
+- Task ID: ${state.taskId}
+- Parent Task: ${state.parentId || "None"}
+
+# EXECUTION GUIDELINES
+1. Start by calling get_state to understand the current browser state
+2. Break the objective into small, verifiable steps
+3. Verify each step succeeded before proceeding
+4. Save important findings with write_to_scratchpad
+5. When fully complete, call complete_task with the result
+
+Always pass taskId: ${state.taskId} to every tool call.`));
+        void updateScratchpad(state.taskId, `**Objective:** ${state.objective}`, false);
+    }
+    const messagesToInvoke = [...initialMessages, ...state.messages];
+    emitTaskUpdate(state.taskId, "Thinking...");
+    const response = await invokeLLMWithRetry(messagesToInvoke, state.taskId);
+    let status = state.status;
+    let finalResult = state.finalResult;
+    if (response.tool_calls?.some(tc => tc.name === "complete_task")) {
+        const completeCall = response.tool_calls.find(tc => tc.name === "complete_task");
+        status = completeCall?.args.success ? "success" : "failed";
+        finalResult = completeCall?.args.result;
+        emitTaskUpdate(state.taskId, `Task ${status}`, { result: finalResult });
+        if (taskState)
+            taskState.result = finalResult;
+    }
+    return { messages: [...initialMessages, response], status, finalResult, errorCount: newErrorCount };
+}
+function shouldContinue(state) {
+    if (state.status === "success" || state.status === "failed" || state.status === "interrupted")
+        return langgraph_1.END;
+    const lastMessage = state.messages[state.messages.length - 1];
+    if (lastMessage.tool_calls && lastMessage.tool_calls.length > 0)
+        return "execute_tools";
+    return langgraph_1.END;
+}
+// ============================================================================
+// 5. COMPILE GRAPH
+// ============================================================================
+const toolNode = new prebuilt_1.ToolNode(exports.aetherTools);
+const workflow = new langgraph_1.StateGraph({ channels: graphState })
+    .addNode("agent", callModel)
+    .addNode("execute_tools", toolNode)
+    .addEdge(langgraph_1.START, "agent")
+    .addConditionalEdges("agent", shouldContinue)
+    .addEdge("execute_tools", "agent");
+const checkpointer = new langgraph_1.MemorySaver();
+exports.aetherNavigationAgent = workflow.compile({ checkpointer });
+// ============================================================================
+// 6. ORCHESTRATOR DELEGATION
+// ============================================================================
+/**
+ * Idempotency guard: tracks taskIds that are currently being processed.
+ * Prevents duplicate dispatches of the same taskId.
+ */
+const dispatchingTasks = new Set();
+async function delegateToBrowser(objective, taskId, parentId) {
+    // --- Idempotency check ---
+    if (dispatchingTasks.has(taskId)) {
+        const existing = exports.activeTasks.get(taskId);
+        if (existing && !["success", "failed", "crashed", "interrupted", "timeout"].includes(existing.status) && !existing.status.startsWith("Crashed")) {
+            console.error(`[Agent] Idempotency guard: task ${taskId} is already running`);
+            throw new Error(`Task "${taskId}" is already in progress. Use aether_check_status to monitor it, or aether_interrupt_task to stop it before re-dispatching.`);
+        }
+        // Task was terminal — clean up and allow re-dispatch
+        dispatchingTasks.delete(taskId);
+    }
+    // --- Circuit breaker check ---
+    if (isCircuitBreakerOpen()) {
+        console.error(`[Agent] Circuit breaker is open — rejecting task ${taskId}`);
+        throw new Error(`Browser extension circuit breaker is OPEN (${getCircuitBreakerStatus()}). The extension has failed too many times. Wait for cooldown or check extension health at GET /health.`);
+    }
+    // --- Active tasks memory check ---
+    if (exports.activeTasks.size >= MAX_ACTIVE_TASKS) {
+        // Force purge to make room
+        purgeCompletedTasks();
+        if (exports.activeTasks.size >= MAX_ACTIVE_TASKS) {
+            throw new Error(`Too many active tasks (${exports.activeTasks.size}). Maximum is ${MAX_ACTIVE_TASKS}. Wait for some to complete or interrupt them.`);
+        }
+    }
+    const config = { configurable: { thread_id: taskId } };
+    const initialState = { objective, taskId, parentId, status: "pending", errorCount: 0, stepCount: 0 };
+    dispatchingTasks.add(taskId);
+    exports.activeTasks.set(taskId, {
+        objective,
+        status: "Starting Engine...",
+        lastObservation: "N/A",
+        shouldInterrupt: false,
+        startedAt: Date.now(),
+        stepCount: 0,
+        consecutiveErrors: 0,
+        toolCallHistory: [],
+    });
+    (0, ws_server_1.setActiveTaskCount)(exports.activeTasks.size);
+    // Persist as "running" so a server restart can detect crashed tasks
+    await saveTaskState(taskId, objective, "running");
+    emitTaskUpdate(taskId, "Starting Engine...");
+    // Task timeout wrapper
+    const taskTimeout = setTimeout(() => {
+        const task = exports.activeTasks.get(taskId);
+        if (task && !["success", "failed", "interrupted", "crashed", "timeout"].includes(task.status) && !task.status.startsWith("Crashed")) {
+            void updateScratchpad(taskId, `⏰ TASK TIMEOUT: Exceeded ${TASK_TIMEOUT_MS / 1000}s limit`);
+            emitAgentEvent({ taskId, timestamp: new Date().toISOString(), eventType: "timeout", data: { timeoutMs: TASK_TIMEOUT_MS } });
+            emitTaskUpdate(taskId, "timeout", { reason: "task_timeout" });
+            task.shouldInterrupt = true;
+        }
+    }, TASK_TIMEOUT_MS);
+    try {
+        const stream = await exports.aetherNavigationAgent.stream(initialState, config);
+        try {
+            for await (const chunk of stream) {
+                const currentTask = exports.activeTasks.get(taskId);
+                // Interrupt check
+                if (currentTask?.shouldInterrupt)
+                    break;
+                // Process stream chunks to extract state updates
+                // LangGraph stream chunks contain node outputs - extract status changes
+                if (chunk && typeof chunk === "object") {
+                    for (const [nodeName, nodeOutput] of Object.entries(chunk)) {
+                        if (nodeOutput && typeof nodeOutput === "object" && "status" in nodeOutput) {
+                            const newStatus = nodeOutput.status;
+                            if (newStatus && newStatus !== currentTask?.status) {
+                                emitTaskUpdate(taskId, newStatus, { node: nodeName });
+                            }
+                            // Extract error count if present
+                            if ("errorCount" in nodeOutput) {
+                                const task = exports.activeTasks.get(taskId);
+                                if (task)
+                                    task.consecutiveErrors = nodeOutput.errorCount;
+                            }
+                            // Extract step count if present
+                            if ("stepCount" in nodeOutput) {
+                                const task = exports.activeTasks.get(taskId);
+                                if (task)
+                                    task.stepCount = nodeOutput.stepCount;
+                            }
+                        }
+                    }
+                }
+                // Check for consecutive errors from task tracker
+                if (currentTask && currentTask.consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                    void updateScratchpad(taskId, `## MAX ERRORS REACHED (${currentTask.consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS})\nForcing task to failed state.`);
+                    emitTaskUpdate(taskId, "failed", { reason: "max_consecutive_errors" });
+                    break;
+                }
+                // Check task duration
+                if (currentTask) {
+                    const elapsed = Date.now() - currentTask.startedAt;
+                    if (elapsed > TASK_TIMEOUT_MS) {
+                        void updateScratchpad(taskId, `⏰ Task exceeded ${TASK_TIMEOUT_MS / 1000}s limit`);
+                        emitTaskUpdate(taskId, "timeout", { reason: "task_timeout", elapsedMs: elapsed });
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            if (typeof stream.return === "function") {
+                await stream.return(undefined);
+            }
+        }
+    }
+    catch (err) {
+        void updateScratchpad(taskId, `## CRITICAL FAILURE\n${err.message}`);
+        emitAgentEvent({ taskId, timestamp: new Date().toISOString(), eventType: "critical_error", data: { error: err.message, stack: err.stack } });
+        await saveTaskState(taskId, objective, "crashed", { errorCount: exports.activeTasks.get(taskId)?.consecutiveErrors ?? 0, stepCount: exports.activeTasks.get(taskId)?.stepCount ?? 0 });
+        emitTaskUpdate(taskId, "crashed", { error: err.message });
+        throw err;
+    }
+    finally {
+        clearTimeout(taskTimeout);
+        dispatchingTasks.delete(taskId);
+        (0, ws_server_1.setActiveTaskCount)(exports.activeTasks.size);
+    }
+    const finalState = await exports.aetherNavigationAgent.getState(config);
+    const finalValues = finalState.values;
+    const finalStatus = finalValues.status ?? "unknown";
+    // Update task tracker with final values
+    const task = exports.activeTasks.get(taskId);
+    if (task) {
+        task.status = finalStatus;
+        task.result = finalValues.finalResult;
+        task.stepCount = finalValues.stepCount ?? task.stepCount;
+        task.consecutiveErrors = finalValues.errorCount ?? task.consecutiveErrors;
+    }
+    await saveTaskState(taskId, objective, finalStatus, {
+        errorCount: task?.consecutiveErrors ?? 0,
+        stepCount: task?.stepCount ?? 0
+    });
+    // Emit final completion event
+    emitAgentEvent({
+        taskId,
+        timestamp: new Date().toISOString(),
+        eventType: finalStatus === "success" ? "completion" : "state_change",
+        data: { status: finalStatus, result: finalValues.finalResult, stepCount: task?.stepCount, errorCount: task?.consecutiveErrors },
+    });
+    emitTaskUpdate(taskId, finalStatus, {
+        result: finalValues.finalResult,
+        stepCount: task?.stepCount,
+        errorCount: task?.consecutiveErrors,
+    });
+    (0, ws_server_1.setActiveTaskCount)(exports.activeTasks.size);
+    return finalState;
+}