@opencode/ai 2.0.14 → 2.0.16

package/dist/protocols/xai-images.js

@@ -1,14 +1,20 @@
-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 { Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
+import { Effect, Schema } from "effect";
+import { ImageModel, ImageResponse } from "../image.js";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared, optionalNull } from "./shared.js";
-import { ImageInputs } from "./utils/image-input.js";
+import { MediaInput } from "./utils/media-input.js";
 const ADAPTER = "xai-images";
+const NAME = "xAI Images";
+const PROVIDER = ProviderID.make("xai");
 export const DEFAULT_BASE_URL = "https://api.x.ai/v1";
 export const PATH = "/images/generations";
 export const EDIT_PATH = "/images/edits";
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
 const XAIImageResponse = Schema.Struct({
     data: Schema.Array(Schema.Struct({
         b64_json: optionalNull(Schema.String),
@@ -18,89 +24,74 @@ const XAIImageResponse = Schema.Struct({
     })),
     usage: Schema.optional(Schema.Unknown),
 });
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
 const nativeOptions = (options) => {
     if (!options)
         return undefined;
-    const { aspectRatio, responseFormat, ...native } = options;
-    return {
-        aspect_ratio: aspectRatio,
-        response_format: responseFormat,
-        ...native,
-    };
+    const { responseFormat, ...native } = options;
+    return { response_format: responseFormat, ...native };
 };
-const applyQuery = (url, query) => {
-    if (!query)
-        return url;
-    const next = new URL(url);
-    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
-    return next.toString();
-};
-export const model = (input) => {
-    const route = {
-        id: ADAPTER,
-        generate: Effect.fn("XAIImages.generate")(function* (request, execute) {
-            const http = mergeHttpOptions(request.model.http, request.http);
-            const imageReferences = (request.images ?? []).map((image) => {
-                if (image.type === "bytes")
-                    return { url: ImageInputs.dataUrl(image), type: "image_url" };
-                if (image.type === "url")
-                    return { url: image.url, type: "image_url" };
-                if (image.type === "file-id")
-                    return { file_id: image.id };
-                return undefined;
-            });
-            if (imageReferences.some((image) => image === undefined))
-                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,
-                image: imageReferences.length === 1 ? imageReferences[0] : undefined,
-                images: imageReferences.length > 1 ? imageReferences : undefined,
-            }, nativeOptions(request.options), http?.body);
-            const text = ProviderShared.encodeJson(requestBody);
-            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${imageReferences.length === 0 ? PATH : EDIT_PATH}`, http?.query);
-            const headers = yield* Auth.toEffect(input.auth)({
-                request,
-                method: "POST",
-                url,
-                body: text,
-                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-            });
-            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
-            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((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
-                            ? undefined
-                            : { xai: { revisedPrompt: item.revised_prompt } },
-                    })));
-                if (item.url)
-                    return Effect.succeed(new GeneratedImage({
-                        mediaType,
-                        data: item.url,
-                        providerMetadata: item.revised_prompt === undefined || item.revised_prompt === null
-                            ? undefined
-                            : { xai: { revisedPrompt: item.revised_prompt } },
-                    }));
-                return Effect.fail(output.invalid(`xAI Images result ${index} has neither image data nor a URL`));
-            });
-            if (images.length === 0)
-                return yield* output.invalid("xAI Images returned no images");
-            const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined;
-            return new ImageResponse({
-                images,
-                usage: usage === undefined ? undefined : new Usage({ providerMetadata: { xai: usage } }),
-                providerMetadata: usage === undefined ? undefined : { xai: { usage } },
+const isEdit = (request) => (request.images?.length ?? 0) > 0;
+const reference = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((item) => item.type === "ref" ? { file_id: item.value } : { url: item.value, type: "image_url" }));
+const fromRequest = Effect.fn("XAIImages.fromRequest")(function* (request) {
+    const references = yield* Effect.forEach(request.images ?? [], reference);
+    return MediaProtocol.json(mergeJsonRecords({
+        model: request.model.id,
+        prompt: request.prompt,
+        // xAI takes one edit source as `image` and several as `images`.
+        image: references.length === 1 ? references[0] : undefined,
+        images: references.length > 1 ? references : undefined,
+        n: request.n,
+        aspect_ratio: request.aspectRatio,
+    }, nativeOptions(request.providerOptions), request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeResponse = Effect.fn("XAIImages.decodeResponse")(function* (response) {
+    const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, XAIImageResponse)(response);
+    const decoded = output.value;
+    const images = yield* Effect.forEach(decoded.data, (item, index) => {
+        const providerMetadata = item.revised_prompt === undefined || item.revised_prompt === null
+            ? undefined
+            : { xai: { revisedPrompt: item.revised_prompt } };
+        if (item.b64_json)
+            return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, item.mime_type ?? undefined, {
+                providerMetadata,
             });
-        }),
-    };
-    return ImageModel.make({ id: input.id, provider: "xai", route, http: input.http });
-};
+        if (item.url)
+            return Effect.succeed(Media.url(item.url, { mediaType: item.mime_type ?? undefined, providerMetadata }));
+        return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`));
+    });
+    if (images.length === 0)
+        return yield* output.invalid(`${NAME} returned no images`);
+    const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined;
+    // xAI reports image counts rather than tokens, seconds, or credits; the raw record stays in provider metadata.
+    return new ImageResponse({
+        images,
+        providerMetadata: usage === undefined ? undefined : { xai: { usage } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["mask", "size", "seed", "format"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH),
+}, input);
 export const XAIImages = {
+    protocol,
     model,
 };

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

@@ -67,8 +67,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -104,8 +104,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";

package/dist/protocols/xai-video.d.ts

@@ -0,0 +1,34 @@
+import { Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
+export declare const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export declare const PATH = "/videos/generations";
+export declare const EDIT_PATH = "/videos/edits";
+export declare const EXTEND_PATH = "/videos/extensions";
+export declare const STATUS_PATH = "/videos";
+/**
+ * Provider-native options. Common fields (`frames`, `references`, `video`, `durationSeconds`, `aspectRatio`,
+ * `resolution`, `audio`) live on the request. `mode` selects the endpoint a `video` input is sent to.
+ */
+export type XAIVideoOptions = {
+    readonly mode?: "edit" | "extend";
+    readonly reference_audios?: ReadonlyArray<{
+        readonly voice_id: string;
+    }>;
+} & Record<string, unknown>;
+export type Request = VideoRequestFor<XAIVideoOptions>;
+export declare const Token: Schema.Struct<{
+    readonly requestID: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {
+    readonly requestID: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => VideoModel<XAIVideoOptions>;
+export declare const XAIVideo: {
+    readonly protocol: MediaProtocol.Queued<Request, VideoResponse, {
+        readonly requestID: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => VideoModel<XAIVideoOptions>;
+};

package/dist/protocols/xai-video.js

@@ -0,0 +1,147 @@
+import { Effect, Schema } from "effect";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { VideoModel, VideoResponse } from "../video.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+const ADAPTER = "xai-video";
+const NAME = "xAI Video";
+const PROVIDER = ProviderID.make("xai");
+export const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export const PATH = "/videos/generations";
+export const EDIT_PATH = "/videos/edits";
+export const EXTEND_PATH = "/videos/extensions";
+export const STATUS_PATH = "/videos";
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+export const Token = Schema.Struct({ requestID: Schema.String });
+const StartResponse = Schema.Struct({ request_id: Schema.String });
+const VideoStatus = Schema.Struct({
+    status: Schema.String,
+    progress: optionalNull(Schema.Number),
+    video: optionalNull(Schema.Struct({
+        url: optionalNull(Schema.String),
+        duration: optionalNull(Schema.Number),
+        respect_moderation: optionalNull(Schema.Boolean),
+    })),
+    error: optionalNull(Schema.Struct({
+        code: optionalNull(Schema.String),
+        message: optionalNull(Schema.String),
+    })),
+    model: optionalNull(Schema.String),
+});
+const STATUS = {
+    pending: "running",
+    done: "completed",
+    failed: "failed",
+    expired: "expired",
+};
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const mediaInput = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((reference) => (reference.type === "ref" ? { file_id: reference.value } : { url: reference.value })));
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { mode: _mode, ...native } = options;
+    return native;
+};
+const fromRequest = Effect.fn("XAIVideo.fromRequest")(function* (request) {
+    const image = request.frames?.first === undefined ? undefined : yield* mediaInput(request.frames.first);
+    const lastFrame = request.frames?.last === undefined ? undefined : yield* mediaInput(request.frames.last);
+    const video = request.video === undefined ? undefined : yield* mediaInput(request.video);
+    const references = yield* Effect.forEach(request.references ?? [], mediaInput);
+    return MediaProtocol.json(mergeJsonRecords({
+        model: request.model.id,
+        prompt: request.prompt,
+        image,
+        last_frame: lastFrame,
+        reference_images: references.length === 0 ? undefined : references,
+        video,
+        duration: request.durationSeconds,
+        aspect_ratio: request.aspectRatio,
+        resolution: request.resolution,
+        generate_audio: request.audio,
+    }, nativeOptions(request.providerOptions), request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+    token: { requestID: value.request_id },
+    snapshot: { id: value.request_id, status: "running" },
+}));
+// `progress` is undocumented but observed live as a 0..100 percentage (recorded cassette: 1 → 10 → 37 → 100).
+const fraction = (progress) => progress !== undefined && progress !== null && progress >= 0 && progress <= 100 ? progress / 100 : undefined;
+const decodeVideoStatus = MediaProtocol.decodeJson(ADAPTER, NAME, VideoStatus);
+const decodeStatus = Effect.fn("XAIVideo.decodeStatus")(function* (response, context) {
+    const output = yield* decodeVideoStatus(response);
+    const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
+    return { id: context.token.requestID, status, progress: fraction(output.value.progress) };
+});
+const decodeResult = Effect.fn("XAIVideo.decodeResult")(function* (response, context) {
+    const output = yield* decodeVideoStatus(response);
+    const decoded = output.value;
+    const status = yield* MediaProtocol.status(STATUS, decoded.status, output);
+    if (status === "running")
+        return yield* output.invalid(`${NAME} request ${context.token.requestID} has not finished`);
+    if (status === "failed") {
+        const code = decoded.error?.code ?? undefined;
+        const message = decoded.error?.message ?? undefined;
+        return yield* output.ended("failed", `${NAME} generation failed${code === undefined ? "" : ` (${code})`}${message === undefined ? "" : `: ${message}`}`);
+    }
+    if (status !== "completed")
+        return yield* output.ended("expired", `${NAME} request ${context.token.requestID} expired`);
+    // `respect_moderation: false` marks a filtered result; a URL may still be present, so report it as a notice.
+    const notices = decoded.video?.respect_moderation === false
+        ? [{ type: "moderated", message: `${NAME} flagged the generated video for moderation` }]
+        : undefined;
+    const url = decoded.video?.url ?? undefined;
+    if (url === undefined && notices !== undefined)
+        return yield* output.contentPolicy(`${NAME} withheld the video for moderation`);
+    if (url === undefined)
+        return yield* output.invalid(`${NAME} completed without a video URL`);
+    const duration = decoded.video?.duration ?? undefined;
+    return new VideoResponse({
+        videos: [
+            Media.url(url, {
+                mediaType: "video/mp4",
+                info: duration === undefined ? undefined : { durationSeconds: duration },
+            }),
+        ],
+        notices,
+        providerMetadata: { xai: { requestId: context.token.requestID, model: decoded.model ?? undefined } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+const statusPath = (token) => `${STATUS_PATH}/${token.requestID}`;
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    unsupported: ["n", "seed", "negativePrompt"],
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: statusPath, decode: decodeStatus },
+    result: { path: statusPath, decode: decodeResult },
+});
+// A source video goes to `/videos/edits` unless `providerOptions.mode` asks for an extension.
+const startPath = (request) => {
+    if (request.video === undefined)
+        return PATH;
+    return request.providerOptions?.mode === "extend" ? EXTEND_PATH : EDIT_PATH;
+};
+export const model = (input) => VideoModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => startPath(request),
+}, input);
+export const XAIVideo = {
+    protocol,
+    model,
+};

package/dist/protocols/zai-chat.d.ts

@@ -39,6 +39,12 @@ export declare const protocol: Protocol<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -54,6 +60,12 @@ export declare const protocol: Protocol<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -129,8 +141,8 @@ export declare const protocol: Protocol<{
     readonly response_format?: {
         readonly type: string;
     } | undefined;
-    readonly do_sample?: boolean | undefined;
     readonly request_id?: string | undefined;
+    readonly do_sample?: boolean | undefined;
 }, string, "[DONE]" | {
     readonly [x: string]: unknown;
     readonly error?: {

package/dist/protocols/zai-images.d.ts

@@ -1,22 +1,18 @@
-import { ImageModel } from "../image.js";
-import { type Definition as AuthDefinition } from "../route/auth.js";
-import { type HttpOptions } from "../schema/index.js";
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
 export declare const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
 export declare const PATH = "/images/generations";
 export type ZAIImageString<Known extends string> = Known | (string & {});
+/** Provider-native options. The common `size` field lives on the request. */
 export type ZAIImageOptions = {
-    readonly size?: ZAIImageString<"1024x1024" | "768x1344" | "864x1152" | "1344x768" | "1152x864" | "1440x720" | "720x1440">;
     readonly quality?: ZAIImageString<"hd" | "standard">;
     readonly userID?: string;
 } & Record<string, unknown>;
-export interface ModelInput {
-    readonly id: string;
-    readonly auth: AuthDefinition;
-    readonly baseURL?: string;
-    readonly headers?: Record<string, string>;
-    readonly http?: HttpOptions;
-}
-export declare const model: (input: ModelInput) => ImageModel<ZAIImageOptions>;
+export type Request = ImageRequestFor<ZAIImageOptions>;
+export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<ZAIImageOptions>;
 export declare const ZAIImages: {
-    readonly model: (input: ModelInput) => ImageModel<ZAIImageOptions>;
+    readonly protocol: MediaProtocol.Inline<Request, ImageResponse>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<ZAIImageOptions>;
 };

package/dist/protocols/zai-images.js

@@ -1,13 +1,17 @@
 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 { mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
-import { ProviderShared } from "./shared.js";
-import { ImageInputs } from "./utils/image-input.js";
+import { ImageModel, ImageResponse } from "../image.js";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
 const ADAPTER = "zai-images";
+const NAME = "Z.ai Images";
+const PROVIDER = ProviderID.make("zai");
 export const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
 export const PATH = "/images/generations";
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
 const ZAIImageResponse = Schema.Struct({
     created: Schema.optional(Schema.Int),
     id: Schema.optional(Schema.String),
@@ -18,62 +22,60 @@ const ZAIImageResponse = Schema.Struct({
         level: Schema.optional(Schema.Number),
     }))),
 });
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
 const nativeOptions = (options) => {
     if (!options)
         return undefined;
     const { userID, ...native } = options;
-    return {
-        user_id: userID,
-        ...native,
-    };
-};
-const applyQuery = (url, query) => {
-    if (!query)
-        return url;
-    const next = new URL(url);
-    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
-    return next.toString();
-};
-export const model = (input) => {
-    const route = {
-        id: ADAPTER,
-        generate: Effect.fn("ZAIImages.generate")(function* (request, execute) {
-            if ((request.images?.length ?? 0) > 0)
-                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);
-            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query);
-            const headers = yield* Auth.toEffect(input.auth)({
-                request,
-                method: "POST",
-                url,
-                body: text,
-                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-            });
-            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
-            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* output.invalid("Z.ai Images returned no images");
-            return new ImageResponse({
-                images: decoded.data.map((item) => new GeneratedImage({
-                    mediaType: "application/octet-stream",
-                    data: item.url,
-                })),
-                providerMetadata: {
-                    zai: {
-                        created: decoded.created,
-                        id: decoded.id,
-                        requestID: decoded.request_id,
-                        contentFilter: decoded.content_filter,
-                    },
-                },
-            });
-        }),
-    };
-    return ImageModel.make({ id: input.id, provider: "zai", route, http: input.http });
+    return { user_id: userID, ...native };
 };
+const fromRequest = Effect.fn("ZAIImages.fromRequest")(function* (request) {
+    return MediaProtocol.json(mergeJsonRecords({ model: request.model.id, prompt: request.prompt, size: request.size }, nativeOptions(request.providerOptions), request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeResponse = Effect.fn("ZAIImages.decodeResponse")(function* (response) {
+    const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, ZAIImageResponse)(response);
+    const decoded = output.value;
+    if (decoded.data.length === 0)
+        return yield* output.invalid(`${NAME} returned no images`);
+    const filters = decoded.content_filter ?? [];
+    return new ImageResponse({
+        // Z.ai returns only URLs and no content type; the media type resolves when the asset is materialized.
+        images: decoded.data.map((item) => Media.url(item.url)),
+        // Z.ai reports applied content filters alongside a successful result; surface them instead of dropping them.
+        notices: filters.length === 0
+            ? undefined
+            : filters.map((filter) => ({
+                type: "moderated",
+                message: `${NAME} applied a content filter${filter.role === undefined ? "" : ` for ${filter.role}`}${filter.level === undefined ? "" : ` at level ${filter.level}`}`,
+                providerMetadata: { zai: filter },
+            })),
+        providerMetadata: {
+            zai: {
+                created: decoded.created,
+                id: decoded.id,
+                requestID: decoded.request_id,
+                contentFilter: decoded.content_filter,
+            },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["images", "mask", "n", "aspectRatio", "seed", "format"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const model = (input) => ImageModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
 export const ZAIImages = {
+    protocol,
     model,
 };

package/dist/provider-error.js

@@ -65,6 +65,7 @@ const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error"
 // emits `image_content_policy_violation` as the native code.
 const CONTENT_POLICY_CODES = new Set([
     "content_filter",
+    "content_moderation",
     "responsibleaipolicyviolation",
     "content_policy_violation",
     "image_content_policy_violation",
@@ -157,6 +158,8 @@ function providerCodes(value) {
     const exception = isRecord(decoded.exception) ? decoded.exception : undefined;
     return [
         decoded.code,
+        // Stability's `{ id, name, errors }` bodies carry the code in `name`.
+        Array.isArray(decoded.errors) ? decoded.name : undefined,
         decoded.error_type,
         error?.code,
         error?.type,

package/dist/providers/alibaba.d.ts

@@ -39,6 +39,12 @@ export declare const routes: (Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly role: "user";
@@ -54,6 +60,12 @@ export declare const routes: (Route<{
             readonly image_url: {
                 readonly url: string;
             };
+        } | {
+            readonly type: "file";
+            readonly file: {
+                readonly filename: string;
+                readonly file_data: string;
+            };
         })[];
     } | {
         readonly [x: string]: unknown;
@@ -470,8 +482,8 @@ export declare const routes: (Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -507,8 +519,8 @@ export declare const routes: (Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";