fix streaming flush to include completed tool segments

FlushStreamingText now flushes completed tool segments that appear
before the current text segment. Previously, tool segments could be
skipped when text was being streamed, causing them to appear out of
order or be lost.

Changes:
- Collect and render completed tool segments before flushing text
- Return tool content even when text is below flush threshold
- Use shared contentBuilder to combine tool and text output

Author: SamSaffron

internal/ui/segment_flush_test.go

@@ -283,3 +283,83 @@ func TestFallbackFlushPreservesHeadingSpacing(t *testing.T) {
 		t.Fatalf("Fallback flush output mismatch.\nReference:\n%q\nTotal:\n%q", StripANSI(reference), StripANSI(total))
 	}
 }
+
+func TestFlushStreamingText_FlushesCompletedToolsFirst(t *testing.T) {
+	// Test that FlushStreamingText flushes completed tool segments
+	// that appear before the current text segment.
+	width := 80
+	renderMd := func(s string, w int) string {
+		return RenderMarkdown(s, w)
+	}
+
+	tracker := NewToolTracker()
+
+	// Add a tool segment and mark it complete
+	tracker.HandleToolStart("tool-1", "test_tool", "test info")
+	tracker.HandleToolEnd("tool-1", true)
+
+	// Add an incomplete text segment with content
+	tracker.AddTextSegment("Some streaming text.\n\n", width)
+
+	// FlushStreamingText should flush the tool first, then the text
+	res := tracker.FlushStreamingText(0, width, renderMd)
+
+	output := res.ToPrint
+
+	// Verify tool segment content appears in output
+	stripped := stripAnsiForTest(output)
+	if !strings.Contains(stripped, "●") {
+		t.Error("Expected tool indicator (●) in output, tool segment was not flushed")
+	}
+	if !strings.Contains(stripped, "test_tool") {
+		t.Error("Expected 'test_tool' in output")
+	}
+	if !strings.Contains(stripped, "Some streaming text") {
+		t.Error("Expected 'Some streaming text' in output")
+	}
+
+	// Verify tool appears before text
+	toolIdx := strings.Index(stripped, "●")
+	textIdx := strings.Index(stripped, "Some streaming text")
+	if toolIdx > textIdx {
+		t.Errorf("Tool should appear before text. Tool at %d, text at %d", toolIdx, textIdx)
+	}
+
+	// Verify the tool segment is marked as flushed
+	if !tracker.Segments[0].Flushed {
+		t.Error("Tool segment should be marked as flushed")
+	}
+}
+
+func TestFlushStreamingText_ReturnsToolsEvenWhenTextBelowThreshold(t *testing.T) {
+	// Test that completed tools are returned even when text is below threshold
+	width := 80
+
+	tracker := NewToolTracker()
+
+	// Add a tool segment and mark it complete
+	tracker.HandleToolStart("tool-1", "test_tool", "test info")
+	tracker.HandleToolEnd("tool-1", true)
+
+	// Add an incomplete text segment with minimal content
+	tracker.AddTextSegment("Hi", width)
+
+	// Use high threshold so text won't be flushed, but tool should still be
+	res := tracker.FlushStreamingText(1000, width, nil)
+
+	output := res.ToPrint
+	stripped := stripAnsiForTest(output)
+
+	// Tool should be flushed even though text is below threshold
+	if !strings.Contains(stripped, "●") {
+		t.Error("Expected tool indicator (●) in output even when text is below threshold")
+	}
+	if !strings.Contains(stripped, "test_tool") {
+		t.Error("Expected 'test_tool' in output")
+	}
+
+	// Text should NOT be in output since it's below threshold
+	if strings.Contains(stripped, "Hi") {
+		t.Error("Text should not be flushed when below threshold")
+	}
+}

internal/ui/tool_tracker.go

@@ -495,6 +495,33 @@ func (t *ToolTracker) FlushStreamingText(threshold int, width int, renderMd func
 		return FlushStreamingTextResult{}
 	}
 
+	// First: flush any completed tool segments before the text segment.
+	// Tool calls are always processed before text continues, so any tool segments
+	// that appear before the current text segment are already complete.
+	var contentBuilder strings.Builder
+	var toolsToFlush []*Segment
+	for i := 0; i < segIdx; i++ {
+		s := &t.Segments[i]
+		if s.Type == SegmentTool && !s.Flushed && s.ToolStatus != ToolPending {
+			toolsToFlush = append(toolsToFlush, s)
+			s.Flushed = true
+		}
+	}
+
+	if len(toolsToFlush) > 0 {
+		toolContent := RenderSegments(toolsToFlush, width, -1, nil, true)
+		if t.HasFlushed {
+			toolContent = stripLeadingBlankLine(toolContent)
+			prefix := t.LeadingSeparator(toolsToFlush[0].Type)
+			if prefix != "" {
+				toolContent = prefix + toolContent
+			}
+		}
+		contentBuilder.WriteString(toolContent)
+		t.HasFlushed = true
+		t.LastFlushedType = toolsToFlush[len(toolsToFlush)-1].Type
+	}
+
 	// Get current text length
 	textLen := 0
 	if seg.TextBuilder != nil {
@@ -507,6 +534,10 @@ func (t *ToolTracker) FlushStreamingText(threshold int, width int, renderMd func
 	unflushedLen := textLen - seg.FlushedPos
 	if unflushedLen < threshold {
 		debugFlushf("stream skip seg=%d reason=below-threshold textLen=%d flushedPos=%d unflushedLen=%d threshold=%d", segIdx, textLen, seg.FlushedPos, unflushedLen, threshold)
+		// Return any tool content we already flushed, even if text doesn't need flushing
+		if contentBuilder.Len() > 0 {
+			return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+		}
 		return FlushStreamingTextResult{}
 	}
 
@@ -532,25 +563,32 @@ func (t *ToolTracker) FlushStreamingText(threshold int, width int, renderMd func
 		if safeBoundary <= seg.FlushedPos {
 			// No new committed blocks to flush yet
 			debugFlushf("stream skip seg=%d reason=no-committed committed=%d flushedPos=%d", segIdx, safeBoundary, seg.FlushedPos)
+			// Return any tool content we already flushed
+			if contentBuilder.Len() > 0 {
+				return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+			}
 			return FlushStreamingTextResult{}
 		}
 		rendered := seg.StreamRenderer.RenderedUnflushed()
 		if rendered == "" {
 			debugFlushf("stream skip seg=%d reason=empty-rendered committed=%d flushedPos=%d", segIdx, safeBoundary, seg.FlushedPos)
+			// Return any tool content we already flushed
+			if contentBuilder.Len() > 0 {
+				return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+			}
 			return FlushStreamingTextResult{}
 		}
 
-		var b strings.Builder
 		if t.HasFlushed && seg.FlushedPos == 0 {
-			b.WriteString(t.LeadingSeparator(SegmentText))
+			contentBuilder.WriteString(t.LeadingSeparator(SegmentText))
 		}
 
 		// Strip leading blank line if we've already flushed content,
 		// since tea.Printf adds a newline after each flush
 		if t.HasFlushed {
 			rendered = stripLeadingBlankLine(rendered)
 		}
-		b.WriteString(rendered)
+		contentBuilder.WriteString(rendered)
 
 		// Update tracker state
 		seg.FlushedPos = safeBoundary
@@ -562,7 +600,7 @@ func (t *ToolTracker) FlushStreamingText(threshold int, width int, renderMd func
 		debugFlushf("stream flush seg=%d committed=%d flushedPos=%d renderedUnflushedLen=%d flushedRenderedPos=%d", segIdx, safeBoundary, seg.FlushedPos, len(rendered), seg.FlushedRenderedPos)
 
 		return FlushStreamingTextResult{
-			ToPrint: b.String(),
+			ToPrint: contentBuilder.String(),
 		}
 	}
 
@@ -571,51 +609,74 @@ func (t *ToolTracker) FlushStreamingText(threshold int, width int, renderMd func
 	if safeBoundary <= seg.FlushedPos {
 		// No safe boundary found, can't flush yet
 		debugFlushf("stream skip seg=%d reason=no-safe-boundary flushedPos=%d textLen=%d", segIdx, seg.FlushedPos, len(fullText))
+		// Return any tool content we already flushed
+		if contentBuilder.Len() > 0 {
+			return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+		}
 		return FlushStreamingTextResult{}
 	}
 
 	// Fallback for when no streaming renderer is available (should be rare)
 	toFlush := fullText[seg.FlushedPos:safeBoundary]
 	if toFlush == "" {
 		debugFlushf("stream skip seg=%d reason=empty-toFlush safeBoundary=%d flushedPos=%d", segIdx, safeBoundary, seg.FlushedPos)
+		// Return any tool content we already flushed
+		if contentBuilder.Len() > 0 {
+			return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+		}
 		return FlushStreamingTextResult{}
 	}
 
 	if renderMd == nil {
 		debugFlushf("stream skip seg=%d reason=no-renderer safeBoundary=%d flushedPos=%d", segIdx, safeBoundary, seg.FlushedPos)
+		// Return any tool content we already flushed
+		if contentBuilder.Len() > 0 {
+			return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+		}
 		return FlushStreamingTextResult{}
 	}
 
 	// Render the full committed markdown so inter-block spacing is preserved.
 	renderedAll := renderMd(fullText[:safeBoundary], width)
 	if renderedAll == "" {
 		debugFlushf("stream skip seg=%d reason=empty-rendered-fallback safeBoundary=%d flushedPos=%d", segIdx, safeBoundary, seg.FlushedPos)
+		// Return any tool content we already flushed
+		if contentBuilder.Len() > 0 {
+			return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+		}
 		return FlushStreamingTextResult{}
 	}
 
 	rendered := renderedAll
 	if seg.FlushedRenderedPos > 0 {
 		if seg.FlushedRenderedPos >= len(renderedAll) {
 			debugFlushf("stream skip seg=%d reason=rendered-pos>=len safeBoundary=%d flushedRenderedPos=%d renderedLen=%d", segIdx, safeBoundary, seg.FlushedRenderedPos, len(renderedAll))
+			// Return any tool content we already flushed
+			if contentBuilder.Len() > 0 {
+				return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+			}
 			return FlushStreamingTextResult{}
 		}
 		rendered = renderedAll[seg.FlushedRenderedPos:]
 	}
 	if rendered == "" {
 		debugFlushf("stream skip seg=%d reason=empty-rendered-slice safeBoundary=%d flushedPos=%d", segIdx, safeBoundary, seg.FlushedPos)
+		// Return any tool content we already flushed
+		if contentBuilder.Len() > 0 {
+			return FlushStreamingTextResult{ToPrint: contentBuilder.String()}
+		}
 		return FlushStreamingTextResult{}
 	}
 
-	var b strings.Builder
 	// Only add leading separator if this is the very FIRST flush for this segment.
 	if t.HasFlushed && seg.FlushedPos == 0 {
-		b.WriteString(t.LeadingSeparator(SegmentText))
+		contentBuilder.WriteString(t.LeadingSeparator(SegmentText))
 	}
 	// Strip leading blank line since tea.Printf adds a newline after each flush
 	if t.HasFlushed {
 		rendered = stripLeadingBlankLine(rendered)
 	}
-	b.WriteString(rendered)
+	contentBuilder.WriteString(rendered)
 
 	// Update flushed position/state
 	seg.FlushedPos = safeBoundary
@@ -625,7 +686,7 @@ func (t *ToolTracker) FlushStreamingText(threshold int, width int, renderMd func
 	debugFlushf("stream flush seg=%d safeBoundary=%d flushedPos=%d toFlushLen=%d renderedLen=%d", segIdx, safeBoundary, seg.FlushedPos, len(toFlush), len(rendered))
 
 	return FlushStreamingTextResult{
-		ToPrint: b.String(),
+		ToPrint: contentBuilder.String(),
 	}
 }