@opencode/ai 2.0.15 → 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

@@ -1,8 +1,16 @@
 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. */

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

@@ -10,6 +10,24 @@ export const inlineBytes = (route, asset) => {
         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. */

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/xai-images.js

@@ -34,18 +34,7 @@ const nativeOptions = (options) => {
     return { response_format: responseFormat, ...native };
 };
 const isEdit = (request) => (request.images?.length ?? 0) > 0;
-const reference = (asset) => {
-    const inline = asset.inline();
-    if (inline)
-        return Effect.succeed({ url: inline.dataUrl, type: "image_url" });
-    const url = ProviderShared.mediaUrl(asset);
-    if (url)
-        return Effect.succeed({ url, type: "image_url" });
-    const id = MediaInput.refID(asset, PROVIDER);
-    if (id)
-        return Effect.succeed({ file_id: id });
-    return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts image URLs, data URLs, bytes, and xAI file IDs`));
-};
+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({

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