🤖 refactor: extract compaction logic to separate handler

Move compaction handling from agentSession to dedicated CompactionHandler class.

Changes:
- Created src/node/services/compactionHandler.ts with CompactionHandler class
- Extracted handleAbort, handleCompletion, and performCompaction methods
- Updated agentSession.ts to delegate to CompactionHandler
- Moved frontend compaction handler to browser utils
- Reduced agentSession.ts from 764 to 589 lines

Benefits:
- Better separation of concerns
- Easier to test compaction logic independently
- Cleaner session orchestration code

_Generated with `mux`_

Author: ethanndickson

src/browser/hooks/useAIViewKeybinds.ts

@@ -8,7 +8,7 @@ import { DEFAULT_THINKING_LEVEL } from "@/common/types/thinking";
 import { getThinkingPolicyForModel } from "@/browser/utils/thinking/policy";
 import { getDefaultModelFromLRU } from "@/browser/hooks/useModelLRU";
 import type { StreamingMessageAggregator } from "@/browser/utils/messages/StreamingMessageAggregator";
-import { isCompactingStream, cancelCompaction } from "@/common/utils/compaction/handler";
+import { isCompactingStream, cancelCompaction } from "@/browser/utils/compaction/handler";
 
 interface UseAIViewKeybindsParams {
   workspaceId: string;

src/browser/stores/WorkspaceStore.ts

@@ -17,7 +17,7 @@ import {
   isRestoreToInput,
 } from "@/common/types/ipc";
 import { MapStore } from "./MapStore";
-import { accUsageHistory } from "@/common/utils/tokens/displayUsage";
+import { cumUsageHistory } from "@/common/utils/tokens/displayUsage";
 import { WorkspaceConsumerManager } from "./WorkspaceConsumerManager";
 import type { ChatUsageDisplay } from "@/common/utils/tokens/usageAggregator";
 import type { TokenConsumer } from "@/common/types/chatStats";
@@ -432,7 +432,7 @@ export class WorkspaceStore {
 
       const messages = aggregator.getAllMessages();
       const model = aggregator.getCurrentModel();
-      const usageHistory = accUsageHistory(messages, model);
+      const usageHistory = cumUsageHistory(messages, model);
 
       // Calculate total from usage history (now includes historical)
       const totalTokens = usageHistory.reduce(

src/common/utils/compaction/handler.ts src/browser/utils/compaction/handler.tssrc/common/utils/compaction/handler.ts renamed to src/browser/utils/compaction/handler.ts

@@ -92,7 +92,7 @@ export function createDisplayUsage(
   };
 }
 
-export function accUsageHistory(
+export function cumUsageHistory(
   messages: MuxMessage[],
   fallbackModel?: string
 ): ChatUsageDisplay[] {

src/common/utils/tokens/displayUsage.ts

@@ -15,7 +15,6 @@ import type {
   StreamErrorMessage,
   SendMessageOptions,
   ImagePart,
-  DeleteMessage,
 } from "@/common/types/ipc";
 import type { SendMessageError } from "@/common/types/errors";
 import { createUnknownSendMessageError } from "@/node/services/utils/sendMessageError";
@@ -25,9 +24,7 @@ import { enforceThinkingPolicy } from "@/browser/utils/thinking/policy";
 import { createRuntime } from "@/node/runtime/runtimeFactory";
 import { MessageQueue } from "./messageQueue";
 import type { StreamEndEvent, StreamAbortEvent } from "@/common/types/stream";
-import { sumUsageHistory } from "@/common/utils/tokens/usageAggregator";
-import type { LanguageModelV2Usage } from "@ai-sdk/provider";
-import { accUsageHistory } from "@/common/utils/tokens/displayUsage";
+import { CompactionHandler } from "./compactionHandler";
 
 export interface AgentSessionChatEvent {
   workspaceId: string;
@@ -62,7 +59,7 @@ export class AgentSession {
     [];
   private disposed = false;
   private readonly messageQueue = new MessageQueue();
-  private readonly processedCompactionRequestIds = new Set<string>();
+  private readonly compactionHandler: CompactionHandler;
 
   constructor(options: AgentSessionOptions) {
     assert(options, "AgentSession requires options");
@@ -80,6 +77,12 @@ export class AgentSession {
     this.aiService = aiService;
     this.initStateManager = initStateManager;
 
+    this.compactionHandler = new CompactionHandler({
+      workspaceId: this.workspaceId,
+      historyService: this.historyService,
+      emitter: this.emitter,
+    });
+
     this.attachAiListeners();
     this.attachInitListeners();
   }
@@ -435,7 +438,7 @@ export class AgentSession {
     forward("reasoning-end", (payload) => this.emitChatEvent(payload));
 
     forward("stream-end", async (payload) => {
-      const handled = await this.handleCompactionCompletion(payload as StreamEndEvent);
+      const handled = await this.compactionHandler.handleCompletion(payload as StreamEndEvent);
       if (!handled) {
         this.emitChatEvent(payload);
       }
@@ -444,7 +447,7 @@ export class AgentSession {
     });
 
     forward("stream-abort", async (payload) => {
-      const handled = await this.handleCompactionAbort(payload as StreamAbortEvent);
+      const handled = await this.compactionHandler.handleAbort(payload as StreamAbortEvent);
       if (!handled) {
         this.emitChatEvent(payload);
       }
@@ -569,196 +572,4 @@ export class AgentSession {
   private assertNotDisposed(operation: string): void {
     assert(!this.disposed, `AgentSession.${operation} called after dispose`);
   }
-
-  /**
-   * Handle compaction stream abort (Ctrl+C cancel or Ctrl+A accept early)
-   *
-   * Two flows:
-   * - Ctrl+C: abandonPartial=true → skip compaction
-   * - Ctrl+A: abandonPartial=false/undefined → perform compaction with [truncated]
-   */
-  private async handleCompactionAbort(event: StreamAbortEvent): Promise<boolean> {
-    // Check if the last user message is a compaction-request
-    const historyResult = await this.historyService.getHistory(this.workspaceId);
-    if (!historyResult.success) {
-      return false;
-    }
-
-    const messages = historyResult.data;
-    const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
-    const isCompaction = lastUserMsg?.metadata?.muxMetadata?.type === "compaction-request";
-
-    if (!isCompaction || !lastUserMsg) {
-      return false;
-    }
-
-    // Ctrl+C flow: abandonPartial=true means user cancelled, skip compaction
-    if (event.abandonPartial === true) {
-      return false;
-    }
-
-    // Ctrl+A flow: Accept early with [truncated] sentinel
-    // Get the truncated message from historyResult.data
-    const lastMessage = messages[messages.length - 1];
-    if (!lastMessage || lastMessage.role !== "assistant") {
-      console.warn("[AgentSession] Compaction aborted but last message is not assistant");
-      return false;
-    }
-
-    const partialSummary = lastMessage.parts
-      .filter((part): part is { type: "text"; text: string } => part.type === "text")
-      .map((part) => part.text)
-      .join("");
-
-    // Append [truncated] sentinel
-    const truncatedSummary = partialSummary.trim() + "\n\n[truncated]";
-
-    // Perform compaction with truncated summary
-    const result = await this.performCompaction(truncatedSummary, {
-      model: lastMessage.metadata?.model ?? "unknown",
-      usage: event.metadata?.usage,
-      duration: event.metadata?.duration,
-      providerMetadata: lastMessage.metadata?.providerMetadata,
-      systemMessageTokens: lastMessage.metadata?.systemMessageTokens,
-    });
-    if (!result.success) {
-      console.error("[AgentSession] Early compaction failed:", result.error);
-      return false;
-    }
-
-    this.emitChatEvent(event);
-    return true;
-  }
-
-  /**
-   * Handle compaction stream completion
-   *
-   * Detects when a compaction stream finishes, extracts the summary,
-   * and performs history replacement atomically.
-   */
-  private async handleCompactionCompletion(event: StreamEndEvent): Promise<boolean> {
-    // Check if the last user message is a compaction-request
-    const historyResult = await this.historyService.getHistory(this.workspaceId);
-    if (!historyResult.success) {
-      return false;
-    }
-
-    const messages = historyResult.data;
-    const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
-    const isCompaction = lastUserMsg?.metadata?.muxMetadata?.type === "compaction-request";
-
-    if (!isCompaction || !lastUserMsg) {
-      return false;
-    }
-
-    // Dedupe: If we've already processed this compaction-request, skip
-    if (this.processedCompactionRequestIds.has(lastUserMsg.id)) {
-      return true;
-    }
-
-    const summary = event.parts
-      .filter((part): part is { type: "text"; text: string } => part.type === "text")
-      .map((part) => part.text)
-      .join("");
-
-    // Mark as processed before performing compaction
-    this.processedCompactionRequestIds.add(lastUserMsg.id);
-
-    const result = await this.performCompaction(summary, event.metadata);
-    if (!result.success) {
-      console.error("[AgentSession] Compaction failed:", result.error);
-      return false;
-    }
-
-    // Emit stream-end to frontend so UI knows compaction is complete
-    this.emitCompactionStreamEnd(event);
-    return true;
-  }
-
-  /**
-   * Perform history compaction by replacing all messages with a summary
-   *
-   * Steps:
-   * 1. Calculate cumulative usage from all messages (for historicalUsage field)
-   * 2. Clear entire history and get deleted sequence numbers
-   * 3. Append summary message with metadata
-   * 4. Emit delete event for old messages
-   * 5. Emit summary message to frontend
-   */
-  private async performCompaction(
-    summary: string,
-    metadata: {
-      model: string;
-      usage?: LanguageModelV2Usage;
-      duration?: number;
-      providerMetadata?: Record<string, unknown>;
-      systemMessageTokens?: number;
-    }
-  ): Promise<Result<void, string>> {
-    // Get all messages to calculate cumulative usage
-    const historyResult = await this.historyService.getHistory(this.workspaceId);
-    if (!historyResult.success) {
-      return Err(`Failed to get history for usage calculation: ${historyResult.error}`);
-    }
-
-    const usageHistory = accUsageHistory(historyResult.data, undefined);
-
-    const historicalUsage = usageHistory.length > 0 ? sumUsageHistory(usageHistory) : undefined;
-
-    // Clear entire history and get deleted sequences
-    const clearResult = await this.historyService.clearHistory(this.workspaceId);
-    if (!clearResult.success) {
-      return Err(`Failed to clear history: ${clearResult.error}`);
-    }
-    const deletedSequences = clearResult.data;
-
-    // Create summary message with metadata
-    const summaryMessage = createMuxMessage(
-      `summary-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
-      "assistant",
-      summary,
-      {
-        timestamp: Date.now(),
-        compacted: true,
-        model: metadata.model,
-        usage: metadata.usage,
-        historicalUsage,
-        providerMetadata: metadata.providerMetadata,
-        duration: metadata.duration,
-        systemMessageTokens: metadata.systemMessageTokens,
-        muxMetadata: { type: "normal" },
-      }
-    );
-
-    // Append summary to history
-    const appendResult = await this.historyService.appendToHistory(
-      this.workspaceId,
-      summaryMessage
-    );
-    if (!appendResult.success) {
-      return Err(`Failed to append summary: ${appendResult.error}`);
-    }
-
-    // Emit delete event for old messages
-    if (deletedSequences.length > 0) {
-      const deleteMessage: DeleteMessage = {
-        type: "delete",
-        historySequences: deletedSequences,
-      };
-      this.emitChatEvent(deleteMessage);
-    }
-
-    // Emit summary message to frontend
-    this.emitChatEvent(summaryMessage);
-
-    return Ok(undefined);
-  }
-
-  /**
-   * Emit stream-end event after compaction completes
-   * This notifies the frontend that the stream is done
-   */
-  private emitCompactionStreamEnd(event: StreamEndEvent): void {
-    this.emitChatEvent(event);
-  }
 }