🤖 fix: prevent queued message amnesia by flushing partial before tool-call-end

When a queued message is sent after tool-call-end, the model needs to see
the complete assistant response including tool results. Previously, there
was a race condition where tool-call-end was emitted before the partial
file was written, causing commitToHistory to read stale data.

The fix ensures partial.json is flushed to disk BEFORE emitting the
tool-call-end event, so listeners (like sendQueuedMessages) see the
complete tool result when they read via commitToHistory.

Changes:
- Make completeToolCall async
- Await flushPartialWrite before emitting tool-call-end
- Update callers to await the async method

_Generated with `mux`_

Author: ethanndickson

src/node/services/streamManager.ts

@@ -566,9 +566,11 @@ export class StreamManager extends EventEmitter {
   }
 
   /**
-   * Complete a tool call by updating its part and emitting tool-call-end event
+   * Complete a tool call by updating its part and emitting tool-call-end event.
+   * CRITICAL: Flushes partial to disk BEFORE emitting event to prevent race conditions
+   * where listeners (e.g., sendQueuedMessages) read stale partial data.
    */
-  private completeToolCall(
+  private async completeToolCall(
     workspaceId: WorkspaceId,
     streamInfo: WorkspaceStreamInfo,
     toolCalls: Map<
@@ -578,7 +580,7 @@ export class StreamManager extends EventEmitter {
     toolCallId: string,
     toolName: string,
     output: unknown
-  ): void {
+  ): Promise<void> {
     // Find and update the existing tool part
     const existingPartIndex = streamInfo.parts.findIndex(
       (p) => p.type === "dynamic-tool" && p.toolCallId === toolCallId
@@ -609,7 +611,13 @@ export class StreamManager extends EventEmitter {
       }
     }
 
-    // Emit tool-call-end event
+    // CRITICAL: Flush partial to disk BEFORE emitting event
+    // This ensures listeners (like sendQueuedMessages) see the tool result when they
+    // read partial.json via commitToHistory. Without this await, there's a race condition
+    // where the partial is read before the tool result is written, causing "amnesia".
+    await this.flushPartialWrite(workspaceId, streamInfo);
+
+    // Emit tool-call-end event (listeners can now safely read partial)
     this.emit("tool-call-end", {
       type: "tool-call-end",
       workspaceId: workspaceId as string,
@@ -618,9 +626,6 @@ export class StreamManager extends EventEmitter {
       toolName,
       result: output,
     } as ToolCallEndEvent);
-
-    // Schedule partial write
-    void this.schedulePartialWrite(workspaceId, streamInfo);
   }
 
   /**
@@ -762,8 +767,8 @@ export class StreamManager extends EventEmitter {
               const strippedOutput = stripEncryptedContent(part.output);
               toolCall.output = strippedOutput;
 
-              // Use shared completion logic
-              this.completeToolCall(
+              // Use shared completion logic (await to ensure partial is flushed before event)
+              await this.completeToolCall(
                 workspaceId,
                 streamInfo,
                 toolCalls,
@@ -799,8 +804,8 @@ export class StreamManager extends EventEmitter {
                     : JSON.stringify(toolErrorPart.error),
             };
 
-            // Use shared completion logic
-            this.completeToolCall(
+            // Use shared completion logic (await to ensure partial is flushed before event)
+            await this.completeToolCall(
               workspaceId,
               streamInfo,
               toolCalls,