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

package/dist/providers/runway.js

@@ -0,0 +1,22 @@
+import { AuthOptions } from "../route/auth-options.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { DEFAULT_BASE_URL, RunwayVideo } from "../protocols/runway-video.js";
+export const id = ProviderID.make("runway");
+const baseURL = DEFAULT_BASE_URL;
+const auth = (options) => AuthOptions.bearer(options, "RUNWAYML_API_SECRET");
+export const configure = (input = {}) => {
+    const video = (modelID) => RunwayVideo.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/xai.d.ts

@@ -16,6 +16,7 @@ export type Settings = ProviderPackage.Settings & XAIProviderOptionsInput & {
     readonly baseURL?: string;
 };
 export type { XAIImageOptions } from "../protocols/xai-images.js";
+export type { XAIVideoOptions } from "../protocols/xai-video.js";
 declare const responsesRoute: Route<unknown, import("../protocols/open-responses-channel.js").Prepared, {
     endpoint: import("../route/client.js").CompactOperation;
 }>;
@@ -130,6 +131,7 @@ export declare const configure: (input?: LanguageModelOptions) => {
     }>;
     chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/xai-video.js").XAIVideoOptions>;
     configure: (input?: LanguageModelOptions) => /*elided*/ any;
 };
 export declare const provider: {
@@ -142,6 +144,7 @@ export declare const provider: {
     }>;
     chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
+    video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/xai-video.js").XAIVideoOptions>;
     configure: (input?: LanguageModelOptions) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, {
@@ -152,6 +155,7 @@ export declare const provider: {
         }>;
         chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
+        video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/xai-video.js").XAIVideoOptions>;
         configure: /*elided*/ any;
     };
 };
@@ -161,3 +165,4 @@ export declare const responses: (modelID: string | ModelID) => import("../schema
 }>;
 export declare const chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<XAIProviderOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/xai-images.js").XAIImageOptions>;
+export declare const video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/xai-video.js").XAIVideoOptions>;

package/dist/providers/xai.js

@@ -6,6 +6,7 @@ import { OpenAIChat } from "../protocols/openai-chat.js";
 import { OpenResponsesChannel } from "../protocols/open-responses-channel.js";
 import { XAIResponses } from "../protocols/xai-responses.js";
 import { XAIImages } from "../protocols/xai-images.js";
+import { XAIVideo } from "../protocols/xai-video.js";
 export const id = ProviderID.make("xai");
 const baseURL = "https://api.x.ai/v1";
 const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000;
@@ -59,7 +60,7 @@ export const configure = (input = {}) => {
     const chatRoute = configuredChatRoute(input);
     const responses = (modelID) => responsesRoute.model({ id: modelID });
     const chat = (modelID) => chatRoute.model({ id: modelID });
-    const image = (modelID) => XAIImages.model({
+    const media = (modelID) => ({
         id: modelID,
         auth: auth(input),
         baseURL: input.baseURL ?? baseURL,
@@ -71,7 +72,8 @@ export const configure = (input = {}) => {
         model: responses,
         responses,
         chat,
-        image,
+        image: (modelID) => XAIImages.model(media(modelID)),
+        video: (modelID) => XAIVideo.model(media(modelID)),
         configure,
     };
 };
@@ -86,3 +88,4 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
 export const responses = provider.responses;
 export const chat = provider.chat;
 export const image = provider.image;
+export const video = provider.video;

package/dist/providers/zai-coding-plan.d.ts

@@ -290,8 +290,8 @@ export declare const routes: (Route<{
     readonly response_format?: {
         readonly type: string;
     } | undefined;
-    readonly do_sample?: boolean | undefined;
     readonly request_id?: string | undefined;
+    readonly do_sample?: boolean | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined> | Route<{
     readonly max_tokens: number;
     readonly model: string;

package/dist/providers/zai.d.ts

@@ -120,8 +120,8 @@ export declare const routes: Route<{
     readonly response_format?: {
         readonly type: string;
     } | undefined;
-    readonly do_sample?: boolean | undefined;
     readonly request_id?: string | undefined;
+    readonly do_sample?: boolean | undefined;
 }, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;

package/dist/route/auth.d.ts

@@ -13,7 +13,7 @@ export interface AuthInput {
     readonly request: {
         readonly http?: HttpOptions;
     };
-    readonly method: "POST" | "GET";
+    readonly method: "POST" | "GET" | "PUT" | "DELETE";
     readonly url: string;
     readonly body: string;
     readonly headers: Headers.Headers;
@@ -47,5 +47,8 @@ export declare function header(name: string): (source: Secret | Credential) => D
 export declare function header(name: string, source: Secret | Credential): Definition;
 export declare function bearerHeader(name: string): (source: Secret | Credential) => Definition;
 export declare function bearerHeader(name: string, source: Secret | Credential): Definition;
+/** `Authorization: <scheme> <secret>` for providers whose scheme is not `Bearer`, such as fal's `Key`. */
+export declare function scheme(name: string): (source: Secret | Credential) => Definition;
+export declare function scheme(name: string, source: Secret | Credential): Definition;
 export declare const toEffect: (input: Definition) => (authInput: AuthInput) => Effect.Effect<Headers.Headers, AIError>;
 export * as Auth from "./auth.js";

package/dist/route/auth.js

@@ -73,6 +73,12 @@ export function bearerHeader(name, source) {
         return render;
     return render(source);
 }
+export function scheme(name, source) {
+    const render = (input) => fromCredential(credentialInput(input), (secret) => ({ authorization: `${name} ${secret}` }));
+    if (source === undefined)
+        return render;
+    return render(source);
+}
 const toAIError = (error) => {
     if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
         return new AIError({

package/dist/route/media-protocol.d.ts

@@ -1,5 +1,8 @@
-import { Effect, Schema } from "effect";
+import { Duration, Effect, Schema } from "effect";
 import { HttpClientResponse } from "effect/unstable/http";
+import type { Snapshot, Status } from "../generation.js";
+import { Media } from "../media.js";
+import type { AuthInput } from "./auth.js";
 import { AIError, HttpContext } from "../schema/index.js";
 export type Body = {
     readonly type: "json";
@@ -29,17 +32,80 @@ export interface Inline<Request, Response> {
     };
 }
 export declare const inline: <Request, Response>(input: Omit<Inline<Request, Response>, "kind">) => Inline<Request, Response>;
-/** Read a text body while retaining the original payload and HTTP context on every downstream error. */
+/** What `start` learned from the submission response: the route-owned handle plus the first observation. */
+export interface Started<Token> {
+    readonly token: Token;
+    readonly snapshot: Snapshot;
+}
+/**
+ * A follow-up call's inputs: the decoded token and the auth headers the route sent, so a protocol can attach them
+ * to output URLs that require the same credentials to download (Veo).
+ */
+export interface PollContext<Token> {
+    readonly token: Token;
+    readonly auth: Record<string, string>;
+}
+/**
+ * Submit, then poll. `start` posts the body to the route endpoint; `status`, `result`, and `cancel` are follow-up
+ * calls addressed by the token. Paths are relative to the route base URL unless the provider hands back absolute
+ * URLs (fal `status_url`), in which case they are used verbatim. `result` is always its own GET: providers that
+ * return the output inside the status body (Veo, xAI, Runway) point `result.path` at the status path and decode the
+ * same document, so `Generation.await` and `Video.resume(...).await()` behave identically everywhere.
+ */
+export interface Queued<Request, Response, Token> {
+    readonly kind: "queued";
+    readonly id: string;
+    readonly name: string;
+    /** Common request fields this protocol cannot lower; the route rejects them before `start.body.from` runs. */
+    readonly unsupported?: ReadonlyArray<keyof Request & string>;
+    /** Serializable handle. `Generation.token` carries the encoded form so it can be persisted and resumed elsewhere. */
+    readonly token: Schema.Codec<Token, unknown>;
+    readonly start: {
+        readonly body: {
+            readonly from: (request: Request) => Effect.Effect<Body, AIError>;
+        };
+        readonly decode: (response: HttpClientResponse.HttpClientResponse, context: DecodeContext<Request>) => Effect.Effect<Started<Token>, AIError>;
+    };
+    readonly status: {
+        readonly path: (token: Token) => string;
+        readonly decode: (response: HttpClientResponse.HttpClientResponse, context: PollContext<Token>) => Effect.Effect<Snapshot, AIError>;
+    };
+    readonly result: {
+        readonly path: (token: Token) => string;
+        readonly decode: (response: HttpClientResponse.HttpClientResponse, context: PollContext<Token>) => Effect.Effect<Response, AIError>;
+    };
+    readonly cancel?: {
+        readonly method: AuthInput["method"];
+        readonly path: (token: Token) => string;
+    };
+}
+export declare const queued: <Request, Response, Token>(input: Omit<Queued<Request, Response, Token>, "kind">) => Queued<Request, Response, Token>;
+/**
+ * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
+ * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
+ * provider-side, `cancelled`/`expired` mean the result will never exist); `contentPolicy` is a moderated result.
+ */
 export declare const text: (route: string, name: string, response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
     body: string;
     http: HttpContext;
     invalid: (message: string, cause?: unknown) => AIError;
+    ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
+    contentPolicy: (message: string) => AIError;
 }, AIError, never>;
+export type Output = Effect.Success<ReturnType<typeof text>>;
 /** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
 export declare const decodeJson: <A>(route: string, name: string, schema: Schema.Codec<A, unknown>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
     value: A;
     body: string;
     http: HttpContext;
     invalid: (message: string, cause?: unknown) => AIError;
+    ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
+    contentPolicy: (message: string) => AIError;
 }, AIError, never>;
+/** Decode a submission response into the token and first snapshot. */
+export declare const decodeStarted: <A, Token>(route: string, name: string, schema: Schema.Codec<A, unknown>, started: (value: A) => Started<Token>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<Started<Token>, AIError, never>;
+/** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
+export declare const status: <Table extends Record<string, Status>>(table: Table, raw: string, output: Output) => Effect.Effect<Status, AIError>;
+/** A `url` asset whose provider-declared retention window starts now. */
+export declare const expiringUrl: (url: string, retention: Duration.Duration, options?: Parameters<typeof Media.url>[1]) => Effect.Effect<Media.Asset, never, never>;
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media-protocol.js

@@ -1,17 +1,26 @@
-import { Effect, Schema } from "effect";
+import { Clock, Duration, Effect, Schema } from "effect";
 import { HttpClientResponse } from "effect/unstable/http";
-import { AIError, HttpContext, InvalidProviderOutputError } from "../schema/index.js";
+import { Media } from "../media.js";
+import { AIError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderInternalError, } from "../schema/index.js";
 export const json = (value) => ({ type: "json", value });
 export const multipart = (value) => ({ type: "multipart", value });
 export const inline = (input) => ({
     kind: "inline",
     ...input,
 });
+export const queued = (input) => ({
+    kind: "queued",
+    ...input,
+});
 // ---------------------------------------------------------------------------
 // Response helpers
 // ---------------------------------------------------------------------------
 const context = (response) => new HttpContext({ url: response.request.url, status: response.status, headers: response.headers });
-/** Read a text body while retaining the original payload and HTTP context on every downstream error. */
+/**
+ * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
+ * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
+ * provider-side, `cancelled`/`expired` mean the result will never exist); `contentPolicy` is a moderated result.
+ */
 export const text = Effect.fn("MediaProtocol.text")(function* (route, name, response) {
     const http = context(response);
     const body = yield* response.text.pipe(Effect.mapError((cause) => new AIError({
@@ -26,6 +35,12 @@ export const text = Effect.fn("MediaProtocol.text")(function* (route, name, resp
         body,
         http,
         invalid: (message, cause) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body, http, cause }) }),
+        ended: (status, message) => new AIError({
+            reason: status === "failed"
+                ? new ProviderInternalError({ message, body, http })
+                : new InvalidRequestError({ message, body, http }),
+        }),
+        contentPolicy: (message) => new AIError({ reason: new ContentPolicyError({ message, body, http }) }),
     };
 });
 /** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
@@ -37,4 +52,18 @@ export const decodeJson = (route, name, schema) => {
         return { ...output, value };
     });
 };
+/** Decode a submission response into the token and first snapshot. */
+export const decodeStarted = (route, name, schema, started) => {
+    const decode = decodeJson(route, name, schema);
+    return (response) => decode(response).pipe(Effect.map((output) => started(output.value)));
+};
+/** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
+export const status = (table, raw, output) => {
+    const normalized = table[raw];
+    if (normalized === undefined)
+        return Effect.fail(output.invalid(`Unknown generation status "${raw}"`));
+    return Effect.succeed(normalized);
+};
+/** A `url` asset whose provider-declared retention window starts now. */
+export const expiringUrl = (url, retention, options) => Clock.currentTimeMillis.pipe(Effect.map((now) => Media.url(url, { ...options, expiresAt: now + Duration.toMillis(retention) })));
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media.d.ts

@@ -3,6 +3,7 @@ import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
 import type { Interface } from "./executor-service.js";
 import { MediaProtocol } from "./media-protocol.js";
+import { Generation } from "../generation.js";
 import { AIError, HttpOptions, ProviderID } from "../schema/index.js";
 export type Execute = Interface["execute"];
 /** The minimum a media request must carry for the route to build a transport request. */
@@ -22,25 +23,47 @@ export interface ModelInput {
     readonly headers?: Record<string, string>;
     readonly http?: HttpOptions;
 }
+/** One request, one response. */
 export interface Route<Request extends MediaRequest, Response> {
     readonly id: string;
     readonly provider: ProviderID;
     readonly protocol: string;
     readonly generate: (request: Request, execute: Execute) => Effect.Effect<Response, AIError>;
 }
-export interface MakeInput<Request extends MediaRequest, Response> {
+/** Submit, then poll through the returned `Generation`. */
+export interface QueuedRoute<Request extends MediaRequest, Response> {
+    readonly id: string;
+    readonly provider: ProviderID;
+    readonly protocol: string;
+    readonly start: (request: Request, execute: Execute) => Effect.Effect<Generation<Response>, AIError>;
+    /** Rebuild a handle from a persisted `Generation.token`; fails typed when the token is not this route's. */
+    readonly resume: (model: MediaRequest["model"], token: unknown, execute: Execute) => Effect.Effect<Generation<Response>, AIError>;
+}
+export interface Composition<Request extends MediaRequest> {
     readonly id: string;
     readonly provider: string | ProviderID;
-    readonly protocol: MediaProtocol.Inline<Request, Response>;
     readonly endpoint: Endpoint.Definition<MediaProtocol.Body, Request>;
     readonly auth: Auth.Definition;
     /** Deployment headers applied before transport authentication. */
     readonly headers?: Record<string, string>;
 }
+export interface InlineInput<Request extends MediaRequest, Response> extends Composition<Request> {
+    readonly protocol: MediaProtocol.Inline<Request, Response>;
+}
+export interface QueuedInput<Request extends MediaRequest, Response, Token> extends Composition<Request> {
+    readonly protocol: MediaProtocol.Queued<Request, Response, Token>;
+}
 /**
  * Compose an inline media protocol with an endpoint and auth into a runnable route. The route owns the transport
- * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field rejection, URL and query
- * rendering, auth headers, JSON vs multipart encoding, and handing the response back to the protocol for decoding.
+ * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field
+ * rejection, URL and query rendering, auth headers, JSON vs multipart encoding, and handing responses back to the
+ * protocol.
+ */
+export declare const inline: <Request extends MediaRequest, Response>(input: InlineInput<Request, Response>) => Route<Request, Response>;
+/**
+ * Compose a queued media protocol the same way, adding `start`/`resume` handles whose polls reuse the route's auth,
+ * deployment headers, and (for `start`) the request's `http` overlay. The token is decoded once at the boundary and
+ * closed over by the resulting `Generation.Route`.
  */
-export declare const make: <Request extends MediaRequest, Response>(input: MakeInput<Request, Response>) => Route<Request, Response>;
+export declare const queued: <Request extends MediaRequest, Response, Token>(input: QueuedInput<Request, Response, Token>) => QueuedRoute<Request, Response>;
 export * as MediaRoute from "./media.js";

package/dist/route/media.js

@@ -1,33 +1,97 @@
-import { Effect } from "effect";
+import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
 import { MediaProtocol } from "./media-protocol.js";
+import { Generation } from "../generation.js";
 import { ProviderShared } from "../protocols/shared.js";
-import { AIError, HttpOptions, ProviderID, mergeHttpOptions } from "../schema/index.js";
+import { AIError, HttpOptions, InvalidRequestError, ProviderID, mergeHttpOptions } from "../schema/index.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 /**
  * Compose an inline media protocol with an endpoint and auth into a runnable route. The route owns the transport
- * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field rejection, URL and query
- * rendering, auth headers, JSON vs multipart encoding, and handing the response back to the protocol for decoding.
+ * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field
+ * rejection, URL and query rendering, auth headers, JSON vs multipart encoding, and handing responses back to the
+ * protocol.
  */
-export const make = (input) => {
+export const inline = (input) => {
+    const transport = makeTransport(input);
+    return {
+        id: input.id,
+        provider: transport.provider,
+        protocol: input.protocol.id,
+        generate: Effect.fn(`MediaRoute.generate`)(function* (request, execute) {
+            const submitted = yield* transport.submit(request, { unsupported: input.protocol.unsupported, from: input.protocol.body.from }, execute);
+            return yield* input.protocol.response.decode(submitted.response, submitted.context);
+        }),
+    };
+};
+/**
+ * Compose a queued media protocol the same way, adding `start`/`resume` handles whose polls reuse the route's auth,
+ * deployment headers, and (for `start`) the request's `http` overlay. The token is decoded once at the boundary and
+ * closed over by the resulting `Generation.Route`.
+ */
+export const queued = (input) => {
+    const transport = makeTransport(input);
+    const protocol = input.protocol;
+    const decodeToken = Schema.decodeUnknownEffect(protocol.token);
+    // A protocol producing a token its own codec rejects is a programmer defect, not a provider error.
+    const encodeToken = Schema.encodeSync(protocol.token);
+    const generationRoute = (token, http, execute) => {
+        const poll = (operation) => transport
+            .call("GET", operation.path(token), http, execute)
+            .pipe(Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth })));
+        const cancel = protocol.cancel;
+        const route = {
+            status: poll(protocol.status),
+            result: poll(protocol.result),
+            cancel: cancel === undefined
+                ? undefined
+                : transport.call(cancel.method, cancel.path(token), http, execute).pipe(Effect.asVoid),
+        };
+        return route;
+    };
+    const start = Effect.fn("MediaRoute.start")(function* (request, execute) {
+        const submitted = yield* transport.submit(request, { unsupported: protocol.unsupported, from: protocol.start.body.from }, execute);
+        const started = yield* protocol.start.decode(submitted.response, submitted.context);
+        const route = generationRoute(started.token, submitted.context.request.http, execute);
+        return new Generation(route, encodeToken(started.token), started.snapshot);
+    });
+    const resume = Effect.fn("MediaRoute.resume")(function* (model, raw, execute) {
+        const token = yield* decodeToken(raw).pipe(Effect.mapError((cause) => new AIError({
+            reason: new InvalidRequestError({
+                message: `${input.id} cannot resume a generation from this token`,
+                cause,
+            }),
+        })));
+        const route = generationRoute(token, transport.http(model), execute);
+        return new Generation(route, encodeToken(token), yield* route.status);
+    });
+    return { id: input.id, provider: transport.provider, protocol: protocol.id, start, resume };
+};
+// ---------------------------------------------------------------------------
+// Transport plumbing shared by both kinds
+// ---------------------------------------------------------------------------
+const makeTransport = (input) => {
     const provider = ProviderID.make(input.provider);
     const routeHttp = input.headers === undefined ? undefined : new HttpOptions({ headers: input.headers });
     const authorize = Auth.toEffect(input.auth);
+    const withQuery = (url, http) => {
+        for (const [key, value] of Object.entries(http?.query ?? {}))
+            url.searchParams.set(key, value);
+        return url;
+    };
     return {
-        id: input.id,
         provider,
-        protocol: input.protocol.id,
-        generate: Effect.fn(`MediaRoute.generate`)(function* (request, execute) {
-            yield* rejectUnsupported(input.id, provider, request, input.protocol.unsupported);
+        /** Route and model overlays; `start` additionally merges the request's own `http`. */
+        http: (model) => mergeHttpOptions(routeHttp, model.http),
+        /** POST the protocol body to the route endpoint. */
+        submit: Effect.fn("MediaRoute.submit")(function* (request, protocol, execute) {
+            yield* rejectUnsupported(input.id, provider, request, protocol.unsupported);
             const http = mergeHttpOptions(routeHttp, request.model.http, request.http);
             // Sanitize after merging so model-level overlays are covered; the model value is restored, not sanitized.
             const resolved = { ...sanitizeSurrogates({ ...request, http }), model: request.model };
-            const body = yield* input.protocol.body.from(resolved);
-            const url = Endpoint.render(input.endpoint, { request: resolved, body });
-            for (const [key, value] of Object.entries(http?.query ?? {}))
-                url.searchParams.set(key, value);
+            const body = yield* protocol.from(resolved);
+            const url = withQuery(Endpoint.render(input.endpoint, { request: resolved, body }), http);
             const encoded = body.type === "json" ? ProviderShared.encodeJson(body.value) : "[multipart/form-data]";
             const baseHeaders = Headers.fromInput(http?.headers);
             const headers = yield* authorize({
@@ -42,7 +106,24 @@ export const make = (input) => {
                 ? HttpClientRequest.bodyText(encoded, "application/json")
                 : HttpClientRequest.bodyFormData(body.value));
             const response = yield* execute(transport);
-            return yield* input.protocol.response.decode(response, { request: resolved, body });
+            return { response, context: { request: resolved, body } };
+        }),
+        /**
+         * Bodiless follow-up call (status, result, cancel) with the same auth and headers as `submit`. `auth` is only
+         * what `Auth` added, so protocols can hand download credentials to output assets without deployment headers.
+         */
+        call: Effect.fn("MediaRoute.call")(function* (method, path, http, execute) {
+            // Provider-issued absolute URLs (fal `status_url`) are used as-is; everything else resolves against the base.
+            const url = withQuery(/^https?:\/\//.test(path)
+                ? new URL(path)
+                : new URL(`${ProviderShared.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`), http);
+            for (const [key, value] of Object.entries(input.endpoint.query ?? {}))
+                url.searchParams.set(key, value);
+            const base = Headers.fromInput(http?.headers);
+            const headers = yield* authorize({ request: { http }, method, url: url.toString(), body: "", headers: base });
+            const response = yield* execute(HttpClientRequest.make(method)(url.toString()).pipe(HttpClientRequest.setHeaders(headers)));
+            const auth = Object.fromEntries(Object.entries(headers).filter(([key]) => !(key in base)));
+            return { response, auth };
         }),
     };
 };

package/dist/schema/events.d.ts

@@ -365,7 +365,6 @@ export declare const MediaEvent: Schema.Struct<{
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -578,7 +577,6 @@ declare const llmEventTagged: Schema.toTaggedUnion<"type", readonly [Schema.refi
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -820,7 +818,6 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -1064,7 +1061,6 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
                     readonly url: Schema.String;
                     readonly mediaType: Schema.optional<Schema.String>;
                     readonly expiresAt: Schema.optional<Schema.Number>;
-                    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
                 }>, Schema.Struct<{
                     readonly type: Schema.Literal<"ref">;
                     readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -4805,7 +4801,6 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 readonly url: Schema.String;
                 readonly mediaType: Schema.optional<Schema.String>;
                 readonly expiresAt: Schema.optional<Schema.Number>;
-                readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"ref">;
                 readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -5049,7 +5044,6 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                         readonly url: Schema.String;
                         readonly mediaType: Schema.optional<Schema.String>;
                         readonly expiresAt: Schema.optional<Schema.Number>;
-                        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
                     }>, Schema.Struct<{
                         readonly type: Schema.Literal<"ref">;
                         readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;

package/dist/schema/messages.d.ts

@@ -44,7 +44,6 @@ export declare const MediaPart: Schema.Struct<{
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -305,7 +304,6 @@ export declare const ContentPart: Schema.toTaggedUnion<"type", readonly [Schema.
             readonly url: Schema.String;
             readonly mediaType: Schema.optional<Schema.String>;
             readonly expiresAt: Schema.optional<Schema.Number>;
-            readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"ref">;
             readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;
@@ -450,7 +448,6 @@ declare const Message_base: Schema.Class<Message, Schema.Struct<{
                 readonly url: Schema.String;
                 readonly mediaType: Schema.optional<Schema.String>;
                 readonly expiresAt: Schema.optional<Schema.Number>;
-                readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
             }>, Schema.Struct<{
                 readonly type: Schema.Literal<"ref">;
                 readonly provider: Schema.brand<Schema.String, "AI.ProviderID">;

package/dist/video-client.d.ts

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import type { AwaitOptions, Generation } from "./generation.js";
+import { RequestExecutor } from "./route/executor.js";
+import type { AIError } from "./schema/index.js";
+import { type VideoEvent, type VideoModel, type VideoOptions, type VideoRequestFor, type VideoResponse } from "./video.js";
+export interface Interface {
+    readonly start: <Options extends VideoOptions>(request: VideoRequestFor<Options>) => Effect.Effect<Generation<VideoResponse>, AIError>;
+    readonly resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError>;
+    readonly generate: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<VideoResponse, AIError>;
+    readonly stream: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<VideoEvent, AIError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/VideoClient", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const start: <Options extends VideoOptions>(request: VideoRequestFor<Options>) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
+export declare const resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
+export declare const generate: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<VideoResponse, AIError, Service>;
+export declare const stream: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<VideoEvent, AIError, Service>;
+export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+export declare const VideoClient: {
+    readonly Service: typeof Service;
+    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly start: <Options extends VideoOptions>(request: VideoRequestFor<Options>) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
+    readonly resume: <Options extends VideoOptions>(model: VideoModel<Options>, token: unknown) => Effect.Effect<Generation<VideoResponse>, AIError, Service>;
+    readonly generate: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<VideoResponse, AIError, Service>;
+    readonly stream: <Options extends VideoOptions>(request: VideoRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<VideoEvent, AIError, Service>;
+};
+export {};