Function handleStream

pkg/runtime/streaming.go:73–406

handleStream reads a chat.MessageStream to completion, emitting streaming events (content deltas, partial tool calls, reasoning tokens) and returning the aggregated streamResult. The caller is responsible for adding the resulting assistant message to the session. cancelStream, when non-nil, is call

(ctx context.Context, cancelStream context.CancelCauseFunc, stream chat.MessageStream, a *agent.Agent, agentTools []tools.Tool, sess *session.Session, m *modelsdev.Model, tel Telemetry, events EventSink, idleTimeout time.Duration)

// so the dependency direction is explicit (the loop calls into the chunker,
// never the reverse).
func handleStream(ctx context.Context, cancelStream context.CancelCauseFunc, stream chat.MessageStream, a *agent.Agent, agentTools []tools.Tool, sess *session.Session, m *modelsdev.Model, tel Telemetry, events EventSink, idleTimeout time.Duration) (streamResult, error) {
	// done is closed when handleStream exits (for any reason) so the reader
	// goroutine below can detect it and stop trying to send on recvCh.
	done := make(chan struct{})
	defer close(done)
	defer stream.Close()

	type recvResult struct {
		response chat.MessageStreamResponse
		err      error
	}
	recvCh := make(chan recvResult, 1)

	// Read chunks in a dedicated goroutine so the main select below can
	// enforce both context cancellation and the idle timeout without
	// blocking on a potentially stalled network read.
	go func() {
		for {
			r, err := stream.Recv()
			select {
			case recvCh <- recvResult{r, err}:
				if err != nil {
					return
				}
			case <-done:
				return
			case <-ctx.Done():
				return
			}
		}
	}()

	idleTimer := time.NewTimer(idleTimeout)
	defer idleTimer.Stop()

	var fullContent strings.Builder
	var fullReasoningContent strings.Builder
	var thinkingSignature string
	var thoughtSignature []byte
	var toolCalls []tools.ToolCall
	var messageUsage *chat.Usage
	var providerFinishReason chat.FinishReason

	toolCallIndex := make(map[string]int)   // toolCallID -> index in toolCalls slice
	emittedPartial := make(map[string]bool) // toolCallID -> whether we've emitted a partial event
	toolDefMap := make(map[string]tools.Tool, len(agentTools))

	// xmlToolCallGate suppresses AgentChoice events once a <tool_call> tag is
	// seen, preventing raw XML from rendering in the TUI.
	xmlToolCallGate := false
	for _, t := range agentTools {
		toolDefMap[t.Name] = t
	}

	// applyXMLFallback extracts <tool_call> blocks from accumulated content when
	// no structured tool calls were received. Called from both the early-return
	// and EOF paths.
	applyXMLFallback := func() {