visionclaw 0.1.35 → 0.1.37

package/dist/agent/loop.js

@@ -1,169 +1,41 @@
 import { buildSystemPrompt } from "./system-prompt.js";
 import { AgentSession } from "./session.js";
-import { buildWakeContext, buildInterruptContext, buildInterruptWithBriefing } from "./context.js";
+import { buildWakeContext } from "./context.js";
 import { createToolServer } from "../tools/index.js";
 import { MessageQueue } from "../channels/queue.js";
 import { ChannelManager } from "../channels/manager.js";
-import { takeScreenshot } from "../tools/screenshot.js";
-import { getCalendarSummary } from "../calendar/scheduler.js";
 import { ActivityTracker } from "./activity-tracker.js";
-import { fastRespond } from "./fast-responder.js";
+import { shouldNotifyUpdate } from "../utils/version-check.js";
+import { loadOwnerConfig, saveOwnerConfig } from "../config/index.js";
 import { logger } from "../logger.js";
-import { checkForUpdate, shouldNotifyUpdate, recordUpdateNotification } from "../utils/version-check.js";
-import { isOnboardingComplete, loadOwnerConfig, ownerConfigExists } from "../config/index.js";
-import { TelegramOnboardingHandler } from "../onboarding/telegram-onboarding.js";
-import { sendOnboardingEmail } from "../onboarding/send-invite.js";
-// Module-level state so tools can access it
-let agentState = null;
-export function getAgentState() {
-    if (!agentState) {
-        throw new Error("Agent state not initialized");
-    }
-    return agentState;
-}
-/**
- * Log an SDK result message (success or error).
- */
-function logResult(msg) {
-    const cost = msg.total_cost_usd.toFixed(4);
-    logger.result(msg.num_turns, msg.usage.input_tokens, msg.usage.output_tokens, cost);
-    if (msg.is_error) {
-        const errors = "errors" in msg ? msg.errors.join("; ") : msg.subtype;
-        logger.err(`Agent ended with error (${msg.subtype}): ${errors}`);
-    }
-}
-function captureUsageSnapshotFromResult(session, msg) {
-    try {
-        logger.debug("Capturing model usage snapshot from result message...");
-        const modelUsage = msg.modelUsage ??
-            msg.model_usage;
-        if (!modelUsage || typeof modelUsage !== "object") {
-            logger.debug("[modelUsage] missing on result message");
-            return;
-        }
-        // Prefer the primary model when present, otherwise pick the first entry.
-        const byModel = modelUsage;
-        const primary = typeof msg.model === "string"
-            ? (msg.model)
-            : undefined;
-        const usageObjUnknown = (primary && byModel[primary] !== undefined ? byModel[primary] : undefined) ??
-            Object.values(byModel)[0];
-        if (!usageObjUnknown || typeof usageObjUnknown !== "object")
-            return;
-        const u = usageObjUnknown;
-        const contextWindow = typeof u.contextWindow === "number" ? u.contextWindow : undefined;
-        if (!contextWindow || contextWindow <= 0) {
-            logger.debug("[modelUsage] missing/invalid contextWindow", { contextWindow });
-            return;
-        }
-        const inputTokens = typeof u.inputTokens === "number" ? u.inputTokens : 0;
-        const cacheReadInputTokens = typeof u.cacheReadInputTokens === "number" ? u.cacheReadInputTokens : 0;
-        const cacheCreationInputTokens = typeof u.cacheCreationInputTokens === "number" ? u.cacheCreationInputTokens : 0;
-        const usedInputTokens = inputTokens + cacheReadInputTokens + cacheCreationInputTokens;
-        const usedPct = usedInputTokens / contextWindow;
-        if (!Number.isFinite(usedPct) || usedPct < 0) {
-            logger.debug("[modelUsage] computed invalid usedPct", {
-                usedPct,
-                usedInputTokens,
-                contextWindow,
-            });
-            return;
-        }
-        session.captureUsageSnapshot({
-            usedInputTokens,
-            contextWindow,
-            usedPct,
-        });
-        logger.debug(`[modelUsage] snapshot: usedPct=${(usedPct * 100).toFixed(1)}% used=${usedInputTokens} window=${contextWindow} (in=${inputTokens} cache_read=${cacheReadInputTokens} cache_create=${cacheCreationInputTokens})`);
-    }
-    catch {
-        // ignore
-    }
-}
+import { initAgentState } from "./state.js";
+import { runOnboardingGate } from "./onboarding-gate.js";
+import { InterruptHandler } from "./interrupt-handler.js";
+import { processAgentStream } from "./stream-handler.js";
+import { gatherWakeContext } from "./gather-context.js";
+export { getAgentState } from "./state.js";
 /**
  * Main agent loop. This is the entry point that runs forever.
  */
 export async function startAgentLoop(config) {
-    // --- Initialize components ---
     const messageQueue = new MessageQueue();
     const channelManager = new ChannelManager(config, messageQueue);
     const activityTracker = new ActivityTracker();
-    // Start all enabled channels (needed for both onboarding and normal operation)
     await channelManager.startAll();
     // --- Onboarding gate ---
-    // If owner onboarding is not complete, run the restricted Telegram onboarding
-    // loop before entering the normal agent loop.
-    if (!isOnboardingComplete()) {
-        if (!ownerConfigExists()) {
-            logger.system("No owner configured. Run 'visionclaw set-owner --email <email>' to set up the owner.");
-            process.exit(1);
-        }
-        const partialOwner = loadOwnerConfig();
-        logger.system("Owner onboarding not complete. Entering onboarding mode...");
-        // Only send invitation email if the verification code hasn't been used yet
-        if (!partialOwner.onboardingCodeVerified) {
-            try {
-                await sendOnboardingEmail(config, partialOwner);
-            }
-            catch (err) {
-                logger.err(`Failed to send onboarding email: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        else {
-            logger.system("Code already verified — resuming onboarding conversation...");
-        }
-        // Run restricted loop: only process Telegram messages for onboarding
-        const botToken = config.channels.telegram?.botToken ?? "";
-        const handler = new TelegramOnboardingHandler(partialOwner, config, botToken, channelManager);
-        const sendReply = async (chatId, text) => {
-            await channelManager.sendMessage("telegram", String(chatId), text);
-        };
-        await new Promise((resolve) => {
-            channelManager.on("message", () => {
-                void (async () => {
-                    while (!messageQueue.isEmpty()) {
-                        const msg = messageQueue.dequeue();
-                        if (!msg)
-                            continue;
-                        if (msg.channel !== "telegram") {
-                            logger.debug(`Onboarding: ignoring ${msg.channel} message`);
-                            continue;
-                        }
-                        logger.log("info", "incoming", `[onboarding] [${msg.channel}] ${msg.sender}: ${msg.text}`, {
-                            channel: msg.channel,
-                            sender: msg.sender,
-                            text: msg.text,
-                        });
-                        const done = await handler.handleMessage(msg, sendReply);
-                        if (done) {
-                            resolve();
-                            return;
-                        }
-                    }
-                })();
-            });
-        });
-        logger.system("Owner onboarding complete! Restarting to clean up onboarding context...\n");
-        // Stop all channels before restart so listeners are torn down cleanly.
-        await channelManager.stopAll();
-        // Restart the process so the normal agent loop starts with a clean slate
-        // (no leftover onboarding session state, event listeners, etc.).
-        const { scheduleRestart } = await import("../utils/restart.js");
-        scheduleRestart(2_000);
+    if (await runOnboardingGate(config, channelManager, messageQueue)) {
         return;
     }
     // --- Normal operation (onboarding complete) ---
     const ownerConfig = loadOwnerConfig();
-    // Apply Telegram allowed chat IDs from owner config
     if (ownerConfig.allowedTelegramChatIds.length > 0) {
         channelManager.setTelegramAllowedChatIds(ownerConfig.allowedTelegramChatIds);
     }
-    // Apply Discord allowed channel IDs from owner config
     if (ownerConfig.allowedDiscordChannelIds.length > 0) {
         channelManager.setDiscordAllowedChannelIds(ownerConfig.allowedDiscordChannelIds);
     }
     let requestSessionStop = () => { };
-    agentState = {
+    const agentState = {
         config,
         ownerConfig,
         channelManager,
@@ -172,21 +44,18 @@ export async function startAgentLoop(config) {
         busy: false,
         stopRequested: false,
         requestStop: () => {
-            if (agentState)
-                agentState.stopRequested = true;
+            agentState.stopRequested = true;
             requestSessionStop();
         },
     };
+    initAgentState(agentState);
     logger.system(`Agent: ${ownerConfig.agentName} <${config.gmail}>`);
     logger.system(`Owner: ${ownerConfig.ownerName} <${ownerConfig.ownerEmail}>`);
     logger.system(`Heartbeat interval: ${ownerConfig.heartbeatIntervalMs / 1000}s`);
     logger.system("");
     // Create the in-process MCP tool server
     const toolServer = createToolServer();
-    // Create the agent session (uses V1 query API with full tool support)
-    // Pass a builder function so the system prompt is regenerated fresh
-    // each wake cycle (keeps current time / heartbeat interval accurate).
-    const session = new AgentSession(config, () => buildSystemPrompt(config, ownerConfig), {
+    const mcpServers = {
         visionclaw: toolServer,
         playwright: {
             command: "npx",
@@ -196,149 +65,39 @@ export async function startAgentLoop(config) {
                 process.env.PLAYWRIGHT_MCP_CDP_ENDPOINT ?? "http://127.0.0.1:9222",
             ],
         },
-    });
+    };
+    if (config.provider === "bedrock" && config.serpApiKey) {
+        mcpServers.serpapi = {
+            type: "http",
+            url: `https://mcp.serpapi.com/${config.serpApiKey}/mcp`,
+        };
+    }
+    const session = new AgentSession(config, () => buildSystemPrompt(config, ownerConfig), mcpServers);
     requestSessionStop = () => session.requestStop();
-    // Listen for incoming messages to wake the agent or inject interrupts
+    // --- Interrupt handling ---
     let wakeResolver = null;
-    // Debounce + concurrency guard for interrupt handling.
-    // When messages arrive in quick succession while the agent is busy, we
-    // wait a short window to batch them, then process the batch in a single
-    // fast-responder call.  Only one interrupt batch runs at a time; messages
-    // arriving while a batch is in-flight are picked up by the next batch.
-    const INTERRUPT_DEBOUNCE_MS = 10000;
-    const FAST_RESPONDER_TIMEOUT_MS = 8000;
-    let interruptTimer = null;
-    let interruptInFlight = false;
-    function requeue(batch) {
-        logger.warn(`Session closed before inject — re-queuing ${batch.length} message(s) for next wake cycle`);
-        for (const msg of batch) {
-            messageQueue.enqueue(msg);
-        }
-    }
-    async function processInterruptBatch() {
-        if (interruptInFlight || !agentState?.busy)
-            return;
-        interruptInFlight = true;
-        try {
-            // Drain everything currently in the queue
-            const batch = [];
-            while (!messageQueue.isEmpty()) {
-                const msg = messageQueue.dequeue();
-                if (msg)
-                    batch.push(msg);
-            }
-            if (batch.length === 0)
-                return;
-            // Update last-message tracking
-            const last = batch[batch.length - 1];
-            agentState.lastMessageChannel = last.channel;
-            agentState.lastMessageSender = last.sender;
-            // Log each interrupt message
-            for (const msg of batch) {
-                logger.log("info", "incoming", `[interrupt] [${msg.channel}] ${msg.sender}: ${msg.text}`, {
-                    channel: msg.channel,
-                    sender: msg.sender,
-                    text: msg.text,
-                    id: msg.id,
-                    interrupt: true,
-                });
-            }
-            // Single fast-responder call for the entire batch
-            const fr = await Promise.race([
-                fastRespond({
-                    systemPrompt: buildSystemPrompt(config, ownerConfig),
-                    messages: batch,
-                    activitySummary: activityTracker.getSummary(),
-                    apiKey: config.anthropicApiKey,
-                }),
-                new Promise((resolve) => setTimeout(() => resolve(null), FAST_RESPONDER_TIMEOUT_MS)),
-            ]);
-            if (fr) {
-                // Build a lookup from the per-recipient replies
-                const replyMap = new Map();
-                for (const r of fr.replies) {
-                    replyMap.set(`${r.channel}::${r.sender}`, r.reply);
-                }
-                // Send each recipient their personalized reply
-                const sent = new Set();
-                for (const msg of batch) {
-                    const key = `${msg.channel}::${msg.sender}`;
-                    if (sent.has(key))
-                        continue;
-                    sent.add(key);
-                    const reply = replyMap.get(key);
-                    if (!reply)
-                        continue;
-                    try {
-                        await channelManager.sendMessage(msg.channel, msg.sender, reply);
-                    }
-                    catch (sendErr) {
-                        logger.warn(`Failed to send fast response: ${sendErr instanceof Error ? sendErr.message : String(sendErr)}`);
-                    }
-                }
-                logger.log("info", "fast_response", `Replied to ${sent.size} recipient(s) for ${batch.length} message(s)`, {
-                    messageCount: batch.length,
-                    recipientCount: sent.size,
-                    needsPrimaryAction: fr.needsPrimaryAction,
-                });
-                // Inject briefing into the primary session if follow-up is needed
-                if (fr.needsPrimaryAction) {
-                    const briefingBlocks = buildInterruptWithBriefing({
-                        messages: batch,
-                        fastResponse: fr,
-                    });
-                    if (!session.injectMessage(briefingBlocks)) {
-                        requeue(batch);
-                    }
-                }
-                else {
-                    logger.log("info", "fast_response", `No follow-up needed for ${batch.length} message(s)`, {
-                        messageCount: batch.length,
-                        recipientCount: sent.size,
-                        needsPrimaryAction: fr.needsPrimaryAction,
-                    });
-                }
-            }
-            else {
-                // Fast responder failed — fall back to the original interrupt path
-                const interruptBlocks = await buildInterruptContext({ messages: batch });
-                if (!session.injectMessage(interruptBlocks)) {
-                    requeue(batch);
-                }
-            }
-        }
-        finally {
-            interruptInFlight = false;
-            // If more messages arrived while we were processing, schedule another batch
-            // Re-check module-level state since it may have changed during async work.
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- agentState is module-level and may change across awaits
-            if (!messageQueue.isEmpty() && agentState?.busy) {
-                scheduleInterruptBatch();
-            }
-        }
-    }
-    function scheduleInterruptBatch() {
-        if (interruptTimer !== null)
-            return; // already scheduled
-        interruptTimer = setTimeout(() => {
-            interruptTimer = null;
-            void processInterruptBatch();
-        }, INTERRUPT_DEBOUNCE_MS);
-    }
+    const interruptHandler = new InterruptHandler({
+        session,
+        config,
+        ownerConfig,
+        channelManager,
+        messageQueue,
+        activityTracker,
+        getAgentState: () => agentState,
+    });
     channelManager.on("message", () => {
-        // If agent is sleeping, wake it up immediately
         if (wakeResolver !== null) {
             wakeResolver();
             wakeResolver = null;
             return;
         }
-        // If agent is busy, schedule a debounced interrupt batch
-        if (agentState?.busy) {
-            scheduleInterruptBatch();
+        if (agentState.busy) {
+            interruptHandler.schedule();
         }
     });
+    // --- Channel command handlers ---
     channelManager.on("stop_request", (req) => {
-        if (agentState?.busy && !agentState.stopRequested) {
+        if (agentState.busy && !agentState.stopRequested) {
             agentState.requestStop();
             logger.system(`Agent stop requested via ${req.channel} by ${req.sender}`);
             channelManager
@@ -355,6 +114,29 @@ export async function startAgentLoop(config) {
             });
         }
     });
+    channelManager.on("sleep_request", (req) => {
+        const minutes = Math.max(1, Math.min(1440, req.minutes));
+        const oldMs = ownerConfig.heartbeatIntervalMs;
+        ownerConfig.heartbeatIntervalMs = minutes * 60 * 1000;
+        saveOwnerConfig(ownerConfig);
+        logger.system(`Sleep interval changed from ${oldMs / 60000}m to ${minutes}m by ${req.sender} via ${req.channel}`);
+        channelManager
+            .sendMessage(req.channel, req.sender, `Sleep interval changed from ${oldMs / 60000}m to ${minutes}m.`)
+            .catch((err) => {
+            logger.warn(`Failed to send sleep confirmation: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    });
+    channelManager.on("console_request", (req) => {
+        const url = agentState.consoleUrl;
+        const reply = url
+            ? `${url}/console`
+            : "Console URL is not available yet (tunnel may still be starting).";
+        channelManager
+            .sendMessage(req.channel, req.sender, reply)
+            .catch((err) => {
+            logger.warn(`Failed to send console URL: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    });
     logger.system("Agent loop started. Waiting for messages or heartbeat...");
     // --- Main loop ---
     let firstIteration = true;
@@ -364,12 +146,10 @@ export async function startAgentLoop(config) {
         agentState.stopRequested = false;
         session.clearStop();
         activityTracker.clear();
-        // Fire immediately on startup; sleep on subsequent iterations
         if (firstIteration) {
             firstIteration = false;
         }
         else {
-            // Sleep until heartbeat or new message
             await new Promise((resolve) => {
                 wakeResolver = resolve;
                 const timer = setTimeout(() => {
@@ -387,33 +167,25 @@ export async function startAgentLoop(config) {
         }
         agentState.busy = true;
         activityTracker.clear();
-        // Determine trigger
         const hasMessages = !messageQueue.isEmpty();
         const trigger = hasMessages ? "message" : "heartbeat";
-        // Dequeue all pending messages
         const messages = [];
         while (!messageQueue.isEmpty()) {
             const msg = messageQueue.dequeue();
             if (msg)
                 messages.push(msg);
         }
-        // Track last message for notify_user
         if (messages.length > 0) {
             const last = messages[messages.length - 1];
             agentState.lastMessageChannel = last.channel;
             agentState.lastMessageSender = last.sender;
         }
-        // Start tracking this wake cycle's activity
         const taskDesc = messages.length > 0
             ? messages.map((m) => `[${m.channel}] ${m.sender}: ${m.text}`).join("; ")
             : "heartbeat";
         activityTracker.startTask(taskDesc);
-        // Log the wake event
         logger.wake(trigger, messages.length);
-        // If this is a heartbeat wake (no new messages), it's a good time to compact.
         if (trigger === "heartbeat") {
-            // After a turn completes we have a fresh usage snapshot; it's a safe time
-            // to consider compaction.
             try {
                 await session.maybeCompactByTokens();
             }
@@ -421,7 +193,6 @@ export async function startAgentLoop(config) {
                 logger.warn(`Compaction request failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        // Log each incoming message
         for (const msg of messages) {
             logger.log("info", "incoming", `[${msg.channel}] ${msg.sender}: ${msg.text}`, {
                 channel: msg.channel,
@@ -431,50 +202,8 @@ export async function startAgentLoop(config) {
             });
         }
         // --- Gather context ---
-        // Gather screenshot, calendar, and version check in parallel
         const doVersionCheck = trigger === "heartbeat" && shouldNotifyUpdate();
-        const [screenshotResult, calendarResult, versionResult] = await Promise.allSettled([
-            (async () => {
-                const t0 = Date.now();
-                const base64 = await takeScreenshot();
-                logger.debug(`Screenshot captured in ${Date.now() - t0}ms`);
-                return { base64 };
-            })(),
-            (async () => {
-                const t0 = Date.now();
-                const summary = await getCalendarSummary(config);
-                logger.debug(`Calendar fetched in ${Date.now() - t0}ms`);
-                return summary;
-            })(),
-            (async () => {
-                if (!doVersionCheck)
-                    return undefined;
-                const t0 = Date.now();
-                const result = await checkForUpdate();
-                logger.debug(`Version check completed in ${Date.now() - t0}ms`);
-                if (result.hasUpdate) {
-                    recordUpdateNotification(result.latestVersion);
-                    logger.system(`Update available: ${result.currentVersion} → ${result.latestVersion}`);
-                }
-                return result;
-            })(),
-        ]);
-        const screenshot = screenshotResult.status === "fulfilled" ? screenshotResult.value : undefined;
-        if (screenshotResult.status === "rejected") {
-            logger.warn(`Screenshot failed: ${screenshotResult.reason instanceof Error ? screenshotResult.reason.message : String(screenshotResult.reason)}`);
-        }
-        if (screenshot?.base64) {
-            logger.screenshot(screenshot.base64);
-        }
-        const calendarSummary = calendarResult.status === "fulfilled" ? calendarResult.value : "";
-        if (calendarResult.status === "rejected") {
-            logger.warn(`Calendar fetch failed: ${calendarResult.reason instanceof Error ? calendarResult.reason.message : String(calendarResult.reason)}`);
-        }
-        const versionUpdate = versionResult.status === "fulfilled" ? versionResult.value : undefined;
-        if (versionResult.status === "rejected") {
-            logger.debug(`Version check failed: ${versionResult.reason instanceof Error ? versionResult.reason.message : String(versionResult.reason)}`);
-        }
-        // Build multimodal content blocks
+        const { screenshot, calendarSummary, versionUpdate } = await gatherWakeContext(config, doVersionCheck);
         const contentBlocks = await buildWakeContext({
             config,
             trigger,
@@ -483,219 +212,25 @@ export async function startAgentLoop(config) {
             screenshot,
             versionUpdate,
         });
-        // Map tool_use_id -> tool name for correlating results (per wake cycle)
-        const toolNameById = new Map();
-        // Log the multimodal message being sent (text + image summary)
         logger.sendMultimodal(contentBlocks);
+        if (trigger === "message") {
+            // send typing indicator to all channels
+            for (const msg of messages) {
+                channelManager.sendTypingIndicator(msg.channel, msg.sender).catch(() => { });
+            }
+        }
         try {
-            // Send the multimodal content and stream the response.
-            // Cast through unknown because our ContentBlock type may not
-            // exactly match MessageParam["content"].
             const messageContent = contentBlocks;
             const queryStream = session.sendAndStream(messageContent);
-            // Track Task -> subagent mapping so we can annotate logs for subagent activity.
-            // Per Claude Agent SDK docs, subagents are invoked via the Task tool, and messages
-            // emitted from within a subagent execution context include parent_tool_use_id.
-            const subagentByTaskToolUseId = new Map();
-            // Process the response stream.
-            // We don't break on finish -- breaking calls generator.return() which
-            // can hang waiting for the SDK child process to exit. Instead we
-            // drain the stream naturally and skip logging after finish.
-            let finishCalled = false;
-            for await (const msg of queryStream) {
-                // Always capture session ID
-                if ("session_id" in msg && msg.session_id) {
-                    session.captureSessionId(msg.session_id);
-                }
-                // After finish, only log the result message and skip everything else
-                if (finishCalled) {
-                    if (msg.type === "result") {
-                        logResult(msg);
-                        captureUsageSnapshotFromResult(session, msg);
-                    }
-                    continue;
-                }
-                // Handle different message types
-                switch (msg.type) {
-                    case "user": {
-                        // In Claude Agent SDK v2, tool execution results are surfaced back
-                        // into the stream as "user" messages (not as a separate tool_result
-                        // message type). Capture and log them for OBS.
-                        const um = msg;
-                        const parentToolUseId = typeof um.parent_tool_use_id === "string" && um.parent_tool_use_id.length > 0
-                            ? um.parent_tool_use_id
-                            : undefined;
-                        const subagentMeta = parentToolUseId
-                            ? subagentByTaskToolUseId.get(parentToolUseId)
-                            : undefined;
-                        // Tool results in this SDK are encoded as user message content blocks:
-                        // [{ type: "tool_result", tool_use_id, content: [...] }]
-                        const blocks = um.message?.content;
-                        if (Array.isArray(blocks)) {
-                            for (const b of blocks) {
-                                const block = b;
-                                if (block.type !== "tool_result" || !block.tool_use_id)
-                                    continue;
-                                // If this is the result of a Task tool invocation, extract agentId for correlation.
-                                // The SDK docs show agentId appearing in Task tool results; store it so subsequent
-                                // subagent events (which reference parent_tool_use_id) can include it.
-                                const maybeTask = subagentByTaskToolUseId.get(block.tool_use_id);
-                                if (maybeTask) {
-                                    const contentStr = block.content === undefined
-                                        ? ""
-                                        : typeof block.content === "string"
-                                            ? block.content
-                                            : JSON.stringify(block.content);
-                                    const re = /agentId:\s*([a-f0-9-]+)/i;
-                                    const match = re.exec(contentStr);
-                                    if (match?.[1]) {
-                                        subagentByTaskToolUseId.set(block.tool_use_id, {
-                                            ...maybeTask,
-                                            agentId: match[1],
-                                        });
-                                    }
-                                }
-                                const out = block.content;
-                                const summary = out === undefined
-                                    ? ""
-                                    : typeof out === "string"
-                                        ? out
-                                        : JSON.stringify(out);
-                                const resolvedName = toolNameById.get(block.tool_use_id) ?? "tool";
-                                logger.toolResult(resolvedName, summary, {
-                                    tool_use_id: block.tool_use_id,
-                                    is_error: block.is_error,
-                                    source: "sdk_user_message_block",
-                                    ...(parentToolUseId ? { parent_tool_use_id: parentToolUseId } : {}),
-                                    ...(subagentMeta?.subagent_type
-                                        ? { subagent_type: subagentMeta.subagent_type }
-                                        : {}),
-                                    ...(subagentMeta?.agentId ? { subagent_agent_id: subagentMeta.agentId } : {}),
-                                });
-                                if (!parentToolUseId) {
-                                    activityTracker.recordToolResult(resolvedName, summary);
-                                }
-                            }
-                        }
-                        break;
-                    }
-                    case "assistant": {
-                        const assistantMsg = msg;
-                        const content = assistantMsg.message.content;
-                        const parentToolUseIdRaw = assistantMsg
-                            .parent_tool_use_id;
-                        const parentToolUseId = typeof parentToolUseIdRaw === "string" && parentToolUseIdRaw.length > 0
-                            ? parentToolUseIdRaw
-                            : undefined;
-                        const subagentMeta = parentToolUseId
-                            ? subagentByTaskToolUseId.get(parentToolUseId)
-                            : undefined;
-                        for (const block of content) {
-                            switch (block.type) {
-                                case "text":
-                                    if (block.text) {
-                                        // If this text is produced inside a subagent, annotate it.
-                                        if (parentToolUseId) {
-                                            const tag = subagentMeta?.subagent_type
-                                                ? `subagent:${subagentMeta.subagent_type}`
-                                                : "subagent";
-                                            logger.assistant(`[${tag}] ${block.text}`);
-                                        }
-                                        else {
-                                            logger.assistant(block.text);
-                                            activityTracker.recordAssistantText(block.text);
-                                        }
-                                    }
-                                    break;
-                                case "thinking":
-                                    logger.debug(`[thinking] ${block.thinking.substring(0, 200)}${block.thinking.length > 200 ? "..." : ""}`);
-                                    break;
-                                case "tool_use":
-                                    {
-                                        const toolUseId = block.id ??
-                                            block.tool_use_id;
-                                        if (toolUseId) {
-                                            toolNameById.set(toolUseId, block.name);
-                                        }
-                                        // Detect subagent invocation via Task tool_use blocks.
-                                        if (block.name === "Task" && toolUseId) {
-                                            const input = block.input;
-                                            const subagent_type = typeof input.subagent_type === "string"
-                                                ? (input.subagent_type)
-                                                : undefined;
-                                            subagentByTaskToolUseId.set(toolUseId, { subagent_type });
-                                        }
-                                        logger.toolCall(block.name, block.input, {
-                                            tool_use_id: toolUseId,
-                                            ...(parentToolUseId ? { parent_tool_use_id: parentToolUseId } : {}),
-                                            ...(subagentMeta?.subagent_type
-                                                ? { subagent_type: subagentMeta.subagent_type }
-                                                : {}),
-                                            ...(subagentMeta?.agentId ? { subagent_agent_id: subagentMeta.agentId } : {}),
-                                        });
-                                        if (!parentToolUseId) {
-                                            const inputStr = block.input ? JSON.stringify(block.input) : "";
-                                            activityTracker.recordToolCall(block.name, inputStr);
-                                        }
-                                    }
-                                    if (block.name === "finish" || block.name === "mcp__visionclaw__finish") {
-                                        finishCalled = true;
-                                        session.closeInput();
-                                    }
-                                    break;
-                                default:
-                                    // Log other block types (server_tool_use, mcp_tool_use, etc.)
-                                    logger.debug(`Assistant block: ${block.type}`);
-                                    break;
-                            }
-                        }
-                        // Log assistant-level errors
-                        if (assistantMsg.error) {
-                            logger.err(`Assistant error: ${assistantMsg.error}`);
-                        }
-                        break;
-                    }
-                    case "result":
-                        logResult(msg);
-                        captureUsageSnapshotFromResult(session, msg);
-                        break;
-                    case "system":
-                        logger.debug(`System message: ${JSON.stringify(msg)}`, {
-                            subtype: msg.subtype,
-                        });
-                        break;
-                    default:
-                        // stream_event, status, task_notification, etc. — skip silently
-                        // Also handle tool_result even if the SDK type union doesn't include it.
-                        if (msg.type === "tool_result") {
-                            const tr = msg;
-                            const name = tr.name ?? "tool";
-                            const summary = tr.content === undefined
-                                ? ""
-                                : typeof tr.content === "string"
-                                    ? tr.content
-                                    : JSON.stringify(tr.content);
-                            logger.toolResult(name, summary, {
-                                tool_use_id: tr.tool_use_id,
-                                is_error: tr.is_error,
-                            });
-                        }
-                        break;
-                }
-            }
-            // Ensure generator is closed after stream ends
-            session.closeInput();
+            await processAgentStream(queryStream, session, activityTracker);
         }
         catch (err) {
-            // Ensure generator is closed on error too
             session.closeInput();
-            // When the user requested a stop, the SDK throws an AbortError — this is expected.
             if (session.isStopRequested()) {
                 logger.system("Agent stopped by user request");
             }
             else {
                 logger.err(`Agent loop error: ${err instanceof Error ? err.message : String(err)}`, { stack: err instanceof Error ? err.stack : undefined });
-                // Wait a bit before retrying to avoid tight error loops
                 await new Promise((r) => setTimeout(r, 5000));
             }
         }