@opencode-ai/ai 0.0.0-beta-18387 → 0.0.0-beta-18593

package/dist/route/transport/websocket.js

@@ -1,14 +1,14 @@
 import { Cause, Effect, Queue, Stream } from "effect";
 import { Headers } from "effect/unstable/http";
 import { Socket } from "effect/unstable/socket";
-import { AIError, TransportReason } from "../../schema/index.js";
+import { AIError, AIErrorReason, TransportError, } from "../../schema/index.js";
 import * as HttpTransport from "./http.js";
 const MAX_FRAME_BYTES = 16 * 1024 * 1024;
-const transportError = (method, message, input) => new AIError({
-    module: "WebSocketConnector",
-    method,
-    reason: new TransportReason({
+const transportError = (message, input) => new AIError({
+    reason: new TransportError({
         message,
+        body: input.body,
+        cause: input.cause,
         transport: "websocket",
         operation: input.operation,
         url: input.url,
@@ -19,18 +19,12 @@ const transportError = (method, message, input) => new AIError({
 });
 const annotateTransportError = (error, input) => error.reason._tag === "Transport"
     ? new AIError({
-        module: error.module,
-        method: error.method,
-        reason: new TransportReason({
+        reason: new TransportError({
+            ...error.reason,
             message: error.reason.message,
-            transport: error.reason.transport,
-            operation: error.reason.operation,
-            code: error.reason.code,
-            url: error.reason.url,
-            http: error.reason.http,
+            cause: error.reason.cause,
             phase: input.phase,
             delivery: input.delivery,
-            recovery: error.reason.recovery,
         }),
     })
     : error;
@@ -52,7 +46,7 @@ const waitOpen = (ws, input) => {
     if (ws.readyState === globalThis.WebSocket.OPEN)
         return Effect.void;
     if (ws.readyState === globalThis.WebSocket.CLOSING || ws.readyState === globalThis.WebSocket.CLOSED) {
-        return Effect.fail(transportError("open", `WebSocket closed before opening (state ${ws.readyState})`, {
+        return Effect.fail(transportError(`WebSocket closed before opening (state ${ws.readyState})`, {
             url: input.url,
             operation: "request",
             code: "closed",
@@ -78,7 +72,8 @@ const waitOpen = (ws, input) => {
         };
         const onError = (event) => {
             cleanup();
-            resume(Effect.fail(transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, {
+            resume(Effect.fail(transportError(`Failed to open WebSocket: ${eventMessage(event)}`, {
+                cause: "error" in event ? (event.error ?? event) : event,
                 url: input.url,
                 operation: "request",
                 phase: "connect",
@@ -87,7 +82,9 @@ const waitOpen = (ws, input) => {
         };
         const onClose = (event) => {
             cleanup();
-            resume(Effect.fail(transportError("open", `WebSocket closed before opening with code ${event.code}`, {
+            resume(Effect.fail(transportError(`WebSocket closed before opening with code ${event.code}`, {
+                body: event.reason,
+                cause: event,
                 url: input.url,
                 operation: "request",
                 code: String(event.code),
@@ -114,7 +111,8 @@ export const toWebSocketUrl = (value) => Effect.try({
         }
         throw new Error(`Unsupported WebSocket URL protocol ${url.protocol}`);
     },
-    catch: (error) => transportError("prepare", error instanceof Error ? error.message : "Invalid WebSocket URL", {
+    catch: (error) => transportError(error instanceof Error ? error.message : "Invalid WebSocket URL", {
+        cause: error,
         url: value,
         operation: "request",
         code: "invalid-url",
@@ -131,7 +129,8 @@ export const open = (input) => Effect.gen(function* () {
         constructor(input.url, {
             headers: input.headers,
         }),
-        catch: (error) => transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
+        catch: (error) => transportError(error instanceof Error ? error.message : "Failed to construct WebSocket", {
+            cause: error,
             url: input.url,
             operation: "request",
             phase: "connect",
@@ -147,7 +146,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
     const rejectOversized = (message) => {
         if (!oversized(message))
             return false;
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", "WebSocket message exceeds the 16 MiB limit", {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError("WebSocket message exceeds the 16 MiB limit", {
+            body: typeof message === "string" ? message : new TextDecoder().decode(message),
             url: input.url,
             operation: "read",
             code: "message-too-large",
@@ -162,7 +162,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
             return;
         if (Queue.offerUnsafe(messages, message))
             return;
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", "WebSocket inbound queue overflow", {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError("WebSocket inbound queue overflow", {
+            body: typeof message === "string" ? message : new TextDecoder().decode(message),
             url: input.url,
             operation: "read",
             code: "queue-overflow",
@@ -175,7 +176,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
         const binary = binaryMessage(event.data);
         if (binary)
             return offer(binary);
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", "Unsupported WebSocket message payload", {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError("Unsupported WebSocket message payload", {
+            cause: event,
             url: input.url,
             operation: "read",
             code: "message",
@@ -183,7 +185,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
         })));
     };
     const onError = (event) => {
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", `WebSocket error: ${eventMessage(event)}`, {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError(`WebSocket error: ${eventMessage(event)}`, {
+            cause: "error" in event ? (event.error ?? event) : event,
             url: input.url,
             operation: "read",
             code: "message",
@@ -191,7 +194,9 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
         })));
     };
     const onClose = (event) => {
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", `WebSocket closed with code ${event.code}`, {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError(`WebSocket closed with code ${event.code}`, {
+            body: event.reason,
+            cause: event,
             url: input.url,
             operation: "read",
             code: String(event.code),
@@ -209,7 +214,7 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
     return {
         sendText: (message) => Effect.suspend(() => {
             if (ws.readyState !== globalThis.WebSocket.OPEN)
-                return Effect.fail(transportError("sendText", `WebSocket is not open (state ${ws.readyState})`, {
+                return Effect.fail(transportError(`WebSocket is not open (state ${ws.readyState})`, {
                     url: input.url,
                     operation: "write",
                     phase: "send",
@@ -217,7 +222,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
                 }));
             return Effect.try({
                 try: () => ws.send(message),
-                catch: (error) => transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
+                catch: (error) => transportError(error instanceof Error ? error.message : "Failed to send WebSocket message", {
+                    cause: error,
                     url: input.url,
                     operation: "write",
                     phase: "send",
@@ -246,17 +252,51 @@ export const makeDirect = (connector) => ({
             .open(exchange.connect)
             .pipe(Effect.mapError((error) => annotateTransportError(error, { phase: "connect", delivery: "not-sent" }))), (connection) => connection.close);
         const create = yield* exchange.driver.create(undefined);
-        yield* connection.sendText(create.message);
+        yield* connection.sendText(create.message).pipe(Effect.mapError((error) => new AIError({
+            reason: AIErrorReason.make({
+                ...error.reason,
+                message: error.reason.message,
+                cause: error.reason.cause,
+                http: error.reason.http ?? connection.http,
+            }),
+        })));
         const decoder = new TextDecoder();
         let observed = false;
         return {
+            http: connection.http,
             frames: connection.messages.pipe(Stream.map((message) => {
                 observed = true;
                 return messageText(message, decoder);
             }), Stream.mapError((error) => annotateTransportError(error, {
                 phase: error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
                 delivery: observed ? "accepted" : "ambiguous",
-            })), Stream.mapEffect((frame) => exchange.driver.observe(create, frame)), Stream.takeUntil(observationTerminal), Stream.mapEffect(observationFrame)),
+            })), Stream.mapEffect((frame) => exchange.driver.observe(create, frame).pipe(Effect.mapError((error) => new AIError({
+                reason: AIErrorReason.make({
+                    ...error.reason,
+                    message: error.reason.message,
+                    cause: error.reason.cause,
+                    body: frame,
+                }),
+            })), Effect.map((observation) => "error" in observation
+                ? {
+                    ...observation,
+                    error: new AIError({
+                        reason: AIErrorReason.make({
+                            ...observation.error.reason,
+                            message: observation.error.reason.message,
+                            cause: observation.error.reason.cause,
+                            body: frame,
+                        }),
+                    }),
+                }
+                : observation))), Stream.takeUntil(observationTerminal), Stream.mapEffect(observationFrame), Stream.mapError((error) => new AIError({
+                reason: AIErrorReason.make({
+                    ...error.reason,
+                    message: error.reason.message,
+                    cause: error.reason.cause,
+                    http: error.reason.http ?? connection.http,
+                }),
+            }))),
             complete: Effect.void,
         };
     }),
@@ -283,7 +323,7 @@ export const json = (input) => ({
     execute: (prepared, request, _runtime, options) => {
         const webSocket = options?.webSocket;
         if (!webSocket) {
-            return Effect.fail(transportError("json", "WebSocket JSON transport requires StreamOptions.webSocket", {
+            return Effect.fail(transportError("WebSocket JSON transport requires StreamOptions.webSocket", {
                 url: prepared.url,
                 operation: "request",
                 code: "unavailable",
@@ -298,7 +338,7 @@ export const json = (input) => ({
         const exchange = {
             id: request.id ?? "request",
             connect: { url: prepared.url, headers: prepared.headers },
-            fallback: () => Stream.fail(transportError("fallback", "WebSocket JSON transport does not provide HTTP fallback", {
+            fallback: () => Stream.fail(transportError("WebSocket JSON transport does not provide HTTP fallback", {
                 url: prepared.url,
                 operation: "request",
                 code: "websocket",

package/dist/schema/errors.d.ts

@@ -2,18 +2,12 @@ import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 export declare const ProviderFailureClassification: Schema.Literals<readonly ["context-overflow", "payload-too-large"]>;
 export type ProviderFailureClassification = typeof ProviderFailureClassification.Type;
-declare const HttpRequestDetails_base: Schema.Class<HttpRequestDetails, Schema.Struct<{
-    readonly method: Schema.String;
+declare const HttpContext_base: Schema.Class<HttpContext, Schema.Struct<{
     readonly url: Schema.String;
+    readonly status: Schema.Int;
     readonly headers: Schema.$Record<Schema.String, Schema.String>;
 }>, {}>;
-export declare class HttpRequestDetails extends HttpRequestDetails_base {
-}
-declare const HttpResponseDetails_base: Schema.Class<HttpResponseDetails, Schema.Struct<{
-    readonly status: Schema.Number;
-    readonly headers: Schema.$Record<Schema.String, Schema.String>;
-}>, {}>;
-export declare class HttpResponseDetails extends HttpResponseDetails_base {
+export declare class HttpContext extends HttpContext_base {
 }
 declare const HttpRateLimitDetails_base: Schema.Class<HttpRateLimitDetails, Schema.Struct<{
     readonly retryAfterMs: Schema.optional<Schema.Number>;
@@ -23,126 +17,114 @@ declare const HttpRateLimitDetails_base: Schema.Class<HttpRateLimitDetails, Sche
 }>, {}>;
 export declare class HttpRateLimitDetails extends HttpRateLimitDetails_base {
 }
-declare const HttpContext_base: Schema.Class<HttpContext, Schema.Struct<{
-    readonly request: typeof HttpRequestDetails;
-    readonly response: Schema.optional<typeof HttpResponseDetails>;
-    readonly body: Schema.optional<Schema.String>;
-    readonly bodyTruncated: Schema.optional<Schema.Boolean>;
-    readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
-}>, {}>;
-export declare class HttpContext extends HttpContext_base {
-}
-declare const InvalidRequestReason_base: Schema.Class<InvalidRequestReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"InvalidRequest">;
-    readonly message: Schema.String;
+declare const InvalidRequestError_base: Schema.Class<InvalidRequestError, Schema.TaggedStruct<"InvalidRequest", {
     readonly parameter: Schema.optional<Schema.String>;
     readonly classification: Schema.optional<Schema.Literals<readonly ["context-overflow", "payload-too-large"]>>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class InvalidRequestReason extends InvalidRequestReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidRequestError extends InvalidRequestError_base {
 }
-declare const NoRouteReason_base: Schema.Class<NoRouteReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"NoRoute">;
+declare const NoRouteError_base: Schema.Class<NoRouteError, Schema.TaggedStruct<"NoRoute", {
     readonly route: Schema.String;
     readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
     readonly model: Schema.brand<Schema.String, "AI.ModelID">;
-}>, {}>;
-export declare class NoRouteReason extends NoRouteReason_base {
-    get message(): string;
-}
-declare const AuthenticationReason_base: Schema.Class<AuthenticationReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"Authentication">;
     readonly message: Schema.String;
-    readonly kind: Schema.Literals<readonly ["missing", "invalid", "expired", "insufficient-permissions", "unknown"]>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class AuthenticationReason extends AuthenticationReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class NoRouteError extends NoRouteError_base {
 }
-declare const RateLimitReason_base: Schema.Class<RateLimitReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"RateLimit">;
-    readonly message: Schema.String;
+declare const AuthenticationError_base: Schema.Class<AuthenticationError, Schema.TaggedStruct<"Authentication", {
+    message: Schema.String;
+    body: Schema.optional<Schema.String>;
+    http: Schema.optional<typeof HttpContext>;
+    cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class AuthenticationError extends AuthenticationError_base {
+}
+declare const RateLimitError_base: Schema.Class<RateLimitError, Schema.TaggedStruct<"RateLimit", {
     readonly retryAfterMs: Schema.optional<Schema.Number>;
     readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
-    readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class RateLimitReason extends RateLimitReason_base {
-}
-declare const QuotaExceededReason_base: Schema.Class<QuotaExceededReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"QuotaExceeded">;
     readonly message: Schema.String;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class QuotaExceededReason extends QuotaExceededReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class RateLimitError extends RateLimitError_base {
 }
-declare const ContentPolicyReason_base: Schema.Class<ContentPolicyReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"ContentPolicy">;
-    readonly message: Schema.String;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
-    readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class ContentPolicyReason extends ContentPolicyReason_base {
+declare const QuotaExceededError_base: Schema.Class<QuotaExceededError, Schema.TaggedStruct<"QuotaExceeded", {
+    message: Schema.String;
+    body: Schema.optional<Schema.String>;
+    http: Schema.optional<typeof HttpContext>;
+    cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class QuotaExceededError extends QuotaExceededError_base {
 }
-declare const ProviderInternalReason_base: Schema.Class<ProviderInternalReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"ProviderInternal">;
-    readonly message: Schema.String;
-    readonly status: Schema.optional<Schema.Number>;
+declare const ContentPolicyError_base: Schema.Class<ContentPolicyError, Schema.TaggedStruct<"ContentPolicy", {
+    message: Schema.String;
+    body: Schema.optional<Schema.String>;
+    http: Schema.optional<typeof HttpContext>;
+    cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ContentPolicyError extends ContentPolicyError_base {
+}
+declare const ProviderInternalError_base: Schema.Class<ProviderInternalError, Schema.TaggedStruct<"ProviderInternal", {
     readonly retryAfterMs: Schema.optional<Schema.Number>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class ProviderInternalReason extends ProviderInternalReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProviderInternalError extends ProviderInternalError_base {
 }
 export declare const TransportType: Schema.Literals<readonly ["http", "websocket"]>;
 export type TransportType = typeof TransportType.Type;
 export declare const TransportOperation: Schema.Literals<readonly ["request", "read", "write"]>;
 export type TransportOperation = typeof TransportOperation.Type;
-declare const TransportReason_base: Schema.Class<TransportReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"Transport">;
-    readonly message: Schema.String;
+declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStruct<"Transport", {
     readonly transport: Schema.Literals<readonly ["http", "websocket"]>;
     readonly operation: Schema.Literals<readonly ["request", "read", "write"]>;
     readonly code: Schema.optional<Schema.String>;
     readonly url: Schema.optional<Schema.String>;
-    readonly http: Schema.optional<typeof HttpContext>;
     readonly phase: Schema.optional<Schema.Literals<readonly ["prepare", "queue", "connect", "send", "receive", "decode", "complete", "fallback", "close"]>>;
     readonly delivery: Schema.optional<Schema.Literals<readonly ["not-sent", "rejected", "ambiguous", "accepted"]>>;
     readonly recovery: Schema.optional<Schema.Literals<readonly ["retry-connect", "retry-full", "rotate-and-retry-full", "fallback-http", "fail"]>>;
-}>, {}>;
-export declare class TransportReason extends TransportReason_base {
-}
-declare const InvalidProviderOutputReason_base: Schema.Class<InvalidProviderOutputReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"InvalidProviderOutput">;
     readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
+    readonly http: Schema.optional<typeof HttpContext>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class TransportError extends TransportError_base {
+}
+declare const InvalidProviderOutputError_base: Schema.Class<InvalidProviderOutputError, Schema.TaggedStruct<"InvalidProviderOutput", {
     readonly classification: Schema.optional<Schema.Literals<readonly ["incomplete-stream"]>>;
     readonly route: Schema.optional<Schema.String>;
-    readonly raw: Schema.optional<Schema.String>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
-}>, {}>;
-export declare class InvalidProviderOutputReason extends InvalidProviderOutputReason_base {
-}
-declare const UnknownProviderReason_base: Schema.Class<UnknownProviderReason, Schema.Struct<{
-    readonly _tag: Schema.tag<"UnknownProvider">;
     readonly message: Schema.String;
-    readonly status: Schema.optional<Schema.Number>;
-    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly body: Schema.optional<Schema.String>;
     readonly http: Schema.optional<typeof HttpContext>;
-}>, {}>;
-export declare class UnknownProviderReason extends UnknownProviderReason_base {
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidProviderOutputError extends InvalidProviderOutputError_base {
 }
-export declare const AIErrorReason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestReason, typeof NoRouteReason, typeof AuthenticationReason, typeof RateLimitReason, typeof QuotaExceededReason, typeof ContentPolicyReason, typeof ProviderInternalReason, typeof TransportReason, typeof InvalidProviderOutputReason, typeof UnknownProviderReason]>;
+declare const UnknownProviderError_base: Schema.Class<UnknownProviderError, Schema.TaggedStruct<"UnknownProvider", {
+    message: Schema.String;
+    body: Schema.optional<Schema.String>;
+    http: Schema.optional<typeof HttpContext>;
+    cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnknownProviderError extends UnknownProviderError_base {
+}
+export declare const AIErrorReason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError]>;
 export type AIErrorReason = Schema.Schema.Type<typeof AIErrorReason>;
 declare const AIError_base: Schema.Class<AIError, Schema.TaggedStruct<"AI.Error", {
-    readonly module: Schema.String;
-    readonly method: Schema.String;
-    readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestReason, typeof NoRouteReason, typeof AuthenticationReason, typeof RateLimitReason, typeof QuotaExceededReason, typeof ContentPolicyReason, typeof ProviderInternalReason, typeof TransportReason, typeof InvalidProviderOutputReason, typeof UnknownProviderReason]>;
-    readonly body: Schema.optional<Schema.String>;
+    readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError]>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AIError extends AIError_base {
-    readonly cause: InvalidRequestReason | NoRouteReason | AuthenticationReason | RateLimitReason | QuotaExceededReason | ContentPolicyReason | ProviderInternalReason | TransportReason | InvalidProviderOutputReason | UnknownProviderReason;
+    readonly cause: InvalidRequestError | NoRouteError | AuthenticationError | RateLimitError | QuotaExceededError | ContentPolicyError | ProviderInternalError | TransportError | InvalidProviderOutputError | UnknownProviderError;
     get message(): string;
 }
 /**

package/dist/schema/errors.js

@@ -1,16 +1,10 @@
 import { Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { ModelID, ProviderID, RouteID } from "./ids.js";
-import { ProviderMetadata } from "./messages.js";
 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"]);
-export class HttpRequestDetails extends Schema.Class("AI.HttpRequestDetails")({
-    method: Schema.String,
+export class HttpContext extends Schema.Class("AI.HttpContext")({
     url: Schema.String,
-    headers: Schema.Record(Schema.String, Schema.String),
-}) {
-}
-export class HttpResponseDetails extends Schema.Class("AI.HttpResponseDetails")({
-    status: Schema.Number,
+    status: Schema.Int.check(Schema.isBetween({ minimum: 100, maximum: 599 })),
     headers: Schema.Record(Schema.String, Schema.String),
 }) {
 }
@@ -21,128 +15,82 @@ export class HttpRateLimitDetails extends Schema.Class("AI.HttpRateLimitDetails"
     reset: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 }) {
 }
-export class HttpContext extends Schema.Class("AI.HttpContext")({
-    request: HttpRequestDetails,
-    response: Schema.optional(HttpResponseDetails),
-    body: Schema.optional(Schema.String),
-    bodyTruncated: Schema.optional(Schema.Boolean),
-    rateLimit: Schema.optional(HttpRateLimitDetails),
-}) {
-}
-export class InvalidRequestReason extends Schema.Class("AI.Error.InvalidRequest")({
-    _tag: Schema.tag("InvalidRequest"),
+const ReasonFields = {
     message: Schema.String,
+    // Preserve the complete original response or triggering event before decoding narrows it.
+    body: Schema.optional(Schema.String),
+    http: Schema.optional(HttpContext),
+    cause: Schema.optional(Schema.Defect({ includeStack: true })),
+};
+export class InvalidRequestError extends Schema.TaggedError("AI.Error.InvalidRequest")("InvalidRequest", {
+    ...ReasonFields,
     parameter: Schema.optional(Schema.String),
     classification: Schema.optional(ProviderFailureClassification),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
 }) {
 }
-export class NoRouteReason extends Schema.Class("AI.Error.NoRoute")({
-    _tag: Schema.tag("NoRoute"),
+export class NoRouteError extends Schema.TaggedError("AI.Error.NoRoute")("NoRoute", {
+    ...ReasonFields,
     route: RouteID,
     provider: ProviderID,
     model: ModelID,
 }) {
-    get message() {
-        return `No AI route for ${this.provider}/${this.model} using ${this.route}`;
-    }
 }
-export class AuthenticationReason extends Schema.Class("AI.Error.Authentication")({
-    _tag: Schema.tag("Authentication"),
-    message: Schema.String,
-    kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
-}) {
+export class AuthenticationError extends Schema.TaggedError("AI.Error.Authentication")("Authentication", ReasonFields) {
 }
-export class RateLimitReason extends Schema.Class("AI.Error.RateLimit")({
-    _tag: Schema.tag("RateLimit"),
-    message: Schema.String,
+export class RateLimitError extends Schema.TaggedError("AI.Error.RateLimit")("RateLimit", {
+    ...ReasonFields,
     retryAfterMs: Schema.optional(Schema.Number),
     rateLimit: Schema.optional(HttpRateLimitDetails),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
 }) {
 }
-export class QuotaExceededReason extends Schema.Class("AI.Error.QuotaExceeded")({
-    _tag: Schema.tag("QuotaExceeded"),
-    message: Schema.String,
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
-}) {
+export class QuotaExceededError extends Schema.TaggedError("AI.Error.QuotaExceeded")("QuotaExceeded", ReasonFields) {
 }
-export class ContentPolicyReason extends Schema.Class("AI.Error.ContentPolicy")({
-    _tag: Schema.tag("ContentPolicy"),
-    message: Schema.String,
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
-}) {
+export class ContentPolicyError extends Schema.TaggedError("AI.Error.ContentPolicy")("ContentPolicy", ReasonFields) {
 }
-export class ProviderInternalReason extends Schema.Class("AI.Error.ProviderInternal")({
-    _tag: Schema.tag("ProviderInternal"),
-    message: Schema.String,
-    status: Schema.optional(Schema.Number),
+export class ProviderInternalError extends Schema.TaggedError("AI.Error.ProviderInternal")("ProviderInternal", {
+    ...ReasonFields,
     retryAfterMs: Schema.optional(Schema.Number),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
 }) {
 }
 export const TransportType = Schema.Literals(["http", "websocket"]);
 export const TransportOperation = Schema.Literals(["request", "read", "write"]);
-export class TransportReason extends Schema.Class("AI.Error.Transport")({
-    _tag: Schema.tag("Transport"),
-    message: Schema.String,
+export class TransportError extends Schema.TaggedError("AI.Error.Transport")("Transport", {
+    ...ReasonFields,
     transport: TransportType,
     operation: TransportOperation,
     code: Schema.optional(Schema.String),
     url: Schema.optional(Schema.String),
-    http: Schema.optional(HttpContext),
     phase: Schema.optional(Schema.Literals(["prepare", "queue", "connect", "send", "receive", "decode", "complete", "fallback", "close"])),
     delivery: Schema.optional(Schema.Literals(["not-sent", "rejected", "ambiguous", "accepted"])),
     recovery: Schema.optional(Schema.Literals(["retry-connect", "retry-full", "rotate-and-retry-full", "fallback-http", "fail"])),
 }) {
 }
-export class InvalidProviderOutputReason extends Schema.Class("AI.Error.InvalidProviderOutput")({
-    _tag: Schema.tag("InvalidProviderOutput"),
-    message: Schema.String,
+export class InvalidProviderOutputError extends Schema.TaggedError("AI.Error.InvalidProviderOutput")("InvalidProviderOutput", {
+    ...ReasonFields,
     classification: Schema.optional(Schema.Literals(["incomplete-stream"])),
     route: Schema.optional(Schema.String),
-    raw: Schema.optional(Schema.String),
-    providerMetadata: Schema.optional(ProviderMetadata),
 }) {
 }
-export class UnknownProviderReason extends Schema.Class("AI.Error.UnknownProvider")({
-    _tag: Schema.tag("UnknownProvider"),
-    message: Schema.String,
-    status: Schema.optional(Schema.Number),
-    providerMetadata: Schema.optional(ProviderMetadata),
-    http: Schema.optional(HttpContext),
-}) {
+export class UnknownProviderError extends Schema.TaggedError("AI.Error.UnknownProvider")("UnknownProvider", ReasonFields) {
 }
 export const AIErrorReason = Schema.Union([
-    InvalidRequestReason,
-    NoRouteReason,
-    AuthenticationReason,
-    RateLimitReason,
-    QuotaExceededReason,
-    ContentPolicyReason,
-    ProviderInternalReason,
-    TransportReason,
-    InvalidProviderOutputReason,
-    UnknownProviderReason,
+    InvalidRequestError,
+    NoRouteError,
+    AuthenticationError,
+    RateLimitError,
+    QuotaExceededError,
+    ContentPolicyError,
+    ProviderInternalError,
+    TransportError,
+    InvalidProviderOutputError,
+    UnknownProviderError,
 ]).pipe(Schema.toTaggedUnion("_tag"));
 export class AIError extends Schema.TaggedError()("AI.Error", {
-    module: Schema.String,
-    method: Schema.String,
     reason: AIErrorReason,
-    // Raw provider payload as a string, so classified failures never lose the
-    // original error detail even when the pretty message is a summary.
-    body: Schema.optional(Schema.String),
 }) {
     cause = this.reason;
     get message() {
-        return `${this.module}.${this.method}: ${this.reason.message}`;
+        return this.reason.message;
     }
 }
 /**