@pi-in-go/pigpen-jev 0.1.0

package/libs/typesafe/libraries/typesafe/entry.go

@@ -0,0 +1,142 @@
+package typesafe
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// Entry is text, a JSON object, a JSON array, or null: the value of a state, of a
+// question's instructions, and of every criterion description (the TypeScript
+// EntryType). The zero Entry is OMITTED: the field is left out of the request body,
+// which is different from an explicit null that is sent as null.
+//
+// Build an Entry with [Text], [Value] or [Null], or let a builder convert a plain Go
+// value with [EntryOf]. A JSON number or boolean is not an Entry; marshalling one
+// fails with a *TypeSafeError.
+type Entry struct {
+	present bool
+	value   any
+}
+
+// Null is the explicit JSON null.
+var Null = Entry{present: true}
+
+// Text returns a text Entry.
+func Text(s string) Entry { return Entry{present: true, value: s} }
+
+// Value returns an Entry holding v: a map, slice, struct or json.RawMessage that
+// marshals to a JSON object or array, a string, or nil (which is null). To keep key
+// order, pass a json.RawMessage; Go maps marshal with sorted keys.
+func Value(v any) Entry { return Entry{present: true, value: v} }
+
+// EntryOf converts what a builder accepts: nil is [Null], an Entry is returned as is,
+// anything else is [Value].
+func EntryOf(v any) Entry {
+	switch x := v.(type) {
+	case nil:
+		return Null
+	case Entry:
+		return x
+	}
+	return Value(v)
+}
+
+// IsOmitted reports whether the Entry is the zero value (left out of the request).
+func (e Entry) IsOmitted() bool { return !e.present }
+
+// IsNull reports whether the Entry is an explicit null.
+func (e Entry) IsNull() bool { return e.present && e.value == nil }
+
+// Data returns the Go value of the Entry: string, map[string]any, []any, or nil for
+// null and omitted.
+func (e Entry) Data() any {
+	if !e.present || e.value == nil {
+		return nil
+	}
+	if s, ok := e.value.(string); ok {
+		return s
+	}
+	raw, err := e.MarshalJSON()
+	if err != nil {
+		return nil
+	}
+	var out any
+	if json.Unmarshal(raw, &out) != nil {
+		return nil
+	}
+	return out
+}
+
+// marshalPlain is json.Marshal without HTML escaping: the bodies then carry <, > and & as
+// written, like the official SDK's JSON.stringify. U+2028 and U+2029 are always escaped
+// (\u2028, \u2029; the receiving JSON parser decodes them the same): encoding/json escapes
+// them in a string, but Go 1.26 copies them through raw from a Marshaler or json.RawMessage
+// when HTML escaping is off, and Go 1.27 escapes those too. The raw bytes can only occur
+// inside a JSON string, so replacing them keeps the body (and its Content-Length) the same
+// on every toolchain.
+func marshalPlain(v any) ([]byte, error) {
+	var b bytes.Buffer
+	enc := json.NewEncoder(&b)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(v); err != nil {
+		return nil, err
+	}
+	return escapeLineSeparators(bytes.TrimSuffix(b.Bytes(), []byte("\n"))), nil
+}
+
+// escapeLineSeparators replaces raw U+2028 and U+2029 in encoded JSON with \u2028 and \u2029.
+// Neither is common: a body that holds neither is returned as it is, not copied (bytes.ReplaceAll copies even
+// when nothing matches).
+func escapeLineSeparators(out []byte) []byte {
+	const ls, ps = "\u2028", "\u2029"
+	if bytes.Contains(out, []byte(ls)) {
+		out = bytes.ReplaceAll(out, []byte(ls), []byte(`\u2028`))
+	}
+	if bytes.Contains(out, []byte(ps)) {
+		out = bytes.ReplaceAll(out, []byte(ps), []byte(`\u2029`))
+	}
+	return out
+}
+
+// MarshalJSON encodes the Entry; an omitted Entry encodes as null (parents skip
+// omitted fields themselves).
+func (e Entry) MarshalJSON() ([]byte, error) {
+	if !e.present || e.value == nil {
+		return []byte("null"), nil
+	}
+	raw, err := marshalPlain(e.value)
+	if err != nil {
+		return nil, &TypeSafeError{Message: fmt.Sprintf("Cannot encode a description or instructions value: %v", err), Cause: err}
+	}
+	switch raw[0] {
+	case '"', '{', '[', 'n':
+		return raw, nil
+	}
+	return nil, &TypeSafeError{Message: fmt.Sprintf("A description, instructions or state must be text, a JSON object, a JSON array or null, got %s.", raw)}
+}
+
+// UnmarshalJSON decodes any JSON value; a decoded null is [Null], not omitted.
+func (e *Entry) UnmarshalJSON(data []byte) error {
+	data = bytes.TrimSpace(data)
+	if len(data) == 0 {
+		return &TypeSafeError{Message: "Empty JSON value."}
+	}
+	switch data[0] {
+	case 'n':
+		*e = Null
+	case '"':
+		var s string
+		if err := json.Unmarshal(data, &s); err != nil {
+			return err
+		}
+		*e = Text(s)
+	case '{', '[':
+		*e = Value(json.RawMessage(append([]byte(nil), data...)))
+	default:
+		return &TypeSafeError{Message: fmt.Sprintf("A description, instructions or state must be text, a JSON object, a JSON array or null, got %s.", data)}
+	}
+	return nil
+}
+
+var _ json.Marshaler = Entry{}

package/libs/typesafe/libraries/typesafe/env.go

@@ -0,0 +1,11 @@
+package typesafe
+
+// Environment variable names for client configuration. Explicit options take
+// precedence over the environment, then the defaults. Empty or whitespace-only
+// values are ignored.
+const (
+	EnvAPIKey       = "TYPESAFE_API_KEY"
+	EnvBaseURL      = "TYPESAFE_BASE_URL"
+	EnvDefaultModel = "TYPESAFE_DEFAULT_MODEL"
+	EnvLogLevel     = "TYPESAFE_LOG_LEVEL"
+)

package/libs/typesafe/libraries/typesafe/errors.go

@@ -0,0 +1,310 @@
+package typesafe
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf16"
+)
+
+// TypeSafeError is the base of every error this package returns: configuration
+// mistakes, invalid questions, API errors, connection failures and aborts. Every other
+// error type unwraps to a *TypeSafeError, so
+//
+//	var base *typesafe.TypeSafeError
+//	errors.As(err, &base)
+//
+// matches them all. The hierarchy of the TypeScript SDK maps to errors.As targets:
+//
+//	TypeSafeError
+//	├─ APIError (Status, Header, Body, RequestID)
+//	│  ├─ BadRequestError 400          ├─ AuthenticationError 401
+//	│  ├─ PermissionDeniedError 403    ├─ NotFoundError 404
+//	│  ├─ UnprocessableEntityError 422 ├─ RateLimitError 429 (RetryAfter)
+//	│  └─ InternalServerError >= 500   (any other status: a bare *APIError)
+//	├─ APIConnectionError (Cause)
+//	│  └─ APITimeoutError (Timeout)
+//	└─ APIUserAbortError (Cause: the context error)
+//
+// Each subclass embeds a pointer to its parent and unwraps to it.
+type TypeSafeError struct {
+	Message string
+	Cause   error
+}
+
+func (e *TypeSafeError) Error() string { return e.Message }
+func (e *TypeSafeError) Unwrap() error { return e.Cause }
+
+func errorf(format string, args ...any) *TypeSafeError {
+	return &TypeSafeError{Message: fmt.Sprintf(format, args...)}
+}
+
+// APIError is an unsuccessful HTTP response from the API.
+type APIError struct {
+	*TypeSafeError
+	// Status is the HTTP status code.
+	Status int
+	// Header holds the response headers.
+	Header http.Header
+	// Body is the parsed JSON (map[string]any, []any, float64, bool), the response text
+	// (string), or nil for an empty body.
+	Body any
+	// RequestID is the x-typesafe-request-id header, or "".
+	RequestID string
+}
+
+// requestIDHeader is the response header that carries the request ID.
+const requestIDHeader = "x-typesafe-request-id"
+
+// NewAPIError returns the error type for an HTTP status (the TypeScript
+// APIError.fromResponse): a *BadRequestError for 400, and so on. The result's Error
+// text is "<status> <detail>" where detail is extracted from the body (error string,
+// error.message, message, detail string, detail.message, or FastAPI validation
+// entries formatted as "loc: msg" joined by "; "), or the raw body truncated to 200
+// characters plus "…", or "status code (no body)".
+func NewAPIError(status int, body any, header http.Header) error {
+	return newAPIError(status, body, "", header)
+}
+
+// newAPIError is NewAPIError with the raw JSON text of the body, which keeps the key
+// order of the server's answer in the message.
+func newAPIError(status int, body any, rawJSON string, header http.Header) error {
+	if header == nil {
+		header = http.Header{}
+	}
+	base := &APIError{
+		TypeSafeError: &TypeSafeError{Message: describeAPIError(status, body, rawJSON)},
+		Status:        status,
+		Header:        header,
+		Body:          body,
+		RequestID:     header.Get(requestIDHeader),
+	}
+	switch {
+	case status == 400:
+		return &BadRequestError{base}
+	case status == 401:
+		return &AuthenticationError{base}
+	case status == 403:
+		return &PermissionDeniedError{base}
+	case status == 404:
+		return &NotFoundError{base}
+	case status == 422:
+		return &UnprocessableEntityError{base}
+	case status == 429:
+		e := &RateLimitError{APIError: base}
+		e.RetryAfter, e.HasRetryAfter = ParseRetryAfter(header, time.Now())
+		return e
+	case status >= 500:
+		return &InternalServerError{base}
+	}
+	return base
+}
+
+func (e *APIError) Error() string { return e.Message }
+func (e *APIError) Unwrap() error { return e.TypeSafeError }
+
+const maxRawBodyInMessage = 200
+
+func describeAPIError(status int, body any, rawJSON string) string {
+	if detail := extractMessage(body); detail != "" {
+		return fmt.Sprintf("%d %s", status, detail)
+	}
+	if body == nil {
+		return fmt.Sprintf("%d status code (no body)", status)
+	}
+	raw := ""
+	if s, ok := body.(string); ok {
+		raw = s
+	} else if rawJSON != "" {
+		var buf bytes.Buffer
+		if json.Compact(&buf, []byte(rawJSON)) == nil {
+			raw = buf.String()
+		} else {
+			raw = rawJSON
+		}
+	} else if b, err := json.Marshal(body); err == nil {
+		raw = string(b)
+	}
+	units := utf16.Encode([]rune(raw))
+	if len(units) > maxRawBodyInMessage {
+		raw = string(utf16.Decode(units[:maxRawBodyInMessage])) + "…"
+	}
+	return fmt.Sprintf("%d %s", status, raw)
+}
+
+// extractMessage returns the message of a text, error, or validation response body.
+func extractMessage(body any) string {
+	if s, ok := body.(string); ok {
+		return s
+	}
+	m, ok := body.(map[string]any)
+	if !ok {
+		return ""
+	}
+	if s, ok := m["error"].(string); ok {
+		return s
+	}
+	if e, ok := m["error"].(map[string]any); ok {
+		if s, ok := e["message"].(string); ok {
+			return s
+		}
+	}
+	if s, ok := m["message"].(string); ok {
+		return s
+	}
+	if s, ok := m["detail"].(string); ok {
+		return s
+	}
+	switch d := m["detail"].(type) {
+	case map[string]any:
+		if s, ok := d["message"].(string); ok {
+			return s
+		}
+	case []any:
+		return describeValidationErrors(d)
+	}
+	return ""
+}
+
+// describeValidationErrors formats validation errors as semicolon-separated "path: message" entries.
+func describeValidationErrors(errs []any) string {
+	var parts []string
+	for _, e := range errs {
+		m, ok := e.(map[string]any)
+		if !ok {
+			continue
+		}
+		msg, ok := m["msg"].(string)
+		if !ok {
+			continue
+		}
+		var loc []string
+		if l, ok := m["loc"].([]any); ok {
+			for _, x := range l {
+				if s, isStr := x.(string); isStr && s == "body" {
+					continue
+				}
+				loc = append(loc, jsString(x))
+			}
+		}
+		if p := strings.Join(loc, "."); p != "" {
+			parts = append(parts, p+": "+msg)
+		} else {
+			parts = append(parts, msg)
+		}
+	}
+	return strings.Join(parts, "; ")
+}
+
+// jsString is JavaScript's String(x) for a decoded JSON scalar (array join semantics: null is empty).
+func jsString(x any) string {
+	switch v := x.(type) {
+	case nil:
+		return ""
+	case string:
+		return v
+	case float64:
+		return strconv.FormatFloat(v, 'f', -1, 64)
+	case bool:
+		return strconv.FormatBool(v)
+	}
+	b, _ := json.Marshal(x)
+	return string(b)
+}
+
+// BadRequestError is HTTP 400.
+type BadRequestError struct{ *APIError }
+
+// AuthenticationError is HTTP 401.
+type AuthenticationError struct{ *APIError }
+
+// PermissionDeniedError is HTTP 403.
+type PermissionDeniedError struct{ *APIError }
+
+// NotFoundError is HTTP 404.
+type NotFoundError struct{ *APIError }
+
+// UnprocessableEntityError is HTTP 422.
+type UnprocessableEntityError struct{ *APIError }
+
+// InternalServerError is HTTP 5xx (500 and above).
+type InternalServerError struct{ *APIError }
+
+// RateLimitError is HTTP 429.
+type RateLimitError struct {
+	*APIError
+	// RetryAfter is the server's retry delay from retry-after-ms or Retry-After;
+	// HasRetryAfter is false when the header is absent or invalid.
+	RetryAfter    time.Duration
+	HasRetryAfter bool
+}
+
+func (e *BadRequestError) Unwrap() error          { return e.APIError }
+func (e *AuthenticationError) Unwrap() error      { return e.APIError }
+func (e *PermissionDeniedError) Unwrap() error    { return e.APIError }
+func (e *NotFoundError) Unwrap() error            { return e.APIError }
+func (e *UnprocessableEntityError) Unwrap() error { return e.APIError }
+func (e *InternalServerError) Unwrap() error      { return e.APIError }
+func (e *RateLimitError) Unwrap() error           { return e.APIError }
+
+// APIConnectionError is a failed request or response-body delivery (DNS, TLS, closed
+// connection, interrupted body). The message is "Connection error: <cause>".
+type APIConnectionError struct {
+	*TypeSafeError
+}
+
+// APITimeoutError is a request whose full response did not arrive within the
+// per-attempt timeout; it is also an *APIConnectionError. The message is
+// "Request timed out after <n>ms."
+type APITimeoutError struct {
+	*APIConnectionError
+	// TimeoutMs is the configured timeout in milliseconds.
+	TimeoutMs int64
+}
+
+// APIUserAbortError is a request cancelled through its context. Cause is the context
+// error, so errors.Is(err, context.Canceled) holds. Message: "Request was aborted."
+type APIUserAbortError struct {
+	*TypeSafeError
+}
+
+func (e *APIConnectionError) Unwrap() error { return e.TypeSafeError }
+func (e *APITimeoutError) Unwrap() error    { return e.APIConnectionError }
+func (e *APIUserAbortError) Unwrap() error  { return e.TypeSafeError }
+
+func newConnectionError(cause error) *APIConnectionError {
+	msg := "Connection error."
+	if cause != nil {
+		msg = "Connection error: " + cause.Error()
+	}
+	return &APIConnectionError{&TypeSafeError{Message: msg, Cause: cause}}
+}
+
+func newTimeoutError(timeout time.Duration, cause error) *APITimeoutError {
+	ms := timeout.Milliseconds()
+	return &APITimeoutError{
+		APIConnectionError: &APIConnectionError{&TypeSafeError{Message: fmt.Sprintf("Request timed out after %dms.", ms), Cause: cause}},
+		TimeoutMs:          ms,
+	}
+}
+
+func newAbortError(cause error) *APIUserAbortError {
+	return &APIUserAbortError{&TypeSafeError{Message: "Request was aborted.", Cause: cause}}
+}
+
+// NewConnectionError returns an *APIConnectionError with the SDK's message for cause.
+// Sources of model or HTTP calls use it to report transport failures the retry policy
+// recognizes.
+func NewConnectionError(cause error) *APIConnectionError { return newConnectionError(cause) }
+
+// NewTimeoutError returns an *APITimeoutError for a timeout that elapsed.
+func NewTimeoutError(timeout time.Duration, cause error) *APITimeoutError {
+	return newTimeoutError(timeout, cause)
+}
+
+// NewAbortError returns an *APIUserAbortError carrying the context's cause.
+func NewAbortError(cause error) *APIUserAbortError { return newAbortError(cause) }

package/libs/typesafe/libraries/typesafe/errors_test.go

@@ -0,0 +1,175 @@
+package typesafe
+
+import (
+	"errors"
+	"net/http"
+	"reflect"
+	"strings"
+	"testing"
+	"unicode/utf8"
+)
+
+// clientReturning returns a client whose every response is resp() with retries off.
+func clientReturning(t *testing.T, resp func() *http.Response) *Client {
+	t.Helper()
+	return newClient(t, always(resp), func(c *Config) { c.Retry = RetryOverrides{MaxRetries: Ptr(0)} })
+}
+
+func TestAPIError_FromResponseMapsStatusesToTheirClasses(t *testing.T) {
+	twin(t,
+		"errors.test.ts | APIError.fromResponse maps 400 to [Function BadRequestError]",
+		"errors.test.ts | APIError.fromResponse maps 401 to [Function AuthenticationError]",
+		"errors.test.ts | APIError.fromResponse maps 403 to [Function PermissionDeniedError]",
+		"errors.test.ts | APIError.fromResponse maps 404 to [Function NotFoundError]",
+		"errors.test.ts | APIError.fromResponse maps 422 to [Function UnprocessableEntityError]",
+		"errors.test.ts | APIError.fromResponse maps 429 to [Function RateLimitError]",
+		"errors.test.ts | APIError.fromResponse maps 500 to [Function InternalServerError]",
+		"errors.test.ts | APIError.fromResponse maps 503 to [Function InternalServerError]",
+		"errors.test.ts | APIError.fromResponse maps 418 to [Function APIError]")
+	cases := []struct {
+		status int
+		class  string
+	}{{400, "BadRequestError"}, {401, "AuthenticationError"}, {403, "PermissionDeniedError"}, {404, "NotFoundError"}, {422, "UnprocessableEntityError"}, {429, "RateLimitError"}, {500, "InternalServerError"}, {503, "InternalServerError"}, {418, "APIError"}}
+	for _, tc := range cases {
+		err := NewAPIError(tc.status, nil, http.Header{})
+		if got := reflect.TypeOf(err).Elem().Name(); got != tc.class {
+			t.Fatalf("%d: got %s, want %s", tc.status, got, tc.class)
+		}
+		api := mustAs[*APIError](t, err)
+		eq(t, api.Status, tc.status)
+		mustAs[*TypeSafeError](t, err)
+		if tc.class != "APIError" {
+			// Exactly its own class among the subclasses.
+			eq(t, errorClass(err), tc.class)
+		}
+		if err.Error() == "" {
+			t.Fatal("empty message")
+		}
+	}
+}
+
+// errorClass names the subclass an error is (not the parents it unwraps to).
+func errorClass(err error) string {
+	switch err.(type) {
+	case *BadRequestError:
+		return "BadRequestError"
+	case *AuthenticationError:
+		return "AuthenticationError"
+	case *PermissionDeniedError:
+		return "PermissionDeniedError"
+	case *NotFoundError:
+		return "NotFoundError"
+	case *UnprocessableEntityError:
+		return "UnprocessableEntityError"
+	case *RateLimitError:
+		return "RateLimitError"
+	case *InternalServerError:
+		return "InternalServerError"
+	case *APIError:
+		return "APIError"
+	}
+	return "?"
+}
+
+func TestErrorMessagesAndBodies_UsesErrorMessageFromAJSONBodyAndExposesTheRequestID(t *testing.T) {
+	twin(t, "errors.test.ts | error messages and bodies uses error.message from a JSON body and exposes the request id")
+	c := clientReturning(t, func() *http.Response {
+		return jsonResp(401, map[string]any{"error": map[string]any{"message": "invalid api key"}}, "x-typesafe-request-id", "req_123")
+	})
+	_, err := c.Models().List(ctxBG(), nil)
+	mustAs[*AuthenticationError](t, err)
+	api := mustAs[*APIError](t, err)
+	eq(t, api.Error(), "401 invalid api key")
+	eq(t, api.RequestID, "req_123")
+	eq(t, api.Body, any(map[string]any{"error": map[string]any{"message": "invalid api key"}}))
+	eq(t, api.Header.Get("x-typesafe-request-id"), "req_123")
+}
+
+func TestErrorMessagesAndBodies_ExtractsAMessage(t *testing.T) {
+	twin(t,
+		"errors.test.ts | error messages and bodies extracts a message from { error: 'plain string' }",
+		"errors.test.ts | error messages and bodies extracts a message from { message: 'top-level message' }",
+		"errors.test.ts | error messages and bodies extracts a message from { detail: 'fastapi style' }",
+		"errors.test.ts | error messages and bodies extracts a message from { detail: { error_type: 'api_usage_error', message: 'Unknown model: x' } }",
+		"errors.test.ts | error messages and bodies extracts a message from { detail: [ { type: 'list_type', loc: [ 'body', 'questions', 'q', 'score', 'criteria' ], msg: 'Input should be a valid list' }, { type: 'too_short', loc: [ 'body', 'questions' ], msg: 'Dictionary should have at least 1 item' } ] }")
+	cases := []struct{ body, want string }{
+		{`{"error":"plain string"}`, "plain string"},
+		{`{"message":"top-level message"}`, "top-level message"},
+		{`{"detail":"fastapi style"}`, "fastapi style"},
+		{`{"detail":{"error_type":"api_usage_error","message":"Unknown model: x"}}`, "Unknown model: x"},
+		{`{"detail":[{"type":"list_type","loc":["body","questions","q","score","criteria"],"msg":"Input should be a valid list"},{"type":"too_short","loc":["body","questions"],"msg":"Dictionary should have at least 1 item"}]}`,
+			"questions.q.score.criteria: Input should be a valid list; questions: Dictionary should have at least 1 item"},
+	}
+	for _, tc := range cases {
+		c := clientReturning(t, func() *http.Response { return jsonResp(400, decode(t, tc.body)) })
+		_, err := c.Models().List(ctxBG(), nil)
+		eq(t, err.Error(), "400 "+tc.want)
+	}
+}
+
+func TestErrorMessagesAndBodies_FallsBackToTheRawBodyWhenNoMessageCanBeExtractedTruncated(t *testing.T) {
+	twin(t, "errors.test.ts | error messages and bodies falls back to the raw body when no message can be extracted, truncated")
+	c := clientReturning(t, func() *http.Response { return jsonResp(400, map[string]any{"code": 7}) })
+	_, err := c.Models().List(ctxBG(), nil)
+	eq(t, err.Error(), `400 {"code":7}`)
+	c = clientReturning(t, func() *http.Response { return jsonResp(400, map[string]any{"blob": strings.Repeat("x", 500)}) })
+	_, err = c.Models().List(ctxBG(), nil)
+	eq(t, utf8.RuneCountInString(err.Error()), len("400 ")+200+1)
+	if !strings.HasSuffix(err.Error(), "…") {
+		t.Fatalf("not truncated with an ellipsis: %s", err)
+	}
+}
+
+func TestErrorMessagesAndBodies_KeepsNonJSONBodiesAsText(t *testing.T) {
+	twin(t, "errors.test.ts | error messages and bodies keeps non-JSON bodies as text")
+	c := clientReturning(t, func() *http.Response { return textResp(502, "<h1>bad gateway</h1>", "content-type", "text/html") })
+	_, err := c.Models().List(ctxBG(), nil)
+	mustAs[*InternalServerError](t, err)
+	eq(t, mustAs[*APIError](t, err).Body, any("<h1>bad gateway</h1>"))
+	eq(t, err.Error(), "502 <h1>bad gateway</h1>")
+}
+
+func TestErrorMessagesAndBodies_HandlesEmptyBodies(t *testing.T) {
+	twin(t, "errors.test.ts | error messages and bodies handles empty bodies")
+	c := clientReturning(t, func() *http.Response { return textResp(429, "") })
+	_, err := c.Models().List(ctxBG(), nil)
+	mustAs[*RateLimitError](t, err)
+	if mustAs[*APIError](t, err).Body != nil {
+		t.Fatal("an empty body is nil")
+	}
+	eq(t, err.Error(), "429 status code (no body)")
+}
+
+func TestErrorMessagesAndBodies_ParsesJSONEvenWhenContentTypeIsMissing(t *testing.T) {
+	twin(t, "errors.test.ts | error messages and bodies parses JSON even when content-type is missing")
+	c := clientReturning(t, func() *http.Response { return textResp(400, `{"message":"no content type"}`) })
+	_, err := c.Models().List(ctxBG(), nil)
+	eq(t, mustAs[*APIError](t, err).Body, any(map[string]any{"message": "no content type"}))
+}
+
+// Go-specific cases beyond the upstream suite.
+
+func TestAPIError_SubclassesUnwrapToTheirParents(t *testing.T) {
+	var err error = NewAPIError(404, nil, http.Header{})
+	mustAs[*NotFoundError](t, err)
+	mustAs[*APIError](t, err)
+	mustAs[*TypeSafeError](t, err)
+	notAs[*BadRequestError](t, err)
+	notAs[*APIConnectionError](t, err)
+	conn := &APITimeoutError{APIConnectionError: &APIConnectionError{TypeSafeError: &TypeSafeError{Message: "Request timed out after 5ms."}}, TimeoutMs: 5}
+	mustAs[*APITimeoutError](t, conn)
+	mustAs[*APIConnectionError](t, conn)
+	mustAs[*TypeSafeError](t, conn)
+	notAs[*APIError](t, conn)
+	abort := &APIUserAbortError{TypeSafeError: &TypeSafeError{Message: "Request was aborted.", Cause: errors.New("c")}}
+	mustAs[*TypeSafeError](t, abort)
+	notAs[*APIConnectionError](t, abort)
+}
+
+func TestAPIError_RawBodyKeepsKeyOrderInTheMessage(t *testing.T) {
+	c := clientReturning(t, func() *http.Response {
+		return textResp(400, `{ "b": 1,  "a": [1, 2] }`, "content-type", "application/json")
+	})
+	_, err := c.Models().List(ctxBG(), nil)
+	eq(t, err.Error(), `400 {"b":1,"a":[1,2]}`)
+}