errors_test.go

// Copyright (c) 2026 Matthew Winter
//
// This source code is licensed under the MIT license found in the LICENSE file
// in the root directory of this source tree.

package sigma

import (
	"context"
	stderrors "errors"
	"fmt"
	"io"
	"net/http"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/wintermi/sigma/internal/redact"
)

func TestErrorSentinelsMatchTypedErrors(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name   string
		err    error
		target error
	}{
		{
			name:   "no provider",
			err:    &Error{Code: ErrorProviderNotFound, Message: "text provider is not registered"},
			target: ErrNoProvider,
		},
		{
			name:   "model not found",
			err:    &Error{Code: ErrorModelNotFound, Message: "model is not registered"},
			target: ErrModelNotFound,
		},
		{
			name:   "aborted",
			err:    &Error{Code: ErrorAborted, Message: "stream aborted"},
			target: ErrAborted,
		},
		{
			name:   "context overflow",
			err:    &Error{Code: ErrorContextOverflow, Message: "too many input tokens"},
			target: ErrContextOverflow,
		},
		{
			name:   "tool validation",
			err:    &Error{Code: ErrorToolValidation, Message: "tool schema is invalid"},
			target: ErrToolValidation,
		},
		{
			name:   "invalid options",
			err:    &Error{Code: ErrorInvalidOptions, Message: "temperature must be non-negative"},
			target: ErrInvalidOptions,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			if !stderrors.Is(tt.err, tt.target) {
				t.Fatalf("errors.Is(%T, %v) = false", tt.err, tt.target)
			}
		})
	}
}

func TestProviderErrorRedactsBodyCauseAndDiagnostics(t *testing.T) {
	t.Parallel()

	body := []byte(`{
		"error": {"message": "quota exceeded"},
		"api_key": "sk-live-jsonsecret",
		"nested": {
			"access_token": "access-secret",
			"refresh_token": "refresh-secret",
			"device_code": "device-secret",
			"user_code": "user-secret"
		},
		"url": "https://example.test/download?X-Amz-Signature=signed-secret&access_token=query-secret"
	}`)
	err := NewProviderError(
		ProviderOpenAI,
		APIOpenAIResponses,
		"gpt-test",
		429,
		"req_123",
		2*time.Second,
		body,
		stderrors.New("upstream said Authorization: Bearer sk-live-cause"),
	)

	assertNoSecrets(t, err.BodyPreview)
	assertNoSecrets(t, err.Error())
	assertNoSecrets(t, fmt.Sprintf("%+v", err))
	if !stderrors.Is(err, ErrProviderResponse) {
		t.Fatal("ProviderError does not match ErrProviderResponse")
	}

	var providerErr *ProviderError
	if !stderrors.As(err, &providerErr) {
		t.Fatalf("errors.As(%T, *ProviderError) = false", err)
	}
	if providerErr.StatusCode != 429 {
		t.Fatalf("status code = %d, want 429", providerErr.StatusCode)
	}

	diagnostic := err.Diagnostic()
	assertNoSecrets(t, diagnostic.BodyPreview)
	assertNoSecrets(t, diagnostic.UnderlyingMessage)
	if diagnostic.RetryAfterMillis != 2000 {
		t.Fatalf("retry after millis = %d, want 2000", diagnostic.RetryAfterMillis)
	}
}

func TestClassifyError(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name      string
		err       error
		class     ErrorClass
		retryable bool
		split     bool
		after     time.Duration
		code      string
	}{
		{
			name:  "nil",
			class: ErrorClassUnknown,
		},
		{
			name:  "invalid options",
			err:   &Error{Code: ErrorInvalidOptions, Message: "bad option"},
			class: ErrorClassInvalidRequest,
		},
		{
			name:  "unsupported",
			err:   &Error{Code: ErrorUnsupported, Message: "unsupported"},
			class: ErrorClassInvalidRequest,
		},
		{
			name:  "credential unavailable",
			err:   &Error{Message: "missing key", Err: ErrCredentialUnavailable},
			class: ErrorClassAuth,
		},
		{
			name:  "wrapped provider",
			err:   &GenerationError{Err: NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 401, "req_1", 0, []byte(`{"error":{"code":"unauthorized","message":"bad key"}}`), ErrProviderResponse)},
			class: ErrorClassAuth,
			code:  "unauthorized",
		},
		{
			name:  "quota",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 429, "", 0, []byte(`{"error":{"code":"insufficient_quota","message":"quota exceeded"}}`), ErrProviderResponse),
			class: ErrorClassQuota,
			code:  "insufficient_quota",
		},
		{
			name:  "billing",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 429, "", 0, []byte(`{"error":{"code":"usage_not_included","message":"upgrade your plan"}}`), ErrProviderResponse),
			class: ErrorClassBilling,
			code:  "usage_not_included",
		},
		{
			name:      "rate limited",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 429, "", 2*time.Second, []byte(`{"error":{"message":"slow down"}}`), ErrProviderResponse),
			class:     ErrorClassRateLimited,
			retryable: true,
			after:     2 * time.Second,
		},
		{
			name:      "transient",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 503, "", 0, []byte(`{"error":{"message":"try later"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "request timeout status",
			err:       NewProviderError(ProviderGoogleVertex, APIGoogleVertex, "gemini-test", http.StatusRequestTimeout, "", 0, []byte(`{"error":{"message":"request timed out"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "conflict status",
			err:       NewProviderError(ProviderGoogleVertex, APIGoogleVertex, "gemini-test", http.StatusConflict, "", 0, []byte(`{"error":{"message":"request conflict"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:  "structured quota code overrides conflict status",
			err:   NewProviderError(ProviderGoogleVertex, APIGoogleVertex, "gemini-test", http.StatusConflict, "", 0, []byte(`{"error":{"code":"quota_exceeded","message":"request conflict"}}`), ErrProviderResponse),
			class: ErrorClassQuota,
			code:  "quota_exceeded",
		},
		{
			name:      "upstream request buffer exhaustion overrides bad request status",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "req_buffer", 0, []byte(`{"error":{"message":"Error: EXCEEDED REQUEST BUFFER LIMIT WHILE RETRYING UPSTREAM; try later"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "dns lookup failure overrides bad request status",
			err:       NewProviderError(ProviderAmazonBedrock, APIBedrockConverseStream, "claude-test", 400, "", 0, []byte(`{"error":{"message":"getaddrinfo ENOTFOUND bedrock-runtime.example.test"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "temporary dns failure overrides bad request status",
			err:       NewProviderError(ProviderGoogle, APIGoogleGenerativeAI, "gemini-test", 400, "", 0, []byte(`{"error":{"message":"lookup generativelanguage.example.test: EAI_AGAIN"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "connection loss overrides bad request status",
			err:       NewProviderError(ProviderOpenRouter, APIOpenAICompletions, "auto", 400, "", 0, []byte(`{"error":{"message":"upstream connection lost"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "socket closure overrides bad request status",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"the socket connection was closed unexpectedly"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "websocket closure overrides bad request status",
			err:       NewProviderError(ProviderOpenAICodex, APIOpenAICodexResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"websocket closed before the response completed"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "reset before headers overrides bad request status",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"upstream reset before headers"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "http2 no response overrides bad request status",
			err:       NewProviderError(ProviderAmazonBedrock, APIBedrockConverseStream, "claude-test", 400, "", 0, []byte(`{"error":{"message":"http2 request did not get a response"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "provider returned error guidance overrides bad request status",
			err:       NewProviderError(ProviderOpenRouter, APIOpenAICompletions, "auto", 400, "", 0, []byte(`{"error":{"message":"Provider returned error while processing the request"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "explicit retry guidance overrides bad request status",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"An error occurred while processing your request. You can retry your request."}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "resource exhausted overrides bad request status",
			err:       NewProviderError(ProviderNVIDIA, APIOpenAICompletions, "nim-test", 400, "", 0, []byte(`{"error":{"message":"ResourceExhausted: worker request limit reached"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "premature stream provider error overrides bad request status",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"stream ended before terminal response event"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:  "different request buffer wording remains invalid",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"request buffer limit exceeded"}}`), ErrProviderResponse),
			class: ErrorClassInvalidRequest,
		},
		{
			name:  "generic termination wording remains invalid",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"request terminated by policy"}}`), ErrProviderResponse),
			class: ErrorClassInvalidRequest,
		},
		{
			name:  "generic timeout wording remains invalid",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"timeout policy is invalid"}}`), ErrProviderResponse),
			class: ErrorClassInvalidRequest,
		},
		{
			name:  "context overflow",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"code":"context_length_exceeded","message":"too many tokens"}}`), ErrContextOverflow),
			class: ErrorClassContextOverflow,
			split: true,
			code:  "context_length_exceeded",
		},
		{
			name:  "request too large code",
			err:   NewProviderError(ProviderOpenAI, API(EmbeddingAPIOpenAIEmbeddings), "embed-test", 400, "", 0, []byte(`{"error":{"code":"request_too_large","message":"request too large"}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
			code:  "request_too_large",
		},
		{
			name:  "http 413",
			err:   NewProviderError(ProviderOpenAI, API(EmbeddingAPIOpenAIEmbeddings), "embed-test", 413, "", 0, []byte(`{"error":{"message":"payload too large"}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "cerebras bodyless 400",
			err:   NewProviderError(ProviderCerebras, APIOpenAICompletions, "gpt-oss-120b", 400, "", 0, nil, ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "other bodyless 400",
			err:   NewProviderError(ProviderOpenAI, APIOpenAICompletions, "gpt-test", 400, "", 0, nil, ErrProviderResponse),
			class: ErrorClassInvalidRequest,
		},
		{
			name:  "ollama tokenizer eof",
			err:   NewProviderError(ProviderCustom, API(EmbeddingAPIOpenAIEmbeddings), "nomic-embed", 400, "", 0, []byte(`{"error":{"message":"tokenizer failed: EOF"}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "openai compatible maximum context length",
			err:   NewProviderError(ProviderOpenAI, APIOpenAICompletions, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"Input length (265330) exceeds model's maximum context length (262144)."}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "openrouter maximum allowed input length",
			err:   NewProviderError(ProviderOpenRouter, APIOpenAICompletions, "auto", 400, "", 0, []byte(`{"error":{"message":"Input length 131393 exceeds the maximum allowed input length of 131040 tokens."}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "together input longer than context length",
			err:   NewProviderError(ProviderTogether, APIOpenAICompletions, "deepseek-test", 400, "", 0, []byte(`{"error":{"message":"The input (516368 tokens) is longer than the model's context length (262144 tokens)."}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "copilot prompt token limit",
			err:   NewProviderError(ProviderGitHubCopilot, APIOpenAICompletions, "gemini-test", 400, "", 0, []byte(`{"error":{"message":"prompt token count of 1196265 exceeds the limit of 1048575"}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "kimi model token limit",
			err:   NewProviderError(ProviderKimi, APIOpenAICompletions, "kimi-test", 400, "", 0, []byte(`{"error":{"message":"Your request exceeded model token limit: 131072 (requested: 140000)"}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "minimax context window limit",
			err:   NewProviderError(ProviderMiniMax, APIOpenAICompletions, "minimax-test", 400, "", 0, []byte(`{"error":{"message":"invalid params, context window exceeds limit"}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:  "ollama prompt too long",
			err:   NewProviderError(ProviderCustom, APIOpenAICompletions, "ollama-test", 400, "", 0, []byte(`{"error":{"message":"prompt too long; exceeded max context length by 100918 tokens"}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
		},
		{
			name:      "plain eof",
			err:       io.EOF,
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:  "canceled context",
			err:   context.Canceled,
			class: ErrorClassUnknown,
		},
		{
			name:  "context deadline",
			err:   context.DeadlineExceeded,
			class: ErrorClassUnknown,
		},
		{
			name:      "google premature stream",
			err:       &Error{Code: ErrorStream, Message: "google generative ai: stream ended before finish reason"},
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "mistral premature stream",
			err:       &Error{Code: ErrorStream, Message: "mistral conversations: stream ended before conversation.response.done"},
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "bedrock premature stream",
			err:       &Error{Code: ErrorStream, Message: "bedrock converse stream: stream ended before message_stop"},
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:  "invalid request",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 422, "", 0, []byte(`{"error":{"message":"bad request"}}`), ErrProviderResponse),
			class: ErrorClassInvalidRequest,
		},
		{
			name:  "provider",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 418, "", 0, []byte(`{"error":{"message":"teapot"}}`), ErrProviderResponse),
			class: ErrorClassProvider,
		},
		{
			name:  "unclassified stream error",
			err:   &Error{Code: ErrorStream, Message: "stream parser failed"},
			class: ErrorClassProvider,
		},
		{
			name:      "rate limit text wins over token overflow text on 429",
			err:       NewProviderError(ProviderAmazonBedrock, APIBedrockConverseStream, "claude-test", 429, "", 0, []byte(`{"error":{"message":"Throttling error: Too many tokens, please wait before trying again."}}`), ErrProviderResponse),
			class:     ErrorClassRateLimited,
			retryable: true,
		},
		{
			name:      "generic rate limit text is not overflow",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"message":"Rate limit exceeded, please retry after 30 seconds."}}`), ErrProviderResponse),
			class:     ErrorClassRateLimited,
			retryable: true,
		},
		{
			name:      "service unavailable text is not overflow",
			err:       NewProviderError(ProviderAmazonBedrock, APIBedrockConverseStream, "claude-test", 400, "", 0, []byte(`{"error":{"message":"Service unavailable: The service is temporarily unavailable."}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:  "generic plan wording is not billing",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 0, "", 0, []byte(`{"error":{"message":"invalid execution plan"}}`), ErrProviderResponse),
			class: ErrorClassUnknown,
		},
		{
			name:  "structured code wins over status",
			err:   NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"code":"usage_not_included","message":"upgrade required"}}`), ErrProviderResponse),
			class: ErrorClassBilling,
			code:  "usage_not_included",
		},
		{
			name:  "overflow message behind generic invalid request code",
			err:   NewProviderError(ProviderAnthropic, APIAnthropicMessages, "claude-test", 400, "", 0, []byte(`{"type":"error","error":{"type":"invalid_request_error","message":"prompt is too long: 213462 tokens > 200000 maximum"}}`), ErrProviderResponse),
			class: ErrorClassContextOverflow,
			split: true,
			code:  "invalid_request_error",
		},
		{
			name:  "overflow message behind bedrock validation exception",
			err:   &ProviderError{Provider: ProviderAmazonBedrock, StatusCode: 400, ProviderCode: "ValidationException", ProviderMessage: "Input is too long for requested model.", Err: ErrProviderResponse},
			class: ErrorClassContextOverflow,
			split: true,
			code:  "ValidationException",
		},
		{
			name:      "server busy code",
			err:       NewProviderError(ProviderOpenAI, APIOpenAIResponses, "gpt-test", 0, "", 0, []byte(`{"error":{"code":"server_busy","message":"busy"}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
			code:      "server_busy",
		},
		{
			name:      "servers are currently busy",
			err:       NewProviderError(ProviderDeepSeek, APIOpenAICompletions, "deepseek-test", 0, "", 0, []byte(`{"error":{"message":"Our servers are currently busy, please try again later."}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "selected model is at capacity",
			err:       NewProviderError(ProviderOpenRouter, APIOpenAICompletions, "router-test", 400, "", 0, []byte(`{"error":{"message":"Selected model is at capacity. Please try a different model."}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
		},
		{
			name:      "azure peak load behind generic invalid request code",
			err:       NewProviderError(ProviderAzureOpenAIResponses, APIAzureOpenAIResponses, "gpt-test", 400, "", 0, []byte(`{"error":{"code":"invalid_request_error","message":"The system is currently experiencing high demand and cannot process your request. Your request exceeds the maximum usage size allowed during peak load."}}`), ErrProviderResponse),
			class:     ErrorClassTransient,
			retryable: true,
			code:      "invalid_request_error",
		},
		{
			name:  "generic invalid request code without overflow message",
			err:   NewProviderError(ProviderAnthropic, APIAnthropicMessages, "claude-test", 400, "", 0, []byte(`{"type":"error","error":{"type":"invalid_request_error","message":"messages.0.content: field required"}}`), ErrProviderResponse),
			class: ErrorClassInvalidRequest,
			code:  "invalid_request_error",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			classification := ClassifyError(tt.err)
			if classification.Class != tt.class {
				t.Fatalf("class = %q, want %q", classification.Class, tt.class)
			}
			if classification.RetryHint.Retryable != tt.retryable {
				t.Fatalf("retryable = %v, want %v", classification.RetryHint.Retryable, tt.retryable)
			}
			if classification.SplitRecoverable != tt.split {
				t.Fatalf("split recoverable = %v, want %v", classification.SplitRecoverable, tt.split)
			}
			if classification.RetryHint.After != tt.after {
				t.Fatalf("retry after = %v, want %v", classification.RetryHint.After, tt.after)
			}
			if classification.ProviderCode != tt.code {
				t.Fatalf("provider code = %q, want %q", classification.ProviderCode, tt.code)
			}
		})
	}
}

func TestClassifyUpstreamRequestBufferGenerationErrorPreservesFinal(t *testing.T) {
	t.Parallel()

	providerErr := NewProviderError(
		ProviderOpenAI,
		APIOpenAIResponses,
		"gpt-test",
		400,
		"req_buffer",
		0,
		[]byte(`{"error":{"message":"exceeded request buffer limit while retrying upstream"}}`),
		ErrProviderResponse,
	)
	err := &GenerationError{
		Final: AssistantMessage{
			Content:    []ContentBlock{Text("partial answer")},
			StopReason: StopReasonError,
			Model:      "gpt-test",
			Provider:   ProviderOpenAI,
		},
		Err: providerErr,
	}

	classification := ClassifyError(err)
	if got, want := classification.Class, ErrorClassTransient; got != want {
		t.Fatalf("class = %q, want %q", got, want)
	}
	if !classification.RetryHint.Retryable {
		t.Fatal("request buffer exhaustion was not retryable")
	}
	if got, want := classification.Provider, ProviderOpenAI; got != want {
		t.Fatalf("provider = %q, want %q", got, want)
	}
	if got, want := classification.API, APIOpenAIResponses; got != want {
		t.Fatalf("API = %q, want %q", got, want)
	}
	if got, want := classification.Model, ModelID("gpt-test"); got != want {
		t.Fatalf("model = %q, want %q", got, want)
	}
	if got, want := classification.StatusCode, 400; got != want {
		t.Fatalf("status = %d, want %d", got, want)
	}
	if got, want := classification.RequestID, "req_buffer"; got != want {
		t.Fatalf("request ID = %q, want %q", got, want)
	}
	final, ok := err.FinalMessage()
	if !ok {
		t.Fatal("GenerationError missing final message")
	}
	if got, want := final.Content[0].Text, "partial answer"; got != want {
		t.Fatalf("final text = %q, want %q", got, want)
	}
}

func TestClassifyTransientGenerationErrorPreservesPartialFinal(t *testing.T) {
	t.Parallel()

	final := AssistantMessage{
		Content:    []ContentBlock{Text("partial answer")},
		StopReason: StopReasonError,
		Model:      "gpt-test",
		Provider:   ProviderOpenAI,
	}
	providerErr := NewProviderError(
		ProviderOpenAI,
		APIOpenAIResponses,
		"gpt-test",
		400,
		"req_socket",
		0,
		[]byte(`{"error":{"message":"the socket connection was closed unexpectedly"}}`),
		ErrProviderResponse,
	)
	err := &GenerationError{Final: final, Err: providerErr}

	classification := ClassifyError(err)
	if classification.Class != ErrorClassTransient || !classification.RetryHint.Retryable {
		t.Fatalf("classification = %#v, want retryable transient", classification)
	}
	got, ok := err.FinalMessage()
	if !ok {
		t.Fatal("GenerationError missing final message")
	}
	if got.StopReason != StopReasonError || len(got.Content) != 1 || got.Content[0].Text != "partial answer" {
		t.Fatalf("final = %#v, want unchanged partial answer", got)
	}
}

func TestProviderErrorClassificationRedactsParsedFields(t *testing.T) {
	t.Parallel()

	err := NewProviderError(
		ProviderOpenAI,
		APIOpenAIResponses,
		"gpt-test",
		401,
		"req_secret",
		0,
		[]byte(`{"error":{"code":"unauthorized","message":"bad key sk-live-jsonsecret"}}`),
		ErrProviderResponse,
	)

	assertNoSecrets(t, err.ProviderMessage)
	assertNoSecrets(t, err.Error())
	classification := ClassifyError(err)
	assertNoSecrets(t, classification.Message)
	if classification.Class != ErrorClassAuth {
		t.Fatalf("class = %q, want %q", classification.Class, ErrorClassAuth)
	}
}

func TestIsContextOverflow(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name          string
		message       AssistantMessage
		contextWindow int
		want          bool
	}{
		{
			name: "provider diagnostic",
			message: AssistantMessage{
				StopReason: StopReasonError,
				Diagnostics: []Diagnostic{{
					Provider:        ProviderOpenAI,
					API:             APIOpenAIResponses,
					Model:           "gpt-test",
					StatusCode:      400,
					ProviderMessage: "Input length (265330) exceeds model's maximum context length (262144).",
				}},
			},
			want: true,
		},
		{
			name: "normal stop above context window",
			message: AssistantMessage{
				StopReason: StopReasonEndTurn,
				Usage:      &Usage{InputTokens: 120, CacheReadInputTokens: 10},
			},
			contextWindow: 100,
			want:          true,
		},
		{
			name: "max tokens zero output with full context",
			message: AssistantMessage{
				StopReason: StopReasonMaxTokens,
				Usage:      &Usage{InputTokens: 58, CacheReadInputTokens: 1048512},
			},
			contextWindow: 1048576,
			want:          true,
		},
		{
			name: "max tokens with output is not overflow",
			message: AssistantMessage{
				StopReason: StopReasonMaxTokens,
				Usage:      &Usage{InputTokens: 990, OutputTokens: 1},
			},
			contextWindow: 1000,
		},
		{
			name: "max tokens below context is not overflow",
			message: AssistantMessage{
				StopReason: StopReasonMaxTokens,
				Usage:      &Usage{InputTokens: 100},
			},
			contextWindow: 1000,
		},
		{
			name: "usage detection requires context window",
			message: AssistantMessage{
				StopReason: StopReasonEndTurn,
				Usage:      &Usage{InputTokens: 120},
			},
		},
		{
			name: "non-overflow diagnostic",
			message: AssistantMessage{
				StopReason: StopReasonError,
				Diagnostics: []Diagnostic{{
					StatusCode:      429,
					ProviderMessage: "Too many requests. Please slow down.",
				}},
			},
		},
		{
			name: "overflow message behind generic invalid request code",
			message: AssistantMessage{
				StopReason: StopReasonError,
				Diagnostics: []Diagnostic{{
					StatusCode:      400,
					ProviderCode:    "invalid_request_error",
					ProviderMessage: "prompt is too long: 213462 tokens > 200000 maximum",
				}},
			},
			want: true,
		},
		{
			name: "provider-detected overflow behind generic invalid request code",
			message: AssistantMessage{
				StopReason: StopReasonError,
				Diagnostics: []Diagnostic{(&ProviderError{
					Provider:        ProviderAnthropic,
					StatusCode:      400,
					ProviderCode:    "invalid_request_error",
					ProviderMessage: "request rejected",
					Err:             ErrContextOverflow,
				}).Diagnostic()},
			},
			want: true,
		},
		{
			name: "generic invalid request diagnostic without overflow",
			message: AssistantMessage{
				StopReason: StopReasonError,
				Diagnostics: []Diagnostic{{
					StatusCode:      400,
					ProviderCode:    "invalid_request_error",
					ProviderMessage: "messages.0.content: field required",
				}},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			if got := IsContextOverflow(tt.message, tt.contextWindow); got != tt.want {
				t.Fatalf("IsContextOverflow() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestIsRecoverableMaxTokens(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name             string
		message          AssistantMessage
		desiredMaxOutput int
		want             bool
	}{
		{
			name:             "short output",
			message:          AssistantMessage{StopReason: StopReasonMaxTokens, Usage: &Usage{OutputTokens: 16}},
			desiredMaxOutput: 128000,
			want:             true,
		},
		{
			name:             "zero output",
			message:          AssistantMessage{StopReason: StopReasonMaxTokens, Usage: &Usage{}},
			desiredMaxOutput: 128000,
			want:             true,
		},
		{
			name:             "exact limit",
			message:          AssistantMessage{StopReason: StopReasonMaxTokens, Usage: &Usage{OutputTokens: 1024}},
			desiredMaxOutput: 1024,
		},
		{
			name:             "above limit",
			message:          AssistantMessage{StopReason: StopReasonMaxTokens, Usage: &Usage{OutputTokens: 1025}},
			desiredMaxOutput: 1024,
		},
		{
			name:             "missing usage",
			message:          AssistantMessage{StopReason: StopReasonMaxTokens},
			desiredMaxOutput: 1024,
		},
		{
			name:             "zero desired output",
			message:          AssistantMessage{StopReason: StopReasonMaxTokens, Usage: &Usage{}},
			desiredMaxOutput: 0,
		},
		{
			name:             "negative desired output",
			message:          AssistantMessage{StopReason: StopReasonMaxTokens, Usage: &Usage{}},
			desiredMaxOutput: -1,
		},
		{
			name:             "other stop reason",
			message:          AssistantMessage{StopReason: StopReasonEndTurn, Usage: &Usage{OutputTokens: 16}},
			desiredMaxOutput: 128000,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			if got := IsRecoverableMaxTokens(tt.message, tt.desiredMaxOutput); got != tt.want {
				t.Fatalf("IsRecoverableMaxTokens() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestRedactionCoversHeadersQueriesJSONAndMultilineBodies(t *testing.T) {
	t.Parallel()

	headers := redact.Headers(map[string][]string{
		"Authorization": {"Bearer sk-live-headersecret"},
		"Cookie":        {"session=header-cookie-secret; other=value"},
		"X-Debug":       {"callback=https://example.test/cb?api_key=query-secret&X-Goog-Signature=signed-secret"},
	})

	if got := headers["Authorization"][0]; got != "[redacted]" {
		t.Fatalf("authorization header = %q, want redacted", got)
	}
	if got := headers["Cookie"][0]; got != "[redacted]" {
		t.Fatalf("cookie header = %q, want redacted", got)
	}
	assertNoSecrets(t, headers["X-Debug"][0])

	multiline := strings.Join([]string{
		"HTTP/1.1 401 Unauthorized",
		"Authorization: Bearer sk-live-multiline",
		"Set-Cookie: session=multiline-cookie-secret",
		`{"api_key":"json-secret","access_token":"access-secret","refresh_token":"refresh-secret"}`,
		"https://example.test/upload?AWSAccessKeyId=aws-secret&Signature=signed-secret&device_code=device-secret",
	}, "\n")

	redacted := redact.String(multiline)
	assertNoSecrets(t, redacted)
	if !strings.Contains(redacted, "[redacted]") {
		t.Fatalf("redacted body = %q, want redaction marker", redacted)
	}
	if !strings.Contains(redacted, "401 Unauthorized") {
		t.Fatalf("redacted body lost non-secret context: %q", redacted)
	}
}

func TestGenerationErrorCarriesFinalMessageAndWrappedProviderError(t *testing.T) {
	t.Parallel()

	providerErr := NewProviderError(
		ProviderAnthropic,
		APIAnthropicMessages,
		"claude-test",
		500,
		"req_provider_failure",
		0,
		[]byte(`{"access_token":"stream-secret","error":"provider failed"}`),
		stderrors.New("provider failed"),
	)
	final := AssistantMessage{
		Content:     []ContentBlock{Text("partial answer")},
		StopReason:  StopReasonError,
		Model:       "claude-test",
		Provider:    ProviderAnthropic,
		Diagnostics: []Diagnostic{providerErr.Diagnostic()},
	}
	stream, writer := NewStream(context.Background())
	writeErr := make(chan error, 1)
	go func() {
		writeErr <- writer.Error(context.Background(), providerErr, final)
	}()

	collected, err := Collect(context.Background(), stream)
	if err == nil {
		t.Fatal("Collect returned nil error")
	}
	if err := <-writeErr; err != nil {
		t.Fatalf("writer returned error: %v", err)
	}
	if got, want := collected.StopReason, StopReasonError; got != want {
		t.Fatalf("collected stop reason = %q, want %q", got, want)
	}

	var generationErr *GenerationError
	if !stderrors.As(err, &generationErr) {
		t.Fatalf("Collect error type = %T, want GenerationError", err)
	}
	finalFromError, ok := generationErr.FinalMessage()
	if !ok {
		t.Fatal("GenerationError missing final message")
	}
	if got, want := finalFromError.Content[0].Text, "partial answer"; got != want {
		t.Fatalf("final text = %q, want %q", got, want)
	}
	if !stderrors.Is(err, ErrProviderResponse) {
		t.Fatal("GenerationError does not match ErrProviderResponse")
	}

	var unwrappedProvider *ProviderError
	if !stderrors.As(err, &unwrappedProvider) {
		t.Fatal("GenerationError does not expose ProviderError")
	}
	assertNoSecrets(t, err.Error())
}

func TestGenerationErrorMapsAbortedStopReasonToSentinel(t *testing.T) {
	t.Parallel()

	stream, writer := NewStream(context.Background())
	writeErr := make(chan error, 1)
	go func() {
		writeErr <- writer.Error(
			context.Background(),
			context.Canceled,
			AssistantMessage{StopReason: StopReasonAborted},
		)
	}()

	final, err := Collect(context.Background(), stream)
	if err == nil {
		t.Fatal("Collect returned nil error")
	}
	if err := <-writeErr; err != nil {
		t.Fatalf("writer returned error: %v", err)
	}
	if got, want := final.StopReason, StopReasonAborted; got != want {
		t.Fatalf("stop reason = %q, want %q", got, want)
	}
	if !stderrors.Is(err, ErrAborted) {
		t.Fatal("GenerationError does not match ErrAborted")
	}
}

func assertNoSecrets(t *testing.T, value string) {
	t.Helper()

	secrets := []string{
		"sk-live-jsonsecret",
		"access-secret",
		"refresh-secret",
		"device-secret",
		"user-secret",
		"signed-secret",
		"query-secret",
		"sk-live-cause",
		"sk-live-headersecret",
		"header-cookie-secret",
		"multiline-cookie-secret",
		"sk-live-multiline",
		"aws-secret",
		"stream-secret",
	}
	for _, secret := range secrets {
		if strings.Contains(value, secret) {
			t.Fatalf("value leaked %q: %q", secret, value)
		}
	}
}

func TestClassifyErrorRecognizesProviderOverflowMessages(t *testing.T) {
	t.Parallel()

	overflow := []string{
		"prompt is too long: 213462 tokens > 200000 maximum",
		"Prompt exceeds max length",
		"request_too_large",
		"Input is too long for requested model.",
		"Your input exceeds the context window of this model.",
		"This model's maximum context length is 128000 tokens.",
		"The input token count (1200000) exceeds the maximum number of tokens allowed (1048576).",
		"This model's maximum prompt length is 131072 but the request contains 140000 tokens.",
		"Please reduce the length of the messages or completion.",
		"Input length 300000 exceeds the maximum allowed input length of 262144 tokens.",
		"The input (300000 tokens) is longer than the model's context length (262144 tokens).",
		"prompt token count of 140000 exceeds the limit of 128000",
		"the request exceeds the available context size, try increasing it",
		"The number of tokens to keep is greater than the context length",
		"invalid params, context window exceeds limit",
		"Your request exceeded model token limit: 262144 (requested: 300000)",
		"Prompt contains 300000 tokens and 0 draft tokens, too large for model with 262144 maximum context length",
		"Prompt has 300,000 tokens, but the configured context size is 262,144 tokens",
		"prompt too long; exceeded max context length by 100 tokens",
		"Range of input length should be [1, 98304]",
		"context length exceeded",
		"Request has too many tokens for this model",
		"token limit exceeded",
	}
	for _, message := range overflow {
		body := []byte(`{"error":{"message":` + strconv.Quote(message) + `}}`)
		err := NewProviderError("test-provider", APIOpenAICompletions, "model", 400, "", 0, body, ErrProviderResponse)
		if got := ClassifyError(err).Class; got != ErrorClassContextOverflow {
			t.Errorf("%q classified as %q, want context overflow", message, got)
		}
	}

	throttled := NewProviderError(ProviderAmazonBedrock, APIBedrockConverseStream, "model", 0, "", 0,
		[]byte(`{"error":{"message":"ThrottlingException: Too many tokens, please wait before trying again."}}`), ErrProviderResponse)
	if got := ClassifyError(throttled).Class; got == ErrorClassContextOverflow {
		t.Errorf("Bedrock throttling classified as context overflow")
	}
}