@kolisachint/hoocode-agent 0.4.112 → 0.4.113

package/dist/modes/interactive/interactive-mode.js

@@ -62,6 +62,44 @@ function isDeadTerminalError(error) {
     const code = error.code;
     return code !== undefined && DEAD_TERMINAL_ERROR_CODES.has(code);
 }
+// How often the streaming assistant message re-parses its markdown. Deltas can
+// arrive far faster than this; every application re-lexes the growing tail
+// block, so applying per-delta made streaming cost O(message²).
+const STREAM_RENDER_THROTTLE_MS = 100;
+// Task-store mutations (subagent tool progress, usage ticks) arrive in bursts;
+// each render they trigger reassembles the whole component tree, so cap them.
+const TASK_RENDER_THROTTLE_MS = 50;
+// Finished tool blocks beyond this many (oldest first) are frozen to release
+// their retained output/image payloads (see ToolExecutionComponent.freeze).
+// Generous so nothing near the viewport is ever frozen; the cap bounds the
+// view layer's memory across a long session heavy on tool output.
+const LIVE_TOOL_WINDOW = 50;
+/**
+ * Leading+trailing throttle: the first call runs immediately, calls landing
+ * inside the window coalesce into one trailing run with the latest state.
+ */
+function throttled(ms, fn) {
+    let timer;
+    let pending = false;
+    const run = () => {
+        fn();
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (pending) {
+                pending = false;
+                run();
+            }
+        }, ms);
+        timer.unref?.();
+    };
+    return () => {
+        if (timer) {
+            pending = true;
+            return;
+        }
+        run();
+    };
+}
 export class InteractiveMode {
     options;
     runtimeHost;
@@ -101,6 +139,17 @@ export class InteractiveMode {
     // Streaming message tracking
     streamingComponent = undefined;
     streamingMessage = undefined;
+    /** Throttled re-parse/re-render of the in-flight assistant message. The
+     * guard makes a trailing run after message_end/agent_end a no-op; a direct
+     * updateContent on message_end flushes the final state regardless. */
+    scheduleStreamingRender = throttled(STREAM_RENDER_THROTTLE_MS, () => {
+        if (!this.streamingComponent || !this.streamingMessage)
+            return;
+        // streaming=true: large blocks render segmented so only the tail chunk
+        // re-parses; message_end's direct updateContent renders the canonical form.
+        this.streamingComponent.updateContent(this.streamingMessage, true);
+        this.ui.requestRender();
+    });
     // Tool execution tracking: toolCallId -> component
     pendingTools = new Map();
     // Tool output expansion state
@@ -582,10 +631,12 @@ export class InteractiveMode {
         this.footerDataProvider.onBranchChange(() => {
             this.ui.requestRender();
         });
-        // Re-render the UI when the task list changes (task panel shows active tasks).
-        this.taskStoreUnsubscribe = taskStore.subscribe(() => {
+        // Re-render the UI when the task list changes (task panel shows active
+        // tasks). Throttled: subagent progress mutates the store in bursts, and
+        // each resulting render reassembles the entire component tree.
+        this.taskStoreUnsubscribe = taskStore.subscribe(throttled(TASK_RENDER_THROTTLE_MS, () => {
             this.ui.requestRender();
-        });
+        }));
         // Initialize available provider count for footer display
         await this.modelController.updateAvailableProviderCount();
     }
@@ -826,6 +877,25 @@ export class InteractiveMode {
         this.pendingTools.clear();
         this.renderInitialMessages();
     }
+    /**
+     * Bound the view layer's memory: freeze finished tool blocks once more than
+     * LIVE_TOOL_WINDOW of them are live, releasing their retained tool output and
+     * base64 image copies. Runs on tool completion (infrequent) and only ever
+     * freezes blocks far above the viewport. The session data stays intact, so a
+     * later full rebuild (theme toggle / reload) restores full fidelity.
+     */
+    trimTranscriptMemory() {
+        const freezable = [];
+        for (const child of this.chatContainer.children) {
+            if (child instanceof ToolExecutionComponent && child.isFreezable()) {
+                freezable.push(child);
+            }
+        }
+        const excess = freezable.length - LIVE_TOOL_WINDOW;
+        for (let i = 0; i < excess; i++) {
+            freezable[i].freeze();
+        }
+    }
     /**
      * Get a registered tool definition by name (for custom rendering).
      */
@@ -1537,7 +1607,7 @@ export class InteractiveMode {
             case "message_update":
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.scheduleStreamingRender();
                     for (const content of this.streamingMessage.content) {
                         if (content.type === "toolCall") {
                             if (!this.pendingTools.has(content.id)) {
@@ -1627,6 +1697,7 @@ export class InteractiveMode {
                 if (component) {
                     component.updateResult({ ...event.result, isError: event.isError });
                     this.pendingTools.delete(event.toolCallId);
+                    this.trimTranscriptMemory();
                     this.ui.requestRender();
                 }
                 break;