Function readSSE

internal/llm/llm.go:468–536

readSSE reads OpenAI SSE frames until [DONE] or EOF, forwarding content/reasoning/tool-call events to out. Returns the final assistant message (content + accumulated tool calls), the server completion and prompt token counts, and any scanner error. parent is threaded through so sends abort on cancel

(parent context.Context, body io.Reader, budget cloud.BudgetStatus, out chan<- Event, onFrame func())

// own name in each dialect (OpenAI "reasoning.effort", vLLM "Unexpected
// reasoning effort", Ollama's "<model> does not support thinking"), never on a
// lone generic word, so an unrelated 400 that merely mentions "thinking" can't
// latch reasoning off for the Client's whole life. Dropping the field is the
// right remedy for all of them, but note what it costs: the server then applies
// its own default (on the Qwen3.8 scale that is xhigh, i.e. MORE reasoning than
// we asked for, not less). A compatibility fix, never a way to think less.
func rejectsReasoning(errBody []byte) bool {
	for _, sig := range []string{"reasoning.effort", "reasoning_effort", "reasoning effort", "does not support thinking"} {
		if bytes.Contains(errBody, []byte(sig)) {
			return true
		}
	}
	return false
}

// 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/402, so
// post can check it for the reasoning fallback signal without re-reading.
func (c *Client) doPost(parent context.Context, body request) (*http.Response, cloud.BudgetStatus, []byte, error) {
	buf, err := json.Marshal(body)
	if err != nil {
		return nil, cloud.BudgetStatus{}, nil, err
	}
	req, err := http.NewRequestWithContext(parent, "POST", c.BaseURL+"/v1/responses", bytes.NewReader(buf))
	if err != nil {
		return nil, cloud.BudgetStatus{}, nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "text/event-stream")
	if c.Token != "" {
		req.Header.Set("Authorization", cloud.AuthHeader(c.Token))
	}
	resp, err := c.HTTP.Do(req)
	if err != nil {
		return nil, cloud.BudgetStatus{}, nil, cloud.ErrUnreachable{Err: err}
	}
	if resp.StatusCode == 200 {
		return resp, cloud.BudgetStatus{}, nil, nil
	}
	defer resp.Body.Close()
	switch resp.StatusCode {
	case 401:
		// Drain before the deferred Close so the keep-alive connection returns
		// to the pool instead of being discarded, same as the 402/default arms.
		_, _ = io.Copy(io.Discard, resp.Body)
		return nil, cloud.BudgetStatus{}, nil, cloud.ErrUnauthorized
	case 402:
		// Pass depleted. Body ignored: the status code is the whole signal,
		// the UI banner is fixed text, the returned snapshot reflects it.
		_, _ = io.Copy(io.Discard, resp.Body)
		return nil, cloud.BudgetStatus{Set: true, Remaining: 0}, nil, cloud.ErrBudgetExhausted
	default:
		b, _ := io.ReadAll(resp.Body)
		msg := errorMessageFromBody(b)
		if resp.StatusCode == 404 && strings.Contains(msg, "litellm.NotFoundError") {
			msg += " · check LiteLLM's upstream URL and model; if that upstream only supports /chat/completions, set use_chat_completions_api: true under this model's litellm_params in the proxy config"
		} else if resp.StatusCode == 404 {