@leverageaiapps/locus 2.2.2 → 2.2.4

package/dist/agent/agent-loop.js

@@ -0,0 +1,936 @@
+"use strict";
+/**
+ * Core Agent Loop — runs locally on the user's Mac inside Locus.
+ * Adapted from container-agent/src/agent-loop.ts.
+ *
+ * Key differences from container-agent (sandbox):
+ *   - Memory paths: ~/.leverage/memory/ (not /root/memory/)
+ *   - Working directory: user-specified or HOME (not /root)
+ *   - No browser_action tool, no request_human_help tool
+ *   - No ensureDesktop(), no refreshDesktopIfNeeded()
+ *   - No R2 file sync for bash output (files already local on Mac)
+ *   - install_skill: fetches from ClawHub locally → creates via WorkerProxy
+ *   - Persistent process — no DO eviction recovery needed
+ */
+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.cancelCurrentTask = cancelCurrentTask;
+exports.injectUserMessage = injectUserMessage;
+exports.isRunning = isRunning;
+exports.runAgentLoop = runAgentLoop;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const worker_proxy_1 = require("./worker-proxy");
+const tool_defs_1 = require("./tool-defs");
+const local_tools_1 = require("./local-tools");
+const compaction_1 = require("./compaction");
+const types_1 = require("./types");
+const crypto = __importStar(require("node:crypto"));
+// ─── Memory Path ────────────────────────────────────────────────
+const MEMORY_DIR = `${(0, node_os_1.homedir)()}/.leverage/memory`;
+// ─── State ───────────────────────────────────────────────────────
+let cancelled = false;
+let currentTaskId = null;
+let pendingUserMessages = [];
+function cancelCurrentTask() {
+    if (!currentTaskId)
+        return false;
+    cancelled = true;
+    return true;
+}
+function injectUserMessage(message, images) {
+    if (!currentTaskId)
+        return false;
+    pendingUserMessages.push({ message, images });
+    return true;
+}
+function isRunning() {
+    return currentTaskId !== null;
+}
+// ─── Sequence counter ────────────────────────────────────────────
+let currentSequence = 0;
+function makeEvent(taskId, userId, conversationId, eventType, data) {
+    currentSequence++;
+    return {
+        taskId, userId, conversationId,
+        sequence: currentSequence,
+        eventType,
+        data,
+    };
+}
+// Batch emit helper — sends multiple events in one HTTP call
+async function emitEvents(proxy, events) {
+    if (events.length === 0)
+        return;
+    try {
+        await proxy.emitEvents(events);
+    }
+    catch (err) {
+        console.error(`[Agent] Failed to emit ${events.length} events: ${err.message}`);
+    }
+}
+async function emitEvent(proxy, taskId, userId, conversationId, eventType, data) {
+    await emitEvents(proxy, [makeEvent(taskId, userId, conversationId, eventType, data)]);
+}
+// ─── Main Agent Loop ─────────────────────────────────────────────
+async function runAgentLoop(req) {
+    const { taskId, userId, sandboxId, message, sessionId, workerUrl, token } = req;
+    const conversationId = sessionId || '0';
+    const isCronTask = !!(req.cronJobId && req.cronRunId);
+    // Reset state
+    cancelled = false;
+    currentTaskId = taskId;
+    currentSequence = 0;
+    pendingUserMessages = [];
+    // Set working directory for local tools
+    const workDir = req.workingDirectory || (0, node_os_1.homedir)();
+    (0, local_tools_1.setWorkingDirectory)(workDir);
+    const proxy = new worker_proxy_1.WorkerProxy(workerUrl, token, taskId, userId);
+    // Chat function — proxied through Worker (API keys stay on Cloudflare)
+    const chatFn = (msgs, opts) => proxy.claudeChat(msgs, opts);
+    // Hoist messages so catch block can save partial conversation on failure
+    const messages = [];
+    try {
+        // Mark task as running
+        await proxy.updateTaskStatus('running');
+        // Load context from Worker (conversation history, system prompt, skills)
+        // Read local memory files first
+        let memoryContent = '';
+        let recentNotes = '';
+        try {
+            memoryContent = await (0, promises_1.readFile)(`${MEMORY_DIR}/MEMORY.md`, 'utf-8').catch(() => '');
+            // Read last 2 days of notes
+            const today = new Date();
+            for (let i = 0; i < 2; i++) {
+                const d = new Date(today);
+                d.setDate(d.getDate() - i);
+                const dateStr = d.toISOString().split('T')[0];
+                try {
+                    const note = await (0, promises_1.readFile)(`${MEMORY_DIR}/${dateStr}.md`, 'utf-8');
+                    if (note)
+                        recentNotes += `\n--- ${dateStr} ---\n${note}`;
+                }
+                catch { }
+            }
+        }
+        catch { }
+        const ctx = await proxy.loadContext(sandboxId, conversationId, isCronTask, memoryContent, recentNotes.trim(), req.workingDirectory);
+        // Build messages array
+        if (ctx.conversationHistory.length > 0) {
+            messages.push(...ctx.conversationHistory);
+        }
+        // Build user message (with optional images)
+        const cronPrefix = isCronTask ? '[Scheduled Task Notification]\n\n' : '';
+        const userContent = [];
+        if (req.images && req.images.length > 0) {
+            for (const img of req.images) {
+                const match = img.match(/^data:(image\/\w+);base64,(.+)/);
+                if (match) {
+                    userContent.push({ type: 'image', source: { type: 'base64', media_type: match[1], data: match[2] } });
+                }
+            }
+        }
+        userContent.push({ type: 'text', text: cronPrefix + message });
+        messages.push({ role: 'user', content: userContent.length === 1 ? cronPrefix + message : userContent });
+        const systemPrompt = ctx.systemPrompt;
+        let fullOutput = '';
+        // Emit connected event
+        await emitEvent(proxy, taskId, userId, conversationId, 'connected', {
+            request_id: taskId,
+            sandbox_id: sandboxId,
+        });
+        const loopStartTime = Date.now();
+        // ─── Agentic Loop ────────────────────────────────────────
+        for (let turn = 0; turn < types_1.MAX_AGENT_TURNS; turn++) {
+            if (cancelled) {
+                await emitEvent(proxy, taskId, userId, conversationId, 'done', { finish_reason: 'cancelled' });
+                break;
+            }
+            // Check total elapsed time
+            if (Date.now() - loopStartTime > types_1.LOOP_TIMEOUT) {
+                await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', {
+                    content: '\n\n⏰ Task has been running for 15 minutes — auto-stopped.',
+                });
+                break;
+            }
+            // Drain pending user messages injected via /continue
+            while (pendingUserMessages.length > 0) {
+                const pm = pendingUserMessages.shift();
+                await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', {
+                    content: `\n\n**User:** ${pm.message}\n\n`,
+                });
+                messages.push({ role: 'user', content: pm.message });
+            }
+            // Compaction if needed
+            if ((0, compaction_1.estimateMessagesTokens)(messages) > 150000) {
+                const compacted = await (0, compaction_1.maybeCompactMessages)(messages, chatFn, systemPrompt);
+                messages.length = 0;
+                messages.push(...compacted);
+                (0, compaction_1.repairToolUseResultPairing)(messages);
+            }
+            // Image context compaction (strip old base64 images)
+            if (turn >= 1) {
+                (0, compaction_1.compactBrowserContext)(messages, 2);
+            }
+            // Truncate oversized tool results
+            (0, compaction_1.truncateOversizedToolResults)(messages);
+            // Repair orphaned tool_use/tool_result blocks
+            (0, compaction_1.repairToolUseResultPairing)(messages);
+            // Context window guard
+            const systemTokens = (0, compaction_1.estimateTokens)(systemPrompt || '');
+            const ctxCheck = (0, compaction_1.checkContextWindow)(messages, systemTokens);
+            if (!ctxCheck.ok) {
+                await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', {
+                    content: '\n\n⚠️ Context window is full. Please start a new conversation.',
+                });
+                break;
+            }
+            // Emit thinking
+            await emitEvent(proxy, taskId, userId, conversationId, 'thinking', {
+                message: turn === 0 ? 'Thinking...' : 'Processing results...',
+            });
+            // Build tool list
+            const hasSkills = ctx.hasSkills;
+            const skillExclude = hasSkills ? [] : ['get_skill', 'create_skill', 'upload_skill_resource'];
+            const cronExclude = isCronTask ? ['save_memory', 'search_memory', 'read_memory', 'update_memory'] : [];
+            const excludeTools = [...cronExclude, ...skillExclude];
+            const tools = (0, tool_defs_1.buildToolList)(excludeTools);
+            const chatOpts = {
+                model: req.model || 'claude-sonnet-4-6',
+                maxTokens: 16384,
+                systemPrompt,
+                tools,
+                toolChoice: { type: 'auto' },
+            };
+            // Dynamic API timeout
+            const API_TIMEOUT = Math.min(240000 + turn * 15000, 360000);
+            // Heartbeat during API call
+            const heartbeatInterval = setInterval(async () => {
+                try {
+                    await emitEvent(proxy, taskId, userId, conversationId, 'heartbeat', { turn });
+                }
+                catch { }
+            }, 20000);
+            let response;
+            let apiRetries = 0;
+            const MAX_API_RETRIES = 3;
+            while (apiRetries <= MAX_API_RETRIES) {
+                // Check remaining loop time BEFORE each API attempt
+                const remainingLoopTime = types_1.LOOP_TIMEOUT - (Date.now() - loopStartTime);
+                if (remainingLoopTime <= 30000) {
+                    console.error(`[Agent] Turn ${turn}: Only ${Math.round(remainingLoopTime / 1000)}s remaining, aborting retry`);
+                    await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', {
+                        content: '\n\n⚠️ Task timed out. Progress has been saved.',
+                    });
+                    break;
+                }
+                const effectiveApiTimeout = Math.min(API_TIMEOUT, remainingLoopTime - 5000);
+                try {
+                    // Claude API call proxied through Worker (API keys stay on Cloudflare)
+                    response = await proxy.claudeChat(messages, chatOpts);
+                    break;
+                }
+                catch (apiErr) {
+                    apiRetries++;
+                    const errMsg = apiErr.message || '';
+                    console.error(`[Agent] Turn ${turn}: API failed (attempt ${apiRetries}): ${errMsg}`);
+                    // Non-retryable errors — break immediately
+                    if (/incorrect role|roles must alternate/i.test(errMsg)) {
+                        await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', {
+                            content: '\n\n⚠️ Message ordering conflict. Please try again.',
+                        });
+                        break;
+                    }
+                    if (/image exceeds.*mb|image dimensions exceed/i.test(errMsg)) {
+                        await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', {
+                            content: '\n\n⚠️ Image is too large. Please compress it and try again.',
+                        });
+                        break;
+                    }
+                    if (apiRetries > MAX_API_RETRIES) {
+                        await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', {
+                            content: '\n\n⚠️ AI service response timed out.',
+                        });
+                        break;
+                    }
+                    // Detect context overflow vs transient errors
+                    const isContextOverflow = /too long|context length|token limit|prompt.*exceed|request too large|max.*token/i.test(errMsg);
+                    // Multi-layer context overflow recovery
+                    if (isContextOverflow) {
+                        if (apiRetries === 1) {
+                            // Layer 1: Aggressive tool result truncation + image strip
+                            console.log('[Agent] Recovery layer 1: aggressive tool result truncation');
+                            (0, compaction_1.truncateOversizedToolResults)(messages, 10000);
+                            (0, compaction_1.compactBrowserContext)(messages, 1);
+                        }
+                        else if (apiRetries === 2) {
+                            // Layer 2: Full compaction via summary
+                            console.log('[Agent] Recovery layer 2: full compaction');
+                            try {
+                                const compacted = await (0, compaction_1.maybeCompactMessages)(messages, chatFn, systemPrompt);
+                                messages.length = 0;
+                                messages.push(...compacted);
+                            }
+                            catch {
+                                const compacted = (0, compaction_1.emergencyCompactMessages)(messages);
+                                messages.length = 0;
+                                messages.push(...compacted);
+                            }
+                        }
+                        else {
+                            // Layer 3: Emergency compact (nuclear option)
+                            console.log('[Agent] Recovery layer 3: emergency compact');
+                            const compacted = (0, compaction_1.emergencyCompactMessages)(messages);
+                            messages.length = 0;
+                            messages.push(...compacted);
+                        }
+                    }
+                    else {
+                        // Transient error — emergency compact to reduce payload
+                        const compacted = (0, compaction_1.emergencyCompactMessages)(messages);
+                        messages.length = 0;
+                        messages.push(...compacted);
+                    }
+                    // Repair pairing after any compaction
+                    (0, compaction_1.repairToolUseResultPairing)(messages);
+                    // Exponential backoff with jitter
+                    const backoffDelay = Math.min(2000 * Math.pow(2, apiRetries - 1), 15000)
+                        + Math.floor(Math.random() * 1000);
+                    console.log(`[Agent] Retrying in ${backoffDelay}ms...`);
+                    await new Promise(r => setTimeout(r, backoffDelay));
+                }
+            }
+            clearInterval(heartbeatInterval);
+            if (!response) {
+                console.error(`[Agent] Turn ${turn}: No response after retries, breaking`);
+                await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', {
+                    content: '\n\n⚠️ AI service not responding. Please try again.',
+                });
+                break;
+            }
+            console.log(`[Agent] Turn ${turn}: stop_reason=${response.stop_reason}, blocks=${response.content.length}, usage=${JSON.stringify(response.usage)}`);
+            // Turn 0: retry with tool_choice='any' if text-only
+            const hasAnyToolUse = response.content.some((b) => b.type === 'tool_use' || b.type === 'server_tool_use');
+            if (turn === 0 && !hasAnyToolUse && response.stop_reason === 'end_turn') {
+                console.log('[Agent] Turn 0 text-only, retrying with tool_choice=any');
+                const retryHeartbeat = setInterval(async () => {
+                    try {
+                        await emitEvent(proxy, taskId, userId, conversationId, 'heartbeat', {});
+                    }
+                    catch { }
+                }, 20000);
+                try {
+                    const retryResponse = await proxy.claudeChat(messages, {
+                        ...chatOpts,
+                        toolChoice: { type: 'any' },
+                    });
+                    if (retryResponse.content.length > 0) {
+                        response = retryResponse;
+                    }
+                    else {
+                        console.log('[Agent] Turn 0 retry returned empty, keeping original text response');
+                    }
+                }
+                catch (retryErr) {
+                    console.error(`[Agent] Turn 0 retry failed (${retryErr.message}), keeping original text response`);
+                }
+                finally {
+                    clearInterval(retryHeartbeat);
+                }
+            }
+            // Process content blocks
+            const assistantContent = response.content;
+            let hasToolUse = false;
+            const toolResults = [];
+            for (const block of assistantContent) {
+                if (cancelled)
+                    break;
+                if (block.type === 'text' && block.text) {
+                    await emitEvent(proxy, taskId, userId, conversationId, 'text_delta', { content: block.text });
+                    if (fullOutput.length < 10000)
+                        fullOutput += block.text;
+                }
+                else if (block.type === 'tool_use') {
+                    hasToolUse = true;
+                    const toolName = block.name || 'unknown';
+                    const toolInput = block.input || {};
+                    const toolId = block.id || crypto.randomUUID();
+                    await emitEvent(proxy, taskId, userId, conversationId, 'tool_call', {
+                        name: toolName, input: toolInput,
+                    });
+                    // Execute tool locally — zero network latency!
+                    const toolResult = await executeToolLocally(proxy, taskId, userId, sandboxId, conversationId, toolName, toolInput);
+                    // Truncate output
+                    let output = toolResult.output;
+                    if (output.length > types_1.TOOL_OUTPUT_LIMIT) {
+                        output = output.substring(0, types_1.TOOL_OUTPUT_LIMIT) + '\n... (output truncated)';
+                    }
+                    await emitEvent(proxy, taskId, userId, conversationId, 'tool_result', {
+                        name: toolName, output, is_error: toolResult.isError,
+                    });
+                    toolResults.push({ type: 'tool_result', tool_use_id: toolId, content: output });
+                }
+                else if (block.type === 'server_tool_use') {
+                    // Server-side tools (web_search, web_fetch) — already executed by Claude API
+                    await emitEvent(proxy, taskId, userId, conversationId, 'tool_call', {
+                        name: block.name, input: block.input,
+                    });
+                }
+                else if (block.type === 'web_search_tool_result') {
+                    await emitEvent(proxy, taskId, userId, conversationId, 'tool_result', {
+                        name: 'web_search', output: `Search completed (${block.content?.length || 0} results)`, is_error: false,
+                    });
+                }
+                else if (block.type === 'web_fetch_tool_result') {
+                    await emitEvent(proxy, taskId, userId, conversationId, 'tool_result', {
+                        name: 'web_fetch', output: `Fetched: ${block.url || ''}`, is_error: false,
+                    });
+                }
+            }
+            // Continue or break
+            if (response.stop_reason === 'pause_turn') {
+                // Server-side tool finished, Claude needs to keep going
+                messages.push({ role: 'assistant', content: assistantContent });
+                continue;
+            }
+            if (hasToolUse && toolResults.length > 0) {
+                messages.push({ role: 'assistant', content: assistantContent });
+                messages.push({ role: 'user', content: toolResults });
+                continue;
+            }
+            // Handle max_tokens: Claude's output was truncated, auto-continue
+            if (response.stop_reason === 'max_tokens') {
+                console.log(`[Agent] Turn ${turn}: max_tokens hit, auto-continuing`);
+                messages.push({ role: 'assistant', content: assistantContent });
+                messages.push({ role: 'user', content: 'Continue from where you left off.' });
+                continue;
+            }
+            // No tool use — Claude is done
+            break;
+        }
+        // ─── Post-loop ───────────────────────────────────────────
+        // Emit done
+        await emitEvent(proxy, taskId, userId, conversationId, 'done', {
+            finish_reason: cancelled ? 'cancelled' : 'end_turn',
+        });
+        // Save conversation turn
+        if (!isCronTask) {
+            try {
+                const summary = buildTurnSummary(messages, message);
+                await proxy.saveTurn(sandboxId, conversationId, message, summary);
+            }
+            catch (err) {
+                console.error(`[Agent] Failed to save turn: ${err.message}`);
+            }
+        }
+        // Mark task completed
+        await proxy.updateTaskStatus('completed');
+        // Finalize cron run if this was a scheduled task
+        if (isCronTask && req.cronRunId && req.cronJobId) {
+            try {
+                await proxy.finalizeCronRun(req.cronRunId, req.cronJobId, sandboxId, 'completed', fullOutput);
+                console.log(`[Agent] Finalized cron run ${req.cronRunId} for job ${req.cronJobId}: completed`);
+            }
+            catch (cronErr) {
+                console.error(`[Agent] Failed to finalize cron run: ${cronErr.message}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[Agent] Task ${taskId} failed: ${err.message}`);
+        // Save conversation turn even on failure
+        if (!isCronTask && messages.length > 0) {
+            try {
+                const summary = buildTurnSummary(messages, message)
+                    + `\n[Task failed: ${err.message}]`;
+                await proxy.saveTurn(sandboxId, conversationId, message, summary);
+                console.log(`[Agent] Saved partial turn on failure for context continuity`);
+            }
+            catch (saveErr) {
+                console.error(`[Agent] Failed to save turn on failure: ${saveErr.message}`);
+            }
+        }
+        // Emit error event
+        try {
+            await emitEvent(proxy, taskId, userId, conversationId, 'error', {
+                message: `Task failed: ${err.message}`,
+            });
+        }
+        catch { }
+        // Mark task failed
+        try {
+            await proxy.updateTaskStatus('failed', err.message);
+        }
+        catch { }
+        // Finalize cron run as failed
+        if (isCronTask && req.cronRunId && req.cronJobId) {
+            try {
+                await proxy.finalizeCronRun(req.cronRunId, req.cronJobId, sandboxId, 'failed', '', err.message);
+            }
+            catch { }
+        }
+    }
+    finally {
+        currentTaskId = null;
+    }
+}
+// ─── Tool Execution ──────────────────────────────────────────────
+async function executeToolLocally(proxy, taskId, userId, sandboxId, conversationId, toolName, toolInput) {
+    const TOOL_HARD_TIMEOUT = toolName === 'bash' ? 330000 : 120000;
+    // Heartbeat during tool execution
+    const toolHeartbeat = setInterval(async () => {
+        try {
+            await emitEvent(proxy, taskId, userId, conversationId, 'heartbeat', { tool: toolName });
+        }
+        catch { }
+    }, 20000);
+    try {
+        const result = await Promise.race([
+            executeToolInner(proxy, taskId, userId, sandboxId, conversationId, toolName, toolInput),
+            // Hard timeout
+            new Promise((resolve) => setTimeout(() => resolve({
+                output: `Tool ${toolName} timed out after ${TOOL_HARD_TIMEOUT / 1000}s.`,
+                isError: true,
+            }), TOOL_HARD_TIMEOUT)),
+            // Cancellation check
+            new Promise((resolve) => {
+                const check = setInterval(() => {
+                    if (cancelled) {
+                        clearInterval(check);
+                        resolve({ output: 'Cancelled by user.', isError: true });
+                    }
+                }, 500);
+                setTimeout(() => clearInterval(check), TOOL_HARD_TIMEOUT + 1000);
+            }),
+        ]);
+        return result;
+    }
+    finally {
+        clearInterval(toolHeartbeat);
+    }
+}
+async function executeToolInner(proxy, taskId, userId, sandboxId, conversationId, toolName, toolInput) {
+    // ── Local tools ──
+    if (toolName === 'bash') {
+        const cmd = (toolInput.command || 'echo "no command"');
+        return await (0, local_tools_1.executeBash)(cmd);
+    }
+    if (toolName === 'write_file') {
+        const writePath = toolInput.path || toolInput.file_path;
+        return await (0, local_tools_1.executeWriteFile)(writePath, toolInput.content || '');
+    }
+    if (toolName === 'read_file') {
+        return await (0, local_tools_1.executeReadFile)(toolInput.path || toolInput.file_path);
+    }
+    if (toolName === 'show_file') {
+        const showPath = toolInput.path || toolInput.file_path;
+        const result = await (0, local_tools_1.executeShowFile)(showPath);
+        if (!result.isError) {
+            // Upload file to R2 for iOS download
+            try {
+                const fileData = await (0, local_tools_1.readFileBase64)(showPath);
+                if (fileData) {
+                    const uploadResult = await proxy.uploadToR2(sandboxId, showPath, fileData.base64, fileData.size);
+                    if (uploadResult.downloadUrl) {
+                        const fileName = showPath.split('/').pop() || showPath;
+                        await emitEvent(proxy, taskId, userId, conversationId, 'file_download', {
+                            filename: fileName,
+                            download_url: uploadResult.downloadUrl,
+                            file_path: showPath,
+                            file_size: fileData.size,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`[Agent] R2 upload failed for show_file ${showPath}: ${err.message}`);
+            }
+        }
+        return result;
+    }
+    if (toolName === 'search_files') {
+        return await (0, local_tools_1.executeSearchFiles)(toolInput.pattern, toolInput.directory);
+    }
+    // ── Memory tools (local file + Worker R2 backup) ──
+    if (toolName === 'save_memory') {
+        try {
+            const content = toolInput.content || toolInput.text || '';
+            const today = new Date().toISOString().split('T')[0];
+            const filePath = `${MEMORY_DIR}/${today}.md`;
+            const timestamp = new Date().toLocaleTimeString('en-US', { hour12: false });
+            const entry = `\n## ${timestamp}\n${content}\n`;
+            // Append to local file
+            await (0, promises_1.mkdir)(MEMORY_DIR, { recursive: true });
+            await (0, promises_1.appendFile)(filePath, entry, 'utf-8');
+            // Backup to R2
+            try {
+                const fileContent = await (0, promises_1.readFile)(filePath, 'utf-8');
+                await proxy.memoryOp('backup_memory', filePath, fileContent);
+            }
+            catch { }
+            return { output: `Saved to daily log (${today})`, isError: false };
+        }
+        catch (err) {
+            return { output: `Failed to save memory: ${err.message}`, isError: true };
+        }
+    }
+    if (toolName === 'search_memory' || toolName === 'read_memory') {
+        try {
+            const query = (toolInput.query || toolInput.section || '').toLowerCase();
+            const results = [];
+            // Search MEMORY.md
+            try {
+                const mem = await (0, promises_1.readFile)(`${MEMORY_DIR}/MEMORY.md`, 'utf-8');
+                if (mem && (toolName === 'read_memory' || mem.toLowerCase().includes(query))) {
+                    results.push(`--- MEMORY.md ---\n${mem.substring(0, 3000)}`);
+                }
+            }
+            catch { }
+            // Search recent daily logs
+            const today = new Date();
+            for (let i = 0; i < 14; i++) {
+                const d = new Date(today);
+                d.setDate(d.getDate() - i);
+                const dateStr = d.toISOString().split('T')[0];
+                try {
+                    const note = await (0, promises_1.readFile)(`${MEMORY_DIR}/${dateStr}.md`, 'utf-8');
+                    if (note && note.toLowerCase().includes(query)) {
+                        results.push(`--- ${dateStr} ---\n${note.substring(0, 1500)}`);
+                    }
+                }
+                catch { }
+            }
+            return { output: results.join('\n\n') || 'No results found.', isError: false };
+        }
+        catch (err) {
+            return { output: `Search failed: ${err.message}`, isError: true };
+        }
+    }
+    if (toolName === 'update_memory') {
+        try {
+            const content = toolInput.content || '';
+            await (0, promises_1.mkdir)(MEMORY_DIR, { recursive: true });
+            await (0, promises_1.writeFile)(`${MEMORY_DIR}/MEMORY.md`, content, 'utf-8');
+            // Backup to R2
+            try {
+                await proxy.memoryOp('backup_memory', `${MEMORY_DIR}/MEMORY.md`, content);
+            }
+            catch { }
+            return { output: 'MEMORY.md updated successfully.', isError: false };
+        }
+        catch (err) {
+            return { output: `Failed to update memory: ${err.message}`, isError: true };
+        }
+    }
+    // ── Skill tools (via Worker proxy) ──
+    if (toolName === 'get_skill' || toolName === 'create_skill' || toolName === 'upload_skill_resource') {
+        try {
+            const output = await proxy.skillOp(toolName, toolInput);
+            return { output, isError: false };
+        }
+        catch (err) {
+            return { output: `Skill operation failed: ${err.message}`, isError: true };
+        }
+    }
+    // ── install_skill (ClawHub or generic URL) ──
+    if (toolName === 'install_skill') {
+        return await executeInstallSkill(proxy, userId, toolInput);
+    }
+    // ── Schedule tool (via Worker proxy) ──
+    if (toolName === 'manage_schedule') {
+        try {
+            const output = await proxy.scheduleOp(sandboxId, toolInput);
+            return { output, isError: false };
+        }
+        catch (err) {
+            return { output: `Schedule operation failed: ${err.message}`, isError: true };
+        }
+    }
+    return { output: `Unknown tool: ${toolName}`, isError: true };
+}
+// ─── install_skill Implementation ────────────────────────────────
+async function executeInstallSkill(proxy, userId, toolInput) {
+    const sourceUrl = (toolInput.url || '');
+    const overrideSkillId = (toolInput.skill_id || '');
+    if (!sourceUrl) {
+        return { output: 'Error: url is required', isError: true };
+    }
+    try {
+        // ClawHub auto-detection
+        const clawHubSlug = extractClawHubSlug(sourceUrl);
+        if (clawHubSlug) {
+            console.log(`[Agent] install_skill: detected ClawHub URL, slug=${clawHubSlug}`);
+            return await installFromClawHub(proxy, clawHubSlug, sourceUrl, overrideSkillId);
+        }
+        // Generic URL: fetch and auto-detect format
+        const resp = await fetch(sourceUrl, {
+            headers: { 'User-Agent': 'Mozilla/5.0 (compatible; LeverageAI/1.0)', 'Accept': 'application/json, text/html, */*' },
+        });
+        const ctype = resp.headers.get('content-type') || '';
+        const body = await resp.text();
+        if (!resp.ok) {
+            return { output: `install_skill: HTTP ${resp.status} fetching ${sourceUrl}`, isError: true };
+        }
+        if (ctype.includes('json')) {
+            // Path A: JSON API
+            try {
+                const data = JSON.parse(body);
+                const skillData = data.skill || data;
+                const skillId = overrideSkillId || skillData.skill_id || skillData.id || sourceUrl.split('/').pop()?.replace(/\.\w+$/, '') || 'imported-skill';
+                const name = skillData.name || skillData.displayName || skillData.title || skillId;
+                const description = skillData.description || skillData.summary || `Skill from ${sourceUrl}`;
+                const fullPrompt = skillData.full_prompt || skillData.instructions || skillData.prompt || skillData.content || description;
+                if (fullPrompt.length < 20) {
+                    return { output: `install_skill: JSON fetched but content too short.`, isError: true };
+                }
+                const output = await proxy.skillOp('create_skill', {
+                    skill_id: skillId.substring(0, 64),
+                    name: name.substring(0, 128),
+                    description: description.substring(0, 1024),
+                    full_prompt: fullPrompt,
+                    category: skillData.category || 'custom',
+                });
+                return { output, isError: false };
+            }
+            catch (jsonErr) {
+                return { output: `install_skill: JSON parse failed (${jsonErr.message})`, isError: true };
+            }
+        }
+        // Path B: HTML/other — strip tags, return for AI to parse
+        const text = body
+            .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+            .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+            .replace(/<[^>]+>/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim()
+            .substring(0, 50000);
+        return {
+            output: `install_skill: Fetched web page. Extract skill info and use create_skill.\n\n<<<EXTERNAL_WEB_CONTENT>>>\nURL: ${sourceUrl}\n---\n${text}\n<<<END_EXTERNAL_WEB_CONTENT>>>`,
+            isError: false,
+        };
+    }
+    catch (installErr) {
+        return { output: `install_skill error: ${installErr.message}`, isError: true };
+    }
+}
+function extractClawHubSlug(url) {
+    try {
+        const u = new URL(url);
+        if (!u.hostname.match(/^(www\.)?(clawhub\.(ai|com))$/))
+            return null;
+        const segments = u.pathname.split('/').filter(Boolean);
+        if (segments.length === 2 && !segments[0].startsWith('api')) {
+            return segments[1];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function installFromClawHub(proxy, slug, sourceUrl, overrideSkillId) {
+    // Step 1: Fetch metadata
+    let skillName = slug;
+    let description = `Skill from ${sourceUrl}`;
+    let version = 'latest';
+    let category = 'custom';
+    try {
+        const metaResp = await fetch(`https://clawhub.ai/api/v1/skills/${slug}`, {
+            headers: { 'Accept': 'application/json', 'User-Agent': 'Mozilla/5.0 (compatible; LeverageAI/1.0)' },
+        });
+        if (metaResp.ok) {
+            const meta = await metaResp.json();
+            const skill = meta.skill || meta;
+            skillName = skill.displayName || skill.name || slug;
+            description = skill.summary || skill.description || description;
+            version = meta.latestVersion?.version || skill.tags?.latest || version;
+            category = skill.category || category;
+        }
+    }
+    catch (e) {
+        console.log(`[Agent] install_skill: metadata fetch failed (non-fatal): ${e}`);
+    }
+    // Step 2: Download ZIP
+    const downloadUrl = `https://clawhub.ai/api/v1/download?slug=${encodeURIComponent(slug)}&version=${encodeURIComponent(version)}`;
+    console.log(`[Agent] install_skill: Downloading: ${downloadUrl}`);
+    const dlResp = await fetch(downloadUrl, {
+        headers: { 'User-Agent': 'Mozilla/5.0 (compatible; LeverageAI/1.0)' },
+    });
+    if (!dlResp.ok) {
+        return {
+            output: `install_skill: ClawHub download failed (HTTP ${dlResp.status}) for slug="${slug}" version="${version}".`,
+            isError: true,
+        };
+    }
+    // Step 3: Extract SKILL.md from ZIP
+    const zipBuffer = await dlResp.arrayBuffer();
+    const skillMd = await extractFileFromZip(zipBuffer, 'SKILL.md');
+    if (!skillMd || skillMd.length < 20) {
+        return {
+            output: `install_skill: Downloaded ZIP but SKILL.md not found or too short (${skillMd?.length || 0} chars).`,
+            isError: true,
+        };
+    }
+    // Step 4: Parse frontmatter
+    const frontmatterMatch = skillMd.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+        const fm = frontmatterMatch[1];
+        const fmName = fm.match(/^name:\s*(.+)$/m);
+        const fmDesc = fm.match(/^description:\s*(.+)$/m);
+        if (fmName)
+            skillName = fmName[1].trim() || skillName;
+        if (fmDesc)
+            description = fmDesc[1].trim() || description;
+    }
+    const skillId = overrideSkillId || slug;
+    // Step 5: Create skill via Worker proxy
+    try {
+        const output = await proxy.skillOp('create_skill', {
+            skill_id: skillId.substring(0, 64),
+            name: skillName.substring(0, 128),
+            description: description.substring(0, 1024),
+            full_prompt: skillMd,
+            category,
+            trigger_pattern: slug.replace(/-/g, '|'),
+        });
+        return { output, isError: false };
+    }
+    catch (err) {
+        return { output: `install_skill: create failed: ${err.message}`, isError: true };
+    }
+}
+/**
+ * Extract a named file from a ZIP buffer.
+ * Supports stored (uncompressed) and deflated entries.
+ * Node.js has zlib built-in for deflate decompression.
+ */
+async function extractFileFromZip(buffer, targetName) {
+    const view = new DataView(buffer);
+    const bytes = new Uint8Array(buffer);
+    let offset = 0;
+    while (offset + 30 <= bytes.length) {
+        // Check local file header signature: PK\x03\x04
+        if (view.getUint32(offset, true) !== 0x04034b50)
+            break;
+        const compressedSize = view.getUint32(offset + 18, true);
+        const uncompressedSize = view.getUint32(offset + 22, true);
+        const nameLen = view.getUint16(offset + 26, true);
+        const extraLen = view.getUint16(offset + 28, true);
+        const compressionMethod = view.getUint16(offset + 8, true);
+        const nameBytes = bytes.slice(offset + 30, offset + 30 + nameLen);
+        const fileName = new TextDecoder().decode(nameBytes);
+        const dataStart = offset + 30 + nameLen + extraLen;
+        if (fileName === targetName) {
+            if (compressionMethod === 0) {
+                // Stored (no compression)
+                const fileData = bytes.slice(dataStart, dataStart + uncompressedSize);
+                return new TextDecoder().decode(fileData);
+            }
+            else if (compressionMethod === 8) {
+                // Deflate — use Node.js zlib
+                try {
+                    const { inflateRawSync } = require('node:zlib');
+                    const compressed = Buffer.from(bytes.slice(dataStart, dataStart + compressedSize));
+                    const decompressed = inflateRawSync(compressed);
+                    return decompressed.toString('utf-8');
+                }
+                catch (e) {
+                    console.error(`[Agent] ZIP deflate failed for ${targetName}: ${e}`);
+                    return null;
+                }
+            }
+            return null;
+        }
+        offset = dataStart + compressedSize;
+    }
+    return null;
+}
+// ─── Turn Summary Builder ────────────────────────────────────────
+function buildTurnSummary(messages, originalMessage) {
+    const parts = [];
+    for (const msg of messages) {
+        if (msg.role === 'assistant') {
+            if (typeof msg.content === 'string') {
+                parts.push(msg.content.substring(0, 500));
+            }
+            else if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    const b = block;
+                    if (b.type === 'text' && b.text) {
+                        parts.push(b.text.substring(0, 500));
+                    }
+                    else if (b.type === 'tool_use') {
+                        parts.push(`[Used ${b.name}: ${summarizeToolInput(b.name, b.input)}]`);
+                    }
+                }
+            }
+        }
+        else if (msg.role === 'user' && Array.isArray(msg.content)) {
+            // Include tool_result content so next turn has full context
+            for (const block of msg.content) {
+                const b = block;
+                if (b.type === 'tool_result') {
+                    const result = typeof b.content === 'string' ? b.content : JSON.stringify(b.content || '');
+                    const truncated = result.length > 300 ? result.substring(0, 300) + '...' : result;
+                    parts.push(`[Result: ${truncated}]`);
+                }
+            }
+        }
+    }
+    return parts.join('\n').substring(0, 8000);
+}
+function summarizeToolInput(toolName, input) {
+    if (!input)
+        return '';
+    switch (toolName) {
+        case 'bash':
+            return (input.command || '').substring(0, 150);
+        case 'write_file':
+            return `${input.path || input.file_path || ''} (${(input.content || '').length} chars)`;
+        case 'read_file':
+            return input.path || input.file_path || '';
+        case 'show_file':
+            return input.path || input.file_path || '';
+        case 'search_files':
+            return `pattern=${input.pattern || ''} dir=${input.directory || ''}`;
+        case 'save_memory':
+            return (input.content || '').substring(0, 80);
+        case 'search_memory':
+            return input.query || '';
+        default:
+            return JSON.stringify(input).substring(0, 120);
+    }
+}
+//# sourceMappingURL=agent-loop.js.map