@opencode/ai 2.0.14 → 2.0.16

package/dist/protocols/utils/gemini-json-schema.js

@@ -0,0 +1,76 @@
+import { isRecord } from "../../utils/record.js";
+// Gemini's `parametersJsonSchema` accepts standard JSON Schema, but rejects a few shapes that
+// published tool schemas commonly contain. Rewrite only those and send everything else unchanged.
+const SCHEMA_MAPS = new Set([
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+    "dependentSchemas",
+    "dependencies",
+]);
+const VALUES = new Set(["const", "default", "enum", "examples", "dependentRequired"]);
+const mapValues = (record, map) => Object.fromEntries(Object.entries(record).map(([key, value]) => [key, map(value, key)]));
+const normalizeNode = (schema) => {
+    if (Array.isArray(schema))
+        return schema.map(normalizeNode);
+    if (!isRecord(schema))
+        return schema;
+    const properties = isRecord(schema.properties) ? schema.properties : undefined;
+    return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
+        if (VALUES.has(key))
+            return [[key, value]];
+        if (SCHEMA_MAPS.has(key) && isRecord(value))
+            return [[key, mapValues(value, normalizeNode)]];
+        // `required` may only name declared properties.
+        if (key === "required" && properties && Array.isArray(value))
+            return [[key, value.filter((name) => typeof name === "string" && Object.hasOwn(properties, name))]];
+        // Draft-04 boolean exclusive bounds become the numeric form.
+        if (key === "exclusiveMinimum" && typeof value === "boolean")
+            return value && typeof schema.minimum === "number" ? [[key, schema.minimum]] : [];
+        if (key === "exclusiveMaximum" && typeof value === "boolean")
+            return value && typeof schema.maximum === "number" ? [[key, schema.maximum]] : [];
+        if (key === "minimum" && schema.exclusiveMinimum === true)
+            return [];
+        if (key === "maximum" && schema.exclusiveMaximum === true)
+            return [];
+        // Draft-07 tuples (`items` array plus `additionalItems`) are `prefixItems` plus `items` in 2020-12.
+        if (key === "items" && Array.isArray(value))
+            return [["prefixItems", value.map(normalizeNode)]];
+        if (key === "additionalItems" && Array.isArray(schema.items))
+            return [["items", normalizeNode(value)]];
+        return [[key, normalizeNode(value)]];
+    }));
+};
+// Gemini accepts a recursive `$ref` only when the loop passes through an optional property or
+// potentially empty array `items`. Replace other self-references with an unconstrained schema.
+const cutLoops = (schema, target, safe) => {
+    if (Array.isArray(schema))
+        return schema.map((item) => cutLoops(item, target, safe));
+    if (!isRecord(schema))
+        return schema;
+    if (schema.$ref === target && !safe)
+        return {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    return mapValues(schema, (value, key) => {
+        if (VALUES.has(key))
+            return value;
+        if (key === "items")
+            return cutLoops(value, target, safe || !(Number(schema.minItems) > 0));
+        if (key === "properties" && isRecord(value))
+            return mapValues(value, (child, name) => cutLoops(child, target, safe || !required.includes(name)));
+        if (SCHEMA_MAPS.has(key) && isRecord(value))
+            return mapValues(value, (child) => cutLoops(child, target, safe));
+        return cutLoops(value, target, safe);
+    });
+};
+export const normalize = (schema) => {
+    const normalized = normalizeNode(schema);
+    if (!isRecord(normalized))
+        return {};
+    const result = cutLoops(mapValues(normalized, (value, key) => (key === "$defs" || key === "definitions") && isRecord(value)
+        ? mapValues(value, (def, name) => cutLoops(def, `#/${key}/${name}`, false))
+        : value), "#", false);
+    return isRecord(result) ? result : {};
+};
+export * as GeminiJsonSchema from "./gemini-json-schema.js";

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

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { Media } from "../../media.js";
+import type { MediaProtocol } from "../../route/media-protocol.js";
+import type { AIError, ProviderID } from "../../schema/index.js";
+/** Owned bytes for multipart uploads; decodes `base64` sources and rejects remote sources. */
+export declare const inlineBytes: (route: string, asset: Media.Asset) => Effect.Effect<Uint8Array, AIError>;
+/** Copied because `BlobPart` requires a plain `ArrayBuffer`. */
+export declare const blob: (data: Uint8Array, mediaType: string) => Blob;
+export declare const query: (route: string, values: Record<string, unknown>) => Effect.Effect<MediaProtocol.Query, AIError>;
+export declare const dimensions: (size: string) => {
+    width: number;
+    height: number;
+};
+/** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
+export declare const refID: (asset: Media.Asset, provider: ProviderID) => string | undefined;
+/** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */
+export declare const decodedAsset: (invalid: (message: string, cause?: unknown) => AIError, label: string, data: string, mediaType: string | undefined, options?: Media.AssetOptions) => Effect.Effect<Media.Asset, AIError, never>;
+export * as MediaInput from "./media-input.js";

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

@@ -0,0 +1,35 @@
+import { Effect, Encoding } from "effect";
+import { Media } from "../../media.js";
+import { ProviderShared } from "../shared.js";
+/** Owned bytes for multipart uploads; decodes `base64` sources and rejects remote sources. */
+export const inlineBytes = (route, asset) => {
+    if (asset.source.type === "bytes")
+        return Effect.succeed(asset.source.data);
+    const inline = asset.inline();
+    if (!inline)
+        return Effect.fail(ProviderShared.inlineRequired(route, asset));
+    return Effect.fromResult(Encoding.decodeBase64(inline.base64)).pipe(Effect.mapError((cause) => ProviderShared.invalidRequest(`${route} media contains invalid base64 data`, cause)));
+};
+/** Copied because `BlobPart` requires a plain `ArrayBuffer`. */
+export const blob = (data, mediaType) => {
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(data);
+    return new Blob([buffer], { type: mediaType });
+};
+const isScalar = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+export const query = (route, values) => {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    const invalid = entries.find(([, value]) => !isScalar(value) && !(Array.isArray(value) && value.every(isScalar)));
+    if (invalid !== undefined)
+        return Effect.fail(ProviderShared.invalidRequest(`${route} cannot send "${invalid[0]}" as a query parameter`));
+    return Effect.succeed(Object.fromEntries(entries.map(([key, value]) => [key, Array.isArray(value) ? value.map(String) : String(value)])));
+};
+export const dimensions = (size) => {
+    const [width, height] = size.split("x").map(Number);
+    return { width, height };
+};
+/** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
+export const refID = (asset, provider) => asset.source.type === "ref" && asset.source.provider === provider ? asset.source.id : undefined;
+/** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */
+export const decodedAsset = (invalid, label, data, mediaType, options) => Effect.fromResult(Encoding.decodeBase64(data)).pipe(Effect.mapError((cause) => invalid(`${label} contains invalid base64 data`, cause)), Effect.map((bytes) => Media.bytes(bytes, mediaType, options)));
+export * as MediaInput from "./media-input.js";

package/dist/protocols/utils/responses-compaction.js

@@ -6,6 +6,7 @@ import { RequestExecutor } from "../../route/executor.js";
 import { HttpTransport } from "../../route/transport/index.js";
 import { OpenResponses } from "../open-responses.js";
 import { JsonObject, optionalNull, ProviderShared } from "../shared.js";
+import { Media } from "../../media.js";
 const Body = Schema.Struct({
     model: Schema.String,
     input: Schema.Array(Schema.Unknown),
@@ -113,19 +114,19 @@ function toMessage(item, model) {
             if (part.type === "input_image")
                 return {
                     type: "media",
-                    data: part.image_url,
-                    mediaType: /^data:([^;,]+)/.exec(part.image_url)?.[1] ?? "image/*",
+                    media: replayMedia(part.image_url, "image/*"),
                     providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
                 };
-            const data = part.file_url === undefined ? part.file_data : part.file_url;
             return {
                 type: "media",
-                data,
+                media: replayMedia(part.file_url === undefined ? part.file_data : part.file_url, "application/octet-stream"),
                 filename: part.filename,
-                mediaType: /^data:([^;,]+)/.exec(data)?.[1] ?? "application/octet-stream",
                 providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
             };
         }),
     });
 }
+/** Replayed compaction items carry either a data URL or a remote URL; the data URL's own type wins when present. */
+const replayMedia = (value, fallbackType) => Media.parseDataUrl(value) ??
+    (/^https?:\/\//.test(value) ? Media.url(value, { mediaType: fallbackType }) : Media.base64(value, fallbackType));
 export * as ResponsesCompaction from "./responses-compaction.js";

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

@@ -0,0 +1,49 @@
+import { Effect } from "effect";
+import { Media } from "../../media.js";
+import type { AIError, MediaUsage, ProviderID, ProviderMetadata } from "../../schema/index.js";
+import { type SpeechEvent, type SpeechVoice } from "../../speech.js";
+export interface Audio {
+    /** Appended in place: the route creates fresh state for each response through `initial`. */
+    readonly chunks: Array<Uint8Array>;
+}
+export type StepResult<State> = readonly [State, ReadonlyArray<SpeechEvent>];
+/** Empty chunks (keep-alive records) emit nothing. */
+export declare const delta: <State extends Audio>(state: State, chunk: Uint8Array) => StepResult<State>;
+export declare const step: <State extends Audio>(onRecord: (state: State, frame: string) => Effect.Effect<StepResult<State>, AIError>) => (state: State, frame: string | Uint8Array) => Effect.Effect<StepResult<State>, AIError, never>;
+export declare const timestamps: (texts: ReadonlyArray<string>, starts: ReadonlyArray<number>, ends: ReadonlyArray<number>) => ReadonlyArray<SpeechEvent>;
+export declare const voiceID: (voice: SpeechVoice | undefined) => string | undefined;
+export declare const container: (format: string, sampleRate?: number) => {
+    mediaType: string;
+    info: {
+        format: string;
+        sampleRate: number | undefined;
+    };
+};
+declare const PCM_MEDIA_TYPES: {
+    readonly pcm_s16le: "audio/pcm";
+    readonly pcm_f32le: "audio/pcm";
+    readonly pcm_mulaw: "audio/mulaw";
+    readonly pcm_alaw: "audio/alaw";
+};
+export type PcmEncoding = keyof typeof PCM_MEDIA_TYPES;
+export declare const pcm: (encoding: PcmEncoding, sampleRate: number | undefined, mediaType?: string) => {
+    mediaType: string;
+    info: {
+        format: string;
+        encoding: "pcm_s16le" | "pcm_f32le" | "pcm_mulaw" | "pcm_alaw";
+        sampleRate: number | undefined;
+        channels: number;
+    };
+};
+export declare const sampleRate: (mediaType: string | undefined) => number | undefined;
+export declare const unsupportedFormat: (provider: ProviderID, route: string, message: string) => AIError;
+/** A declared `mediaType` wins over sniffing: headerless PCM can start with bytes that look like an MPEG frame sync. */
+export declare const finish: (route: string, state: Audio, output: {
+    readonly mediaType: string | undefined;
+    readonly info?: Media.Info;
+    readonly usage?: MediaUsage;
+    readonly providerMetadata?: ProviderMetadata;
+    readonly detail?: string;
+}) => Effect.Effect<ReadonlyArray<SpeechEvent>, AIError>;
+export declare const headerUsage: (type: "characters" | "credits", value: string | undefined) => MediaUsage | undefined;
+export * as SpeechStream from "./speech-stream.js";

package/dist/protocols/utils/speech-stream.js

@@ -0,0 +1,67 @@
+import { Effect } from "effect";
+import { Media } from "../../media.js";
+import { MediaProtocol } from "../../route/media-protocol.js";
+import { SpeechAudioDeltaEvent, SpeechFinishEvent, SpeechTimestampsEvent, } from "../../speech.js";
+import { concatBytes } from "../../utils/bytes.js";
+import { ProviderShared } from "../shared.js";
+/** Empty chunks (keep-alive records) emit nothing. */
+export const delta = (state, chunk) => {
+    if (chunk.length === 0)
+        return [state, []];
+    state.chunks.push(chunk);
+    return [state, [SpeechAudioDeltaEvent.make({ chunk })]];
+};
+export const step = (onRecord) => (state, frame) => typeof frame === "string" ? onRecord(state, frame) : Effect.succeed(delta(state, frame));
+export const timestamps = (texts, starts, ends) => texts.length === 0
+    ? []
+    : [
+        SpeechTimestampsEvent.make({
+            items: texts.map((text, index) => ({ text, startSeconds: starts[index] ?? 0, endSeconds: ends[index] ?? 0 })),
+        }),
+    ];
+export const voiceID = (voice) => (typeof voice === "object" ? voice.id : voice);
+const CONTAINER_MEDIA_TYPES = {
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    opus: "audio/ogg",
+    aac: "audio/aac",
+    flac: "audio/flac",
+};
+export const container = (format, sampleRate) => ({
+    mediaType: CONTAINER_MEDIA_TYPES[format],
+    info: { format, sampleRate },
+});
+const PCM_MEDIA_TYPES = {
+    pcm_s16le: "audio/pcm",
+    pcm_f32le: "audio/pcm",
+    pcm_mulaw: "audio/mulaw",
+    pcm_alaw: "audio/alaw",
+};
+export const pcm = (encoding, sampleRate, mediaType) => ({
+    mediaType: mediaType ?? PCM_MEDIA_TYPES[encoding],
+    info: { format: "pcm", encoding, sampleRate, channels: 1 },
+});
+export const sampleRate = (mediaType) => {
+    const rate = /rate=(\d+)/i.exec(mediaType ?? "")?.[1];
+    return rate === undefined ? undefined : Number(rate);
+};
+export const unsupportedFormat = (provider, route, message) => ProviderShared.unsupportedOperation({ operation: "media.format", provider, route, message });
+/** A declared `mediaType` wins over sniffing: headerless PCM can start with bytes that look like an MPEG frame sync. */
+export const finish = (route, state, output) => {
+    if (state.chunks.length === 0)
+        return Effect.fail(MediaProtocol.frameError(route, `The provider returned no audio${output.detail === undefined ? "" : ` (${output.detail})`}`));
+    return Effect.succeed([
+        SpeechFinishEvent.make({
+            audio: Media.bytes(concatBytes(state.chunks), output.mediaType, { info: output.info }),
+            usage: output.usage,
+            providerMetadata: output.providerMetadata,
+        }),
+    ]);
+};
+export const headerUsage = (type, value) => {
+    const amount = Number(value);
+    if (!Number.isFinite(amount))
+        return undefined;
+    return type === "credits" ? { type, credits: amount } : { type, characters: amount };
+};
+export * as SpeechStream from "./speech-stream.js";

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

@@ -1,7 +1,7 @@
-import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../schema/index.js";
+import type { JsonSchema, LanguageModel, LanguageModelSanitizerCompatibility } from "../../schema/index.js";
 export declare const ToolSchemaProjection: {
     readonly gemini: (schema: JsonSchema) => JsonSchema;
-    readonly modelCompatibility: (schema: JsonSchema, compatibility: LanguageModelToolSchemaCompatibility | undefined) => JsonSchema;
+    readonly modelCompatibility: (schema: JsonSchema, model: LanguageModel, protocolDefault?: LanguageModelSanitizerCompatibility) => JsonSchema;
     readonly moonshot: (schema: JsonSchema) => JsonSchema;
     readonly openAI: (schema: JsonSchema) => JsonSchema;
     readonly responses: (schema: JsonSchema) => JsonSchema;

package/dist/protocols/utils/tool-schema.js

@@ -1,5 +1,5 @@
 import { isRecord } from "../../utils/record.js";
-import { GeminiToolSchema } from "./gemini-tool-schema.js";
+import { GeminiJsonSchema } from "./gemini-json-schema.js";
 const tupleItemsSchema = (items) => {
     const projected = items.map(moonshotNode);
     if (projected.length === 0)
@@ -8,6 +8,17 @@ const tupleItemsSchema = (items) => {
         return projected[0];
     return { anyOf: projected };
 };
+// Moonshot rejects an `enum` without a sibling `type`. Its `type` may be one type, or one type plus "null".
+const enumType = (values) => {
+    const types = [
+        ...new Set(values.map((value) => (value === null ? "null" : Array.isArray(value) ? "array" : typeof value))),
+    ];
+    if (types.length === 1)
+        return types[0];
+    if (types.length === 2 && types.includes("null"))
+        return [...types.filter((type) => type !== "null"), "null"];
+    return undefined;
+};
 const moonshotNode = (schema) => {
     if (Array.isArray(schema))
         return schema.map(moonshotNode);
@@ -15,18 +26,22 @@ const moonshotNode = (schema) => {
         return schema;
     if (typeof schema.$ref === "string")
         return { $ref: schema.$ref };
-    return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
-        if (key === "items" && Array.isArray(value))
-            return [[key, tupleItemsSchema(value)]];
-        if (key === "prefixItems") {
-            if ("items" in schema)
+    const type = schema.type === undefined && Array.isArray(schema.enum) ? enumType(schema.enum) : undefined;
+    return Object.fromEntries([
+        ...(type === undefined ? [] : [["type", type]]),
+        ...Object.entries(schema).flatMap(([key, value]) => {
+            if (key === "items" && Array.isArray(value))
+                return [[key, tupleItemsSchema(value)]];
+            if (key === "prefixItems") {
+                if ("items" in schema)
+                    return [];
+                return [["items", tupleItemsSchema(Array.isArray(value) ? value : [])]];
+            }
+            if (key === "unevaluatedItems")
                 return [];
-            return [["items", tupleItemsSchema(Array.isArray(value) ? value : [])]];
-        }
-        if (key === "unevaluatedItems")
-            return [];
-        return [[key, moonshotNode(value)]];
-    }));
+            return [[key, moonshotNode(value)]];
+        }),
+    ]);
 };
 const moonshot = (schema) => {
     const projected = moonshotNode(schema);
@@ -34,15 +49,23 @@ const moonshot = (schema) => {
 };
 const openAI = (schema) => schema;
 const responses = openAI;
-const gemini = (schema) => GeminiToolSchema.convert(schema) ?? {};
-const modelCompatibility = (schema, compatibility) => {
-    if (compatibility === undefined)
-        return schema;
-    switch (compatibility) {
+const gemini = GeminiJsonSchema.normalize;
+const MODEL_NAMES = [
+    [/gemini/i, "gemini"],
+    [/kimi/i, "moonshot"],
+];
+// An explicit `sanitizer` wins, and `none` opts out. Otherwise the protocol's own default
+// applies (the Gemini API always uses Gemini's rules), then the model name selects the family's rules
+// so models reached through gateways and OpenAI-compatible endpoints get the same handling.
+const modelCompatibility = (schema, model, protocolDefault) => {
+    switch (model.compatibility?.sanitizer ?? protocolDefault ?? MODEL_NAMES.find(([name]) => name.test(model.id))?.[1]) {
         case "gemini":
             return gemini(schema);
         case "moonshot":
             return moonshot(schema);
+        case "none":
+        case undefined:
+            return schema;
     }
 };
 export const ToolSchemaProjection = {

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

@@ -244,6 +244,14 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
             };
         } | undefined;
         readonly namespace?: string | undefined;
+    } | {
+        readonly type: "media";
+        readonly media: import("../../media.js").Asset;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
     } | {
         readonly type: "step-finish";
         readonly reason: {
@@ -272,12 +280,12 @@ export declare const finish: <K extends StreamKey>(route: string, tools: State<K
     } | {
         readonly type: "provider-error";
         readonly message: string;
+        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
-        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     })[];
 }, AIError, never>;
 /**
@@ -459,6 +467,14 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
             };
         } | undefined;
         readonly namespace?: string | undefined;
+    } | {
+        readonly type: "media";
+        readonly media: import("../../media.js").Asset;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
     } | {
         readonly type: "step-finish";
         readonly reason: {
@@ -487,12 +503,12 @@ export declare const finishWithInput: <K extends StreamKey>(route: string, tools
     } | {
         readonly type: "provider-error";
         readonly message: string;
+        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
-        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     })[];
 }, AIError, never>;
 /**
@@ -671,6 +687,14 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
             };
         } | undefined;
         readonly namespace?: string | undefined;
+    } | {
+        readonly type: "media";
+        readonly media: import("../../media.js").Asset;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
     } | {
         readonly type: "step-finish";
         readonly reason: {
@@ -699,12 +723,12 @@ export declare const finishAll: <K extends StreamKey>(route: string, tools: Stat
     } | {
         readonly type: "provider-error";
         readonly message: string;
+        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
             };
         } | undefined;
-        readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     })[];
 }, AIError, never>;
 export * as ToolStream from "./tool-stream.js";

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

@@ -1,26 +1,20 @@
-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.x.ai/v1";
 export declare const PATH = "/images/generations";
 export declare const EDIT_PATH = "/images/edits";
 export type XAIImageString<Known extends string> = Known | (string & {});
+/** Provider-native options. Common fields (`n`, `aspectRatio`, `images`) live on the request. */
 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 type Request = ImageRequestFor<XAIImageOptions>;
+export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<XAIImageOptions>;
 export declare const XAIImages: {
-    readonly model: (input: ModelInput) => ImageModel<XAIImageOptions>;
+    readonly protocol: MediaProtocol.Inline<Request, ImageResponse>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<XAIImageOptions>;
 };