Method run

internal/llm/llm.go:292–338

(parent context.Context, msgs []chmctx.Message, tools []Tool, out chan<- Event)

	ContextWindow int
	Budget        cloud.BudgetStatus
}

// Probe sends a minimal hello chat just to harvest response headers in one
// round trip: status validates the URL/model/key combo, X-Context-Window gives
// the live size, X-Budget-Remaining the live fraction. The body is closed
// unread; on the cloud proxy that may already charge one token, the cost of a
// single round-trip "key works AND here is your real window". Returns the
// standard cloud errors (Unreachable, Unauthorized, BudgetExhausted) for
// errors.Is branching.
func (c *Client) Probe(parent context.Context) (ProbeResult, error) {
	resp, budget, err := c.post(parent, request{
		Model:  c.Model,
		Input:  []any{messageItem{Type: "message", Role: "user", Content: "hi"}},
		Stream: true,
	})
	if err != nil {
		return ProbeResult{Budget: budget}, err
	}
	defer resp.Body.Close()
	return ProbeResult{
		ContextWindow: cloud.ContextWindowFromHeaders(resp.Header),
		Budget:        cloud.FromHeaders(resp.Header),
	}, nil
}

// Chat streams an assistant response on the returned channel, closing it when
// the stream ends. Reasoning runs at `medium` effort: decode is the serialised
// critical path of every round, and `high` bought deliberation the agent loop
// already gets from seeing each tool result. If the server rejects the effort
// (see rejectsReasoning), post drops it for this Client's lifetime so the model
// still works at the server's own default.
func (c *Client) Chat(parent context.Context, messages []chmctx.Message, tools []Tool) <-chan Event {
	out := make(chan Event, 32)
	go c.run(parent, messages, tools, out)
	return out
}

func (c *Client) run(parent context.Context, msgs []chmctx.Message, tools []Tool, out chan<- Event) {
	defer close(out)
	start := time.Now()

	// Pre-stream retry: transient failures (proxy hiccups: 5xx, 429, LiteLLM's
	// transient 404) are resent after a rising backoff instead of killing the
	// turn. Only here, before any token has streamed — a mid-stream resend
	// would duplicate content already in the transcript. Probe stays
	// retry-free: its job is fast feedback on a misconfigured profile.
	resp, errEvt := c.sendChat(parent, msgs, tools)
	for attempt := 0; errEvt != nil && attempt < len(c.RetryBackoff) && retryable(errEvt.Err); attempt++ {
		delay := c.RetryBackoff[attempt]
		hint := fmt.Sprintf("retry %d/%d in %s", attempt+1, len(c.RetryBackoff), delay)