@opencode/ai 0.0.0-dev-20061 → 0.0.0-dev-20065

package/dist/media-model.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { Endpoint } from "./route/endpoint.js";
-import type { MediaRoute } from "./route/media.js";
+import { MediaRoute } from "./route/media.js";
 import type { MediaProtocol } from "./route/media-protocol.js";
 import { AIError, HttpOptions, ModelID, ProviderID } from "./schema/index.js";
 /**
@@ -33,10 +33,12 @@ export declare namespace MediaModel {
         /** Headers the protocol requires on every call, such as a pinned API version; deployment headers win. */
         readonly headers?: Record<string, string>;
     }
+    type AnyRouteInput<Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token> = RouteInput<Request, MediaProtocol.Inline<Request, Response>> | RouteInput<MediaProtocol.Addressed<Request>, MediaProtocol.Streamed<Request, Event, Frame, State>> | RouteInput<Request, MediaProtocol.Queued<Request, Response, Token>>;
 }
 /** Compose a protocol route input with one deployment through `MediaRoute.inline`, `queued`, or `stream`. */
 export declare const composeRoute: <Request extends MediaRoute.MediaRequest, Protocol, Route>(compose: (input: MediaRoute.Composition<Request> & {
     readonly protocol: Protocol;
 }) => Route, route: MediaModel.RouteInput<Request, Protocol>, input: MediaRoute.ModelInput) => Route;
+export declare const composeAnyRoute: <Request extends MediaRoute.MediaRequest, Event, Response, Frame, State, Token>(route: MediaModel.AnyRouteInput<Request, Event, Response, Frame, State, Token>, input: MediaRoute.ModelInput, collect: (events: ReadonlyArray<Event>) => Effect.Effect<Response, AIError>) => MediaRoute.AnyRoute<Request, Event, Response>;
 /** Lift a synchronous Schema-class constructor into a typed `InvalidRequest` failure. */
 export declare const tryRequest: <A>(make: () => A) => Effect.Effect<A, AIError>;

package/dist/media-model.js

@@ -1,5 +1,6 @@
 import { Effect } from "effect";
 import { Endpoint } from "./route/endpoint.js";
+import { MediaRoute } from "./route/media.js";
 import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID } from "./schema/index.js";
 /**
  * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
@@ -27,6 +28,15 @@ export const composeRoute = (compose, route, input) => compose({
     auth: input.auth,
     headers: route.headers === undefined && input.headers === undefined ? undefined : { ...route.headers, ...input.headers },
 });
+export const composeAnyRoute = (route, input, collect) => {
+    if (isStreamInput(route))
+        return composeRoute((composition) => MediaRoute.stream({ ...composition, collect }), route, input);
+    if (isQueuedInput(route))
+        return composeRoute(MediaRoute.queued, route, input);
+    return composeRoute(MediaRoute.inline, route, input);
+};
+const isStreamInput = (route) => route.protocol.kind === "stream";
+const isQueuedInput = (route) => route.protocol.kind === "queued";
 /** Lift a synchronous Schema-class constructor into a typed `InvalidRequest` failure. */
 export const tryRequest = (make) => Effect.try({
     try: make,

package/dist/promise.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Layer } from "effect";
 import type { AwaitOptions, Snapshot } from "./generation.js";
-import { ImageModel, ImageRequest, type ImageRequestInput } from "./image.js";
+import { ImageModel, ImageRequest, type ImageOptions, type ImageRequestInput } from "./image.js";
 import { ImageClient } from "./image-client.js";
 import { LLMClient } from "./route/client.js";
 import { RequestExecutor } from "./route/executor.js";
@@ -253,8 +253,20 @@ export declare const make: (options?: Options) => {
     };
     image: {
         request: typeof import("./image.js").request;
-        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<import("./image.js").ImageResponse>;
-        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => AsyncIterable<{
+        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: AwaitOptions & RunOptions) => Promise<import("./image.js").ImageResponse>;
+        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: import("./media.js").Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
             readonly image: import("./media.js").Asset;
@@ -296,6 +308,8 @@ export declare const make: (options?: Options) => {
                 } | undefined;
             }[] | undefined;
         }>;
+        start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
     };
     video: {
         request: typeof import("./video.js").request;
@@ -709,8 +723,20 @@ export declare const ai: {
     };
     image: {
         request: typeof import("./image.js").request;
-        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<import("./image.js").ImageResponse>;
-        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => AsyncIterable<{
+        generate: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: AwaitOptions & RunOptions) => Promise<import("./image.js").ImageResponse>;
+        stream: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: AwaitOptions & RunOptions) => AsyncIterable<{
+            readonly id: string;
+            readonly type: "generation-queued";
+            readonly position?: number | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "generation-progress";
+            readonly progress?: number | undefined;
+        } | {
+            readonly type: "image-partial";
+            readonly index: number;
+            readonly image: import("./media.js").Asset;
+        } | {
             readonly type: "image";
             readonly index: number;
             readonly image: import("./media.js").Asset;
@@ -752,6 +778,8 @@ export declare const ai: {
                 } | undefined;
             }[] | undefined;
         }>;
+        start: <const Model extends ImageModel>(input: ImageRequestInput<Model> | ImageRequest, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
+        resume: <Options extends ImageOptions>(model: ImageModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./image.js").ImageResponse>>;
     };
     video: {
         request: typeof import("./video.js").request;

package/dist/promise.js

@@ -49,8 +49,10 @@ export const make = (options = {}) => {
         },
         image: {
             request: Image.request,
-            generate: (input, options) => run(Image.generate(imageRequest(input)), options),
-            stream: (input, options) => iterate(Image.stream(imageRequest(input)), options),
+            generate: (input, options) => run(Image.generate(imageRequest(input), { poll: options?.poll }), options),
+            stream: (input, options) => iterate(Image.stream(imageRequest(input), { poll: options?.poll }), options),
+            start: (input, options) => run(Image.start(imageRequest(input)), options).then(handle),
+            resume: (model, token, options) => run(Image.resume(model, token), options).then(handle),
         },
         video: {
             request: Video.request,

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

@@ -0,0 +1,32 @@
+import { Schema } from "effect";
+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.bfl.ai";
+export type BlackForestLabsImageOptions = {
+    readonly safety_tolerance?: number;
+    readonly prompt_upsampling?: boolean;
+    readonly disable_pup?: boolean;
+    readonly raw?: boolean;
+    readonly guidance?: number;
+    readonly steps?: number;
+} & Record<string, unknown>;
+export type Request = ImageRequestFor<BlackForestLabsImageOptions>;
+/** Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. */
+export declare const Token: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly pollingURL: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, ImageResponse, {
+    readonly id: string;
+    readonly pollingURL: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<BlackForestLabsImageOptions>;
+export declare const BlackForestLabsImages: {
+    readonly protocol: MediaProtocol.Queued<Request, ImageResponse, {
+        readonly id: string;
+        readonly pollingURL: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<BlackForestLabsImageOptions>;
+};

package/dist/protocols/bfl-images.js

@@ -0,0 +1,153 @@
+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 { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "bfl-images";
+const NAME = "Black Forest Labs";
+const PROVIDER = ProviderID.make("black-forest-labs");
+export const DEFAULT_BASE_URL = "https://api.bfl.ai";
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+/** Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. */
+export const Token = Schema.Struct({ id: Schema.String, pollingURL: Schema.String });
+const StartResponse = Schema.Struct({
+    id: Schema.String,
+    polling_url: Schema.String,
+});
+const Result = Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    result: optionalNull(Schema.StructWithRest(Schema.Struct({ sample: Schema.String, seed: optionalNull(Schema.Number), prompt: optionalNull(Schema.String) }), [Schema.Record(Schema.String, Schema.Unknown)])),
+    cost: optionalNull(Schema.Number),
+});
+const STATUS = {
+    Pending: "running",
+    Reasoning: "running",
+    Generating: "running",
+    Ready: "completed",
+    Error: "failed",
+    // Moderation is terminal; `decodeResult` reports it as a content-policy failure.
+    "Content Moderated": "failed",
+    "Request Moderated": "failed",
+    "Task not found": "expired",
+};
+const isModerated = (status) => status === "Content Moderated" || status === "Request Moderated";
+const capabilities = (model) => {
+    if (model.startsWith("flux-pro-1.0-fill"))
+        return { sizing: "none", imageField: "image", maxImages: 1, mask: true };
+    if (model.startsWith("flux-pro-1.0-expand"))
+        return { sizing: "none", imageField: "image", maxImages: 1, mask: false };
+    if (model.startsWith("flux-kontext"))
+        return { sizing: "aspectRatio", imageField: "input_image", maxImages: 4, mask: false };
+    if (model.startsWith("flux-pro-1.1-ultra"))
+        return { sizing: "aspectRatio", imageField: "image_prompt", maxImages: 1, mask: false };
+    if (model.startsWith("flux-pro-1.1") || model.startsWith("flux-dev"))
+        return { sizing: "dimensions", imageField: "image_prompt", maxImages: 1, mask: false };
+    if (model.startsWith("flux-2-klein"))
+        return { sizing: "dimensions", imageField: "input_image", maxImages: 4, mask: false };
+    return { sizing: "dimensions", imageField: "input_image", maxImages: 8, mask: false };
+};
+const unsupported = (model, field, message) => ProviderShared.unsupportedOperation({
+    operation: `media.${field}`,
+    provider: PROVIDER,
+    route: ADAPTER,
+    message: `${model} ${message}`,
+});
+const validate = (request, model) => {
+    const id = request.model.id;
+    const images = request.images?.length ?? 0;
+    if (request.n !== undefined && request.n > 1)
+        return Effect.fail(unsupported(id, "n", "generates one image per request; call it once per image"));
+    if (request.size !== undefined && model.sizing !== "dimensions")
+        return Effect.fail(unsupported(id, "size", "does not take size (width and height)"));
+    if (request.aspectRatio !== undefined && model.sizing !== "aspectRatio")
+        return Effect.fail(unsupported(id, "aspectRatio", "does not take aspectRatio"));
+    if (images > model.maxImages)
+        return Effect.fail(unsupported(id, "images", `takes at most ${model.maxImages} images`));
+    if (request.mask !== undefined && !model.mask)
+        return Effect.fail(unsupported(id, "mask", "does not inpaint; use flux-pro-1.0-fill"));
+    return Effect.void;
+};
+const imageInput = (asset) => {
+    const value = asset.inline()?.base64 ?? ProviderShared.mediaUrl(asset);
+    if (value === undefined)
+        return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts inline images or https URLs`));
+    return Effect.succeed(value);
+};
+const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (request) {
+    const model = capabilities(request.model.id);
+    yield* validate(request, model);
+    const images = yield* Effect.forEach(request.images ?? [], imageInput);
+    const fields = images.map((image, index) => [
+        index === 0 ? model.imageField : `${model.imageField}_${index + 1}`,
+        image,
+    ]);
+    return MediaProtocol.json(mergeJsonRecords({
+        prompt: request.prompt,
+        ...(request.size === undefined ? {} : MediaInput.dimensions(request.size)),
+        aspect_ratio: request.aspectRatio,
+        seed: request.seed,
+        output_format: request.format,
+        mask: request.mask === undefined ? undefined : yield* imageInput(request.mask),
+        ...Object.fromEntries(fields),
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+    token: { id: value.id, pollingURL: value.polling_url },
+    snapshot: { id: value.id, status: "queued" },
+}));
+const decodeDocument = MediaProtocol.decodeJson(ADAPTER, NAME, Result);
+const decodeStatus = Effect.fn("BlackForestLabsImages.decodeStatus")(function* (response, context) {
+    const output = yield* decodeDocument(response);
+    return { id: context.token.id, status: yield* MediaProtocol.status(STATUS, output.value.status, output) };
+});
+const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (response, context) {
+    const output = yield* decodeDocument(response);
+    const document = output.value;
+    const status = yield* MediaProtocol.status(STATUS, document.status, output);
+    if (isModerated(document.status))
+        return yield* output.contentPolicy(`${NAME} moderated the generation`);
+    if (status === "failed" || status === "expired")
+        return yield* output.ended(status, `${NAME} generation ${context.token.id} ended with ${document.status}`);
+    if (status !== "completed" || document.result === undefined || document.result === null)
+        return yield* output.invalid(`${NAME} generation ${context.token.id} has no result`);
+    const { sample, seed, prompt, ...rest } = document.result;
+    return new ImageResponse({
+        // `sample` is a signed URL that expires 10 minutes after the result is ready, so it is downloaded now.
+        images: [yield* context.materialize(Media.url(sample))],
+        usage: document.cost === undefined || document.cost === null ? undefined : { type: "credits", credits: document.cost },
+        providerMetadata: {
+            bfl: { id: context.token.id, seed: seed ?? undefined, prompt: prompt ?? undefined, ...rest },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: (token) => token.pollingURL, decode: decodeStatus },
+    result: { path: (token) => token.pollingURL, decode: decodeResult },
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => `/v1/${request.model.id}`,
+}, input);
+export const BlackForestLabsImages = {
+    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

@@ -1,8 +1,6 @@
-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://queue.fal.run";
 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
@@ -13,14 +11,6 @@ export type FalVideoOptions = {
     readonly duration?: FalVideoString<"4s" | "6s" | "8s" | "5" | "10">;
 } & Record<string, unknown>;
 export type Request = VideoRequestFor<FalVideoOptions>;
-/** fal hands back absolute follow-up URLs on submit; they are authoritative for status, result, and cancel. */
-export declare const Token: Schema.Struct<{
-    readonly requestID: Schema.String;
-    readonly statusURL: Schema.String;
-    readonly responseURL: Schema.String;
-    readonly cancelURL: Schema.String;
-}>;
-export type Token = Schema.Schema.Type<typeof Token>;
 export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {
     readonly requestID: string;
     readonly statusURL: string;

package/dist/protocols/fal-video.js

@@ -5,32 +5,13 @@ 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");
-export const DEFAULT_BASE_URL = "https://queue.fal.run";
 // ---------------------------------------------------------------------------
-// 2. Token and response schemas
+// 2. Response schema
 // ---------------------------------------------------------------------------
-/** fal hands back absolute follow-up URLs on submit; they are authoritative for status, result, and cancel. */
-export const Token = Schema.Struct({
-    requestID: Schema.String,
-    statusURL: Schema.String,
-    responseURL: Schema.String,
-    cancelURL: Schema.String,
-});
-const StartResponse = Schema.Struct({
-    request_id: Schema.String,
-    status_url: Schema.String,
-    response_url: Schema.String,
-    cancel_url: Schema.String,
-    queue_position: optionalNull(Schema.Number),
-});
-const QueueStatus = Schema.Struct({
-    status: Schema.String,
-    queue_position: optionalNull(Schema.Number),
-    error: optionalNull(Schema.Unknown),
-});
 const QueueResult = Schema.StructWithRest(Schema.Struct({
     video: Schema.Struct({
         url: Schema.String,
@@ -40,16 +21,9 @@ const QueueResult = Schema.StructWithRest(Schema.Struct({
     }),
     seed: optionalNull(Schema.Number),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-const STATUS = {
-    IN_QUEUE: "queued",
-    IN_PROGRESS: "running",
-    COMPLETED: "completed",
-};
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
-// fal accepts public URLs and data URIs; there is no provider file handle to forward.
-const mediaUrl = (asset) => ProviderShared.mediaReference(asset, undefined, NAME).pipe(Effect.map((reference) => reference.value));
 const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request) {
     if (request.frames?.last !== undefined)
         return yield* ProviderShared.unsupportedOperation({
@@ -58,8 +32,8 @@ const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request) {
             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* mediaUrl(request.frames.first);
-    const videoUrl = request.video === undefined ? undefined : yield* mediaUrl(request.video);
+    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,
@@ -74,29 +48,7 @@ const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request) {
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
-    token: {
-        requestID: value.request_id,
-        statusURL: value.status_url,
-        responseURL: value.response_url,
-        cancelURL: value.cancel_url,
-    },
-    snapshot: { id: value.request_id, status: "queued", position: value.queue_position ?? undefined },
-}));
-const decodeQueueStatus = MediaProtocol.decodeJson(ADAPTER, NAME, QueueStatus);
 const decodeQueueResult = MediaProtocol.decodeJson(ADAPTER, NAME, QueueResult);
-const decodeStatus = Effect.fn("FalVideo.decodeStatus")(function* (response, context) {
-    const output = yield* decodeQueueStatus(response);
-    const decoded = output.value;
-    const status = yield* MediaProtocol.status(STATUS, decoded.status, output);
-    // fal reports request failures as COMPLETED with an `error`; the response endpoint carries the details.
-    const failed = status === "completed" && decoded.error !== undefined && decoded.error !== null;
-    return {
-        id: context.token.requestID,
-        status: failed ? "failed" : status,
-        position: status === "queued" ? (decoded.queue_position ?? undefined) : undefined,
-    };
-});
 const decodeResult = Effect.fn("FalVideo.decodeResult")(function* (response, context) {
     const output = yield* decodeQueueResult(response);
     const { video, seed, ...rest } = output.value;
@@ -116,21 +68,18 @@ const decodeResult = Effect.fn("FalVideo.decodeResult")(function* (response, con
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.queued({
+export const protocol = FalQueue.protocol({
     id: ADAPTER,
     name: NAME,
-    token: Token,
     unsupported: ["n", "durationSeconds", "references"],
-    start: { body: { from: fromRequest }, decode: decodeStart },
-    status: { path: (token) => token.statusURL, decode: decodeStatus },
-    result: { path: (token) => token.responseURL, decode: decodeResult },
-    cancel: { method: "PUT", path: (token) => token.cancelURL },
+    from: fromRequest,
+    decodeResult,
 });
 export const model = (input) => VideoModel.fromRoute({
     id: ADAPTER,
     provider: PROVIDER,
     protocol,
-    baseURL: DEFAULT_BASE_URL,
+    baseURL: FalQueue.DEFAULT_BASE_URL,
     path: ({ request }) => `/${request.model.id}`,
 }, input);
 export const FalVideo = {