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

package/dist/image.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { HttpOptions, InvalidRequestReason, AIError, ModelID, ProviderID, ProviderMetadata, Usage, } from "./schema/index.js";
+import { HttpOptions, InvalidRequestError, AIError, ModelID, ProviderID, ProviderMetadata, Usage, } from "./schema/index.js";
 import { ImageClient, Service } from "./image-client.js";
 export class ImageModel {
     id;
@@ -90,9 +90,10 @@ export function generate(input) {
     return Effect.try({
         try: () => (input instanceof ImageRequest ? input : request(input)),
         catch: (error) => new AIError({
-            module: "Image",
-            method: "generate",
-            reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),
+            reason: new InvalidRequestError({
+                message: error instanceof Error ? error.message : String(error),
+                cause: error,
+            }),
         }),
     }).pipe(Effect.flatMap((request) => ImageClient.generate(request)));
 }

package/dist/llm.js

@@ -1,6 +1,6 @@
 import { Effect, JsonSchema, Schema } from "effect";
 import { LLMClient, Service } from "./route/client.js";
-import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolDefinition, } from "./schema/index.js";
+import { GenerationOptions, HttpOptions, InvalidProviderOutputError, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolDefinition, } from "./schema/index.js";
 import { make as makeTool, toDefinitions } from "./tool.js";
 export const generate = LLMClient.generate;
 export const stream = LLMClient.stream;
@@ -43,17 +43,14 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (options, to
     const call = response.toolCalls.find((event) => LLMEvent.is.toolCall(event) && event.name === GENERATE_OBJECT_TOOL_NAME);
     if (!call || !LLMEvent.is.toolCall(call))
         return yield* new AIError({
-            module: "LLM",
-            method: "generateObject",
-            reason: new InvalidProviderOutputReason({
+            reason: new InvalidProviderOutputError({
                 message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
             }),
         });
     const object = yield* tool._decode(call.input).pipe(Effect.mapError((error) => new AIError({
-        module: "LLM",
-        method: "generateObject",
-        reason: new InvalidProviderOutputReason({
+        reason: new InvalidProviderOutputError({
             message: `generateObject: tool input failed schema decode: ${error.message}`,
+            cause: error,
         }),
     })));
     return new GenerateObjectResponse(object, response);

package/dist/protocols/anthropic-messages.js

@@ -1167,11 +1167,13 @@ const providerErrorMessage = (event) => {
         return `${type}: ${message}`;
     return message || type || "Anthropic Messages stream error";
 };
-const onError = (event) => Effect.fail(new AIError({
-    module: ADAPTER,
-    method: "stream",
-    reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
-}));
+const onError = (event) => {
+    const message = providerErrorMessage(event);
+    const body = ProviderShared.encodeJson(event);
+    return Effect.fail(new AIError({
+        reason: classifyProviderFailure({ message, rawBody: body }),
+    }));
+};
 const isKnownStreamBlockType = (type) => type === "text" ||
     type === "thinking" ||
     type === "redacted_thinking" ||

package/dist/protocols/bedrock-converse.js

@@ -507,14 +507,12 @@ const step = (state, event) => Effect.gen(function* () {
         ];
     }
     if (event.exception) {
+        const message = event.exception.details.message ?? event.exception.details.originalMessage ?? "Bedrock Converse stream error";
+        const body = ProviderShared.encodeJson(event);
         return yield* new AIError({
-            module: ADAPTER,
-            method: "stream",
             reason: classifyProviderFailure({
-                message: event.exception.details.message ??
-                    event.exception.details.originalMessage ??
-                    "Bedrock Converse stream error",
-                code: event.exception.type,
+                message,
+                rawBody: body,
             }),
         });
     }

package/dist/protocols/bedrock-event-stream.js

@@ -1,6 +1,7 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
-import { Effect, Stream } from "effect";
+import { Effect, Encoding, Stream } from "effect";
+import { AIError, AIErrorReason } from "../schema/index.js";
 import { Framing } from "../route/framing.js";
 import { ProviderShared } from "./shared.js";
 // Bedrock streams responses using the AWS event stream binary protocol — each
@@ -30,15 +31,17 @@ const consumeFrames = (route) => (state, chunk) => Effect.gen(function* () {
             break;
         const decoded = yield* Effect.try({
             try: () => eventCodec.decode(view.subarray(0, totalLength)),
-            catch: (error) => ProviderShared.eventError(route, `Failed to decode Bedrock Converse event-stream frame: ${error instanceof Error ? error.message : String(error)}`),
+            catch: (error) => ProviderShared.eventError(route, `Failed to decode Bedrock Converse event-stream frame: ${error instanceof Error ? error.message : String(error)}`, Encoding.encodeBase64(view.subarray(0, totalLength)), error),
         });
         cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength };
+        const payload = utf8.decode(decoded.body);
+        const body = ProviderShared.encodeJson({ headers: decoded.headers, body: payload });
         const messageType = decoded.headers[":message-type"]?.value;
         if (messageType === "error") {
             const code = decoded.headers[":error-code"]?.value;
             const message = decoded.headers[":error-message"]?.value;
             return yield* ProviderShared.eventError(route, [code, message].filter((value) => typeof value === "string").join(": ") ||
-                "Bedrock Converse event-stream error");
+                "Bedrock Converse event-stream error", body);
         }
         const eventType = messageType === "event"
             ? decoded.headers[":event-type"]?.value
@@ -47,16 +50,22 @@ const consumeFrames = (route) => (state, chunk) => Effect.gen(function* () {
                 : undefined;
         if (typeof eventType !== "string")
             continue;
-        const payload = utf8.decode(decoded.body);
         if (!payload)
             continue;
         // The AWS event stream pads short payloads with a `p` field. Drop it
         // before handing the object to the chunk schema. JSON decode goes
         // through the shared Schema-driven codec to satisfy the package rule
         // against ad-hoc `JSON.parse` calls.
-        const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload"));
+        const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload").pipe(Effect.mapError((error) => new AIError({
+            reason: AIErrorReason.make({ ...error.reason, message: error.message, cause: error.reason.cause, body }),
+        }))));
         delete parsed.p;
-        out.push(messageType === "exception" ? { exception: { type: eventType, details: parsed } } : { [eventType]: parsed });
+        out.push({
+            ...(messageType === "exception"
+                ? { exception: { type: eventType, details: parsed } }
+                : { [eventType]: parsed }),
+            rawBody: body,
+        });
     }
     return [cursor, out];
 });
@@ -68,6 +77,7 @@ const consumeFrames = (route) => (state, chunk) => Effect.gen(function* () {
  */
 export const framing = (route) => ({
     id: "aws-event-stream",
+    body: (frame) => ("rawBody" in frame && typeof frame.rawBody === "string" ? frame.rawBody : undefined),
     frame: (bytes) => bytes.pipe(Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 });
 export * as BedrockEventStream from "./bedrock-event-stream.js";

package/dist/protocols/gemini.d.ts

@@ -175,6 +175,7 @@ export declare const protocol: Protocol<{
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
 }, string, {
+    readonly error?: unknown;
     readonly candidates?: readonly {
         readonly content?: {
             readonly parts?: readonly unknown[] | null | undefined;

package/dist/protocols/gemini.js

@@ -5,7 +5,8 @@ import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
-import { LLMEvent, Usage, } from "../schema/index.js";
+import { AIError, LLMEvent, Usage, } from "../schema/index.js";
+import { classifyProviderFailure } from "../provider-error.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { GeminiToolSchema } from "./utils/gemini-tool-schema.js";
 import { Lifecycle } from "./utils/lifecycle.js";
@@ -151,6 +152,7 @@ const GeminiPromptFeedback = Schema.StructWithRest(Schema.Struct({
     safetyRatings: optionalNull(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const GeminiEvent = Schema.Struct({
+    error: Schema.optional(Schema.Unknown),
     candidates: optionalNull(Schema.Array(GeminiCandidate)),
     promptFeedback: optionalNull(GeminiPromptFeedback),
     usageMetadata: optionalNull(GeminiUsage),
@@ -479,6 +481,16 @@ const finish = (state) => {
     return events;
 };
 const step = (state, event) => {
+    if (ProviderShared.isRecord(event.error) && typeof event.error.message === "string") {
+        const body = ProviderShared.encodeJson(event);
+        return Effect.fail(new AIError({
+            reason: classifyProviderFailure({
+                message: event.error.message,
+                status: typeof event.error.code === "number" ? event.error.code : undefined,
+                rawBody: body,
+            }),
+        }));
+    }
     const nextState = {
         ...state,
         promptFeedback: event.promptFeedback ?? state.promptFeedback,

package/dist/protocols/google-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 { AIError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared } from "./shared.js";
 import { ImageInputs } from "./utils/image-input.js";
 const ADAPTER = "google-images";
@@ -58,11 +58,6 @@ const nativeOptions = (options) => {
         thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
     }, native) ?? { responseModalities: ["IMAGE"] });
 };
-const invalidOutput = (message, providerMetadata) => new AIError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER, providerMetadata }),
-});
 const applyQuery = (url, query) => {
     if (!query)
         return url;
@@ -90,8 +85,8 @@ 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 Google Images response")));
-            const decoded = yield* Schema.decodeUnknownEffect(GoogleImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("Google Images returned an invalid response")));
+            const output = yield* ProviderShared.imageResponse(ADAPTER, "Google Images", response);
+            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(GoogleImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("Google Images returned an invalid response", cause)));
             const candidates = decoded.candidates ?? [];
             const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
                 index: candidate.index ?? candidateIndex,
@@ -117,7 +112,7 @@ export const model = (input) => {
             const encoded = candidates.flatMap((candidate, candidateIndex) => (candidate.content?.parts ?? []).flatMap((part, partIndex) => part.inlineData === undefined || part.thought === true
                 ? []
                 : [{ candidate, candidateIndex, partIndex, inlineData: part.inlineData }]));
-            const images = yield* Effect.forEach(encoded, (item) => Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(Effect.mapError(() => invalidOutput(`Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`)), Effect.map((data) => new GeneratedImage({
+            const images = yield* Effect.forEach(encoded, (item) => Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(Effect.mapError((cause) => output.invalid(`Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`, cause)), Effect.map((data) => new GeneratedImage({
                 mediaType: item.inlineData.mimeType,
                 data,
                 providerMetadata: {
@@ -134,12 +129,7 @@ export const model = (input) => {
             }))));
             if (images.length === 0) {
                 const finishReasons = candidates.flatMap((candidate) => candidate.finishReason === undefined ? [] : [candidate.finishReason]);
-                return yield* invalidOutput(`Google Images returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect reason.providerMetadata.google for prompt feedback and candidate details`, {
-                    google: {
-                        promptFeedback: decoded.promptFeedback,
-                        candidates: candidateMetadata,
-                    },
-                });
+                return yield* output.invalid(`Google Images returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect body for prompt feedback and candidate details`);
             }
             const usage = decoded.usageMetadata;
             const outputTokens = usage?.candidatesTokenCount === undefined
@@ -177,14 +167,14 @@ const googleImagePart = (image) => {
     if (image.type === "file-uri")
         return Effect.succeed({ fileData: { mimeType: image.mediaType, fileUri: image.uri } });
     if (image.type === "url")
-        return ImageInputs.decodeDataUrl(image.url, ADAPTER).pipe(Effect.flatMap((decoded) => {
+        return ImageInputs.decodeDataUrl(image.url).pipe(Effect.flatMap((decoded) => {
             if (decoded === undefined)
-                return Effect.fail(ImageInputs.invalid(ADAPTER, "Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI"));
+                return Effect.fail(ImageInputs.invalid("Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI"));
             return Effect.succeed({
                 inlineData: { mimeType: decoded.mediaType, data: Encoding.encodeBase64(decoded.data) },
             });
         }));
-    return Effect.fail(ImageInputs.invalid(ADAPTER, "Google generateContent requires Gemini file URIs rather than provider file IDs"));
+    return Effect.fail(ImageInputs.invalid("Google generateContent requires Gemini file URIs rather than provider file IDs"));
 };
 export const GoogleImages = {
     model,

package/dist/protocols/open-responses-channel.js

@@ -28,15 +28,15 @@ const driver = (options, body) => {
             return { message: body, mode: "full" };
         }),
         observe: (_create, frame) => Effect.gen(function* () {
-            const event = yield* decodeEvent(frame).pipe(Effect.mapError(() => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame)));
+            const event = yield* decodeEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause)));
             if (terminal)
                 return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} after a terminal event`, frame);
             if (event.type === "error") {
                 terminal = true;
-                yield* OpenResponses.decodeKnownErrorEvent(event).pipe(Effect.mapError(() => ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame)));
+                yield* OpenResponses.decodeKnownErrorEvent(event).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame, cause)));
                 return {
                     type: "provider-failure",
-                    error: OpenResponses.providerFailure(options.id, event, `${options.name} stream error`),
+                    error: OpenResponses.providerFailure(event, `${options.name} stream error`, frame),
                 };
             }
             if (event.type === "response.failed") {
@@ -45,7 +45,7 @@ const driver = (options, body) => {
                     return yield* ProviderShared.eventError(options.id, `${options.name} response ID changed during execution`, frame);
                 return {
                     type: "provider-failure",
-                    error: OpenResponses.providerFailure(options.id, event, `${options.name} response failed`),
+                    error: OpenResponses.providerFailure(event, `${options.name} response failed`, frame),
                 };
             }
             if (event.type === "response.created") {
@@ -110,9 +110,10 @@ export const transport = (options) => {
                 channel,
             };
         }),
-        execute: (prepared, request, runtime, executeOptions) => {
+        execute: (prepared, request, runtime, executeOptions) => Effect.gen(function* () {
             if (!executeOptions?.webSocket || !prepared.channel)
-                return http.execute(prepared.http, request, runtime);
+                return yield* http.execute(prepared.http, request, runtime);
+            let fallbackHttp;
             const exchange = {
                 id: request.id ?? "request",
                 connect: {
@@ -120,11 +121,21 @@ export const transport = (options) => {
                     headers: prepared.channel.headers,
                     rotateAfterMs: prepared.channel.rotateAfterMs,
                 },
-                fallback: () => Stream.unwrap(http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => execution.frames))),
+                fallback: () => Stream.unwrap(http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => {
+                    fallbackHttp = execution.http;
+                    return execution.frames;
+                }))),
                 driver: prepared.channel.driver,
             };
-            return executeOptions.webSocket.execute(exchange);
-        },
+            const execution = yield* executeOptions.webSocket.execute(exchange);
+            return {
+                frames: execution.frames,
+                complete: execution.complete,
+                get http() {
+                    return fallbackHttp ?? execution.http;
+                },
+            };
+        }),
     };
 };
 export const OpenResponsesChannel = { transport };

package/dist/protocols/open-responses-continuation.js

@@ -1,4 +1,4 @@
-import { AIError, TransportReason } from "../schema/index.js";
+import { AIError, TransportError } from "../schema/index.js";
 import { Effect, Option, Schema } from "effect";
 import * as ProviderShared from "./shared.js";
 import { OpenResponses } from "./open-responses.js";
@@ -81,14 +81,15 @@ const incremental = (request, checkpoint) => {
     return input.slice(baseline.length);
 };
 const code = (event) => event.code || event.error?.code || event.response?.error?.code || undefined;
-const rejected = (input, observation, recovery) => ({
+const rejected = (observation, recovery) => ({
     type: "rejected",
     recovery,
     error: new AIError({
-        module: input.id,
-        method: "stream",
-        reason: new TransportReason({
+        reason: new TransportError({
             message: observation.error.message,
+            body: observation.error.reason.body,
+            http: observation.error.reason.http,
+            cause: observation.error.reason.cause,
             transport: "websocket",
             operation: "read",
             phase: "receive",
@@ -113,16 +114,16 @@ export const driver = (input) => {
             };
         }),
         observe: (create, frame) => Effect.gen(function* () {
-            const event = yield* decodeEvent(frame).pipe(Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame)));
+            const event = yield* decodeEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause)));
             const observation = yield* input.base.observe(create, frame);
             if (event.type === "response.output_item.done" && event.item)
                 output.push(event.item);
             if (observation.type === "provider-failure") {
                 const rejection = code(event);
                 if (rejection === "previous_response_not_found")
-                    return rejected(input, observation, "retry-full");
+                    return rejected(observation, "retry-full");
                 if (rejection === "websocket_connection_limit_reached")
-                    return rejected(input, observation, "rotate-and-retry-full");
+                    return rejected(observation, "rotate-and-retry-full");
             }
             if (observation.type !== "completed")
                 return observation;

package/dist/protocols/open-responses.d.ts

@@ -804,7 +804,7 @@ export declare const terminal: (event: Event) => boolean;
 export declare const outputItemID: (state: ParserState, event: Event) => string | undefined;
 export declare const onReasoningDelta: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const onReasoningDone: (state: ParserState, event: Event, itemID: string) => StepResult;
-export declare const providerFailure: (id: string, event: Event, fallback: string) => AIError;
+export declare const providerFailure: (event: Event, fallback: string, body?: string) => AIError;
 export declare const step: (state: ParserState, input: Event) => AIError | Effect.Effect<[ParserState, readonly ({
     readonly type: "step-start";
     readonly index: number;

package/dist/protocols/open-responses.js

@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
-import { AIError, LLMEvent, ProviderInternalReason, Usage, } from "../schema/index.js";
+import { AIError, LLMEvent, ProviderInternalError, Usage, } from "../schema/index.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
@@ -918,11 +918,8 @@ const providerErrorMessage = (event, nested) => {
         return `${code}: ${message}`;
     return message || code;
 };
-export const providerFailure = (id, event, fallback) => {
+export const providerFailure = (event, fallback, body = ProviderShared.encodeJson(event)) => {
     const nested = event.error ?? event.response?.error ?? undefined;
-    const code = event.code || nested?.code || undefined;
-    // Keep the full raw payload on the error even when the message is a summary.
-    const body = JSON.stringify(nested ?? event) ?? "";
     const summary = providerErrorMessage(event, nested);
     const message = summary ?? (body === "{}" ? fallback : body);
     const status = typeof event.status === "number"
@@ -935,16 +932,10 @@ export const providerFailure = (id, event, fallback) => {
         event.response === undefined &&
         summary === undefined &&
         status === undefined
-        ? new ProviderInternalReason({ message })
-        : classifyProviderFailure({ message, code, status, rawBody: body });
-    return new AIError({
-        module: id,
-        method: "stream",
-        body,
-        reason,
-    });
+        ? new ProviderInternalError({ message, body })
+        : classifyProviderFailure({ message, status, rawBody: body });
+    return new AIError({ reason });
 };
-const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);
 export const step = (state, input) => {
     // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
     const event = input.item_id !== undefined && outputItemID(state, input) !== input.item_id
@@ -1005,9 +996,9 @@ export const step = (state, input) => {
     if (event.type === "response.completed" || event.type === "response.incomplete")
         return onResponseFinish(state, event);
     if (event.type === "response.failed")
-        return providerError(state, event, `${state.name} response failed`);
+        return providerFailure(event, `${state.name} response failed`);
     if (event.type === "error")
-        return decodeKnownErrorEvent(event).pipe(Effect.mapError(() => ProviderShared.eventError(state.id, `${state.name} returned a malformed error event`)), Effect.flatMap(() => providerError(state, event, `${state.name} stream error`)));
+        return decodeKnownErrorEvent(event).pipe(Effect.mapError((cause) => ProviderShared.eventError(state.id, `${state.name} returned a malformed error event`, ProviderShared.encodeJson(event), cause)), Effect.flatMap(() => providerFailure(event, `${state.name} stream error`)));
     return Effect.succeed([state, NO_EVENTS]);
 };
 // =============================================================================

package/dist/protocols/openai-chat.js

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
-import { AIError, InvalidProviderOutputReason, LLMEvent, ProviderInternalReason, UnknownProviderReason, Usage, } from "../schema/index.js";
+import { AIError, AIErrorReason, InvalidProviderOutputError, LLMEvent, ProviderInternalError, UnknownProviderError, Usage, } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { OpenAIOptions } from "./utils/openai-options.js";
@@ -613,18 +613,22 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
 // Streaming parsers are small state machines: every event returns a new state
 // plus the common `LLMEvent`s produced by that event. Tool calls are accumulated
 // because OpenAI streams JSON arguments across multiple deltas.
-const finishReasonError = (event, reason) => new AIError({
-    module: ADAPTER,
-    method: "stream",
-    body: ProviderShared.encodeJson(event),
-    reason,
-});
 const mapFinishReason = Effect.fn("OpenAIChat.mapFinishReason")(function* (event, reason) {
     switch (reason) {
         case "error":
-            return yield* finishReasonError(event, new UnknownProviderReason({ message: "Provider reported an error (finish_reason: error)" }));
+            return yield* new AIError({
+                reason: new UnknownProviderError({
+                    message: "Provider reported an error (finish_reason: error)",
+                    body: ProviderShared.encodeJson(event),
+                }),
+            });
         case "network_error":
-            return yield* finishReasonError(event, new ProviderInternalReason({ message: "Provider reported a network error (finish_reason: network_error)" }));
+            return yield* new AIError({
+                reason: new ProviderInternalError({
+                    message: "Provider reported a network error (finish_reason: network_error)",
+                    body: ProviderShared.encodeJson(event),
+                }),
+            });
         case "stop":
         case "end":
             return "stop";
@@ -738,12 +742,8 @@ const step = (state, event) => Effect.gen(function* () {
     if (event.error) {
         const body = ProviderShared.encodeJson(event);
         return yield* new AIError({
-            module: ADAPTER,
-            method: "stream",
-            body,
             reason: classifyProviderFailure({
                 message: event.error.message,
-                code: event.error.code === undefined || event.error.code === null ? undefined : String(event.error.code),
                 status: typeof event.error.code === "number" ? event.error.code : undefined,
                 rawBody: body,
             }),
@@ -831,7 +831,14 @@ const step = (state, event) => Effect.gen(function* () {
         }
         const result = ToolStream.appendOrStart(ADAPTER, tools, index, { id: id || undefined, name: name || undefined, text }, "OpenAI Chat tool call delta is missing id or name");
         if (ToolStream.isError(result))
-            return yield* ProviderShared.eventError(ADAPTER, result.reason.message, ProviderShared.encodeJson(event));
+            return yield* new AIError({
+                reason: AIErrorReason.make({
+                    ...result.reason,
+                    message: result.message,
+                    cause: result.reason.cause,
+                    body: ProviderShared.encodeJson(event),
+                }),
+            });
         tools = result.tools;
         if (result.events.length)
             lifecycle = Lifecycle.stepStart(lifecycle, events);
@@ -867,11 +874,9 @@ const step = (state, event) => Effect.gen(function* () {
 const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state) {
     if (state.finishReason === undefined && state.requireFinishReason)
         return yield* new AIError({
-            module: ADAPTER,
-            method: "stream",
-            reason: new InvalidProviderOutputReason({
-                classification: "incomplete-stream",
+            reason: new InvalidProviderOutputError({
                 message: "OpenAI Chat stream ended without finish_reason",
+                classification: "incomplete-stream",
                 route: ADAPTER,
             }),
         });

package/dist/protocols/openai-images.js

@@ -2,7 +2,7 @@ import { Effect, Encoding, Schema } from "effect";
 import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { ImageModel, GeneratedImage, 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 } from "./shared.js";
 import { ImageInputs } from "./utils/image-input.js";
 import { OpenAIImage } from "./utils/openai-image.js";
@@ -35,11 +35,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;
@@ -53,14 +48,14 @@ export const model = (input) => {
         generate: Effect.fn("OpenAIImages.generate")(function* (request, execute) {
             const mask = request.options?.mask;
             if (mask !== undefined && (request.images?.length ?? 0) === 0)
-                return yield* ImageInputs.invalid(ADAPTER, "An OpenAI image mask requires at least one input image");
+                return yield* ImageInputs.invalid("An OpenAI image mask requires at least one input image");
             const http = mergeHttpOptions(request.model.http, request.http);
             const sourceImages = request.images ?? [];
             const multipartImages = yield* Effect.forEach(sourceImages, (image) => {
                 if (image.type === "bytes")
                     return Effect.succeed({ data: image.data, mediaType: image.mediaType });
                 if (image.type === "url")
-                    return ImageInputs.decodeDataUrl(image.url, ADAPTER);
+                    return ImageInputs.decodeDataUrl(image.url);
                 return Effect.undefined;
             });
             const multipartMask = mask === undefined
@@ -68,7 +63,7 @@ export const model = (input) => {
                 : mask.type === "bytes"
                     ? { data: mask.data, mediaType: mask.mediaType }
                     : mask.type === "url"
-                        ? yield* ImageInputs.decodeDataUrl(mask.url, ADAPTER)
+                        ? yield* ImageInputs.decodeDataUrl(mask.url)
                         : undefined;
             const useMultipart = sourceImages.length > 0 &&
                 multipartImages.every((image) => image !== undefined) &&
@@ -111,7 +106,7 @@ export const model = (input) => {
                 return undefined;
             });
             if (references.some((image) => image === undefined))
-                return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts image URLs, data URLs, bytes, and file IDs");
+                return yield* ImageInputs.invalid("OpenAI Images accepts image URLs, data URLs, bytes, and file IDs");
             const maskReference = mask === undefined
                 ? undefined
                 : mask.type === "bytes"
@@ -122,7 +117,7 @@ export const model = (input) => {
                             ? { file_id: mask.id }
                             : undefined;
             if (mask !== undefined && maskReference === undefined)
-                return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs");
+                return yield* ImageInputs.invalid("OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs");
             const requestBody = mergeJsonRecords({
                 model: request.model.id,
                 prompt: request.prompt,
@@ -144,13 +139,13 @@ export const model = (input) => {
     return ImageModel.make({ id: input.id, provider: "openai", route, http: input.http });
 };
 const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (response, options, overlay) {
-    const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the OpenAI Images response")));
-    const decoded = yield* Schema.decodeUnknownEffect(OpenAIImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("OpenAI Images returned an invalid response")));
+    const output = yield* ProviderShared.imageResponse(ADAPTER, "OpenAI Images", response);
+    const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("OpenAI Images returned an invalid response", cause)));
     const requestBody = mergeJsonRecords(nativeOptions(options), overlay);
     const format = decoded.output_format ?? (typeof requestBody?.output_format === "string" ? requestBody.output_format : "png");
     const images = yield* Effect.forEach(decoded.data, (item, index) => {
         if (item.b64_json)
-            return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError(() => invalidOutput(`OpenAI 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(`OpenAI Images result ${index} contains invalid base64 data`, cause)), Effect.map((data) => new GeneratedImage({
                 mediaType: `image/${format}`,
                 data,
                 providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
@@ -161,10 +156,10 @@ const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (respons
                 data: item.url,
                 providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
             }));
-        return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`));
+        return Effect.fail(output.invalid(`OpenAI Images result ${index} has neither image data nor a URL`));
     });
     if (images.length === 0)
-        return yield* invalidOutput("OpenAI Images returned no images");
+        return yield* output.invalid("OpenAI Images returned no images");
     return new ImageResponse({
         images,
         usage: decoded.usage === undefined

package/dist/protocols/openai-responses.js

@@ -115,7 +115,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
 const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item) {
     const isError = item.error !== undefined && item.error !== null;
     if (item.type === "image_generation_call" && item.result) {
-        yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")));
+        yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64", undefined, cause)));
         const format = item.output_format ?? "png";
         return {
             type: "content",