fix(ai): handle remaining provider failures

packages/ai/src/index.ts

@@ -2,7 +2,8 @@ export { LLMClient } from "./route/client"
 export { Auth } from "./route/auth"
 export { Provider } from "./provider"
 export { ProviderPackage } from "./provider-package"
-export { isContextOverflow, isContextOverflowFailure } from "./provider-error"
+export { classifyProviderFailure, isContextOverflow, isContextOverflowFailure } from "./provider-error"
+export type { ProviderFailure } from "./provider-error"
 export type {
   RouteModelInput,
   RouteRoutedModelInput,

packages/ai/src/protocols/bedrock-event-stream.ts

@@ -1,6 +1,6 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec"
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8"
-import { Effect, Stream } from "effect"
+import { Effect, Option, Schema, Stream } from "effect"
 import { Framing } from "../route/framing"
 import { ProviderShared } from "./shared"
 
@@ -53,8 +53,13 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
       })
       cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength }
 
-      if (decoded.headers[":message-type"]?.value !== "event") continue
-      const eventType = decoded.headers[":event-type"]?.value
+      const messageType = decoded.headers[":message-type"]?.value
+      const eventType =
+        messageType === "event"
+          ? decoded.headers[":event-type"]?.value
+          : messageType === "exception"
+            ? decoded.headers[":exception-type"]?.value
+            : undefined
       if (typeof eventType !== "string") continue
       const payload = utf8.decode(decoded.body)
       if (!payload) continue
@@ -84,4 +89,52 @@ export const framing = (route: string): Framing.Definition<object> => ({
   frame: (bytes) => bytes.pipe(Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 })
 
+class StreamExceptionError extends Error {
+  constructor(
+    message: string,
+    readonly code: string,
+  ) {
+    super(message)
+  }
+}
+
+// The AI SDK Bedrock decoder ignores AWS exception frames before its language
+// model stream can expose them. Fail the byte stream first so the shared AI SDK
+// adapter can classify the transport error instead of accepting a false finish.
+export function monitorExceptions(response: Response) {
+  if (!response.body || !response.headers.get("content-type")?.includes("application/vnd.amazon.eventstream"))
+    return response
+  let state = initialFrameBuffer
+  const body = response.body.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      transform(chunk, controller) {
+        state = appendChunk(state, chunk)
+        while (state.buffer.length - state.offset >= 4) {
+          const view = state.buffer.subarray(state.offset)
+          const totalLength = new DataView(view.buffer, view.byteOffset, view.byteLength).getUint32(0, false)
+          if (view.length < totalLength) break
+          const decoded = eventCodec.decode(view.subarray(0, totalLength))
+          state = { buffer: state.buffer, offset: state.offset + totalLength }
+          const exceptionType = decoded.headers[":exception-type"]?.value
+          if (decoded.headers[":message-type"]?.value === "exception" && typeof exceptionType === "string") {
+            const payload = Option.getOrUndefined(
+              Schema.decodeUnknownOption(Schema.UnknownFromJsonString)(utf8.decode(decoded.body)),
+            )
+            const message =
+              ProviderShared.isRecord(payload) && typeof payload.message === "string" ? payload.message : undefined
+            controller.error(new StreamExceptionError(message ?? `Bedrock ${exceptionType}`, exceptionType))
+            return
+          }
+        }
+        controller.enqueue(chunk)
+      },
+    }),
+  )
+  return new Response(body, {
+    headers: new Headers(response.headers),
+    status: response.status,
+    statusText: response.statusText,
+  })
+}
+
 export * as BedrockEventStream from "./bedrock-event-stream"

packages/ai/src/provider-error.ts

@@ -46,24 +46,45 @@ export const isContextOverflowFailure = (failure: unknown) =>
     : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow"
 
 const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
+const CONTENT_POLICY_CODES = new Set(["content_filter", "content_policy_violation", "safety"])
 const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"])
+const RATE_LIMIT_CODES = new Set(["resource_exhausted", "throttlingexception", "too_many_requests"])
 const SERVER_CODES = new Set([
   "api_error",
+  "internal",
   "internal_error",
+  "internal_server_error",
   "internalserverexception",
   "modelstreamerrorexception",
+  "modeltimeoutexception",
   "overloaded_error",
+  "response_error",
   "server_error",
   "server_is_overloaded",
   "serviceunavailableexception",
 ])
-const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error", "validationexception"])
-const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i
+const INVALID_REQUEST_CODES = new Set([
+  "invalid_argument",
+  "invalid_prompt",
+  "invalid_request_error",
+  "model_not_found",
+  "not_found",
+  "not_found_error",
+  "resourcenotfoundexception",
+  "request_too_large",
+  "validationexception",
+])
+const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|throttl|too[_\s]?many[_\s]?requests/i
 const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i
-const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i
+const CONTENT_POLICY_TEXT =
+  /content[-_\s]?(?:filter|policy)|safety (?:filter|policy|rating)|blocked (?:by|due to) safety/i
+const INVALID_REQUEST_TEXT = /validation (?:error|exception)/i
+const SERVER_TEXT = /internal server error|service unavailable/i
 
 export interface ProviderFailure {
   readonly message: string
+  /** Provider text used only for classification and never retained on the resulting reason. */
+  readonly evidence?: string | undefined
   readonly status?: number | undefined
   readonly code?: string | undefined
   readonly retryAfterMs?: number | undefined
@@ -76,10 +97,11 @@ export interface ProviderFailure {
 // session retry policy never needs provider-specific string matching.
 export function classifyProviderFailure(input: ProviderFailure): LLMError["reason"] {
   const body = input.http?.body ?? ""
-  const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
+  const evidence = input.evidence ?? ""
+  const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message), ...providerCodes(evidence)]
     .filter((code): code is string => code !== undefined)
     .map((code) => code.toLowerCase())
-  const text = body || input.message
+  const texts = [body, input.message, evidence]
   const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http }
   const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500)
 
@@ -87,32 +109,44 @@ export function classifyProviderFailure(input: ProviderFailure): LLMError["reaso
     clientScoped &&
     (codes.includes("context_length_exceeded") ||
       codes.includes("model_context_window_exceeded") ||
-      isContextOverflow(text))
+      texts.some(isContextOverflow))
   )
     return new InvalidRequestReason({ ...common, classification: "context-overflow" })
-  if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyReason(common)
-  if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
+  if (codes.some((code) => CONTENT_POLICY_CODES.has(code)) || texts.some((text) => CONTENT_POLICY_TEXT.test(text)))
+    return new ContentPolicyReason(common)
+  if (
+    codes.some((code) => QUOTA_CODES.has(code)) ||
+    (input.status === 429 && texts.some((text) => QUOTA_TEXT.test(text)))
+  )
     return new QuotaExceededReason(common)
   if (input.status === 401) return new AuthenticationReason({ ...common, kind: "invalid" })
   if (input.status === 403) return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
-  if (codes.includes("authentication_error")) return new AuthenticationReason({ ...common, kind: "invalid" })
-  if (codes.includes("permission_error"))
-    return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
+  if (codes.some((code) => code === "authentication_error" || code === "unauthenticated"))
+    return new AuthenticationReason({ ...common, kind: "invalid" })
   if (
-    codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception")
+    codes.some(
+      (code) => code === "accessdeniedexception" || code === "permission_error" || code === "permission_denied",
+    )
   )
+    return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
+  if (codes.some((code) => code.includes("rate_limit") || RATE_LIMIT_CODES.has(code)))
     return new RateLimitReason({
       ...common,
       retryAfterMs: input.retryAfterMs,
       rateLimit: input.rateLimit,
     })
-  if (RATE_LIMIT_TEXT.test(text))
+  if (texts.some((text) => RATE_LIMIT_TEXT.test(text)))
     return new RateLimitReason({
       ...common,
       retryAfterMs: input.retryAfterMs,
       rateLimit: input.rateLimit,
     })
-  if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
+  if (codes.some((code) => INVALID_REQUEST_CODES.has(code)) || texts.some((text) => INVALID_REQUEST_TEXT.test(text)))
+    return new InvalidRequestReason(common)
+  if (
+    codes.some((code) => SERVER_CODES.has(code) || code.includes("unavailable")) ||
+    texts.some((text) => SERVER_TEXT.test(text))
+  )
     return new ProviderInternalReason({
       ...common,
       status: input.status,
@@ -131,7 +165,6 @@ export function classifyProviderFailure(input: ProviderFailure): LLMError["reaso
       status: input.status,
       retryAfterMs: input.retryAfterMs,
     })
-  if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestReason(common)
   if (
     input.status === 400 ||
     input.status === 404 ||
@@ -147,7 +180,17 @@ function providerCodes(value: string) {
   const decoded = Option.getOrUndefined(decodeJson(value))
   if (!isRecord(decoded)) return []
   const error = isRecord(decoded.error) ? decoded.error : undefined
-  return [decoded.code, error?.code, error?.type].filter((value): value is string => typeof value === "string")
+  const response = isRecord(decoded.response) ? decoded.response : undefined
+  const responseError = isRecord(response?.error) ? response.error : undefined
+  return [
+    decoded.code,
+    decoded.status,
+    error?.code,
+    error?.type,
+    error?.status,
+    responseError?.code,
+    responseError?.type,
+  ].filter((value): value is string => typeof value === "string")
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

packages/ai/src/route/executor.ts

@@ -240,7 +240,32 @@ const statusError =
       })
     })
 
-const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: unknown) => {
+const TIMEOUT_CODES = new Set([
+  "ETIMEDOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+])
+
+const errorCause = (error: unknown) => {
+  if (HttpClientError.isHttpClientError(error) && "cause" in error.reason) return error.reason.cause
+  return error instanceof Error ? error.cause : undefined
+}
+
+const errorCode = (error: unknown) => {
+  if (typeof error !== "object" || error === null) return undefined
+  const code = Reflect.get(error, "code")
+  return typeof code === "string" ? code.toUpperCase() : undefined
+}
+
+const errorMessage = (error: unknown, fallback: string) => {
+  const cause = errorCause(error)
+  if (cause instanceof Error) return cause.message
+  if (error instanceof Error) return error.message
+  return fallback
+}
+
+export const mapHttpClientError = (error: unknown, redactedNames: ReadonlyArray<string | RegExp>) => {
   const transportError = (input: {
     readonly message: string
     readonly kind?: string | undefined
@@ -257,23 +282,30 @@ const toHttpError = (redactedNames: ReadonlyArray<string | RegExp>) => (error: u
       }),
     })
 
-  if (Cause.isTimeoutError(error)) {
-    return transportError({ message: error.message, kind: "Timeout" })
-  }
+  const cause = errorCause(error)
+  const code = errorCode(cause) ?? errorCode(error)
+  const request = HttpClientError.isHttpClientError(error) ? error.request : undefined
+  if (
+    Cause.isTimeoutError(error) ||
+    Cause.isTimeoutError(cause) ||
+    (error instanceof Error && error.name === "TimeoutError") ||
+    (cause instanceof Error && cause.name === "TimeoutError") ||
+    (code !== undefined && TIMEOUT_CODES.has(code))
+  )
+    return transportError({ message: errorMessage(error, "HTTP transport timed out"), kind: code ?? "Timeout", request })
   if (!HttpClientError.isHttpClientError(error)) {
-    return transportError({ message: "HTTP transport failed" })
+    return transportError({ message: errorMessage(error, "HTTP transport failed"), kind: code })
   }
-  const request = "request" in error ? error.request : undefined
   if (error.reason._tag === "TransportError") {
     return transportError({
-      message: error.reason.description ?? "HTTP transport failed",
-      kind: error.reason._tag,
+      message: error.reason.description ?? errorMessage(error, "HTTP transport failed"),
+      kind: code ?? error.reason._tag,
       request,
     })
   }
   return transportError({
-    message: `HTTP transport failed: ${error.reason._tag}`,
-    kind: error.reason._tag,
+    message: errorMessage(error, `HTTP transport failed: ${error.reason._tag}`),
+    kind: code ?? error.reason._tag,
     request,
   })
 }
@@ -287,7 +319,10 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
         const redactedNames = yield* Headers.CurrentRedactedNames
         return yield* http
           .execute(request)
-          .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)))
+          .pipe(
+            Effect.mapError((error) => mapHttpClientError(error, redactedNames)),
+            Effect.flatMap(statusError(request, redactedNames)),
+          )
       })
     return Service.of({
       execute: executeOnce,

packages/ai/src/route/index.ts

@@ -9,7 +9,8 @@ export type {
   Interface as LLMClientShape,
   Service as LLMClientService,
 } from "./client"
-export * from "./executor"
+export { RequestExecutor, Service, fetchLayer, layer } from "./executor"
+export type { Interface } from "./executor"
 export { Auth } from "./auth"
 export { AuthOptions } from "./auth-options"
 export { Endpoint } from "./endpoint"

packages/ai/src/route/transport/http.ts

@@ -6,6 +6,7 @@ import { Framing } from "../framing"
 import type { Transport, TransportPrepareInput } from "./index"
 import * as ProviderShared from "../../protocols/shared"
 import { mergeJsonRecords, type LLMRequest } from "../../schema"
+import { mapHttpClientError } from "../executor"
 
 export type JsonRequestInput<Body> = TransportPrepareInput<Body>
 
@@ -134,14 +135,10 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
         .execute(prepared.request)
         .pipe(
           Effect.map((response) =>
-            prepared.framing.frame(
-              response.stream.pipe(
-                Stream.mapError((error) =>
-                  ProviderShared.eventError(
-                    `${request.model.provider}/${request.model.route.id}`,
-                    `Failed to read ${request.model.provider}/${request.model.route.id} stream`,
-                    ProviderShared.errorText(error),
-                  ),
+            Stream.unwrap(
+              Effect.map(Headers.CurrentRedactedNames, (redactedNames) =>
+                prepared.framing.frame(
+                  response.stream.pipe(Stream.mapError((error) => mapHttpClientError(error, redactedNames))),
                 ),
               ),
             ),

packages/ai/test/executor.test.ts

@@ -121,6 +121,7 @@ describe("RequestExecutor", () => {
       yield* classify("Request rate increased too quickly")
       yield* classify('{"type":"error","error":{"type":"too_many_requests"}}')
       yield* classify('{"type":"error","error":{"code":"rate_limit_exceeded"}}')
+      yield* classify('{"code":"resource_exhausted"}')
     }),
   )
 
@@ -135,7 +136,6 @@ describe("RequestExecutor", () => {
           expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
         }).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))
 
-      yield* classify('{"code":"resource_exhausted"}')
       yield* classify('{"code":"service_unavailable"}')
     }),
   )

packages/ai/test/lib/http.ts

@@ -63,14 +63,14 @@ export const dynamicResponse = (handler: Handler) => runtimeLayer(handlerLayer(h
  * Layer that emits the supplied SSE chunks and then aborts mid-stream. Used to
  * exercise transport errors that surface during parsing.
  */
-export const truncatedStream = (chunks: ReadonlyArray<string>) =>
+export const truncatedStream = (chunks: ReadonlyArray<string>, error: unknown = new Error("connection reset")) =>
   dynamicResponse((input) =>
     Effect.sync(() => {
       const encoder = new TextEncoder()
       const stream = new ReadableStream({
         start(controller) {
           for (const chunk of chunks) controller.enqueue(encoder.encode(chunk))
-          controller.error(new Error("connection reset"))
+          controller.error(error)
         },
       })
       return input.respond(stream, { headers: SSE_HEADERS })

packages/ai/test/provider-error.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { isContextOverflow } from "../src"
+import { HttpContext, HttpRequestDetails, isContextOverflow } from "../src"
 import { classifyProviderFailure } from "../src/provider-error"
 
 describe("provider error classification", () => {
@@ -7,6 +7,33 @@ describe("provider error classification", () => {
     expect(isContextOverflow("tokens in request more than max tokens allowed")).toBe(true)
   })
 
+  test("checks overflow evidence in the message when the response body is uninformative", () => {
+    expect(
+      classifyProviderFailure({
+        message: "Input is too long for requested model",
+        status: 400,
+        http: new HttpContext({
+          request: new HttpRequestDetails({ method: "POST", url: "https://provider.test", headers: {} }),
+          body: "{}",
+        }),
+      }),
+    ).toMatchObject({ classification: "context-overflow" })
+  })
+
+  test("lets semantic invalid-request codes override server status", () => {
+    expect(classifyProviderFailure({ message: "too large", status: 500, code: "request_too_large" })._tag).toBe(
+      "InvalidRequest",
+    )
+  })
+
+  test("does not treat incidental safety text as a content-policy failure", () => {
+    expect(classifyProviderFailure({ message: "Internal safety check failed", status: 500 })._tag).toBe(
+      "ProviderInternal",
+    )
+    expect(classifyProviderFailure({ message: "Blocked by safety policy", status: 400 })._tag).toBe("ContentPolicy")
+    expect(classifyProviderFailure({ message: "Blocked", status: 400, code: "SAFETY" })._tag).toBe("ContentPolicy")
+  })
+
   test("classifies V1 plain-text rate limit fallbacks", () => {
     expect(
       [
@@ -28,12 +55,48 @@ describe("provider error classification", () => {
     ).toEqual(["RateLimit", "RateLimit", "RateLimit", "RateLimit"])
   })
 
-  test("classifies V1 overloaded provider codes", () => {
+  test("classifies canonical provider retry codes", () => {
     expect(
       ['{"code":"resource_exhausted"}', '{"code":"service_unavailable"}'].map(
         (message) => classifyProviderFailure({ message })._tag,
       ),
-    ).toEqual(["ProviderInternal", "ProviderInternal"])
+    ).toEqual(["RateLimit", "ProviderInternal"])
+  })
+
+  test("keeps temporary per-minute quota wording retryable", () => {
+    expect(classifyProviderFailure({ message: "You exceeded your per-minute quota", status: 429 })._tag).toBe(
+      "RateLimit",
+    )
+  })
+
+  test("classifies canonical Google error codes", () => {
+    expect(
+      ["UNAUTHENTICATED", "PERMISSION_DENIED", "INVALID_ARGUMENT", "NOT_FOUND", "INTERNAL"].map(
+        (code) => classifyProviderFailure({ message: "Provider failed", code })._tag,
+      ),
+    ).toEqual(["Authentication", "Authentication", "InvalidRequest", "InvalidRequest", "ProviderInternal"])
+  })
+
+  test("classifies stripped Bedrock stream errors from their messages", () => {
+    expect(
+      ["Internal server error", "Throttling exception", "Validation error: invalid input"].map(
+        (message) => classifyProviderFailure({ message })._tag,
+      ),
+    ).toEqual(["ProviderInternal", "RateLimit", "InvalidRequest"])
+  })
+
+  test("classifies documented Bedrock exception codes", () => {
+    expect(
+      ["accessDeniedException", "modelTimeoutException", "resourceNotFoundException"].map(
+        (code) => classifyProviderFailure({ message: "Bedrock failed", code })._tag,
+      ),
+    ).toEqual(["Authentication", "ProviderInternal", "InvalidRequest"])
+  })
+
+  test("classifies Anthropic not-found stream errors as invalid requests", () => {
+    expect(classifyProviderFailure({ message: "Model unavailable", code: "not_found_error" })._tag).toBe(
+      "InvalidRequest",
+    )
   })
 
   test("classifies nested provider codes when a top-level code is also present", () => {
@@ -42,8 +105,9 @@ describe("provider error classification", () => {
         '{"code":"bad_request","error":{"code":"usage_not_included"}}',
         '{"code":"bad_request","error":{"code":"server_error"}}',
         '{"code":"bad_request","error":{"type":"invalid_request_error"}}',
+        '{"type":"response.failed","response":{"error":{"code":"server_error"}}}',
       ].map((message) => classifyProviderFailure({ message })._tag),
-    ).toEqual(["QuotaExceeded", "ProviderInternal", "InvalidRequest"])
+    ).toEqual(["QuotaExceeded", "ProviderInternal", "InvalidRequest", "ProviderInternal"])
   })
 
   test("keeps unknown and malformed provider payloads non-retryable", () => {

packages/ai/test/provider/bedrock-converse.test.ts

@@ -6,6 +6,7 @@ import { CacheHint, LLM, Message, ToolCallPart, ToolChoice } from "../../src"
 import { LLMClient } from "../../src/route"
 import { AmazonBedrock } from "../../src/providers"
 import * as BedrockConverse from "../../src/protocols/bedrock-converse"
+import { BedrockEventStream } from "../../src/protocols/bedrock-event-stream"
 import { it } from "../lib/effect"
 import { fixedResponse } from "../lib/http"
 import {
@@ -34,6 +35,16 @@ const eventFrame = (type: string, payload: object) =>
     body: utf8Encoder.encode(JSON.stringify(payload)),
   })
 
+const exceptionFrame = (type: string, payload: object) =>
+  codec.encode({
+    headers: {
+      ":message-type": { type: "string", value: "exception" },
+      ":exception-type": { type: "string", value: type },
+      ":content-type": { type: "string", value: "application/json" },
+    },
+    body: utf8Encoder.encode(JSON.stringify(payload)),
+  })
+
 const concat = (frames: ReadonlyArray<Uint8Array>) => {
   const total = frames.reduce((sum, frame) => sum + frame.length, 0)
   const out = new Uint8Array(total)
@@ -48,6 +59,8 @@ const concat = (frames: ReadonlyArray<Uint8Array>) => {
 const eventStreamBody = (...payloads: ReadonlyArray<readonly [string, object]>) =>
   concat(payloads.map(([type, payload]) => eventFrame(type, payload)))
 
+const exceptionStreamBody = (type: string, payload: object) => exceptionFrame(type, payload)
+
 // Override the default SSE content-type with the binary event-stream type so
 // the cassette layer treats the body as bytes when recording.
 const fixedBytes = (bytes: Uint8Array) =>
@@ -357,10 +370,10 @@ describe("Bedrock Converse route", () => {
 
   it.effect("classifies throttlingException as a rate limit", () =>
     Effect.gen(function* () {
-      const body = eventStreamBody(
-        ["messageStart", { role: "assistant" }],
-        ["throttlingException", { message: "Slow down" }],
-      )
+      const body = concat([
+        eventStreamBody(["messageStart", { role: "assistant" }]),
+        exceptionStreamBody("throttlingException", { message: "Slow down" }),
+      ])
       const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)
 
       expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "Slow down" })
@@ -371,7 +384,7 @@ describe("Bedrock Converse route", () => {
     Effect.gen(function* () {
       const error = yield* LLMClient.generate(baseRequest).pipe(
         Effect.provide(
-          fixedBytes(eventStreamBody(["validationException", { message: "Input is too long for requested model" }])),
+          fixedBytes(exceptionStreamBody("validationException", { message: "Input is too long for requested model" })),
         ),
         Effect.flip,
       )
@@ -384,6 +397,35 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
+  it.effect("fails monitored AI SDK bodies on exception wire frames", () =>
+    Effect.gen(function* () {
+      const response = BedrockEventStream.monitorExceptions(
+        new Response(exceptionStreamBody("throttlingException", { message: "Slow down" }), {
+          headers: { "content-type": "application/vnd.amazon.eventstream" },
+        }),
+      )
+      const error = yield* Effect.tryPromise({
+        try: () => response.arrayBuffer(),
+        catch: (error) => error,
+      }).pipe(Effect.flip)
+
+      expect(error).toMatchObject({ code: "throttlingException", message: "Slow down" })
+    }),
+  )
+
+  it.effect("classifies serviceUnavailableException wire frames as provider failures", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(baseRequest).pipe(
+        Effect.provide(
+          fixedBytes(exceptionStreamBody("serviceUnavailableException", { message: "Service unavailable" })),
+        ),
+        Effect.flip,
+      )
+
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "Service unavailable" })
+    }),
+  )
+
   it.effect("rejects requests with no auth path", () =>
     Effect.gen(function* () {
       const unsignedModel = AmazonBedrock.configure({

packages/ai/test/provider/openai-chat.test.ts

@@ -651,7 +651,22 @@ describe("OpenAI Chat route", () => {
       ])
       const error = yield* LLMClient.generate(request).pipe(Effect.provide(layer), Effect.flip)
 
-      expect(error.message).toContain("Failed to read openai/openai-chat stream")
+      expect(error).toMatchObject({ reason: { _tag: "Transport", message: "connection reset" } })
+    }),
+  )
+
+  it.effect("classifies response body timeouts as transport timeouts", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          truncatedStream([], Object.assign(new Error("body timed out"), { code: "UND_ERR_BODY_TIMEOUT" })),
+        ),
+        Effect.flip,
+      )
+
+      expect(error).toMatchObject({
+        reason: { _tag: "Transport", kind: "UND_ERR_BODY_TIMEOUT", message: "body timed out" },
+      })
     }),
   )
 

packages/core/src/aisdk.ts

@@ -1,28 +1,45 @@
 export * as AISDK from "./aisdk"
 
 import { makeLocationNode } from "./effect/app-node"
-import type {
-  JSONSchema7,
-  JSONValue,
-  LanguageModelV3,
-  LanguageModelV3CallOptions,
-  LanguageModelV3FinishReason,
-  LanguageModelV3FunctionTool,
-  LanguageModelV3Message,
-  LanguageModelV3Prompt,
-  LanguageModelV3StreamPart,
-  LanguageModelV3ToolChoice,
-  SharedV3ProviderOptions,
+import {
+  APICallError,
+  EmptyResponseBodyError,
+  InvalidArgumentError,
+  InvalidPromptError,
+  InvalidResponseDataError,
+  JSONParseError,
+  LoadAPIKeyError,
+  LoadSettingError,
+  NoContentGeneratedError,
+  NoSuchModelError,
+  TypeValidationError,
+  UnsupportedFunctionalityError,
+  type JSONSchema7,
+  type JSONValue,
+  type LanguageModelV3,
+  type LanguageModelV3CallOptions,
+  type LanguageModelV3FinishReason,
+  type LanguageModelV3FunctionTool,
+  type LanguageModelV3Message,
+  type LanguageModelV3Prompt,
+  type LanguageModelV3StreamPart,
+  type LanguageModelV3ToolChoice,
+  type SharedV3ProviderOptions,
 } from "@ai-sdk/provider"
 import {
+  AuthenticationReason,
+  classifyProviderFailure,
   FinishReason,
+  InvalidRequestReason,
   InvalidProviderOutputReason,
   LLMEvent,
   LLMError,
   Model,
   ProviderID,
+  ProviderInternalReason,
   ProviderMetadata,
   ToolResultValue,
+  TransportReason,
   UnknownProviderReason,
   type ContentPart,
   type LLMRequest,
@@ -30,6 +47,7 @@ import {
   type UsageInput,
 } from "@opencode-ai/ai"
 import { Auth, Endpoint, type AnyRoute } from "@opencode-ai/ai/route"
+import { BedrockEventStream } from "@opencode-ai/ai/protocols/bedrock-event-stream"
 import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream } from "effect"
 import { ModelV2 } from "./model"
 import { ProviderV2 } from "./provider"
@@ -40,6 +58,8 @@ type UserContent = Extract<LanguageModelV3Message, { role: "user" }>["content"]
 type AssistantContent = Extract<LanguageModelV3Message, { role: "assistant" }>["content"]
 type ToolResultContent = Extract<AssistantContent[number], { type: "tool-result" }>
 
+class ChunkTimeoutError extends Error {}
+
 export interface SDKEvent {
   readonly model: ModelV2.Info
   readonly package: string
@@ -64,7 +84,7 @@ function wrapSSE(res: Response, ms: number, ctl: AbortController) {
     async pull(ctrl) {
       const part = await new Promise<Awaited<ReturnType<typeof reader.read>>>((resolve, reject) => {
         const id = setTimeout(() => {
-          const err = new Error("SSE read timed out")
+          const err = new ChunkTimeoutError("SSE read timed out")
           ctl.abort(err)
           void reader.cancel(err)
           reject(err)
@@ -153,8 +173,9 @@ function prepareOptions(model: ModelV2.Info, pkg: string) {
       ...opts,
       timeout: false,
     })
-    if (!chunkAbortCtl || typeof chunkTimeout !== "number") return res
-    return wrapSSE(res, chunkTimeout, chunkAbortCtl)
+    const response = pkg === "@ai-sdk/amazon-bedrock" ? BedrockEventStream.monitorExceptions(res) : res
+    if (!chunkAbortCtl || typeof chunkTimeout !== "number") return response
+    return wrapSSE(response, chunkTimeout, chunkAbortCtl)
   }
 
   return options
@@ -716,10 +737,41 @@ function messageValue(input: unknown) {
 }
 
 function llmError(method: string, error: unknown) {
-  const reason =
-    error instanceof LLMError
-      ? new InvalidProviderOutputReason({ message: error.message })
-      : new UnknownProviderReason({ message: error instanceof Error ? error.message : String(error) })
+  if (error instanceof LLMError) return error
+  const cause = error instanceof Error ? error.cause : undefined
+  const failures = [error, cause]
+  const code = failures.map(machineCode).find((value) => value !== undefined)
+  const providerCode = apiFailureCode(error)?.toLowerCase()
+  const reason = (() => {
+    if (
+      error instanceof ChunkTimeoutError ||
+      failures.some((failure) => failure instanceof Error && failure.name === "TimeoutError") ||
+      providerCode === "timeout_error" ||
+      (code !== undefined && TRANSPORT_TIMEOUT_CODES.has(code))
+    )
+      return new TransportReason({ message: errorMessage(error), kind: code ?? "Timeout" })
+    if (APICallError.isInstance(error)) return apiCallReason(error)
+    if (code !== undefined && TRANSPORT_CONNECTION_CODES.has(code))
+      return new TransportReason({ message: errorMessage(error), kind: code })
+    const malformed = failures.find(isMalformedError)
+    if (malformed) return new InvalidProviderOutputReason({ message: malformed.message })
+    if (LoadAPIKeyError.isInstance(error)) return new AuthenticationReason({ message: error.message, kind: "missing" })
+    if (NoSuchModelError.isInstance(error)) return new InvalidRequestReason({ message: error.message })
+    if (
+      LoadSettingError.isInstance(error) ||
+      InvalidPromptError.isInstance(error) ||
+      InvalidArgumentError.isInstance(error) ||
+      UnsupportedFunctionalityError.isInstance(error)
+    )
+      return new InvalidRequestReason({ message: error.message })
+    const providerReason = classifyProviderFailure({
+      message: apiFailureMessage(error),
+      code: apiFailureCode(error),
+      status: apiFailureStatus(error),
+    })
+    if (providerReason._tag !== "UnknownProvider") return providerReason
+    return new UnknownProviderReason({ message: errorMessage(error) })
+  })()
   return new LLMError({
     module: "AISDK",
     method,
@@ -727,4 +779,133 @@ function llmError(method: string, error: unknown) {
   })
 }
 
+function apiCallReason(error: APICallError) {
+  const malformed = isMalformedError(error.cause) ? error.cause : undefined
+  if (error.statusCode !== undefined && error.statusCode < 400 && malformed)
+    return new InvalidProviderOutputReason({ message: malformed.message })
+  const evidence = apiFailureEvidence(error.responseBody)
+  const code = apiFailureCode(error.data) ?? apiFailureCode(evidence)
+  if (error.statusCode === undefined) {
+    const reason =
+      code === undefined && evidence === undefined
+        ? undefined
+        : classifyProviderFailure({ message: error.message, code, evidence })
+    if (reason && reason._tag !== "UnknownProvider") return reason
+    if (error.isRetryable) return new TransportReason({ message: error.message })
+    return reason ?? new UnknownProviderReason({ message: error.message })
+  }
+  const retryAfter = retryAfterMs(error.responseHeaders)
+  const reason = classifyProviderFailure({
+    message: error.message,
+    evidence,
+    status: error.statusCode,
+    code,
+    retryAfterMs: retryAfter,
+  })
+  if (!error.isRetryable || (reason._tag !== "UnknownProvider" && reason._tag !== "InvalidRequest")) return reason
+  if (classifyProviderFailure({ message: error.message, evidence, code })._tag !== "UnknownProvider") return reason
+  return new ProviderInternalReason({ message: error.message, status: error.statusCode, retryAfterMs: retryAfter })
+}
+
+const TRANSPORT_TIMEOUT_CODES = new Set([
+  "ETIMEDOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+])
+const TRANSPORT_CONNECTION_CODES = new Set([
+  "CONNECTIONCLOSED",
+  "CONNECTIONREFUSED",
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "EPIPE",
+  "FAILEDTOOPENSOCKET",
+  "UND_ERR_SOCKET",
+])
+const FAILURE_EVIDENCE_LIMIT = 65_536
+
+function field(error: unknown, name: string) {
+  return typeof error === "object" && error !== null ? Reflect.get(error, name) : undefined
+}
+
+function machineCode(error: unknown) {
+  const code = field(error, "code")
+  return typeof code === "string" ? code.toUpperCase() : undefined
+}
+
+function apiFailureCode(error: unknown): string | undefined {
+  if (typeof error === "string") {
+    const decoded = Option.getOrUndefined(Schema.decodeUnknownOption(Schema.UnknownFromJsonString)(error))
+    return apiFailureCode(decoded)
+  }
+  const nested = field(error, "error") ?? field(field(error, "response"), "error")
+  const nestedCode = nested === undefined || nested === error ? undefined : apiFailureCode(nested)
+  if (nestedCode) return nestedCode
+  if (typeof field(error, "originalMessage") === "string" && typeof field(error, "originalStatusCode") === "number")
+    return "modelstreamerrorexception"
+  const code = field(error, "code")
+  if (typeof code === "string" || typeof code === "number") return String(code)
+  const status = field(error, "status")
+  if (typeof status === "string") return status
+  const type = field(error, "type")
+  if (typeof type === "string" && type !== "error") return type
+}
+
+function apiFailureMessage(error: unknown): string {
+  const message = field(error, "message")
+  if (typeof message === "string") return message
+  const originalMessage = field(error, "originalMessage")
+  if (typeof originalMessage === "string") return originalMessage
+  const nested = field(error, "error") ?? field(field(error, "response"), "error")
+  return nested === undefined || nested === error ? String(error) : apiFailureMessage(nested)
+}
+
+function apiFailureStatus(error: unknown): number | undefined {
+  const status = field(error, "status")
+  const statusCode = field(error, "statusCode")
+  const originalStatusCode = field(error, "originalStatusCode")
+  const code = field(error, "code")
+  const value = [status, statusCode, originalStatusCode, code]
+    .map((value) => (typeof value === "number" ? value : typeof value === "string" ? Number(value) : undefined))
+    .find((value) => value !== undefined && Number.isInteger(value) && value >= 400 && value < 600)
+  if (value !== undefined) return value
+  const nested = field(error, "error") ?? field(field(error, "response"), "error")
+  return nested === undefined || nested === error ? undefined : apiFailureStatus(nested)
+}
+
+function apiFailureEvidence(error: string | undefined) {
+  return error === undefined ? undefined : error.slice(0, FAILURE_EVIDENCE_LIMIT)
+}
+
+function retryAfterMs(headers: Record<string, string> | undefined) {
+  if (!headers) return undefined
+  const normalized = Object.fromEntries(Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value]))
+  const millis = Number(normalized["retry-after-ms"])
+  if (Number.isFinite(millis)) return Math.max(0, millis)
+  const value = normalized["retry-after"]
+  if (!value) return undefined
+  const seconds = Number(value)
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000)
+  const date = Date.parse(value)
+  return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now())
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function isMalformedError(error: unknown): error is Error {
+  return (
+    InvalidResponseDataError.isInstance(error) ||
+    JSONParseError.isInstance(error) ||
+    TypeValidationError.isInstance(error) ||
+    EmptyResponseBodyError.isInstance(error) ||
+    NoContentGeneratedError.isInstance(error)
+  )
+}
+
 export const node = makeLocationNode({ service: Service, layer: locationLayer, deps: [] })

packages/core/test/aisdk.test.ts

@@ -1,11 +1,19 @@
-import type { LanguageModelV3CallOptions } from "@ai-sdk/provider"
+import {
+  APICallError,
+  InvalidPromptError,
+  InvalidResponseDataError,
+  LoadAPIKeyError,
+  type LanguageModelV3,
+  type LanguageModelV3CallOptions,
+  type LanguageModelV3StreamPart,
+} from "@ai-sdk/provider"
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { LLM, Message } from "@opencode-ai/ai"
+import { InvalidRequestReason, LLM, LLMError, Message } from "@opencode-ai/ai"
 import { LLMClient } from "@opencode-ai/ai/route"
 import { expect } from "bun:test"
-import { Effect } from "effect"
+import { Effect, Stream } from "effect"
 import { testEffect } from "./lib/effect"
 
 const it = testEffect(AISDK.locationLayer)
@@ -19,6 +27,49 @@ const model = (packageName: string, settings: Record<string, unknown> = {}) =>
     limit: { context: 100, output: 20 },
   })
 
+const failingLanguage = (error: unknown): LanguageModelV3 => ({
+  specificationVersion: "v3",
+  provider: "test-provider",
+  modelId: "api-model",
+  supportedUrls: {},
+  doGenerate: async () => {
+    throw error
+  },
+  doStream: async () => {
+    throw error
+  },
+})
+
+const streamingLanguage = (...events: LanguageModelV3StreamPart[]): LanguageModelV3 => ({
+  ...failingLanguage(new Error("unused")),
+  doStream: async () => ({
+    stream: new ReadableStream<LanguageModelV3StreamPart>({
+      start(controller) {
+        events.forEach((event) => controller.enqueue(event))
+        controller.close()
+      },
+    }),
+    request: { body: {} },
+  }),
+})
+
+const streamFailure = (language: LanguageModelV3) =>
+  Effect.gen(function* () {
+    const aisdk = yield* AISDK.Service
+    yield* aisdk.hook.sdk((event) => {
+      event.sdk = {}
+    })
+    yield* aisdk.hook.language((event) => {
+      event.language = language
+    })
+    const resolved = yield* aisdk.model(model("@ai-sdk/openai"))
+    const request = LLM.request({ model: resolved, prompt: "Hello" })
+    const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(request)
+    return yield* resolved.route
+      .streamPrepared(prepared.body, request, { http: { execute: () => Effect.die("unused") } })
+      .pipe(Stream.runDrain, Effect.flip)
+  })
+
 it.effect("keys language models by package and flattened overlays", () =>
   Effect.gen(function* () {
     const aisdk = yield* AISDK.Service
@@ -238,3 +289,403 @@ it.effect("projects replay metadata onto AI SDK prompt parts", () =>
     ])
   }),
 )
+
+it.effect("classifies AI SDK API failures", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Bad Request",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 400,
+          responseBody: '{"error":{"code":"insufficient_quota","detail":"quota-body-secret"}}',
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "QuotaExceeded" } })
+    expect("http" in error.reason ? error.reason.http : undefined).toBeUndefined()
+    expect(JSON.stringify(error)).not.toContain("quota-body-secret")
+  }),
+)
+
+it.effect("keeps retryable quota responses terminal", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Quota exceeded",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 429,
+          responseBody: '{"error":{"code":"insufficient_quota"}}',
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "QuotaExceeded" } })
+  }),
+)
+
+it.effect("uses response bodies as transient classification evidence", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Bad Request",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 400,
+          responseBody: "Input is too long for requested model overflow-body-secret",
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "InvalidRequest", classification: "context-overflow" } })
+    expect("http" in error.reason ? error.reason.http : undefined).toBeUndefined()
+    expect(JSON.stringify(error)).not.toContain("overflow-body-secret")
+  }),
+)
+
+it.effect("honors retryable AI SDK request timeouts", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "HTTP 408",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 408,
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 408 } })
+  }),
+)
+
+it.effect("honors retryable AI SDK conflicts", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "HTTP 409",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 409,
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 409 } })
+  }),
+)
+
+it.effect("keeps semantic invalid requests terminal on retryable statuses", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Conflict",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 409,
+          responseBody: '{"error":{"code":"request_too_large"}}',
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" } })
+  }),
+)
+
+it.effect("retries unknown coded conflicts", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Conflict",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 409,
+          responseBody: '{"error":{"code":"conflict"}}',
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 409 } })
+  }),
+)
+
+it.effect("preserves AI SDK retry delays without HTTP diagnostics", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Too Many Requests",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 429,
+          responseHeaders: { "Retry-After-Ms": "250" },
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "RateLimit", retryAfterMs: 250 } })
+    expect("http" in error.reason ? error.reason.http : undefined).toBeUndefined()
+  }),
+)
+
+it.effect("classifies statusless retryable API failures as transport failures", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Cannot connect to API",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          isRetryable: true,
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "Transport" } })
+  }),
+)
+
+it.effect("classifies AI SDK timeouts", () =>
+  Effect.gen(function* () {
+    const timeout = yield* streamFailure(failingLanguage(new DOMException("timed out", "TimeoutError")))
+
+    expect(timeout).toMatchObject({ reason: { _tag: "Transport", kind: "Timeout" } })
+  }),
+)
+
+it.effect("classifies AI SDK connection failures", () =>
+  Effect.gen(function* () {
+    const reset = yield* streamFailure(
+      failingLanguage(Object.assign(new Error("connection reset"), { code: "ECONNRESET" })),
+    )
+
+    expect(reset).toMatchObject({ reason: { _tag: "Transport", kind: "ECONNRESET" } })
+  }),
+)
+
+it.effect("classifies Bun connection failures", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(Object.assign(new Error("connection refused"), { code: "ConnectionRefused" })),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "Transport", kind: "CONNECTIONREFUSED" } })
+  }),
+)
+
+it.effect("classifies structured AI SDK stream errors", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({ type: "error", error: { type: "overloaded_error", message: "Overloaded" } }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", message: "Overloaded" } })
+  }),
+)
+
+it.effect("classifies AI Gateway errors with statusCode", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({
+        type: "error",
+        error: { type: "internal_server_error", message: "Gateway failed", statusCode: 503 },
+      }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 503 } })
+  }),
+)
+
+it.effect("classifies AI Gateway timeouts as retryable", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({
+        type: "error",
+        error: { type: "timeout_error", message: "Gateway timed out", statusCode: 408 },
+      }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "Transport", kind: "Timeout" } })
+  }),
+)
+
+it.effect("classifies stripped Bedrock model stream errors", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({
+        type: "error",
+        error: {
+          message: "The model stream failed",
+          originalMessage: "Upstream provider failed",
+          originalStatusCode: 424,
+        },
+      }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 424 } })
+  }),
+)
+
+it.effect("classifies structured stream messages without codes", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(streamingLanguage({ type: "error", error: { message: "Rate limit exceeded" } }))
+
+    expect(error).toMatchObject({ reason: { _tag: "RateLimit" } })
+  }),
+)
+
+it.effect("classifies nested OpenAI Responses stream errors", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({
+        type: "error",
+        error: {
+          type: "response.failed",
+          response: { error: { code: "server_error", message: "Provider failed" } },
+        },
+      }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", message: "Provider failed" } })
+  }),
+)
+
+it.effect("classifies numeric string stream statuses", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      streamingLanguage({ type: "error", error: { code: "503", message: "Unavailable" } }),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "ProviderInternal", status: 503 } })
+  }),
+)
+
+it.effect("classifies readable stream failures", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure({
+      ...failingLanguage(new Error("unused")),
+      doStream: async () => ({
+        stream: new ReadableStream<LanguageModelV3StreamPart>({
+          start(controller) {
+            controller.error(Object.assign(new Error("connection reset"), { code: "ECONNRESET" }))
+          },
+        }),
+        request: { body: {} },
+      }),
+    })
+
+    expect(error).toMatchObject({ method: "readStream", reason: { _tag: "Transport", kind: "ECONNRESET" } })
+  }),
+)
+
+it.live("times out stalled SSE chunks", () =>
+  Effect.acquireUseRelease(
+    Effect.sync(() =>
+      Bun.serve({
+        port: 0,
+        fetch: () =>
+          new Response(
+            new ReadableStream<Uint8Array>({
+              start(controller) {
+                controller.enqueue(new TextEncoder().encode(": connected\n\n"))
+              },
+            }),
+            { headers: { "content-type": "text/event-stream" } },
+          ),
+      }),
+    ),
+    (server) =>
+      Effect.gen(function* () {
+        const aisdk = yield* AISDK.Service
+        let wrappedFetch: typeof fetch | undefined
+        yield* aisdk.hook.sdk((event) => {
+          wrappedFetch = event.options.fetch
+          event.sdk = {}
+        })
+        yield* aisdk.hook.language((event) => {
+          event.language = {
+            ...failingLanguage(new Error("unused")),
+            doStream: async () => {
+              const fetcher = wrappedFetch
+              if (!fetcher) throw new Error("AI SDK fetch was not configured")
+              const response = await fetcher(server.url, { method: "POST" })
+              if (!response.body) throw new Error("AI SDK response body was missing")
+              return {
+                stream: response.body.pipeThrough(
+                  new TransformStream<Uint8Array, LanguageModelV3StreamPart>({ transform() {} }),
+                ),
+                request: { body: {} },
+              }
+            },
+          }
+        })
+        const resolved = yield* aisdk.model(model("@ai-sdk/openai", { chunkTimeout: 10 }))
+        const request = LLM.request({ model: resolved, prompt: "Hello" })
+        const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(request)
+        const error = yield* resolved.route
+          .streamPrepared(prepared.body, request, { http: { execute: () => Effect.die("unused") } })
+          .pipe(Stream.runDrain, Effect.flip)
+
+        expect(error).toMatchObject({ method: "readStream", reason: { _tag: "Transport", kind: "Timeout" } })
+      }),
+    (server) => Effect.promise(() => server.stop(true)),
+  ),
+)
+
+it.effect("classifies missing AI SDK API keys", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(failingLanguage(new LoadAPIKeyError({ message: "API key is missing" })))
+
+    expect(error).toMatchObject({ reason: { _tag: "Authentication", kind: "missing" } })
+  }),
+)
+
+it.effect("classifies invalid AI SDK prompts", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(new InvalidPromptError({ prompt: [], message: "unsupported prompt" })),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" } })
+  }),
+)
+
+it.effect("preserves existing LLM errors", () =>
+  Effect.gen(function* () {
+    const original = new LLMError({
+      module: "test",
+      method: "run",
+      reason: new InvalidRequestReason({ message: "invalid" }),
+    })
+    const error = yield* streamFailure(failingLanguage(original))
+
+    expect(error).toBe(original)
+  }),
+)
+
+it.effect("classifies malformed AI SDK response causes", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(
+      failingLanguage(
+        new APICallError({
+          message: "Failed to process response",
+          url: "https://provider.test/v1",
+          requestBodyValues: {},
+          statusCode: 200,
+          cause: new InvalidResponseDataError({ data: { invalid: true } }),
+        }),
+      ),
+    )
+
+    expect(error).toMatchObject({ reason: { _tag: "InvalidProviderOutput" } })
+  }),
+)