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

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",

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
@@ -117,17 +117,21 @@ export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty / `[DONE]`
- * keep-alive events so the protocol event schema sees one JSON string per
- * element. Retry control events are ignored without interrupting the stream.
+ * decoder, optionally filters named events, and drops empty events. `[DONE]`
+ * is dropped by default or retained for protocols that use it as their stream
+ * boundary. Retry control events are ignored without interrupting the stream.
  * Decoder failures become provider output errors so the public error channel
  * stays `AIError`.
  */
-export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>, events?: ReadonlySet<string>) => Stream.Stream<string, AIError>;
+export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>, events?: ReadonlySet<string>, includeDone?: boolean) => Stream.Stream<string, AIError>;
 /**
  * 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
@@ -160,13 +158,13 @@ export const errorText = (error) => {
 };
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty / `[DONE]`
- * keep-alive events so the protocol event schema sees one JSON string per
- * element. Retry control events are ignored without interrupting the stream.
+ * decoder, optionally filters named events, and drops empty events. `[DONE]`
+ * is dropped by default or retained for protocols that use it as their stream
+ * boundary. Retry control events are ignored without interrupting the stream.
  * Decoder failures become provider output errors so the public error channel
  * stays `AIError`.
  */
-export const sseFraming = (bytes, events) => bytes.pipe(Stream.decodeText(), Stream.mapAccumEffect(() => {
+export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Stream.decodeText(), Stream.mapAccumEffect(() => {
     const output = [];
     return {
         output,
@@ -178,18 +176,33 @@ 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 &&
-    (event.data !== "[DONE]" || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
+    (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
 /**
  * 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/utils/lifecycle.d.ts

@@ -10,8 +10,12 @@ export declare const textStart: (state: State, events: LLMEvent[], id: string, p
 export declare const textDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
 export declare const reasoningStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
 export declare const reasoningDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
-export declare const reasoningEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
-export declare const textEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text?: string) => State;
+export declare const textEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text?: string) => State;
 export declare const finish: (state: State, events: LLMEvent[], input: {
     readonly reason: FinishReasonDetails;
     readonly usage?: Usage;

package/dist/protocols/utils/lifecycle.js

@@ -30,23 +30,27 @@ export const reasoningDelta = (state, events, id, text, providerMetadata) => {
     events.push(LLMEvent.reasoningDelta({ id, text, providerMetadata }));
     return started;
 };
-export const reasoningEnd = (state, events, id, providerMetadata) => {
+export const reasoningEnd = (state, events, id, providerMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text) => {
     if (!state.reasoning.has(id))
         return state;
     const stepped = stepStart(state, events);
-    events.push(LLMEvent.reasoningEnd({ id, providerMetadata }));
+    events.push(LLMEvent.reasoningEnd({ id, text, providerMetadata }));
     const reasoning = new Set(stepped.reasoning);
     reasoning.delete(id);
     return { ...stepped, reasoning };
 };
-export const textEnd = (state, events, id, providerMetadata) => {
+export const textEnd = (state, events, id, providerMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text) => {
     if (!state.text.has(id))
         return state;
     const stepped = stepStart(state, events);
-    events.push(LLMEvent.textEnd({ id, providerMetadata }));
-    const text = new Set(stepped.text);
-    text.delete(id);
-    return { ...stepped, text };
+    events.push(LLMEvent.textEnd({ id, text, providerMetadata }));
+    const open = new Set(stepped.text);
+    open.delete(id);
+    return { ...stepped, text: open };
 };
 const closeOpenBlocks = (state, events) => {
     for (const id of state.reasoning)

package/dist/protocols/utils/tool-stream.d.ts

@@ -93,6 +93,7 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
     } | {
         readonly id: string;
         readonly type: "text-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -118,6 +119,7 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
     } | {
         readonly id: string;
         readonly type: "reasoning-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -287,6 +289,7 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
     } | {
         readonly id: string;
         readonly type: "text-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -312,6 +315,7 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
     } | {
         readonly id: string;
         readonly type: "reasoning-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -478,6 +482,7 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
     } | {
         readonly id: string;
         readonly type: "text-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -503,6 +508,7 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
     } | {
         readonly id: string;
         readonly type: "reasoning-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;

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"];