@opencode-ai/ai 0.0.0-dev-18409 → 0.0.0-dev-18412

package/dist/protocols/shared.d.ts

@@ -1,6 +1,6 @@
 import { Tool } from "@opencode-ai/schema/tool";
 import { Effect, Schema, Stream } from "effect";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { AIError, type ContentPart, type LLMRequest, type MediaPart, type ToolResultPart } from "../schema/index.js";
 import { isRecord } from "../utils/record.js";
 export { isRecord };
@@ -54,7 +54,7 @@ export declare const subtractTokens: (total: number | undefined, subtrahend: num
  * (e.g. Anthropic, whose `input_tokens` is already non-cached only).
  */
 export declare const sumTokens: (...values: ReadonlyArray<number | undefined>) => number | undefined;
-export declare const eventError: (route: string, message: string, raw?: string) => AIError;
+export declare const eventError: (route: string, message: string, body?: string, cause?: unknown) => AIError;
 export declare const parseJson: (route: string, input: string, message: string) => Effect.Effect<unknown, AIError, never>;
 /**
  * Join the `text` field of a list of parts with newlines. Used by routes
@@ -127,7 +127,11 @@ export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>, eve
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */
-export declare const invalidRequest: (message: string) => AIError;
+export declare const invalidRequest: (message: string, cause?: unknown) => AIError;
+export declare const imageResponse: (route: string, name: string, response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
+    body: string;
+    invalid: (message: string, cause?: unknown) => AIError;
+}, AIError, never>;
 export declare const matchToolChoice: <Auto, None, Required, Tool>(route: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>, cases: {
     readonly auto: () => Auto;
     readonly none: () => None;

package/dist/protocols/shared.js

@@ -2,8 +2,8 @@ import { Buffer } from "node:buffer";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Effect, Schema, Stream } from "effect";
 import * as Sse from "effect/unstable/encoding/Sse";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { InvalidProviderOutputReason, InvalidRequestReason, AIError, } from "../schema/index.js";
+import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { InvalidProviderOutputError, InvalidRequestError, AIError, HttpContext, } from "../schema/index.js";
 import { isRecord } from "../utils/record.js";
 export { isRecord };
 export const Json = Schema.fromJsonString(Schema.Unknown);
@@ -72,14 +72,12 @@ export const sumTokens = (...values) => {
         return undefined;
     return values.reduce((acc, value) => acc + (value ?? 0), 0);
 };
-export const eventError = (route, message, raw) => new AIError({
-    module: "ProviderShared",
-    method: "stream",
-    reason: new InvalidProviderOutputReason({ route, message, raw }),
+export const eventError = (route, message, body, cause) => new AIError({
+    reason: new InvalidProviderOutputError({ route, message, body, cause }),
 });
 export const parseJson = (route, input, message) => Effect.try({
     try: () => decodeJson(input),
-    catch: () => eventError(route, message, input),
+    catch: (cause) => eventError(route, message, input, cause),
 });
 /**
  * Join the `text` field of a list of parts with newlines. Used by routes
@@ -178,7 +176,7 @@ export const sseFraming = (bytes, events) => bytes.pipe(Stream.decodeText(), Str
 }, (state, chunk) => Effect.gen(function* () {
     const error = state.parser.feed(chunk);
     if (error)
-        return yield* eventError("sse", error.message);
+        return yield* eventError("sse", error.message, chunk, error);
     return [state, state.output.splice(0)];
 })), Stream.filter((event) => (events === undefined || events.has(event.event)) &&
     event.data.length > 0 &&
@@ -186,10 +184,25 @@ export const sseFraming = (bytes, events) => bytes.pipe(Stream.decodeText(), Str
 /**
  * Canonical invalid-request constructor shared by protocol lowering.
  */
-export const invalidRequest = (message) => new AIError({
-    module: "ProviderShared",
-    method: "request",
-    reason: new InvalidRequestReason({ message }),
+export const invalidRequest = (message, cause) => new AIError({
+    reason: new InvalidRequestError({ message, cause }),
+});
+export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (route, name, response) {
+    const http = new HttpContext({ url: response.request.url, status: response.status, headers: response.headers });
+    const body = yield* response.text.pipe(Effect.mapError((cause) => new AIError({
+        reason: new InvalidProviderOutputError({
+            route,
+            message: `Failed to read the ${name} response`,
+            http,
+            cause,
+        }),
+    })));
+    return {
+        body,
+        invalid: (message, cause) => new AIError({
+            reason: new InvalidProviderOutputError({ route, message, body, http, cause }),
+        }),
+    };
 });
 export const matchToolChoice = (route, toolChoice, cases) => Effect.gen(function* () {
     if (toolChoice.type === "auto")
@@ -217,7 +230,7 @@ export const unsupportedContent = (route, role, types) => invalidRequest(`${rout
  * invalid(e.message)))`. Any decode error is translated into
  * `AIError` carrying the original parse-error message.
  */
-export const validateWith = (decode) => (payload) => decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message)));
+export const validateWith = (decode) => (payload) => decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message, error)));
 /**
  * Build an HTTP POST with a JSON body. Sets `content-type: application/json`
  * automatically after caller-supplied headers so routes cannot accidentally

package/dist/protocols/utils/image-input.d.ts

@@ -4,18 +4,18 @@ import { AIError } from "../../schema/index.js";
 export declare const dataUrl: (input: Extract<ImageInput, {
     readonly type: "bytes";
 }>) => string;
-export declare const decodeDataUrl: (url: string, module: string) => Effect.Effect<{
+export declare const decodeDataUrl: (url: string) => Effect.Effect<{
     readonly mediaType: string;
     readonly data: Uint8Array;
 } | undefined, AIError>;
-export declare const invalidImageInput: (module: string, message: string) => AIError;
+export declare const invalidImageInput: (message: string, cause?: unknown) => AIError;
 export declare const ImageInputs: {
     readonly dataUrl: (input: Extract<ImageInput, {
         readonly type: "bytes";
     }>) => string;
-    readonly decodeDataUrl: (url: string, module: string) => Effect.Effect<{
+    readonly decodeDataUrl: (url: string) => Effect.Effect<{
         readonly mediaType: string;
         readonly data: Uint8Array;
     } | undefined, AIError>;
-    readonly invalid: (module: string, message: string) => AIError;
+    readonly invalid: (message: string, cause?: unknown) => AIError;
 };

package/dist/protocols/utils/image-input.js

@@ -1,18 +1,16 @@
 import { Effect, Encoding } from "effect";
-import { InvalidRequestReason, AIError } from "../../schema/index.js";
-const invalid = (module, message) => new AIError({
-    module,
-    method: "generate",
-    reason: new InvalidRequestReason({ message }),
+import { InvalidRequestError, AIError } from "../../schema/index.js";
+const invalid = (message, cause) => new AIError({
+    reason: new InvalidRequestError({ message, cause }),
 });
 export const dataUrl = (input) => `data:${input.mediaType};base64,${Encoding.encodeBase64(input.data)}`;
-export const decodeDataUrl = (url, module) => {
+export const decodeDataUrl = (url) => {
     if (!url.startsWith("data:"))
         return Effect.undefined;
     const match = /^data:([^;,]+);base64,(.*)$/s.exec(url);
     if (!match)
-        return Effect.fail(invalid(module, "Image data URLs must contain a MIME type and base64 data"));
-    return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(Effect.mapError(() => invalid(module, "Image data URL contains invalid base64 data")), Effect.map((data) => ({ mediaType: match[1], data })));
+        return Effect.fail(invalid("Image data URLs must contain a MIME type and base64 data"));
+    return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(Effect.mapError((cause) => invalid("Image data URL contains invalid base64 data", cause)), Effect.map((data) => ({ mediaType: match[1], data })));
 };
 export const invalidImageInput = invalid;
 export const ImageInputs = {

package/dist/protocols/xai-images.js

@@ -2,7 +2,7 @@ import { Effect, Encoding, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { GeneratedImage, ImageModel, ImageResponse } from "../image.js";
 import { Auth } from "../route/auth.js";
-import { InvalidProviderOutputReason, AIError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema/index.js";
+import { Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared, optionalNull } from "./shared.js";
 import { ImageInputs } from "./utils/image-input.js";
 const ADAPTER = "xai-images";
@@ -28,11 +28,6 @@ const nativeOptions = (options) => {
         ...native,
     };
 };
-const invalidOutput = (message) => new AIError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
-});
 const applyQuery = (url, query) => {
     if (!query)
         return url;
@@ -55,7 +50,7 @@ export const model = (input) => {
                 return undefined;
             });
             if (imageReferences.some((image) => image === undefined))
-                return yield* ImageInputs.invalid(ADAPTER, "xAI Images accepts image URLs, data URLs, bytes, and file IDs");
+                return yield* ImageInputs.invalid("xAI Images accepts image URLs, data URLs, bytes, and file IDs");
             const requestBody = mergeJsonRecords({
                 model: request.model.id,
                 prompt: request.prompt,
@@ -72,12 +67,12 @@ export const model = (input) => {
                 headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
             });
             const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
-            const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the xAI Images response")));
-            const decoded = yield* Schema.decodeUnknownEffect(XAIImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("xAI Images returned an invalid response")));
+            const output = yield* ProviderShared.imageResponse(ADAPTER, "xAI Images", response);
+            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(XAIImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("xAI Images returned an invalid response", cause)));
             const images = yield* Effect.forEach(decoded.data, (item, index) => {
                 const mediaType = item.mime_type ?? "application/octet-stream";
                 if (item.b64_json)
-                    return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError(() => invalidOutput(`xAI Images result ${index} contains invalid base64 data`)), Effect.map((data) => new GeneratedImage({
+                    return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError((cause) => output.invalid(`xAI Images result ${index} contains invalid base64 data`, cause)), Effect.map((data) => new GeneratedImage({
                         mediaType,
                         data,
                         providerMetadata: item.revised_prompt === undefined || item.revised_prompt === null
@@ -92,10 +87,10 @@ export const model = (input) => {
                             ? undefined
                             : { xai: { revisedPrompt: item.revised_prompt } },
                     }));
-                return Effect.fail(invalidOutput(`xAI Images result ${index} has neither image data nor a URL`));
+                return Effect.fail(output.invalid(`xAI Images result ${index} has neither image data nor a URL`));
             });
             if (images.length === 0)
-                return yield* invalidOutput("xAI Images returned no images");
+                return yield* output.invalid("xAI Images returned no images");
             const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined;
             return new ImageResponse({
                 images,

package/dist/protocols/zai-images.js

@@ -2,7 +2,7 @@ import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { GeneratedImage, ImageModel, ImageResponse } from "../image.js";
 import { Auth } from "../route/auth.js";
-import { InvalidProviderOutputReason, AIError, mergeHttpOptions, mergeJsonRecords, } from "../schema/index.js";
+import { mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared } from "./shared.js";
 import { ImageInputs } from "./utils/image-input.js";
 const ADAPTER = "zai-images";
@@ -27,11 +27,6 @@ const nativeOptions = (options) => {
         ...native,
     };
 };
-const invalidOutput = (message) => new AIError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
-});
 const applyQuery = (url, query) => {
     if (!query)
         return url;
@@ -44,7 +39,7 @@ export const model = (input) => {
         id: ADAPTER,
         generate: Effect.fn("ZAIImages.generate")(function* (request, execute) {
             if ((request.images?.length ?? 0) > 0)
-                return yield* ImageInputs.invalid(ADAPTER, "Z.ai hosted image generation does not support image inputs");
+                return yield* ImageInputs.invalid("Z.ai hosted image generation does not support image inputs");
             const http = mergeHttpOptions(request.model.http, request.http);
             const requestBody = mergeJsonRecords({ model: request.model.id, prompt: request.prompt }, nativeOptions(request.options), http?.body);
             const text = ProviderShared.encodeJson(requestBody);
@@ -57,10 +52,10 @@ export const model = (input) => {
                 headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
             });
             const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
-            const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the Z.ai Images response")));
-            const decoded = yield* Schema.decodeUnknownEffect(ZAIImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("Z.ai Images returned an invalid response")));
+            const output = yield* ProviderShared.imageResponse(ADAPTER, "Z.ai Images", response);
+            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(ZAIImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("Z.ai Images returned an invalid response", cause)));
             if (decoded.data.length === 0)
-                return yield* invalidOutput("Z.ai Images returned no images");
+                return yield* output.invalid("Z.ai Images returned no images");
             return new ImageResponse({
                 images: decoded.data.map((item) => new GeneratedImage({
                     mediaType: "application/octet-stream",

package/dist/provider-error.d.ts

@@ -1,15 +1,15 @@
-import { AIError, type HttpContext, type HttpRateLimitDetails, type ProviderMetadata } from "./schema/index.js";
+import { AIError, type HttpContext, type HttpRateLimitDetails } from "./schema/index.js";
 export declare const isContextOverflow: (message: string) => boolean;
 export declare const isPayloadTooLarge: (message: string) => boolean;
 export declare const isContextOverflowFailure: (failure: unknown) => boolean;
 export interface ProviderFailure {
     readonly message: string;
     readonly status?: number | undefined;
-    readonly code?: string | undefined;
     readonly rawBody?: string | undefined;
+    readonly data?: unknown;
+    readonly http?: HttpContext | undefined;
+    readonly cause?: unknown;
     readonly retryAfterMs?: number | undefined;
     readonly rateLimit?: HttpRateLimitDetails | undefined;
-    readonly http?: HttpContext | undefined;
-    readonly providerMetadata?: ProviderMetadata | undefined;
 }
 export declare function classifyProviderFailure(input: ProviderFailure): AIError["reason"];

package/dist/provider-error.js

@@ -1,5 +1,5 @@
 import { Option, Schema } from "effect";
-import { AuthenticationReason, ContentPolicyReason, InvalidRequestReason, AIError, ProviderErrorEvent, ProviderInternalReason, QuotaExceededReason, RateLimitReason, UnknownProviderReason, } from "./schema/index.js";
+import { AuthenticationError, ContentPolicyError, InvalidRequestError, AIError, ProviderErrorEvent, ProviderInternalError, QuotaExceededError, RateLimitError, UnknownProviderError, } from "./schema/index.js";
 const patterns = [
     /prompt is too long/i,
     /input is too long for requested model/i,
@@ -57,80 +57,79 @@ const NETWORK_ERROR_TEXT = /network[-_\s]error/i;
 // Keep HTTP failures and provider-reported stream failures on one typed path so
 // session retry policy never needs provider-specific string matching.
 export function classifyProviderFailure(input) {
-    const body = input.http?.body ?? input.rawBody ?? "";
-    const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
-        .filter((code) => code !== undefined)
-        .map((code) => code.toLowerCase());
+    const details = { message: input.message, body: input.rawBody, http: input.http, cause: input.cause };
+    const body = input.rawBody ?? "";
+    const codes = [...providerCodes(input.data), ...providerCodes(body), ...providerCodes(input.message)].map((code) => code.toLowerCase());
     // Scan the raw payload too so signals missing from the summary message
     // (e.g. overflow phrases nested in a JSON error body) still classify.
     const text = [input.message, body].filter((value) => value.length > 0).join("\n");
-    const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http };
     const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500);
     if (clientScoped &&
         (codes.includes("context_length_exceeded") ||
             codes.includes("model_context_window_exceeded") ||
             codes.includes("request_too_large") ||
             isContextOverflow(text)))
-        return new InvalidRequestReason({ ...common, classification: "context-overflow" });
+        return new InvalidRequestError({ ...details, classification: "context-overflow" });
     if (input.status === 413 || isPayloadTooLarge(text))
-        return new InvalidRequestReason({ ...common, classification: "payload-too-large" });
+        return new InvalidRequestError({ ...details, classification: "payload-too-large" });
     if (CONTENT_POLICY_TEXT.test(text))
-        return new ContentPolicyReason(common);
+        return new ContentPolicyError(details);
     if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
-        return new QuotaExceededReason(common);
+        return new QuotaExceededError(details);
     if (input.status === 401)
-        return new AuthenticationReason({ ...common, kind: "invalid" });
+        return new AuthenticationError({ ...details, kind: "invalid" });
     if (input.status === 403)
-        return new AuthenticationReason({ ...common, kind: "insufficient-permissions" });
+        return new AuthenticationError({ ...details, kind: "insufficient-permissions" });
     if (codes.includes("authentication_error"))
-        return new AuthenticationReason({ ...common, kind: "invalid" });
+        return new AuthenticationError({ ...details, kind: "invalid" });
     if (codes.includes("permission_error"))
-        return new AuthenticationReason({ ...common, kind: "insufficient-permissions" });
+        return new AuthenticationError({ ...details, kind: "insufficient-permissions" });
     if (codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception"))
-        return new RateLimitReason({
-            ...common,
+        return new RateLimitError({
+            ...details,
             retryAfterMs: input.retryAfterMs,
             rateLimit: input.rateLimit,
         });
     if (RATE_LIMIT_TEXT.test(text))
-        return new RateLimitReason({
-            ...common,
+        return new RateLimitError({
+            ...details,
             retryAfterMs: input.retryAfterMs,
             rateLimit: input.rateLimit,
         });
     if (NETWORK_ERROR_TEXT.test(text))
-        return new ProviderInternalReason({ ...common, status: input.status });
+        return new ProviderInternalError(details);
     if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
-        return new ProviderInternalReason({
-            ...common,
-            status: input.status,
+        return new ProviderInternalError({
+            ...details,
             retryAfterMs: input.retryAfterMs,
         });
     if (input.status === 429) {
-        return new RateLimitReason({
-            ...common,
+        return new RateLimitError({
+            ...details,
             retryAfterMs: input.retryAfterMs,
             rateLimit: input.rateLimit,
         });
     }
     if (input.status === 408 || input.status === 409 || (input.status !== undefined && input.status >= 500))
-        return new ProviderInternalReason({
-            ...common,
-            status: input.status,
+        return new ProviderInternalError({
+            ...details,
             retryAfterMs: input.retryAfterMs,
         });
     if (codes.some((code) => INVALID_REQUEST_CODES.has(code)))
-        return new InvalidRequestReason(common);
+        return new InvalidRequestError(details);
     if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
-        return new InvalidRequestReason(common);
-    return new UnknownProviderReason({ ...common, status: input.status });
+        return new InvalidRequestError(details);
+    return new UnknownProviderError(details);
 }
 function providerCodes(value) {
-    const decoded = Option.getOrUndefined(decodeJson(value));
+    const decoded = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value;
     if (!isRecord(decoded))
         return [];
     const error = isRecord(decoded.error) ? decoded.error : undefined;
-    return [decoded.code, error?.code, error?.type].filter((value) => typeof value === "string");
+    const response = isRecord(decoded.response) ? decoded.response : undefined;
+    const responseError = response && isRecord(response.error) ? response.error : undefined;
+    const exception = isRecord(decoded.exception) ? decoded.exception : undefined;
+    return [decoded.code, error?.code, error?.type, error?.status, responseError?.code, exception?.type].filter((value) => typeof value === "string");
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null;

package/dist/route/auth.js

@@ -1,6 +1,6 @@
 import { Config, Effect, Redacted } from "effect";
 import { Headers } from "effect/unstable/http";
-import { AuthenticationReason, InvalidRequestReason, AIError } from "../schema/index.js";
+import { AuthenticationError, InvalidRequestError, AIError } from "../schema/index.js";
 export class MissingCredentialError extends Error {
     source;
     _tag = "MissingCredentialError";
@@ -76,11 +76,9 @@ export function bearerHeader(name, source) {
 const toAIError = (error) => {
     if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
         return new AIError({
-            module: "Auth",
-            method: "apply",
             reason: error instanceof MissingCredentialError
-                ? new AuthenticationReason({ message: error.message, kind: "missing" })
-                : new InvalidRequestReason({ message: `Failed to resolve auth config: ${error.message}` }),
+                ? new AuthenticationError({ message: error.message, cause: error, kind: "missing" })
+                : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
         });
     }
     return error;

package/dist/route/client.js

@@ -7,7 +7,7 @@ import { HttpTransport } from "./transport/index.js";
 import { applyCachePolicy } from "../cache-policy.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 import * as ProviderShared from "../protocols/shared.js";
-import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, InvalidProviderOutputReason, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
+import { AIError, AIErrorReason, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, InvalidProviderOutputError, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
 const makeRouteLanguageModel = (route, mapped) => {
     const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined);
     if (!provider)
@@ -60,14 +60,12 @@ const streamError = (route, message, cause) => {
     const failed = cause.reasons.find(Cause.isFailReason)?.error;
     if (failed instanceof AIError)
         return failed;
-    return ProviderShared.eventError(route, message, Cause.pretty(cause));
+    return ProviderShared.eventError(route, message, undefined, cause);
 };
 const incompleteStreamError = (route) => new AIError({
-    module: "LLMClient",
-    method: "stream",
-    reason: new InvalidProviderOutputReason({
-        classification: "incomplete-stream",
+    reason: new InvalidProviderOutputError({
         message: "The provider response ended unexpectedly.",
+        classification: "incomplete-stream",
         route,
     }),
 });
@@ -85,7 +83,7 @@ function makeFromTransport(input) {
     const protocol = input.protocol;
     const encodeBody = Schema.encodeSync(Schema.fromJsonString(protocol.body.schema));
     const decodeEventEffect = Schema.decodeUnknownEffect(protocol.stream.event);
-    const decodeEvent = (route) => (frame) => decodeEventEffect(frame).pipe(Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${route} stream event`, typeof frame === "string" ? frame : ProviderShared.encodeJson(frame))));
+    const decodeEvent = (route) => (frame) => decodeEventEffect(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${route} stream event`, typeof frame === "string" ? frame : ProviderShared.encodeJson(frame), cause)));
     const build = (routeInput) => {
         const route = {
             id: routeInput.id,
@@ -127,18 +125,38 @@ function makeFromTransport(input) {
             streamPrepared: (prepared, request, runtime, options) => {
                 const route = `${request.model.provider}/${request.model.route.id}`;
                 return Stream.unwrap(routeInput.transport.execute(prepared, request, runtime, options).pipe(Effect.map((execution) => {
-                    const events = execution.frames.pipe(Stream.mapEffect(decodeEvent(route)), protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream);
+                    const terminal = protocol.stream.terminal;
+                    // Preserve assembled inputs; replace only serialized event fallbacks with their original wire data.
+                    const frameError = (frame, event = frame) => (error) => new AIError({
+                        reason: AIErrorReason.make({
+                            ...error.reason,
+                            message: error.reason.message,
+                            cause: error.reason.cause,
+                            body: error.reason.body !== undefined && error.reason.body !== ProviderShared.encodeJson(event)
+                                ? error.reason.body
+                                : (execution.body?.(frame) ??
+                                    (typeof frame === "string" ? frame : ProviderShared.encodeJson(frame))),
+                        }),
+                    });
+                    const events = execution.frames.pipe(Stream.mapEffect((frame) => decodeEvent(route)(frame).pipe(Effect.catchCause((cause) => Effect.fail(streamError(route, `Failed to decode ${route} event`, cause))), Effect.map((event) => ({ event, frame })), Effect.mapError(frameError(frame)))), terminal ? Stream.takeUntil(({ event }) => terminal(event)) : (stream) => stream);
                     const stream = Stream.suspend(() => {
                         let state = protocol.stream.initial(request);
-                        const parsed = events.pipe(Stream.mapEffect((event) => protocol.stream.step(state, event).pipe(Effect.map(([next, output]) => {
+                        const parsed = events.pipe(Stream.mapEffect(({ event, frame }) => protocol.stream.step(state, event).pipe(Effect.catchCause((cause) => Effect.fail(streamError(route, `Failed to parse ${route} event`, cause))), Effect.map(([next, output]) => {
                             state = next;
                             return output;
-                        }))), Stream.flatMap(Stream.fromIterable));
+                        }), Effect.mapError(frameError(frame, event)))), Stream.flatMap(Stream.fromIterable));
                         const onHalt = protocol.stream.onHalt;
                         return onHalt
                             ? parsed.pipe(Stream.concat(Stream.suspend(() => Stream.unwrap(onHalt(state).pipe(Effect.map(Stream.fromIterable))))))
                             : parsed;
-                    }).pipe(Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))), requireTerminalEvent(route));
+                    }).pipe(Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))), requireTerminalEvent(route), Stream.mapError((error) => new AIError({
+                        reason: AIErrorReason.make({
+                            ...error.reason,
+                            message: error.reason.message,
+                            cause: error.reason.cause,
+                            http: error.reason.http ?? execution.http,
+                        }),
+                    })));
                     return execution.complete ? stream.pipe(Stream.onEnd(execution.complete)) : stream;
                 })));
             },

package/dist/route/executor.d.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer, Stream } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
-import { AIError, TransportReason } from "../schema/index.js";
+import { HttpContext, AIError } from "../schema/index.js";
 export interface Interface {
     readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
 }
@@ -9,14 +9,18 @@ export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, hand
 declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const classifyHttpFailure: (input: {
+export declare const responseHttp: (response: HttpClientResponse.HttpClientResponse) => HttpContext;
+/** Preserve HTTP diagnostics for executor and externally captured failures alike. */
+export declare const httpFailure: (input: {
     readonly message: string;
-    readonly url: string;
+    readonly url?: string | undefined;
     readonly status?: number | undefined;
-    readonly code?: string | undefined;
+    readonly data?: unknown;
     readonly responseHeaders?: Record<string, string> | undefined;
     readonly responseBody?: string | undefined;
-}) => import("../schema/errors.js").InvalidRequestReason | import("../schema/errors.js").NoRouteReason | import("../schema/errors.js").AuthenticationReason | import("../schema/errors.js").RateLimitReason | import("../schema/errors.js").QuotaExceededReason | import("../schema/errors.js").ContentPolicyReason | import("../schema/errors.js").ProviderInternalReason | TransportReason | import("../schema/errors.js").InvalidProviderOutputReason | import("../schema/errors.js").UnknownProviderReason;
+    readonly cause?: unknown;
+}) => AIError;
+export declare const responseStream: (response: HttpClientResponse.HttpClientResponse) => Stream.Stream<Uint8Array, AIError>;
 export declare const stream: (executor: Interface, request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Stream.Stream<Uint8Array, AIError>;
 export declare const layer: Layer.Layer<Service, never, HttpClient.HttpClient>;
 export declare const fetchLayer: Layer.Layer<Service, never, never>;