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

package/dist/media.js

@@ -27,8 +27,6 @@ const UrlSource = Schema.Struct({
     mediaType: Schema.optional(Schema.String),
     /** Epoch milliseconds after which the provider no longer serves the URL. */
     expiresAt: Schema.optional(Schema.Number),
-    /** Headers required to fetch the URL, such as provider auth for Veo downloads. */
-    headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 });
 /** A provider-side handle: OpenAI `file_id`, Gemini file URI, `gs://`, `runway://`, or a prior generation id. */
 const RefSource = Schema.Struct({
@@ -40,9 +38,7 @@ const RefSource = Schema.Struct({
 export const Source = Schema.Union([BytesSource, Base64Source, UrlSource, RefSource])
     .pipe(Schema.toTaggedUnion("type"))
     .annotate({ identifier: "Media.Source" });
-// ---------------------------------------------------------------------------
-// Kind, Info, Notice
-// ---------------------------------------------------------------------------
+export const AspectRatio = Schema.declare((value) => typeof value === "string" && /^\d+(?:\.\d+)?:\d+(?:\.\d+)?$/.test(value), { title: "Media.AspectRatio" });
 export const Kind = Schema.Literals(["image", "video", "audio", "document", "other"]);
 export const kindOf = (mediaType) => {
     const lower = mediaType.toLowerCase();
@@ -85,6 +81,8 @@ export class Asset {
     /** Epoch milliseconds after which a `url` source stops resolving. */
     expiresAt;
     providerMetadata;
+    /** Transient download credentials for `url` sources; see `Asset.Input.headers`. */
+    headers;
     // Derived payload forms are cached on the instance because every protocol lowering re-reads the same payload. The
     // cache is check-then-set (concurrent first reads of a `url` source may both download) and is never observable
     // through `source`, so round-tripping through `Media.from(asset.source)` stays lossless.
@@ -100,6 +98,7 @@ export class Asset {
         this.info = input.info;
         this.expiresAt = input.source.type === "url" ? input.source.expiresAt : undefined;
         this.providerMetadata = input.providerMetadata;
+        this.headers = input.source.type === "url" ? input.headers : undefined;
     }
     /** Inline payload without effects, for protocols that embed base64 or data URLs directly. */
     inline() {
@@ -122,7 +121,7 @@ export class Asset {
                 return Effect.fail(invalid(`Cannot materialize provider ref ${source.provider}:${source.id}`));
             const decoded = source.type === "base64"
                 ? Effect.fromResult(Encoding.decodeBase64(source.data)).pipe(Effect.mapError((cause) => invalid(`Media asset contains invalid base64 data`, cause)))
-                : download(source);
+                : download(source, this.headers);
             return decoded.pipe(Effect.tap((data) => Effect.sync(() => (this.#bytes = data))));
         });
     }
@@ -177,9 +176,9 @@ export const AssetSchema = AssetEncoded.pipe(Schema.decodeTo(AssetInstance, {
     decode: SchemaGetter.transform((encoded) => new Asset(encoded)),
     encode: SchemaGetter.transform(encodeAsset),
 }));
-const download = Effect.fn("Media.download")(function* (source) {
+const download = Effect.fn("Media.download")(function* (source, headers) {
     const executor = yield* Service;
-    const response = yield* executor.execute(HttpClientRequest.get(source.url).pipe(HttpClientRequest.setHeaders(source.headers ?? {})));
+    const response = yield* executor.execute(HttpClientRequest.get(source.url).pipe(HttpClientRequest.setHeaders(headers ?? {})));
     const buffer = yield* response.arrayBuffer.pipe(Effect.mapError((cause) => new AIError({
         reason: new InvalidProviderOutputError({
             message: `Failed to read media from ${source.url}`,
@@ -193,8 +192,8 @@ export const from = (source, options) => new Asset({ ...options, source });
 export const bytes = (data, mediaType, options) => from({ type: "bytes", data, mediaType: mediaType ?? detectMediaType(data) ?? OCTET_STREAM }, options);
 export const base64 = (data, mediaType, options) => from({ type: "base64", data, mediaType }, options);
 export const url = (value, options) => {
-    const { mediaType, expiresAt, headers, ...rest } = options ?? {};
-    return from({ type: "url", url: value, mediaType, expiresAt, headers }, rest);
+    const { mediaType, expiresAt, ...rest } = options ?? {};
+    return from({ type: "url", url: value, mediaType, expiresAt }, rest);
 };
 export const ref = (provider, id, mediaType, options) => from({ type: "ref", provider: ProviderID.make(provider), id, mediaType }, options);
 const DATA_URL = /^data:([^;,]+)(?:;[^,]*)*;base64,(.*)$/s;

package/dist/promise.d.ts

@@ -1,13 +1,16 @@
 import { Effect, Layer } from "effect";
+import type { AwaitOptions, Snapshot } from "./generation.js";
 import { ImageModel, ImageRequest, type ImageRequestInput } from "./image.js";
 import { ImageClient } from "./image-client.js";
 import { LLMClient } from "./route/client.js";
 import { RequestExecutor } from "./route/executor.js";
 import { LanguageModel, LLMRequest } from "./schema/index.js";
 import type { RequestInput } from "./llm.js";
+import { VideoModel, VideoRequest, type VideoOptions, type VideoRequestInput } from "./video.js";
+import { VideoClient } from "./video-client.js";
 /**
- * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM and image clients
- * over a request executor; every method runs the corresponding Effect API and rethrows `AIError` unchanged.
+ * Promise-first entrypoint for scripts and non-Effect callers. One `ManagedRuntime` hosts the LLM, image, and video
+ * clients over a request executor; every method runs the corresponding Effect API and rethrows `AIError` unchanged.
  */
 export interface Options {
     /** Executor layer; defaults to `RequestExecutor.fetchLayer`. Inject a recorder or middleware here. */
@@ -16,7 +19,15 @@ export interface Options {
 export interface RunOptions {
     readonly signal?: AbortSignal;
 }
-export type Services = Layer.Success<typeof LLMClient.layer> | Layer.Success<typeof ImageClient.layer> | RequestExecutor.Service;
+export type Services = Layer.Success<typeof LLMClient.layer> | Layer.Success<typeof ImageClient.layer> | Layer.Success<typeof VideoClient.layer> | RequestExecutor.Service;
+/** Promise view of a `Generation`: its snapshot plus `await`, `refresh`, and `cancel` returning promises. */
+export type GenerationHandle<Response> = Snapshot & {
+    /** Serializable JSON; pass it back to `resume` from another process. */
+    readonly token: unknown;
+    readonly await: (options?: AwaitOptions & RunOptions) => Promise<Response>;
+    readonly refresh: (options?: RunOptions) => Promise<GenerationHandle<Response>>;
+    readonly cancel: (options?: RunOptions) => Promise<void>;
+};
 export declare const make: (options?: Options) => {
     run: <A, E>(effect: Effect.Effect<A, E, Services>, options?: RunOptions) => Promise<A>;
     llm: {
@@ -281,6 +292,62 @@ export declare const make: (options?: Options) => {
             }[] | undefined;
         }>;
     };
+    video: {
+        request: typeof import("./video.js").request;
+        start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        generate: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => Promise<import("./video.js").VideoResponse>;
+        resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, 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: "video";
+            readonly index: number;
+            readonly video: import("./media.js").Asset;
+        } | {
+            readonly type: "finish";
+            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;
+        }>;
+    };
     dispose: () => Promise<void>;
 };
 export type Client = ReturnType<typeof make>;
@@ -549,6 +616,62 @@ export declare const ai: {
             }[] | undefined;
         }>;
     };
+    video: {
+        request: typeof import("./video.js").request;
+        start: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        generate: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, options?: AwaitOptions & RunOptions) => Promise<import("./video.js").VideoResponse>;
+        resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown, options?: RunOptions) => Promise<GenerationHandle<import("./video.js").VideoResponse>>;
+        stream: <const Model extends VideoModel>(input: VideoRequestInput<Model> | VideoRequest, 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: "video";
+            readonly index: number;
+            readonly video: import("./media.js").Asset;
+        } | {
+            readonly type: "finish";
+            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;
+        }>;
+    };
     dispose: () => Promise<void>;
 };
 export * as AI from "./promise.js";

package/dist/promise.js

@@ -5,6 +5,8 @@ import { LLM } from "./index.js";
 import { LLMClient } from "./route/client.js";
 import { RequestExecutor } from "./route/executor.js";
 import { LanguageModel, LLMRequest } from "./schema/index.js";
+import { Video, VideoModel, VideoRequest } from "./video.js";
+import { VideoClient } from "./video-client.js";
 const abortEffect = (signal) => signal === undefined
     ? Effect.never
     : Effect.callback((resume) => {
@@ -17,13 +19,21 @@ const abortEffect = (signal) => signal === undefined
         return Effect.sync(() => signal.removeEventListener("abort", onAbort));
     });
 export const make = (options = {}) => {
-    const runtime = ManagedRuntime.make(Layer.mergeAll(LLMClient.layer, ImageClient.layer).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)));
+    const runtime = ManagedRuntime.make(Layer.mergeAll(LLMClient.layer, ImageClient.layer, VideoClient.layer).pipe(Layer.provideMerge(options.layer ?? RequestExecutor.fetchLayer)));
     /** Run any package Effect (for example `asset.bytes()`) inside this runtime. */
     const run = (effect, options) => runtime.runPromise(effect, { signal: options?.signal });
     const iterate = (stream, options) => Stream.toAsyncIterable(Stream.unwrap(runtime.contextEffect.pipe(Effect.map((context) => stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context))))));
+    const handle = (generation) => ({
+        ...generation.snapshot,
+        token: generation.token,
+        await: (options) => run(generation.await({ poll: options?.poll }), options),
+        refresh: (options) => run(generation.refresh(), options).then(handle),
+        cancel: (options) => run(generation.cancel(), options),
+    });
     // The typed `generate`/`stream` overloads take a concrete input or a request, not the union; normalize once here.
     const llmRequest = (input) => (input instanceof LLMRequest ? input : LLM.request(input));
     const imageRequest = (input) => input instanceof ImageRequest ? input : Image.request(input);
+    const videoRequest = (input) => input instanceof VideoRequest ? input : Video.request(input);
     return {
         run,
         llm: {
@@ -36,6 +46,13 @@ export const make = (options = {}) => {
             generate: (input, options) => run(Image.generate(imageRequest(input)), options),
             stream: (input, options) => iterate(Image.stream(imageRequest(input)), options),
         },
+        video: {
+            request: Video.request,
+            start: (input, options) => run(Video.start(videoRequest(input)), options).then(handle),
+            generate: (input, options) => run(Video.generate(videoRequest(input), { poll: options?.poll }), options),
+            resume: (model, token, options) => run(Video.resume(model, token), options).then(handle),
+            stream: (input, options) => iterate(Video.stream(videoRequest(input), { poll: options?.poll }), options),
+        },
         dispose: () => runtime.dispose(),
     };
 };

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

@@ -0,0 +1,39 @@
+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
+ * 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>;
+/** 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;
+    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,139 @@
+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 = "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
+// ---------------------------------------------------------------------------
+/** 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,
+        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)]);
+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({
+            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* mediaUrl(request.frames.first);
+    const videoUrl = request.video === undefined ? undefined : yield* mediaUrl(request.video);
+    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 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;
+    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 = MediaProtocol.queued({
+    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 },
+});
+export const model = (input) => VideoModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => `/${request.model.id}`,
+}, input);
+export const FalVideo = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,26 @@
+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://generativelanguage.googleapis.com/v1beta";
+export type GoogleVideoString<Known extends string> = Known | (string & {});
+/** Provider-native `parameters`. Common fields (`aspectRatio`, `resolution`, `durationSeconds`, `seed`) live on the request. */
+export type GoogleVideoOptions = {
+    readonly personGeneration?: GoogleVideoString<"allow_all" | "allow_adult" | "dont_allow">;
+} & Record<string, unknown>;
+export type Request = VideoRequestFor<GoogleVideoOptions>;
+/** The long-running operation name, e.g. `models/veo-3.1-generate-preview/operations/abc123`. */
+export declare const Token: Schema.Struct<{
+    readonly operation: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {
+    readonly operation: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => VideoModel<GoogleVideoOptions>;
+export declare const GoogleVideo: {
+    readonly protocol: MediaProtocol.Queued<Request, VideoResponse, {
+        readonly operation: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => VideoModel<GoogleVideoOptions>;
+};

package/dist/protocols/google-video.js

@@ -0,0 +1,158 @@
+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 } from "./shared.js";
+const ADAPTER = "google-video";
+const NAME = "Google Veo";
+const PROVIDER = ProviderID.make("google");
+export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+/** Veo keeps generated files for two days; the asset carries that deadline so callers materialize in time. */
+const FILE_RETENTION = Duration.days(2);
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+/** The long-running operation name, e.g. `models/veo-3.1-generate-preview/operations/abc123`. */
+export const Token = Schema.Struct({ operation: Schema.String });
+const StartResponse = Schema.Struct({ name: Schema.String });
+const Operation = Schema.Struct({
+    done: Schema.optional(Schema.Boolean),
+    error: Schema.optional(Schema.Struct({ message: Schema.optional(Schema.String) })),
+    response: Schema.optional(Schema.Struct({
+        generateVideoResponse: Schema.optional(Schema.Struct({
+            generatedSamples: optionalArray(Schema.Struct({
+                video: Schema.optional(Schema.Struct({
+                    uri: Schema.optional(Schema.String),
+                    mimeType: Schema.optional(Schema.String),
+                })),
+            })),
+            raiMediaFilteredCount: Schema.optional(Schema.Number),
+            raiMediaFilteredReasons: optionalArray(Schema.String),
+        })),
+    })),
+    metadata: Schema.optional(Schema.Unknown),
+});
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+// Veo takes inline media only; a prior Veo output is `Media.url` with transient auth, so materialize it first.
+const inlineMedia = (asset) => ProviderShared.requireInlineMedia(NAME, asset).pipe(Effect.map((inline) => ({ inlineData: { mimeType: inline.mime, data: inline.base64 } })));
+const fromRequest = Effect.fn("GoogleVideo.fromRequest")(function* (request) {
+    if (request.n !== undefined && request.n > 1)
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "video.n",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${NAME} generates one video per request; call it once per video instead of n=${request.n}`,
+        });
+    if (request.audio === false)
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "video.audio",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${NAME} always generates audio; audio: false cannot be honored`,
+        });
+    if (request.frames?.last !== undefined && request.frames.first === undefined)
+        return yield* ProviderShared.invalidRequest(`${NAME} requires frames.first when frames.last is set`);
+    const image = request.frames?.first === undefined ? undefined : yield* inlineMedia(request.frames.first);
+    const lastFrame = request.frames?.last === undefined ? undefined : yield* inlineMedia(request.frames.last);
+    const video = request.video === undefined ? undefined : yield* inlineMedia(request.video);
+    const referenceImages = yield* Effect.forEach(request.references ?? [], (asset) => inlineMedia(asset).pipe(Effect.map((image) => ({ image, referenceType: "asset" }))));
+    return MediaProtocol.json(mergeJsonRecords({
+        instances: [
+            {
+                prompt: request.prompt,
+                image,
+                lastFrame,
+                referenceImages: referenceImages.length === 0 ? undefined : referenceImages,
+                video,
+            },
+        ],
+        parameters: mergeJsonRecords({
+            aspectRatio: request.aspectRatio,
+            resolution: request.resolution,
+            durationSeconds: request.durationSeconds,
+            negativePrompt: request.negativePrompt,
+            seed: request.seed,
+        }, request.providerOptions),
+    }, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+    token: { operation: value.name },
+    snapshot: { id: value.name, status: "running" },
+}));
+// Operations carry no status string: not done is running, done with `error` failed, otherwise completed.
+const statusOf = (operation) => {
+    if (operation.done !== true)
+        return "running";
+    return operation.error === undefined ? "completed" : "failed";
+};
+const decodeOperation = MediaProtocol.decodeJson(ADAPTER, NAME, Operation);
+const decodeStatus = Effect.fn("GoogleVideo.decodeStatus")(function* (response, context) {
+    const output = yield* decodeOperation(response);
+    return { id: context.token.operation, status: statusOf(output.value) };
+});
+const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (response, context) {
+    const output = yield* decodeOperation(response);
+    const operation = output.value;
+    const status = statusOf(operation);
+    if (status === "running")
+        return yield* output.invalid(`${NAME} operation ${context.token.operation} has not finished`);
+    if (status === "failed")
+        return yield* output.ended("failed", `${NAME} operation failed${operation.error?.message === undefined ? "" : `: ${operation.error.message}`}`);
+    const generated = operation.response?.generateVideoResponse;
+    // Downloads require the same API key as the poll; the asset carries it transiently and follows the redirect.
+    const videos = yield* Effect.forEach((generated?.generatedSamples ?? []).flatMap((sample) => sample.video?.uri === undefined ? [] : [{ uri: sample.video.uri, mimeType: sample.video.mimeType }]), (video) => MediaProtocol.expiringUrl(video.uri, FILE_RETENTION, {
+        mediaType: video.mimeType ?? "video/mp4",
+        headers: context.auth,
+    }));
+    const reasons = generated?.raiMediaFilteredReasons ?? [];
+    const notices = reasons.map((reason) => ({
+        type: "filtered",
+        message: `${NAME} filtered media: ${reason}`,
+        providerMetadata: { google: { raiMediaFilteredReason: reason } },
+    }));
+    if (videos.length === 0 && (reasons.length > 0 || (generated?.raiMediaFilteredCount ?? 0) > 0))
+        return yield* output.contentPolicy(`${NAME} filtered every video${reasons.length === 0 ? "" : `: ${reasons.join("; ")}`}`);
+    if (videos.length === 0)
+        return yield* output.invalid(`${NAME} operation completed without any video`);
+    return new VideoResponse({
+        videos,
+        notices: notices.length === 0 ? undefined : notices,
+        providerMetadata: {
+            google: {
+                operation: context.token.operation,
+                raiMediaFilteredCount: generated?.raiMediaFilteredCount,
+                metadata: operation.metadata,
+            },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+const operationPath = (token) => `/${token.operation}`;
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: operationPath, decode: decodeStatus },
+    result: { path: operationPath, decode: decodeResult },
+});
+export const model = (input) => VideoModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => `/models/${request.model.id}:predictLongRunning`,
+}, input);
+export const GoogleVideo = {
+    protocol,
+    model,
+};

package/dist/protocols/meta-images.js

@@ -37,15 +37,8 @@ const Response = Schema.Struct({
 // 5. Request body construction
 // ---------------------------------------------------------------------------
 const isEdit = (request) => (request.images?.length ?? 0) > 0;
-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 });
-    return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts image bytes and URLs`));
-};
+// Meta has no file handles: refs are rejected even when they name this provider.
+const reference = (asset) => ProviderShared.mediaReference(asset, undefined, NAME).pipe(Effect.map((item) => ({ image_url: item.value })));
 const fromRequest = Effect.fn("MetaImages.fromRequest")(function* (request) {
     const images = yield* Effect.forEach(request.images ?? [], reference);
     const { responseFormat, reasoningStrength, toolEnablement, ...native } = request.providerOptions ?? {};