@opencode/ai 0.0.0-dev-20035 → 0.0.0-dev-20038

package/dist/protocols/openai-images.js

@@ -48,18 +48,7 @@ const blob = (data, mediaType) => {
     new Uint8Array(buffer).set(data);
     return new Blob([buffer], { type: mediaType });
 };
-const reference = (asset) => {
-    const inline = asset.inline();
-    if (inline)
-        return Effect.succeed({ image_url: inline.dataUrl });
-    const url = ProviderShared.mediaUrl(asset);
-    if (url)
-        return Effect.succeed({ image_url: url });
-    const id = MediaInput.refID(asset, PROVIDER);
-    if (id)
-        return Effect.succeed({ file_id: id });
-    return Effect.fail(ProviderShared.invalidRequest("OpenAI Images accepts image URLs, data URLs, bytes, and OpenAI file IDs"));
-};
+const reference = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((item) => (item.type === "ref" ? { file_id: item.value } : { image_url: item.value })));
 const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
     const images = request.images ?? [];
     const mask = request.mask;

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

@@ -0,0 +1,38 @@
+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.dev.runwayml.com/v1";
+/** Every Runway request must pin the API version. */
+export declare const API_VERSION = "2024-11-06";
+export declare const TEXT_TO_VIDEO_PATH = "/text_to_video";
+export declare const IMAGE_TO_VIDEO_PATH = "/image_to_video";
+export declare const VIDEO_TO_VIDEO_PATH = "/video_to_video";
+export declare const TASKS_PATH = "/tasks";
+export type RunwayVideoString<Known extends string> = Known | (string & {});
+/**
+ * Provider-native options. Common fields lower to Runway's names: `aspectRatio` → `ratio` (Runway expects pixel
+ * ratios such as `1280:720` for most models), `durationSeconds` → `duration`, `audio`, `negativePrompt`,
+ * `resolution`, `references`, and `frames` → `promptImage`.
+ */
+export type RunwayVideoOptions = {
+    readonly contentModeration?: {
+        readonly publicFigureThreshold?: RunwayVideoString<"auto" | "low">;
+    };
+    readonly outputFormat?: RunwayVideoString<"mp4" | "prores" | "png_sequence">;
+} & Record<string, unknown>;
+export type Request = VideoRequestFor<RunwayVideoOptions>;
+export declare const Token: Schema.Struct<{
+    readonly taskID: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {
+    readonly taskID: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => VideoModel<RunwayVideoOptions>;
+export declare const RunwayVideo: {
+    readonly protocol: MediaProtocol.Queued<Request, VideoResponse, {
+        readonly taskID: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => VideoModel<RunwayVideoOptions>;
+};

package/dist/protocols/runway-video.js

@@ -0,0 +1,146 @@
+import { Duration, 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, optionalArray, optionalNull } from "./shared.js";
+const ADAPTER = "runway-video";
+const NAME = "Runway";
+const PROVIDER = ProviderID.make("runway");
+export const DEFAULT_BASE_URL = "https://api.dev.runwayml.com/v1";
+/** Every Runway request must pin the API version. */
+export const API_VERSION = "2024-11-06";
+export const TEXT_TO_VIDEO_PATH = "/text_to_video";
+export const IMAGE_TO_VIDEO_PATH = "/image_to_video";
+export const VIDEO_TO_VIDEO_PATH = "/video_to_video";
+export const TASKS_PATH = "/tasks";
+/** Output URLs are valid for 24–48 hours; the asset carries the conservative bound. */
+const OUTPUT_RETENTION = Duration.hours(24);
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+export const Token = Schema.Struct({ taskID: Schema.String });
+const Cost = Schema.Struct({ credits: Schema.Number });
+const StartResponse = Schema.Struct({ id: Schema.String });
+const Task = Schema.Struct({
+    status: Schema.String,
+    progress: optionalNull(Schema.Number),
+    output: optionalArray(Schema.String),
+    failure: optionalNull(Schema.String),
+    failureCode: optionalNull(Schema.String),
+    cost: Schema.optional(Cost),
+    estimatedCost: Schema.optional(Cost),
+});
+const STATUS = {
+    PENDING: "queued",
+    THROTTLED: "queued",
+    RUNNING: "running",
+    SUCCEEDED: "completed",
+    FAILED: "failed",
+    CANCELLED: "cancelled",
+};
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+// Runway accepts HTTPS URLs, `runway://` upload URIs, and data URIs, all as one string.
+const mediaUri = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((reference) => reference.value));
+const fromRequest = Effect.fn("RunwayVideo.fromRequest")(function* (request) {
+    const first = request.frames?.first === undefined ? undefined : yield* mediaUri(request.frames.first);
+    const last = request.frames?.last === undefined ? undefined : yield* mediaUri(request.frames.last);
+    const promptImage = [
+        ...(first === undefined ? [] : [{ uri: first, position: "first" }]),
+        ...(last === undefined ? [] : [{ uri: last, position: "last" }]),
+    ];
+    const videoUri = request.video === undefined ? undefined : yield* mediaUri(request.video);
+    const references = yield* Effect.forEach(request.references ?? [], (asset) => mediaUri(asset).pipe(Effect.map((uri) => ({ uri }))));
+    return MediaProtocol.json(mergeJsonRecords({
+        model: request.model.id,
+        promptText: request.prompt,
+        promptImage: promptImage.length === 0 ? undefined : promptImage,
+        videoUri,
+        references: references.length === 0 ? undefined : references,
+        ratio: request.aspectRatio,
+        duration: request.durationSeconds,
+        resolution: request.resolution,
+        audio: request.audio,
+        negativePrompt: request.negativePrompt,
+        seed: request.seed,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+    token: { taskID: value.id },
+    snapshot: { id: value.id, status: "queued" },
+}));
+const decodeTask = MediaProtocol.decodeJson(ADAPTER, NAME, Task);
+const decodeStatus = Effect.fn("RunwayVideo.decodeStatus")(function* (response, context) {
+    const output = yield* decodeTask(response);
+    const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
+    return { id: context.token.taskID, status, progress: output.value.progress ?? undefined };
+});
+const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (response, context) {
+    const output = yield* decodeTask(response);
+    const task = output.value;
+    const status = yield* MediaProtocol.status(STATUS, task.status, output);
+    if (status === "failed") {
+        const code = task.failureCode ?? undefined;
+        const message = `${NAME} task failed${code === undefined ? "" : ` (${code})`}${task.failure ? `: ${task.failure}` : ""}`;
+        // Runway failure codes are dotted paths; every moderation outcome carries a SAFETY segment.
+        if (code !== undefined && /(^|\.)SAFETY(\.|$)/.test(code))
+            return yield* output.contentPolicy(message);
+        return yield* output.ended("failed", message);
+    }
+    if (status === "cancelled")
+        return yield* output.ended("cancelled", `${NAME} task ${context.token.taskID} was cancelled`);
+    if (status !== "completed")
+        return yield* output.invalid(`${NAME} task ${context.token.taskID} has not finished`);
+    const urls = task.output ?? [];
+    if (urls.length === 0)
+        return yield* output.invalid(`${NAME} task succeeded without any output`);
+    return new VideoResponse({
+        videos: yield* Effect.forEach(urls, (url) => MediaProtocol.expiringUrl(url, OUTPUT_RETENTION, { mediaType: "video/mp4" })),
+        usage: task.cost === undefined ? undefined : { type: "credits", credits: task.cost.credits },
+        providerMetadata: {
+            runway: {
+                taskId: context.token.taskID,
+                estimatedCredits: task.estimatedCost?.credits,
+            },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+const taskPath = (token) => `${TASKS_PATH}/${token.taskID}`;
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    unsupported: ["n"],
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: taskPath, decode: decodeStatus },
+    result: { path: taskPath, decode: decodeResult },
+    cancel: { method: "DELETE", path: taskPath },
+});
+const startPath = (request) => {
+    if (request.video !== undefined)
+        return VIDEO_TO_VIDEO_PATH;
+    if (request.frames?.first !== undefined || request.frames?.last !== undefined)
+        return IMAGE_TO_VIDEO_PATH;
+    return TEXT_TO_VIDEO_PATH;
+};
+export const model = (input) => VideoModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    headers: { "X-Runway-Version": API_VERSION },
+    path: ({ request }) => startPath(request),
+}, input);
+export const RunwayVideo = {
+    protocol,
+    model,
+};

package/dist/protocols/shared.d.ts

@@ -116,6 +116,16 @@ export declare const requireInlineMedia: (route: string, asset: Media.Asset) =>
 export declare const inlineRequired: (route: string, asset: Media.Asset) => AIError;
 /** The remote URL of a `url` asset, for protocols that accept `http(s)` references natively. */
 export declare const mediaUrl: (asset: Media.Asset) => string | undefined;
+export type MediaReference = {
+    readonly type: "dataUrl" | "url" | "ref";
+    readonly value: string;
+};
+/**
+ * The one string a provider can address an asset by: inline payloads as a data URL, `url` sources as their URL, and
+ * this provider's own `ref` as its id. Other providers' refs are never forwarded and fail typed; omit `provider` for
+ * APIs with no file handles at all.
+ */
+export declare const mediaReference: (asset: Media.Asset, provider: ProviderID | undefined, label: string) => Effect.Effect<MediaReference, AIError>;
 /**
  * Lift a tool-result file into a `MediaPart`. Tool files carry either a data URL, an `http(s)` URL, or raw base64 in
  * `uri`; the declared `mime` wins over any data-URL prefix so tool authors control the type the model sees.

package/dist/protocols/shared.js

@@ -134,6 +134,23 @@ export const requireInlineMedia = (route, asset) => {
 export const inlineRequired = (route, asset) => invalidRequest(`${route} requires inline media (bytes or base64); ${asset.source.type} sources must be materialized first`);
 /** The remote URL of a `url` asset, for protocols that accept `http(s)` references natively. */
 export const mediaUrl = (asset) => (asset.source.type === "url" ? asset.source.url : undefined);
+/**
+ * The one string a provider can address an asset by: inline payloads as a data URL, `url` sources as their URL, and
+ * this provider's own `ref` as its id. Other providers' refs are never forwarded and fail typed; omit `provider` for
+ * APIs with no file handles at all.
+ */
+export const mediaReference = (asset, provider, label) => {
+    const inline = asset.inline();
+    if (inline)
+        return Effect.succeed({ type: "dataUrl", value: inline.dataUrl });
+    const url = mediaUrl(asset);
+    if (url)
+        return Effect.succeed({ type: "url", value: url });
+    if (provider !== undefined && asset.source.type === "ref" && asset.source.provider === provider)
+        return Effect.succeed({ type: "ref", value: asset.source.id });
+    const accepted = provider === undefined ? "" : `, and ${provider} references`;
+    return Effect.fail(invalidRequest(`${label} accepts inline bytes, data URLs, http(s) URLs${accepted}`));
+};
 /**
  * Lift a tool-result file into a `MediaPart`. Tool files carry either a data URL, an `http(s)` URL, or raw base64 in
  * `uri`; the declared `mime` wins over any data-URL prefix so tool authors control the type the model sees.

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-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

@@ -129,8 +129,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/providers/fal.d.ts

@@ -0,0 +1,24 @@
+import type { ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { FalVideoOptions } from "../protocols/fal-video.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/fal-video.js").FalVideoOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/fal-video.js").FalVideoOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/fal-video.js").FalVideoOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/fal-video.js").FalVideoOptions>;

package/dist/providers/fal.js

@@ -0,0 +1,29 @@
+import { Auth } from "../route/auth.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { DEFAULT_BASE_URL, FalVideo } from "../protocols/fal-video.js";
+export const id = ProviderID.make("fal");
+const baseURL = DEFAULT_BASE_URL;
+// fal authenticates with `Authorization: Key <FAL_KEY>` rather than a bearer token.
+const auth = (options) => {
+    if ("auth" in options && options.auth)
+        return options.auth;
+    return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+        .orElse(Auth.config("FAL_KEY"))
+        .pipe(Auth.scheme("Key"));
+};
+export const configure = (input = {}) => {
+    const video = (modelID) => FalVideo.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return {
+        id,
+        video,
+        configure,
+    };
+};
+export const provider = configure();
+export const video = provider.video;

package/dist/providers/google.d.ts

@@ -4,6 +4,7 @@ import type { ProviderPackage } from "../provider-package.js";
 import { type ModelID } from "../schema/index.js";
 import { Gemini } from "../protocols/gemini.js";
 export type { GoogleImageOptions } from "../protocols/google-images.js";
+export type { GoogleVideoOptions } from "../protocols/google-video.js";
 export type GeminiOptionsInput = Gemini.OptionsInput;
 export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
@@ -104,18 +105,22 @@ export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
+        video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"];
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
+export declare const video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;

package/dist/providers/google.js

@@ -2,6 +2,7 @@ import { Auth } from "../route/auth.js";
 import { HttpOptions, ProviderID, mergeHttpOptions } from "../schema/index.js";
 import { Gemini } from "../protocols/gemini.js";
 import { GoogleImages } from "../protocols/google-images.js";
+import { GoogleVideo } from "../protocols/google-video.js";
 export const id = ProviderID.make("google");
 export const routes = [Gemini.route];
 const auth = (options) => {
@@ -17,7 +18,7 @@ const configuredRoute = (input) => {
 };
 export const configure = (input = {}) => {
     const route = configuredRoute(input);
-    const image = (modelID) => GoogleImages.model({
+    const media = (modelID) => ({
         id: modelID,
         auth: auth(input),
         baseURL: input.baseURL,
@@ -27,7 +28,8 @@ export const configure = (input = {}) => {
     return {
         id,
         model: (modelID) => route.model({ id: modelID }),
-        image,
+        image: (modelID) => GoogleImages.model(media(modelID)),
+        video: (modelID) => GoogleVideo.model(media(modelID)),
         configure,
     };
 };
@@ -40,3 +42,4 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
     providerOptions,
 }).model(modelID);
 export const image = provider.image;
+export const video = provider.video;

package/dist/providers/index.d.ts

@@ -10,6 +10,7 @@ export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js";
 export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js";
 export * as DeepInfra from "./deepinfra.js";
 export * as DeepSeek from "./deepseek.js";
+export * as Fal from "./fal.js";
 export * as Fireworks from "./fireworks.js";
 export * as Google from "./google.js";
 export * as GoogleVertex from "./google-vertex.js";
@@ -26,6 +27,7 @@ export * as OpenAICompatible from "./openai-compatible.js";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
 export * as OpenCodeZen from "./opencode-zen.js";
 export * as OpenRouter from "./openrouter.js";
+export * as Runway from "./runway.js";
 export * as TogetherAI from "./togetherai.js";
 export * as TypeSafeAI from "./typesafe-ai.js";
 export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/index.js

@@ -10,6 +10,7 @@ export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js";
 export * as CloudflareWorkersAI from "./cloudflare-workers-ai.js";
 export * as DeepInfra from "./deepinfra.js";
 export * as DeepSeek from "./deepseek.js";
+export * as Fal from "./fal.js";
 export * as Fireworks from "./fireworks.js";
 export * as Google from "./google.js";
 export * as GoogleVertex from "./google-vertex.js";
@@ -26,6 +27,7 @@ export * as OpenAICompatible from "./openai-compatible.js";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
 export * as OpenCodeZen from "./opencode-zen.js";
 export * as OpenRouter from "./openrouter.js";
+export * as Runway from "./runway.js";
 export * as TogetherAI from "./togetherai.js";
 export * as TypeSafeAI from "./typesafe-ai.js";
 export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/runway.d.ts

@@ -0,0 +1,24 @@
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { RunwayVideoOptions } from "../protocols/runway-video.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/runway-video.js").RunwayVideoOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/runway-video.js").RunwayVideoOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/runway-video.js").RunwayVideoOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/runway-video.js").RunwayVideoOptions>;