fix(anthropic/openai/google): wrap io.ErrUnexpectedEOF as ProviderError

[ljuti]

Summary

When a provider's SSE stream drops mid-response with a raw I/O error like io.ErrUnexpectedEOF (idle timeouts, proxy resets, mid-stream TCP disconnects), toProviderErr in each of the three direct providers returns the error unchanged because errors.As(err, &apiErr) fails for non-API-error values. The retry loop gates on errors.As(err, &ProviderError) + IsRetryable(), so the retry branch is never entered and the bare error propagates to the caller on the first attempt.

This is especially ironic because ProviderError.IsRetryable at errors.go already special-cases io.ErrUnexpectedEOF as retryable — that check is simply never reached for raw stream transport errors in any direct provider except kronk.

This PR wraps io.ErrUnexpectedEOF (including wrapped forms via errors.Is) into a ProviderError with Cause set in all three direct providers, so the existing IsRetryable path engages and transient mid-stream disconnects are retried as intended.

Provider coverage

• anthropic: fixed
• openai: fixed
• google: fixed
• kronk: no change
• bedrock: inherits anthropic fix
• azure: inherits openai fix
• openaicompat: inherits openai fix
• openrouter: inherits openai fix
• vercel: inherits openai fix

Failure trace (Anthropic example)

1. providers/anthropic/anthropic.go — stream.Err() returns io.ErrUnexpectedEOF from the SSE decoder.
2. toProviderErr(err) is called.
3. providers/anthropic/error.go (before this PR) — errors.As(err, &apiErr) fails; raw error returned unchanged.
4. retry.go:112-113 — errors.As(err, &providerErr) fails; retry branch skipped.
5. retry.go:132-133 — first-attempt non-retryable errors return without wrapping in RetryError. Caller gets bare unexpected EOF.

Net effect: IsRetryable never runs, and a failure mode the code already knows how to handle is treated as fatal.

Repro

Reliably reproducible on long-running tool-heavy sessions (~8 minutes of continuous streaming) where idle timeouts / proxy resets sever the SSE connection mid-response. The top-level error bubbles up as a bare unexpected EOF after thousands of successful stream parts.

Change

Minimal targeted wrap in providers/anthropic/error.go:

if errors.Is(err, io.ErrUnexpectedEOF) {
    return &fantasy.ProviderError{
        Title:   "stream transport error",
        Message: err.Error(),
        Cause:   err,
    }
}

Only the io.ErrUnexpectedEOF case is wrapped, to stay conservative. Other transient network errors (*net.OpError, syscall.ECONNRESET, http2.StreamError) are good candidates for a follow-up but aren't included here.

Tests

New providers/anthropic/error_test.go covers:

• TestToProviderErr_WrapsUnexpectedEOF — direct, wrapped once, wrapped twice; verifies the result is *fantasy.ProviderError, Cause chains back to io.ErrUnexpectedEOF, and IsRetryable() returns true.

• TestToProviderErr_PassesThroughUnrelatedErrors — arbitrary non-EOF errors are returned unchanged.

• TestToProviderErr_PassesThroughPlainEOF — clean io.EOF is not wrapped (the stream handler treats io.EOF as a clean terminator; wrapping would invite false retries).

• I have read CONTRIBUTING.md.

[ljuti]

Found the issue to be in openai and google providers as well. Updated the title and the description, and added another commit to fix these two as well.

[andreynering]

Good patch. Thank you @ljuti!