@opencode-ai/ai 0.0.0-next-15903 → 0.0.0-next-15906

package/README.md

@@ -63,6 +63,24 @@ yield *
   })
 ```
 
+xAI image models use the same request API with xAI-native controls:
+
+```ts
+yield *
+  Image.generate({
+    model: XAI.configure({ apiKey }).image("any-model-id"),
+    prompt,
+    options: {
+      n: 2,
+      aspectRatio: "16:9",
+      resolution: "1k",
+      responseFormat: "b64_json",
+      future_option: true,
+    },
+    http,
+  })
+```
+
 Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:
 
 ```ts

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

@@ -0,0 +1,25 @@
+import { ImageModel } from "../image";
+import { type Definition as AuthDefinition } from "../route/auth";
+import { type HttpOptions } from "../schema";
+export declare const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export declare const PATH = "/images/generations";
+export type XAIImageString<Known extends string> = Known | (string & {});
+export type XAIImageOptions = {
+    readonly n?: number;
+    readonly aspectRatio?: XAIImageString<"1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "2:3" | "3:2" | "9:19.5" | "19.5:9" | "9:20" | "20:9" | "1:2" | "2:1" | "auto">;
+    readonly aspect_ratio?: XAIImageString<"1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "2:3" | "3:2" | "9:19.5" | "19.5:9" | "9:20" | "20:9" | "1:2" | "2:1" | "auto">;
+    readonly resolution?: XAIImageString<"1k" | "2k">;
+    readonly responseFormat?: XAIImageString<"url" | "b64_json">;
+    readonly response_format?: XAIImageString<"url" | "b64_json">;
+} & 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<XAIImageOptions>;
+export declare const XAIImages: {
+    readonly model: (input: ModelInput) => ImageModel<XAIImageOptions>;
+};

package/dist/protocols/xai-images.js

@@ -0,0 +1,93 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse } from "../image";
+import { Auth } from "../route/auth";
+import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema";
+import { ProviderShared, optionalNull } from "./shared";
+const ADAPTER = "xai-images";
+export const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export const PATH = "/images/generations";
+const XAIImageResponse = Schema.Struct({
+    data: Schema.Array(Schema.Struct({
+        b64_json: optionalNull(Schema.String),
+        url: optionalNull(Schema.String),
+        revised_prompt: optionalNull(Schema.String),
+        mime_type: optionalNull(Schema.String),
+    })),
+    usage: Schema.optional(Schema.Unknown),
+});
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { aspectRatio, responseFormat, ...native } = options;
+    return {
+        aspect_ratio: aspectRatio,
+        response_format: responseFormat,
+        ...native,
+    };
+};
+const invalidOutput = (message) => new LLMError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+});
+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 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 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 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({
+                        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(invalidOutput(`xAI Images result ${index} has neither image data nor a URL`));
+            });
+            if (images.length === 0)
+                return yield* invalidOutput("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 } },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "xai", route, http: input.http });
+};
+export const XAIImages = {
+    model,
+};

package/dist/providers/xai.d.ts

@@ -5,6 +5,7 @@ export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">
 export type ModelOptions = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
 };
+export type { XAIImageOptions } from "../protocols/xai-images";
 export declare const routes: (import("../route").Route<{
     readonly messages: readonly (import("effect/Schema").Struct.ReadonlySide<{
         readonly role: import("effect/Schema").Literal<"system">;
@@ -162,6 +163,7 @@ export declare const configure: (input?: ModelOptions) => {
     model: (modelID: string | ModelID) => import("..").Model;
     responses: (modelID: string | ModelID) => import("..").Model;
     chat: (modelID: string | ModelID) => import("..").Model;
+    image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
     configure: (input?: ModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
@@ -169,14 +171,17 @@ export declare const provider: {
     model: (modelID: string | ModelID) => import("..").Model;
     responses: (modelID: string | ModelID) => import("..").Model;
     chat: (modelID: string | ModelID) => import("..").Model;
+    image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
     configure: (input?: ModelOptions) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
         model: (modelID: string | ModelID) => import("..").Model;
         responses: (modelID: string | ModelID) => import("..").Model;
         chat: (modelID: string | ModelID) => import("..").Model;
+        image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: (modelID: string | ModelID) => import("..").Model;
 export declare const responses: (modelID: string | ModelID) => import("..").Model;
 export declare const chat: (modelID: string | ModelID) => import("..").Model;
+export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./xai").XAIImageOptions>;

package/dist/providers/xai.js

@@ -1,8 +1,9 @@
 import { AuthOptions } from "../route/auth-options";
-import { ProviderID } from "../schema";
+import { HttpOptions, ProviderID } from "../schema";
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile";
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat";
 import * as OpenAIResponses from "../protocols/openai-responses";
+import { XAIImages } from "../protocols/xai-images";
 export const id = ProviderID.make("xai");
 export const routes = [OpenAIResponses.route, OpenAICompatibleChat.route];
 const auth = (options) => AuthOptions.bearer(options, "XAI_API_KEY");
@@ -29,11 +30,19 @@ export const configure = (input = {}) => {
     const chatRoute = configuredChatRoute(input);
     const responses = (modelID) => responsesRoute.model({ id: modelID });
     const chat = (modelID) => chatRoute.model({ id: modelID });
+    const image = (modelID) => XAIImages.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? OpenAICompatibleProfiles.profiles.xai.baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
     return {
         id,
         model: responses,
         responses,
         chat,
+        image,
         configure,
     };
 };
@@ -41,3 +50,4 @@ export const provider = configure();
 export const model = provider.model;
 export const responses = provider.responses;
 export const chat = provider.chat;
+export const image = provider.image;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-15903",
+  "version": "0.0.0-next-15906",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-beta.98",
-    "@opencode-ai/http-recorder": "0.0.0-next-15903",
+    "@opencode-ai/http-recorder": "0.0.0-next-15906",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-next-15903",
+    "@opencode-ai/schema": "0.0.0-next-15906",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.98",
     "google-auth-library": "10.5.0"