🤖 fix: persist status_url when loading historical messages

ammar-agent · ammar-agent · commit 496a3ea81db9 · 2025-12-01T11:58:37.000-06:00
The loadHistoricalMessages function was only processing the most recent assistant message, which meant that lastStatusUrl wasn't populated from earlier messages. This caused the URL to be lost when: 1. User sends a message with status_set that includes a URL 2. User sends another message with status_set WITHOUT a URL 3. Page reloads or workspace switches Now we scan ALL historical messages in chronological order to build up lastStatusUrl before processing the final state. Additionally, status URLs now persist through compaction: - CompactionHandler extracts lastStatusUrl from messages being compacted - The URL is preserved in the compacted summary message metadata - Frontend reads lastStatusUrl from message metadata on historical load Regression introduced in cc64299 by ammar-agent. _Generated with `mux`_
diff --git a/src/browser/utils/messages/StreamingMessageAggregator.status.test.ts b/src/browser/utils/messages/StreamingMessageAggregator.status.test.ts
@@ -759,4 +759,121 @@ describe("StreamingMessageAggregator - Agent Status", () => {
     expect(finalStatus?.message).toBe("Tests passed");
     expect(finalStatus?.url).toBe(testUrl); // URL from previous stream persists!
   });
+
+  it("should persist URL across multiple assistant messages when loading from history", () => {
+    // Regression test: URL should persist even when only the most recent assistant message
+    // has a status_set without a URL - the URL from an earlier message should be used
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+    const testUrl = "https://github.com/owner/repo/pull/123";
+
+    // Historical messages: first assistant sets URL, second assistant updates status without URL
+    const historicalMessages = [
+      {
+        id: "user1",
+        role: "user" as const,
+        parts: [{ type: "text" as const, text: "Make a PR" }],
+        metadata: { timestamp: 1000, historySequence: 1 },
+      },
+      {
+        id: "assistant1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolName: "status_set",
+            toolCallId: "tool1",
+            state: "output-available" as const,
+            input: { emoji: "🔗", message: "PR submitted", url: testUrl },
+            output: { success: true, emoji: "🔗", message: "PR submitted", url: testUrl },
+            timestamp: 1001,
+            tokens: 10,
+          },
+        ],
+        metadata: { timestamp: 1001, historySequence: 2 },
+      },
+      {
+        id: "user2",
+        role: "user" as const,
+        parts: [{ type: "text" as const, text: "Continue" }],
+        metadata: { timestamp: 2000, historySequence: 3 },
+      },
+      {
+        id: "assistant2",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolName: "status_set",
+            toolCallId: "tool2",
+            state: "output-available" as const,
+            input: { emoji: "✅", message: "Tests passed" },
+            output: { success: true, emoji: "✅", message: "Tests passed" }, // No URL!
+            timestamp: 2001,
+            tokens: 10,
+          },
+        ],
+        metadata: { timestamp: 2001, historySequence: 4 },
+      },
+    ];
+
+    aggregator.loadHistoricalMessages(historicalMessages);
+
+    const status = aggregator.getAgentStatus();
+    expect(status?.emoji).toBe("✅");
+    expect(status?.message).toBe("Tests passed");
+    // URL from the first assistant message should persist!
+    expect(status?.url).toBe(testUrl);
+  });
+
+  it("should restore URL from compacted message metadata", () => {
+    // Simulates loading history after compaction preserved the lastStatusUrl
+    const aggregator = new StreamingMessageAggregator("2024-01-01T00:00:00.000Z");
+    const testUrl = "https://github.com/owner/repo/pull/123";
+
+    // Compacted summary message with preserved lastStatusUrl
+    const historicalMessages = [
+      {
+        id: "summary1",
+        role: "assistant" as const,
+        parts: [{ type: "text" as const, text: "Summary of conversation..." }],
+        metadata: {
+          timestamp: 1000,
+          historySequence: 1,
+          compacted: true,
+          lastStatusUrl: testUrl, // Preserved from before compaction
+        },
+      },
+      {
+        id: "user1",
+        role: "user" as const,
+        parts: [{ type: "text" as const, text: "Continue work" }],
+        metadata: { timestamp: 2000, historySequence: 2 },
+      },
+      {
+        id: "assistant1",
+        role: "assistant" as const,
+        parts: [
+          {
+            type: "dynamic-tool" as const,
+            toolName: "status_set",
+            toolCallId: "tool1",
+            state: "output-available" as const,
+            input: { emoji: "✅", message: "Done" },
+            output: { success: true, emoji: "✅", message: "Done" }, // No URL
+            timestamp: 2001,
+            tokens: 10,
+          },
+        ],
+        metadata: { timestamp: 2001, historySequence: 3 },
+      },
+    ];
+
+    aggregator.loadHistoricalMessages(historicalMessages);
+
+    const status = aggregator.getAgentStatus();
+    expect(status?.emoji).toBe("✅");
+    expect(status?.message).toBe("Done");
+    // URL from the compacted message metadata should be used
+    expect(status?.url).toBe(testUrl);
+  });
 });
diff --git a/src/browser/utils/messages/StreamingMessageAggregator.ts b/src/browser/utils/messages/StreamingMessageAggregator.ts
@@ -232,16 +232,44 @@ export class StreamingMessageAggregator {
       this.messages.set(message.id, message);
     }
 
-    // Then, reconstruct derived state from the most recent assistant message
     // Use "streaming" context if there's an active stream (reconnection), otherwise "historical"
     const context = hasActiveStream ? "streaming" : "historical";
 
-    const sortedMessages = [...messages].sort(
-      (a, b) => (b.metadata?.historySequence ?? 0) - (a.metadata?.historySequence ?? 0)
+    // Sort messages in chronological order for processing
+    const chronologicalMessages = [...messages].sort(
+      (a, b) => (a.metadata?.historySequence ?? 0) - (b.metadata?.historySequence ?? 0)
     );
 
-    // Find the most recent assistant message
-    const lastAssistantMessage = sortedMessages.find((msg) => msg.role === "assistant");
+    // First pass: scan all messages to build up lastStatusUrl
+    // This ensures URL persistence works even if the URL was set in an earlier message
+    // or was preserved through compaction in message metadata
+    for (const message of chronologicalMessages) {
+      // Check if compaction preserved a lastStatusUrl in metadata
+      if (message.metadata?.lastStatusUrl) {
+        this.lastStatusUrl = message.metadata.lastStatusUrl;
+      }
+
+      // Then check tool calls for status_set with URL
+      if (message.role === "assistant") {
+        for (const part of message.parts) {
+          if (
+            isDynamicToolPart(part) &&
+            part.state === "output-available" &&
+            part.toolName === "status_set" &&
+            hasSuccessResult(part.output)
+          ) {
+            const result = part.output as Extract<StatusSetToolResult, { success: true }>;
+            if (result.url) {
+              this.lastStatusUrl = result.url;
+            }
+          }
+        }
+      }
+    }
+
+    // Second pass: reconstruct derived state from the most recent assistant message only
+    // (TODOs and agentStatus should reflect only the latest state)
+    const lastAssistantMessage = chronologicalMessages.findLast((msg) => msg.role === "assistant");
 
     if (lastAssistantMessage) {
       // Process all tool results from the most recent assistant message
diff --git a/src/common/types/message.ts b/src/common/types/message.ts
@@ -50,6 +50,7 @@ export interface MuxMetadata {
   cmuxMetadata?: MuxFrontendMetadata; // Frontend-defined metadata, backend treats as black-box
   muxMetadata?: MuxFrontendMetadata; // Frontend-defined metadata, backend treats as black-box
   historicalUsage?: ChatUsageDisplay; // Cumulative usage from all messages before this compaction (only present on compaction summaries)
+  lastStatusUrl?: string; // Last status_set URL, persisted through compaction so it survives history rewrite
 }
 
 // Extended tool part type that supports interrupted tool calls (input-available state)
diff --git a/src/node/services/compactionHandler.test.ts b/src/node/services/compactionHandler.test.ts
@@ -329,6 +329,110 @@ describe("CompactionHandler", () => {
       const appendedMsg = mockHistoryService.appendToHistory.mock.calls[0][1] as MuxMessage;
       expect(appendedMsg.metadata?.compacted).toBe(true);
     });
+
+    it("should preserve lastStatusUrl from status_set tool calls", async () => {
+      const testUrl = "https://github.com/owner/repo/pull/123";
+
+      // Create message with status_set tool call containing URL
+      const messageWithStatus: MuxMessage = {
+        id: "asst-with-status",
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            toolName: "status_set",
+            toolCallId: "tool1",
+            state: "output-available",
+            input: { emoji: "🔗", message: "PR submitted", url: testUrl },
+            output: { success: true, emoji: "🔗", message: "PR submitted", url: testUrl },
+          },
+        ],
+        metadata: { historySequence: 1 },
+      };
+
+      const compactionReq = createCompactionRequest();
+      compactionReq.metadata = { ...compactionReq.metadata, historySequence: 2 };
+
+      mockHistoryService.mockGetHistory(Ok([messageWithStatus, compactionReq]));
+      mockHistoryService.mockClearHistory(Ok([1, 2]));
+      mockHistoryService.mockAppendToHistory(Ok(undefined));
+
+      const event = createStreamEndEvent("Summary");
+      await handler.handleCompletion(event);
+
+      const appendedMsg = mockHistoryService.appendToHistory.mock.calls[0][1] as MuxMessage;
+      expect(appendedMsg.metadata?.lastStatusUrl).toBe(testUrl);
+    });
+
+    it("should preserve lastStatusUrl from previous compaction metadata", async () => {
+      const testUrl = "https://github.com/owner/repo/pull/456";
+
+      // Create compacted summary with preserved lastStatusUrl
+      const compactedSummary: MuxMessage = {
+        id: "summary-prev",
+        role: "assistant",
+        parts: [{ type: "text", text: "Previous summary" }],
+        metadata: { historySequence: 1, compacted: true, lastStatusUrl: testUrl },
+      };
+
+      const compactionReq = createCompactionRequest();
+      compactionReq.metadata = { ...compactionReq.metadata, historySequence: 2 };
+
+      mockHistoryService.mockGetHistory(Ok([compactedSummary, compactionReq]));
+      mockHistoryService.mockClearHistory(Ok([1, 2]));
+      mockHistoryService.mockAppendToHistory(Ok(undefined));
+
+      const event = createStreamEndEvent("New summary");
+      await handler.handleCompletion(event);
+
+      const appendedMsg = mockHistoryService.appendToHistory.mock.calls[0][1] as MuxMessage;
+      // URL from previous compaction should be preserved
+      expect(appendedMsg.metadata?.lastStatusUrl).toBe(testUrl);
+    });
+
+    it("should use most recent URL when both metadata and tool call have URLs", async () => {
+      const olderUrl = "https://github.com/owner/repo/pull/111";
+      const newerUrl = "https://github.com/owner/repo/pull/222";
+
+      // Compacted summary with older URL
+      const compactedSummary: MuxMessage = {
+        id: "summary-prev",
+        role: "assistant",
+        parts: [{ type: "text", text: "Previous summary" }],
+        metadata: { historySequence: 1, compacted: true, lastStatusUrl: olderUrl },
+      };
+
+      // Newer message with status_set containing newer URL
+      const messageWithStatus: MuxMessage = {
+        id: "asst-with-status",
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            toolName: "status_set",
+            toolCallId: "tool1",
+            state: "output-available",
+            input: { emoji: "🔗", message: "New PR", url: newerUrl },
+            output: { success: true, emoji: "🔗", message: "New PR", url: newerUrl },
+          },
+        ],
+        metadata: { historySequence: 2 },
+      };
+
+      const compactionReq = createCompactionRequest();
+      compactionReq.metadata = { ...compactionReq.metadata, historySequence: 3 };
+
+      mockHistoryService.mockGetHistory(Ok([compactedSummary, messageWithStatus, compactionReq]));
+      mockHistoryService.mockClearHistory(Ok([1, 2, 3]));
+      mockHistoryService.mockAppendToHistory(Ok(undefined));
+
+      const event = createStreamEndEvent("Summary");
+      await handler.handleCompletion(event);
+
+      const appendedMsg = mockHistoryService.appendToHistory.mock.calls[0][1] as MuxMessage;
+      // Newer URL from status_set should win
+      expect(appendedMsg.metadata?.lastStatusUrl).toBe(newerUrl);
+    });
   });
 
   describe("handleCompletion() - Deduplication", () => {
diff --git a/src/node/services/compactionHandler.ts b/src/node/services/compactionHandler.ts
@@ -8,6 +8,8 @@ import type { LanguageModelV2Usage } from "@ai-sdk/provider";
 import { collectUsageHistory } from "@/common/utils/tokens/displayUsage";
 import { sumUsageHistory } from "@/common/utils/tokens/usageAggregator";
 import { createMuxMessage, type MuxMessage } from "@/common/types/message";
+import type { StatusSetToolResult } from "@/common/types/tools";
+import { isDynamicToolPart } from "@/common/types/toolParts";
 
 interface CompactionHandlerOptions {
   workspaceId: string;
@@ -80,15 +82,54 @@ export class CompactionHandler {
     return true;
   }
 
+  /**
+   * Extract the last status URL from messages by scanning all status_set tool results.
+   * Returns undefined if no URL was ever set.
+   */
+  private extractLastStatusUrl(messages: MuxMessage[]): string | undefined {
+    let lastUrl: string | undefined;
+
+    // Sort by historySequence to ensure chronological order
+    const sortedMessages = [...messages].sort(
+      (a, b) => (a.metadata?.historySequence ?? 0) - (b.metadata?.historySequence ?? 0)
+    );
+
+    for (const message of sortedMessages) {
+      // Check if a previous compaction preserved a lastStatusUrl
+      if (message.metadata?.lastStatusUrl) {
+        lastUrl = message.metadata.lastStatusUrl;
+      }
+
+      // Then check tool calls for status_set with URL
+      if (message.role === "assistant") {
+        for (const part of message.parts) {
+          if (
+            isDynamicToolPart(part) &&
+            part.state === "output-available" &&
+            part.toolName === "status_set"
+          ) {
+            const output = part.output as StatusSetToolResult | undefined;
+            if (output && "success" in output && output.success && output.url) {
+              lastUrl = output.url;
+            }
+          }
+        }
+      }
+    }
+
+    return lastUrl;
+  }
+
   /**
    * 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
+   * 2. Extract last status URL from messages (for lastStatusUrl field)
+   * 3. Clear entire history and get deleted sequence numbers
+   * 4. Append summary message with metadata
+   * 5. Emit delete event for old messages
+   * 6. Emit summary message to frontend
    */
   private async performCompaction(
     summary: string,
@@ -102,9 +143,11 @@ export class CompactionHandler {
     }
   ): Promise<Result<void, string>> {
     const usageHistory = collectUsageHistory(messages, undefined);
-
     const historicalUsage = usageHistory.length > 0 ? sumUsageHistory(usageHistory) : undefined;
 
+    // Extract last status URL to preserve through compaction
+    const lastStatusUrl = this.extractLastStatusUrl(messages);
+
     // Clear entire history and get deleted sequences
     const clearResult = await this.historyService.clearHistory(this.workspaceId);
     if (!clearResult.success) {
@@ -126,6 +169,7 @@ export class CompactionHandler {
         model: metadata.model,
         usage: metadata.usage,
         historicalUsage,
+        lastStatusUrl,
         duration: metadata.duration,
         systemMessageTokens: metadata.systemMessageTokens,
         muxMetadata: { type: "normal" },

Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,7 @@ export interface MuxMetadata {`
`50`	`50`	`cmuxMetadata?: MuxFrontendMetadata; // Frontend-defined metadata, backend treats as black-box`
`51`	`51`	`muxMetadata?: MuxFrontendMetadata; // Frontend-defined metadata, backend treats as black-box`
`52`	`52`	`historicalUsage?: ChatUsageDisplay; // Cumulative usage from all messages before this compaction (only present on compaction summaries)`
	`53`	`+ lastStatusUrl?: string; // Last status_set URL, persisted through compaction so it survives history rewrite`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`// Extended tool part type that supports interrupted tool calls (input-available state)`