@opencode/ai 2.0.14 → 2.0.16

package/dist/protocols/deepgram-transcription.js

@@ -0,0 +1,129 @@
+import { Effect, Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
+import { ProviderShared } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "deepgram-transcription";
+const NAME = "Deepgram";
+const PROVIDER = ProviderID.make("deepgram");
+export const DEFAULT_BASE_URL = "https://api.deepgram.com";
+export const PATH = "/v1/listen";
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+const Word = Schema.Struct({
+    word: Schema.String,
+    start: Schema.Number,
+    end: Schema.Number,
+    confidence: Schema.optional(Schema.Number),
+    speaker: Schema.optional(Schema.Number),
+    punctuated_word: Schema.optional(Schema.String),
+});
+const ListenResponse = Schema.Struct({
+    metadata: Schema.optional(Schema.Struct({ request_id: Schema.optional(Schema.String), duration: Schema.optional(Schema.Number) })),
+    results: Schema.Struct({
+        channels: Schema.Array(Schema.Struct({
+            alternatives: Schema.optional(Schema.Array(Schema.Struct({ transcript: Schema.String, words: Schema.optional(Schema.Array(Word)) }))),
+            detected_language: Schema.optional(Schema.String),
+        })),
+        utterances: Schema.optional(Schema.Array(Schema.Struct({
+            start: Schema.Number,
+            end: Schema.Number,
+            transcript: Schema.String,
+            speaker: Schema.optional(Schema.Number),
+            words: Schema.optional(Schema.Array(Word)),
+        }))),
+    }),
+});
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const query = (request) => MediaInput.query(ADAPTER, mergeJsonRecords({
+    model: request.model.id,
+    smart_format: true,
+    language: request.language,
+    // Deepgram assumes English unless asked to detect, unlike the other routes' auto-detection.
+    detect_language: request.language === undefined ? true : undefined,
+    // `diarize=true` is deprecated in favor of choosing a diarization model.
+    diarize_model: request.diarize === true ? "latest" : undefined,
+    utterances: request.diarize === true || request.timestamps === "segment" ? true : undefined,
+}, request.providerOptions) ?? {});
+const fromRequest = Effect.fn("DeepgramTranscription.fromRequest")(function* (request) {
+    const url = ProviderShared.mediaUrl(request.audio);
+    if (url !== undefined)
+        return MediaProtocol.json(mergeJsonRecords({ url }, request.http?.body) ?? {}, yield* query(request));
+    if (request.http?.body !== undefined)
+        return yield* ProviderShared.invalidRequest(`${NAME} sends inline audio as the raw body, so http.body cannot apply`);
+    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+    return MediaProtocol.binary(audio, request.audio.mediaType, yield* query(request));
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeListen = MediaProtocol.decodeJson(ADAPTER, NAME, ListenResponse);
+const speaker = (value) => (value === undefined ? undefined : String(value));
+const wordText = (word) => word.punctuated_word ?? word.word;
+// Utterances split on pauses, not speakers: the v2 diarizer labels a whole utterance with one speaker even when its
+// words change speaker, so segments split each utterance at speaker changes.
+const speakerTurns = (words) => words.reduce((turns, word) => {
+    const last = turns.at(-1);
+    if (last === undefined || last[0].speaker !== word.speaker)
+        return [...turns, [word]];
+    last.push(word);
+    return turns;
+}, []);
+const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(function* (response) {
+    const output = yield* decodeListen(response);
+    const channel = output.value.results.channels[0];
+    const alternative = channel?.alternatives?.[0];
+    if (alternative === undefined)
+        return yield* output.invalid(`${NAME} returned no transcript`);
+    const duration = output.value.metadata?.duration;
+    const requestID = output.value.metadata?.request_id;
+    return new TranscriptionResponse({
+        text: alternative.transcript,
+        segments: output.value.results.utterances?.flatMap((utterance) => utterance.words === undefined || utterance.words.length === 0
+            ? [
+                {
+                    text: utterance.transcript,
+                    startSeconds: utterance.start,
+                    endSeconds: utterance.end,
+                    speaker: speaker(utterance.speaker),
+                },
+            ]
+            : speakerTurns(utterance.words).map((turn) => ({
+                text: turn.map(wordText).join(" "),
+                startSeconds: turn[0].start,
+                endSeconds: turn[turn.length - 1].end,
+                speaker: speaker(turn[0].speaker),
+            }))),
+        words: alternative.words?.map((word) => ({
+            text: wordText(word),
+            startSeconds: word.start,
+            endSeconds: word.end,
+            speaker: speaker(word.speaker),
+            confidence: word.confidence,
+        })),
+        language: channel?.detected_language?.toLowerCase(),
+        durationSeconds: duration,
+        usage: duration === undefined ? undefined : { type: "seconds", seconds: duration },
+        providerMetadata: requestID === undefined ? undefined : { deepgram: { requestId: requestID } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["prompt", "speakers"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const model = (input) => TranscriptionModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const DeepgramTranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/elevenlabs-speech.d.ts

@@ -0,0 +1,122 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { SpeechModel, type SpeechRequestFor } from "../speech.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+export declare const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
+export declare const PATH = "/v1/text-to-speech";
+export type ElevenLabsSpeechString<Known extends string> = Known | (string & {});
+export type ElevenLabsOutputFormat = ElevenLabsSpeechString<"mp3_22050_32" | "mp3_24000_48" | "mp3_44100_32" | "mp3_44100_64" | "mp3_44100_96" | "mp3_44100_128" | "mp3_44100_192" | "pcm_8000" | "pcm_16000" | "pcm_22050" | "pcm_24000" | "pcm_32000" | "pcm_44100" | "pcm_48000" | "wav_8000" | "wav_16000" | "wav_22050" | "wav_24000" | "wav_32000" | "wav_44100" | "wav_48000" | "ulaw_8000" | "alaw_8000" | "opus_48000_32" | "opus_48000_64" | "opus_48000_96" | "opus_48000_128" | "opus_48000_192">;
+export type ElevenLabsSpeechOptions = {
+    readonly outputFormat?: ElevenLabsOutputFormat;
+    readonly voice_settings?: {
+        readonly stability?: number;
+        readonly similarity_boost?: number;
+        readonly style?: number;
+        readonly use_speaker_boost?: boolean;
+    };
+    readonly seed?: number;
+    readonly apply_text_normalization?: ElevenLabsSpeechString<"auto" | "on" | "off">;
+} & Record<string, unknown>;
+export type Request = SpeechRequestFor<ElevenLabsSpeechOptions>;
+export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly type: "audio-delta";
+    readonly chunk: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly type: "timestamps";
+    readonly items: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+    }[];
+} | {
+    readonly type: "finish";
+    readonly audio: import("../media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly usage?: {
+        readonly type: "tokens";
+        readonly input?: number | undefined;
+        readonly output?: number | undefined;
+        readonly total?: number | undefined;
+        readonly details?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "seconds";
+        readonly seconds: number;
+    } | {
+        readonly type: "characters";
+        readonly characters: number;
+    } | {
+        readonly type: "credits";
+        readonly credits: number;
+    } | {
+        readonly type: "compute";
+        readonly seconds: number;
+    } | undefined;
+    readonly notices?: readonly {
+        readonly type: "other" | "moderated" | "filtered";
+        readonly message: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    }[] | undefined;
+}, string | Uint8Array<ArrayBufferLike>, SpeechStream.Audio>;
+export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<ElevenLabsSpeechOptions>;
+export declare const ElevenLabsSpeech: {
+    readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly type: "audio-delta";
+        readonly chunk: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly type: "timestamps";
+        readonly items: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+        }[];
+    } | {
+        readonly type: "finish";
+        readonly audio: import("../media.js").Asset;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly usage?: {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "seconds";
+            readonly seconds: number;
+        } | {
+            readonly type: "characters";
+            readonly characters: number;
+        } | {
+            readonly type: "credits";
+            readonly credits: number;
+        } | {
+            readonly type: "compute";
+            readonly seconds: number;
+        } | undefined;
+        readonly notices?: readonly {
+            readonly type: "other" | "moderated" | "filtered";
+            readonly message: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }[] | undefined;
+    }, string | Uint8Array<ArrayBufferLike>, SpeechStream.Audio>;
+    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<ElevenLabsSpeechOptions>;
+};

package/dist/protocols/elevenlabs-speech.js

@@ -0,0 +1,115 @@
+import { Effect, Schema } from "effect";
+import { Framing } from "../route/framing.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { SpeechModel } from "../speech.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+const ADAPTER = "elevenlabs-speech";
+const NAME = "ElevenLabs";
+const PROVIDER = ProviderID.make("elevenlabs");
+export const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
+export const PATH = "/v1/text-to-speech";
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const Alignment = Schema.Struct({
+    characters: Schema.Array(Schema.String),
+    character_start_times_seconds: Schema.Array(Schema.Number),
+    character_end_times_seconds: Schema.Array(Schema.Number),
+});
+const TimestampedAudio = Schema.Struct({
+    audio_base64: Schema.Uint8ArrayFromBase64,
+    alignment: optionalNull(Alignment),
+});
+const decodeRecord = MediaProtocol.decodeFrame(ADAPTER, NAME, TimestampedAudio);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const OUTPUT_FORMATS = {
+    mp3: "mp3_44100_128",
+    pcm: "pcm_24000",
+    wav: "wav_24000",
+    opus: "opus_48000_64",
+};
+/** WAV is served only by the non-streaming endpoints. */
+const outputFormat = Effect.fn("ElevenLabsSpeech.outputFormat")(function* (request) {
+    const format = request.providerOptions?.outputFormat ?? OUTPUT_FORMATS[request.format ?? "mp3"];
+    if (format === undefined)
+        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} has no default output format for "${request.format}"; pass providerOptions.outputFormat`);
+    if (request.mode === "stream" && format.startsWith("wav_"))
+        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} streams mp3, pcm, opus, ulaw, and alaw but not "${format}"; use generate for WAV`);
+    return format;
+});
+const fromRequest = Effect.fn("ElevenLabsSpeech.fromRequest")(function* (request) {
+    if (request.voice === undefined)
+        return yield* ProviderShared.invalidRequest(`${NAME} requires a voice id; pass it as \`voice\``);
+    const { outputFormat: _outputFormat, ...native } = request.providerOptions ?? {};
+    return MediaProtocol.json(mergeJsonRecords({
+        text: request.text,
+        model_id: request.model.id,
+        language_code: request.language,
+        voice_settings: request.speed === undefined ? undefined : { speed: request.speed },
+    }, native, request.http?.body) ?? {}, { output_format: yield* outputFormat(request) });
+});
+const path = (request) => `${PATH}/${encodeURIComponent(SpeechStream.voiceID(request.voice) ?? "")}${request.mode === "stream" ? "/stream" : ""}${request.timestamps === true ? "/with-timestamps" : ""}`;
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const onRecord = Effect.fn("ElevenLabsSpeech.onRecord")(function* (state, frame) {
+    const record = yield* decodeRecord(frame);
+    const [next, events] = SpeechStream.delta(state, record.audio_base64);
+    const alignment = record.alignment;
+    if (!alignment)
+        return [next, events];
+    return [
+        next,
+        [
+            ...events,
+            ...SpeechStream.timestamps(alignment.characters, alignment.character_start_times_seconds, alignment.character_end_times_seconds),
+        ],
+    ];
+});
+const PCM_CODECS = {
+    pcm: "pcm_s16le",
+    ulaw: "pcm_mulaw",
+    alaw: "pcm_alaw",
+};
+const describeOutput = (format) => {
+    const [codec = format, rate] = format.split("_");
+    const sampleRate = rate === undefined ? undefined : Number(rate);
+    const encoding = PCM_CODECS[codec];
+    return encoding === undefined ? SpeechStream.container(codec, sampleRate) : SpeechStream.pcm(encoding, sampleRate);
+};
+const finish = Effect.fn("ElevenLabsSpeech.finish")(function* (state, context) {
+    const requestID = context.http.headers["request-id"];
+    return yield* SpeechStream.finish(ADAPTER, state, {
+        ...describeOutput(yield* outputFormat(context.request)),
+        // `character-cost` is billed credits, not a character count (3 for 20 characters on `eleven_flash_v2_5`).
+        usage: SpeechStream.headerUsage("credits", context.http.headers["character-cost"]),
+        providerMetadata: requestID === undefined ? undefined : { elevenlabs: { requestId: requestID } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["instructions"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => {
+        if (context.request.timestamps !== true)
+            return bytes;
+        return context.request.mode === "stream" ? Framing.lines.frame(bytes) : Framing.document.frame(bytes);
+    },
+    initial: () => ({ chunks: [] }),
+    step: SpeechStream.step(onRecord),
+    finish,
+});
+export const model = (input) => SpeechModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => path(request) }, input);
+export const ElevenLabsSpeech = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,24 @@
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+export type FalImageOptions = {
+    readonly image_size?: "square_hd" | "square" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9" | (string & {});
+    readonly enable_safety_checker?: boolean;
+} & Record<string, unknown>;
+export type Request = ImageRequestFor<FalImageOptions>;
+export declare const protocol: MediaProtocol.Queued<Request, ImageResponse, {
+    readonly requestID: string;
+    readonly statusURL: string;
+    readonly responseURL: string;
+    readonly cancelURL: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<FalImageOptions>;
+export declare const FalImages: {
+    readonly protocol: MediaProtocol.Queued<Request, ImageResponse, {
+        readonly requestID: string;
+        readonly statusURL: string;
+        readonly responseURL: string;
+        readonly cancelURL: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<FalImageOptions>;
+};

package/dist/protocols/fal-images.js

@@ -0,0 +1,114 @@
+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 { FalQueue } from "./utils/fal-queue.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "fal-images";
+const NAME = "fal Images";
+const PROVIDER = ProviderID.make("fal");
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+const QueueResult = Schema.StructWithRest(Schema.Struct({
+    images: Schema.Array(Schema.Struct({
+        url: Schema.String,
+        width: optionalNull(Schema.Number),
+        height: optionalNull(Schema.Number),
+        content_type: optionalNull(Schema.String),
+    })),
+    seed: optionalNull(Schema.Number),
+    has_nsfw_concepts: optionalNull(Schema.Array(Schema.Boolean)),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const sizing = (model) => {
+    if (/^fal-ai\/(nano-banana|flux-pro\/v1\.1-ultra)/.test(model))
+        return "aspect_ratio";
+    if (model.startsWith("fal-ai/flux"))
+        return "image_size";
+    return undefined;
+};
+const unsupported = (model, field, message) => ProviderShared.unsupportedOperation({
+    operation: `media.${field}`,
+    provider: PROVIDER,
+    route: ADAPTER,
+    message: `${model} ${message}`,
+});
+const validate = (request) => {
+    const id = request.model.id;
+    const field = sizing(id);
+    if (request.size !== undefined && request.aspectRatio !== undefined)
+        return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts either size or aspectRatio, not both`));
+    if (request.size !== undefined && field === "aspect_ratio")
+        return Effect.fail(unsupported(id, "size", "sizes by aspectRatio"));
+    if (request.aspectRatio !== undefined && field === "image_size")
+        return Effect.fail(unsupported(id, "aspectRatio", "sizes by size (image_size)"));
+    if ((request.images?.length ?? 0) > 1 && !isEdit(id))
+        return Effect.fail(unsupported(id, "images", "takes one image_url; use an /edit endpoint for several images"));
+    return Effect.void;
+};
+// `/edit` endpoints take an `image_urls` list; image-to-image, fill, and Ultra take one `image_url` (beside `mask_url`).
+const isEdit = (model) => model.endsWith("/edit");
+const fromRequest = Effect.fn("FalImages.fromRequest")(function* (request) {
+    yield* validate(request);
+    const images = yield* Effect.forEach(request.images ?? [], (image) => FalQueue.mediaUrl(image, NAME));
+    const edit = isEdit(request.model.id);
+    return MediaProtocol.json(mergeJsonRecords({
+        prompt: request.prompt,
+        num_images: request.n,
+        seed: request.seed,
+        image_size: request.size === undefined ? undefined : MediaInput.dimensions(request.size),
+        aspect_ratio: request.aspectRatio,
+        output_format: request.format,
+        image_urls: edit && images.length > 0 ? images : undefined,
+        image_url: edit ? undefined : images[0],
+        mask_url: request.mask === undefined ? undefined : yield* FalQueue.mediaUrl(request.mask, NAME),
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeQueueResult = MediaProtocol.decodeJson(ADAPTER, NAME, QueueResult);
+const decodeResult = Effect.fn("FalImages.decodeResult")(function* (response, context) {
+    const output = yield* decodeQueueResult(response);
+    const { images, seed, has_nsfw_concepts, ...rest } = output.value;
+    if (images.length === 0)
+        return yield* output.invalid(`${NAME} returned no images`);
+    // With the safety checker on, flagged images come back blacked out rather than omitted.
+    const flagged = (has_nsfw_concepts ?? []).flatMap((value, index) => (value ? [index] : []));
+    return new ImageResponse({
+        images: images.map((image) => Media.url(image.url, {
+            mediaType: image.content_type ?? undefined,
+            info: { width: image.width ?? undefined, height: image.height ?? undefined },
+        })),
+        notices: flagged.length === 0
+            ? undefined
+            : flagged.map((index) => ({ type: "moderated", message: `${NAME} flagged image ${index} as NSFW` })),
+        providerMetadata: { fal: { requestId: context.token.requestID, seed: seed ?? undefined, ...rest } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = FalQueue.protocol({
+    id: ADAPTER,
+    name: NAME,
+    from: fromRequest,
+    decodeResult,
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: FalQueue.DEFAULT_BASE_URL,
+    path: ({ request }) => `/${request.model.id}`,
+}, input);
+export const FalImages = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,29 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
+export type FalVideoString<Known extends string> = Known | (string & {});
+/**
+ * Provider-native input. fal video endpoints are model-specific: `duration` is a string enum whose values differ per
+ * model (`"8s"` for Veo, `"5"` for Kling), and last-frame fields are named per model (`end_image_url`,
+ * `last_frame_url`, `tail_image_url`), so those pass through here instead of lowering from common fields.
+ */
+export type FalVideoOptions = {
+    readonly duration?: FalVideoString<"4s" | "6s" | "8s" | "5" | "10">;
+} & Record<string, unknown>;
+export type Request = VideoRequestFor<FalVideoOptions>;
+export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {
+    readonly requestID: string;
+    readonly statusURL: string;
+    readonly responseURL: string;
+    readonly cancelURL: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => VideoModel<FalVideoOptions>;
+export declare const FalVideo: {
+    readonly protocol: MediaProtocol.Queued<Request, VideoResponse, {
+        readonly requestID: string;
+        readonly statusURL: string;
+        readonly responseURL: string;
+        readonly cancelURL: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => VideoModel<FalVideoOptions>;
+};

package/dist/protocols/fal-video.js

@@ -0,0 +1,88 @@
+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";
+import { FalQueue } from "./utils/fal-queue.js";
+const ADAPTER = "fal-video";
+const NAME = "fal Video";
+const PROVIDER = ProviderID.make("fal");
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+const QueueResult = Schema.StructWithRest(Schema.Struct({
+    video: Schema.Struct({
+        url: Schema.String,
+        content_type: optionalNull(Schema.String),
+        file_name: optionalNull(Schema.String),
+        file_size: optionalNull(Schema.Number),
+    }),
+    seed: optionalNull(Schema.Number),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request) {
+    if (request.frames?.last !== undefined)
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "video.frames.last",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${NAME} names the last frame per model; pass it through providerOptions (e.g. end_image_url) instead of frames.last`,
+        });
+    const imageUrl = request.frames?.first === undefined ? undefined : yield* FalQueue.mediaUrl(request.frames.first, NAME);
+    const videoUrl = request.video === undefined ? undefined : yield* FalQueue.mediaUrl(request.video, NAME);
+    return MediaProtocol.json(mergeJsonRecords({
+        prompt: request.prompt,
+        negative_prompt: request.negativePrompt,
+        seed: request.seed,
+        aspect_ratio: request.aspectRatio,
+        resolution: request.resolution,
+        generate_audio: request.audio,
+        image_url: imageUrl,
+        video_url: videoUrl,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeQueueResult = MediaProtocol.decodeJson(ADAPTER, NAME, QueueResult);
+const decodeResult = Effect.fn("FalVideo.decodeResult")(function* (response, context) {
+    const output = yield* decodeQueueResult(response);
+    const { video, seed, ...rest } = output.value;
+    return new VideoResponse({
+        videos: [Media.url(video.url, { mediaType: video.content_type ?? "video/mp4" })],
+        providerMetadata: {
+            fal: {
+                requestId: context.token.requestID,
+                seed: seed ?? undefined,
+                fileName: video.file_name ?? undefined,
+                fileSize: video.file_size ?? undefined,
+                ...rest,
+            },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = FalQueue.protocol({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["n", "durationSeconds", "references"],
+    from: fromRequest,
+    decodeResult,
+});
+export const model = (input) => VideoModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: FalQueue.DEFAULT_BASE_URL,
+    path: ({ request }) => `/${request.model.id}`,
+}, input);
+export const FalVideo = {
+    protocol,
+    model,
+};