Method doPost

internal/llm/llm.go:401–438

doPost performs one round-trip, mapping status into the typed cloud errors Probe and sendChat share. On 200 it returns the live response with body open for streaming; on non-200 the body is drained and closed first. Budget is set only on 402. errBody returns the raw body on a non-2xx other than 401/

(parent context.Context, body chatRequest)

		}
		// MidStream marks a drop the TUI may transparently replay. Gated on a
		// frame having actually arrived: a PREFILL stall is deterministic, so
		// replaying it just re-pays the same wait. A server-reported stream
		// error is its own diagnosis ("context length exceeded") and would
		// replay forever, so it never qualifies either.
		var sse *serverStreamError
		sendEvent(parent, out, Event{Kind: EventError, Err: err, MidStream: streaming.Load() && !errors.As(err, &sse)})
		return
	}
	sendEvent(parent, out, Event{
		Kind:          EventDone,
		Final:         final,
		Budget:        budget,
		ContextWindow: ctxWindow,
		Tokens:        tokens,
		PromptTokens:  promptTokens,
		Elapsed:       time.Since(start),
	})
}

// sendEvent puts e on out, bailing if parent cancels first, so a slow or
// vanished consumer after Ctrl+C can't wedge the stream goroutine on a full
// buffer.
func sendEvent(parent context.Context, out chan<- Event, e Event) bool {
	select {
	case out <- e:
		return true
	case <-parent.Done():
		return false
	}
}

// sendChat POSTs the request and returns the response on 200. On failure it
// returns the Event the caller forwards, populated with Kind/Err/Budget. The
// body is closed on every non-200 branch; 200 leaves it open for the caller.
func (c *Client) sendChat(parent context.Context, msgs []chmctx.Message, tools []Tool) (*http.Response, *Event) {
	resp, budget, err := c.postChat(parent, chatRequest{
		Model:           c.Model,
		Messages:        toWire(msgs),
		Tools:           tools,
		Stream:          true,
		StreamOptions:   &streamOptions{IncludeUsage: true},