@opencode/ai 2.0.15 → 2.0.16

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.
@@ -126,9 +136,9 @@ export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty and bare `null`
- * events. `[DONE]` is dropped by default or retained for protocols that use it
- * as their stream boundary. Retry control events are ignored without
+ * decoder, optionally filters named events, and drops empty events and known
+ * keepalives that proxies send as data. `[DONE]` is dropped by default or
+ * retained for protocols that use it as their stream boundary. Retry control events are ignored without
  * interrupting the stream. Decoder failures become provider output errors so
  * the public error channel stays `AIError`.
  */

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.
@@ -174,9 +191,9 @@ export const errorText = (error) => {
 };
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty and bare `null`
- * events. `[DONE]` is dropped by default or retained for protocols that use it
- * as their stream boundary. Retry control events are ignored without
+ * decoder, optionally filters named events, and drops empty events and known
+ * keepalives that proxies send as data. `[DONE]` is dropped by default or
+ * retained for protocols that use it as their stream boundary. Retry control events are ignored without
  * interrupting the stream. Decoder failures become provider output errors so
  * the public error channel stays `AIError`.
  */
@@ -200,6 +217,9 @@ export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Str
     // `data: null`, between events or after `[DONE]`. No protocol has a
     // null event, so it carries nothing and must not abort the stream.
     event.data !== "null" &&
+    // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
+    // keepalive comment as `data: : keepalive` while reasoning.
+    event.data !== ": keepalive" &&
     (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
 /**
  * Canonical invalid-request constructor shared by protocol lowering.

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

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+export declare const DEFAULT_BASE_URL = "https://api.stability.ai";
+export type StabilityStylePreset = "enhance" | "anime" | "photographic" | "digital-art" | "comic-book" | "fantasy-art" | "line-art" | "analog-film" | "neon-punk" | "isometric" | "low-poly" | "origami" | "modeling-compound" | "cinematic" | "3d-model" | "pixel-art" | "tile-texture" | (string & {});
+export type StabilityImageOptions = {
+    readonly negative_prompt?: string;
+    readonly style_preset?: StabilityStylePreset;
+    readonly strength?: number;
+    readonly cfg_scale?: number;
+} & Record<string, unknown>;
+/** Creative upscale options; the one `images` source is the image to upscale. */
+export type StabilityUpscaleOptions = {
+    readonly negative_prompt?: string;
+    readonly style_preset?: StabilityStylePreset;
+    readonly creativity?: number;
+} & Record<string, unknown>;
+export type Request = ImageRequestFor<StabilityImageOptions>;
+export type UpscaleRequest = ImageRequestFor<StabilityUpscaleOptions>;
+export declare const Token: Schema.Struct<{
+    readonly id: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
+export declare const upscaleProtocol: MediaProtocol.Queued<UpscaleRequest, ImageResponse, {
+    readonly id: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<StabilityImageOptions>;
+export declare const upscaleModel: (input: Omit<MediaRoute.ModelInput, "id">) => ImageModel<StabilityUpscaleOptions>;
+export declare const StabilityImages: {
+    readonly protocol: MediaProtocol.Inline<Request, ImageResponse>;
+    readonly upscaleProtocol: MediaProtocol.Queued<UpscaleRequest, ImageResponse, {
+        readonly id: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<StabilityImageOptions>;
+    readonly upscaleModel: (input: Omit<MediaRoute.ModelInput, "id">) => ImageModel<StabilityUpscaleOptions>;
+};

package/dist/protocols/stability-images.js

@@ -0,0 +1,148 @@
+import { Effect, Schema } from "effect";
+import { ImageModel, ImageResponse } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "stability-images";
+const UPSCALE_ADAPTER = "stability-upscale";
+const NAME = "Stability AI";
+const PROVIDER = ProviderID.make("stability");
+export const DEFAULT_BASE_URL = "https://api.stability.ai";
+const RESULTS_PATH = "/v2beta/results";
+const UPSCALE_MODEL = "creative";
+/** Base64 JSON instead of raw bytes, so the seed and finish reason arrive with the image. */
+const HEADERS = { accept: "application/json" };
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+export const Token = Schema.Struct({ id: Schema.String });
+// Generate names the base64 image `image`; `/v2beta/results/{id}` names it `result`.
+const ImageDocument = Schema.Struct({
+    image: Schema.optional(Schema.String),
+    result: Schema.optional(Schema.String),
+    seed: Schema.optional(Schema.Number),
+    finish_reason: Schema.optional(Schema.String),
+});
+const Started = Schema.Struct({ id: Schema.String });
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+/** `sd3.5-*` ids share the `sd3` endpoint and select the model with a form field. */
+const endpoint = (model) => (model.startsWith("sd3") ? "sd3" : model);
+const RESERVED_FORM_FIELDS = new Set(["image", "prompt", "mode", "model"]);
+const unsupported = (route, operation, message) => ProviderShared.unsupportedOperation({ operation, provider: PROVIDER, route, message });
+const form = Effect.fn("StabilityImages.form")(function* (route, fields, native, source) {
+    if ((source?.length ?? 0) > 1)
+        return yield* unsupported(route, "media.images", `${NAME} takes one source image`);
+    const body = new FormData();
+    const overlay = Object.entries(native ?? {}).filter(([key]) => !RESERVED_FORM_FIELDS.has(key));
+    Object.entries(mergeJsonRecords(fields, Object.fromEntries(overlay)) ?? {}).forEach(([key, value]) => body.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value)));
+    const image = source?.[0];
+    if (image !== undefined)
+        body.append("image", MediaInput.blob(yield* MediaInput.inlineBytes(route, image), image.mediaType), "image");
+    return MediaProtocol.multipart(body);
+});
+const fromRequest = Effect.fn("StabilityImages.fromRequest")(function* (request) {
+    if (request.n !== undefined && request.n > 1)
+        return yield* unsupported(ADAPTER, "media.n", `${NAME} generates one image per request; call it once per image`);
+    const target = endpoint(request.model.id);
+    const edit = (request.images?.length ?? 0) > 0;
+    if (edit && target === "core")
+        return yield* unsupported(ADAPTER, "media.images", `${NAME} core is text-to-image only; use ultra or sd3.5-*`);
+    return yield* form(ADAPTER, {
+        prompt: request.prompt,
+        aspect_ratio: request.aspectRatio,
+        seed: request.seed,
+        output_format: request.format,
+        model: target === "sd3" ? request.model.id : undefined,
+        mode: target === "sd3" && edit ? "image-to-image" : undefined,
+    }, mergeJsonRecords(request.providerOptions, request.http?.body), request.images);
+});
+const fromUpscaleRequest = Effect.fn("StabilityImages.fromUpscaleRequest")(function* (request) {
+    if ((request.images?.length ?? 0) === 0)
+        return yield* ProviderShared.invalidRequest(`${NAME} upscale requires the source image in images`);
+    return yield* form(UPSCALE_ADAPTER, { prompt: request.prompt, seed: request.seed, output_format: request.format }, mergeJsonRecords(request.providerOptions, request.http?.body), request.images);
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeImageDocument = (route) => {
+    const decode = MediaProtocol.decodeJson(route, NAME, ImageDocument);
+    return Effect.fn("StabilityImages.decodeImage")(function* (response) {
+        const output = yield* decode(response);
+        const document = output.value;
+        const data = document.image ?? document.result;
+        if (data === undefined)
+            return yield* output.invalid(`${NAME} returned no image`);
+        const image = yield* MediaInput.decodedAsset(output.invalid, `${NAME} result`, data, undefined);
+        return new ImageResponse({
+            images: [image],
+            notices: document.finish_reason === "CONTENT_FILTERED"
+                ? [{ type: "moderated", message: `${NAME} blurred the image for violating its content policy` }]
+                : undefined,
+            providerMetadata: { stability: { seed: document.seed, finishReason: document.finish_reason } },
+        });
+    });
+};
+const decodeResponse = decodeImageDocument(ADAPTER);
+const decodeUpscaleImage = decodeImageDocument(UPSCALE_ADAPTER);
+const decodeStart = MediaProtocol.decodeStarted(UPSCALE_ADAPTER, NAME, Started, (value) => ({
+    token: { id: value.id },
+    snapshot: { id: value.id, status: "queued" },
+}));
+// `/v2beta/results/{id}` answers 202 while in progress and 200 with the finished image document.
+const decodeStatus = (response, context) => Effect.succeed({
+    id: context.token.id,
+    status: response.status === 202 ? "running" : "completed",
+});
+const decodeUpscaleResult = Effect.fn("StabilityImages.decodeUpscaleResult")(function* (response, context) {
+    if (response.status === 202) {
+        const output = yield* MediaProtocol.text(UPSCALE_ADAPTER, NAME, response);
+        return yield* output.invalid(`${NAME} upscale ${context.token.id} has not finished`);
+    }
+    return yield* decodeUpscaleImage(response);
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["size", "mask"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const upscaleProtocol = MediaProtocol.queued({
+    id: UPSCALE_ADAPTER,
+    name: NAME,
+    token: Token,
+    unsupported: ["n", "size", "aspectRatio", "mask"],
+    start: { body: { from: fromUpscaleRequest }, decode: decodeStart },
+    status: { path: (token) => `${RESULTS_PATH}/${token.id}`, decode: decodeStatus },
+    result: { path: (token) => `${RESULTS_PATH}/${token.id}`, decode: decodeUpscaleResult },
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    headers: HEADERS,
+    path: ({ request }) => `/v2beta/stable-image/generate/${endpoint(request.model.id)}`,
+}, input);
+export const upscaleModel = (input) => ImageModel.fromRoute({
+    id: UPSCALE_ADAPTER,
+    provider: PROVIDER,
+    protocol: upscaleProtocol,
+    baseURL: DEFAULT_BASE_URL,
+    headers: HEADERS,
+    // Only the creative upscaler is asynchronous; fast and conservative answer inline.
+    path: `/v2beta/stable-image/upscale/${UPSCALE_MODEL}`,
+}, { ...input, id: UPSCALE_MODEL });
+export const StabilityImages = {
+    protocol,
+    upscaleProtocol,
+    model,
+    upscaleModel,
+};

package/dist/protocols/utils/fal-queue.d.ts

@@ -0,0 +1,28 @@
+import { Effect, Schema } from "effect";
+import type { HttpClientResponse } from "effect/unstable/http";
+import type { Media } from "../../media.js";
+import { MediaProtocol } from "../../route/media-protocol.js";
+import type { AIError } from "../../schema/index.js";
+export declare const DEFAULT_BASE_URL = "https://queue.fal.run";
+/** 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 mediaUrl: (asset: Media.Asset, name: string) => Effect.Effect<string, AIError, never>;
+export declare const protocol: <Request, Response>(input: {
+    readonly id: string;
+    readonly name: string;
+    readonly unsupported?: ReadonlyArray<keyof Request & string>;
+    readonly from: (request: Request) => Effect.Effect<MediaProtocol.Body, AIError>;
+    readonly decodeResult: (response: HttpClientResponse.HttpClientResponse, context: MediaProtocol.PollContext<Token>) => Effect.Effect<Response, AIError>;
+}) => MediaProtocol.Queued<Request, Response, {
+    readonly requestID: string;
+    readonly statusURL: string;
+    readonly responseURL: string;
+    readonly cancelURL: string;
+}>;
+export * as FalQueue from "./fal-queue.js";

package/dist/protocols/utils/fal-queue.js

@@ -0,0 +1,69 @@
+import { Effect, Schema } from "effect";
+import { MediaProtocol } from "../../route/media-protocol.js";
+import { ProviderShared, optionalNull } from "../shared.js";
+export const DEFAULT_BASE_URL = "https://queue.fal.run";
+/** 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 STATUS = {
+    IN_QUEUE: "queued",
+    IN_PROGRESS: "running",
+    COMPLETED: "completed",
+};
+// fal accepts public URLs and data URIs; there is no provider file handle to forward.
+export const mediaUrl = (asset, name) => ProviderShared.mediaReference(asset, undefined, name).pipe(Effect.map((reference) => reference.value));
+export const protocol = (input) => {
+    const decodeQueueStatus = MediaProtocol.decodeJson(input.id, input.name, QueueStatus);
+    return MediaProtocol.queued({
+        id: input.id,
+        name: input.name,
+        token: Token,
+        unsupported: input.unsupported,
+        start: {
+            body: { from: input.from },
+            decode: MediaProtocol.decodeStarted(input.id, input.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 },
+            })),
+        },
+        status: {
+            path: (token) => token.statusURL,
+            decode: Effect.fn("FalQueue.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,
+                };
+            }),
+        },
+        result: { path: (token) => token.responseURL, decode: input.decodeResult },
+        cancel: { method: "PUT", path: (token) => token.cancelURL },
+    });
+};
+export * as FalQueue from "./fal-queue.js";

package/dist/protocols/utils/gemini-generate-content.d.ts

@@ -0,0 +1,65 @@
+import { Effect, Schema, type Stream } from "effect";
+import type { Media } from "../../media.js";
+import type { MediaProtocol } from "../../route/media-protocol.js";
+import { AIError, type MediaUsage, type ProviderMetadata } from "../../schema/index.js";
+declare const UsageMetadata: Schema.Struct<{
+    readonly promptTokenCount: Schema.optional<Schema.Number>;
+    readonly candidatesTokenCount: Schema.optional<Schema.Number>;
+    readonly totalTokenCount: Schema.optional<Schema.Number>;
+}>;
+type UsageMetadata = Schema.Schema.Type<typeof UsageMetadata>;
+export declare const chunk: <const Part extends Schema.Top>(part: Part) => Schema.Struct<{
+    readonly candidates: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly content: Schema.optional<Schema.Struct<{
+            readonly parts: Schema.optional<Schema.$Array<Part>>;
+        }>>;
+        readonly finishReason: Schema.optional<Schema.String>;
+    }>>>;
+    readonly promptFeedback: Schema.optional<Schema.Struct<{
+        readonly blockReason: Schema.optional<Schema.String>;
+        readonly blockReasonMessage: Schema.optional<Schema.String>;
+    }>>;
+    readonly usageMetadata: Schema.optional<Schema.Struct<{
+        readonly promptTokenCount: Schema.optional<Schema.Number>;
+        readonly candidatesTokenCount: Schema.optional<Schema.Number>;
+        readonly totalTokenCount: Schema.optional<Schema.Number>;
+    }>>;
+    readonly modelVersion: Schema.optional<Schema.String>;
+    readonly responseId: Schema.optional<Schema.String>;
+}>;
+interface Chunk {
+    readonly candidates?: ReadonlyArray<{
+        readonly finishReason?: string;
+    }>;
+    readonly promptFeedback?: {
+        readonly blockReason?: string;
+        readonly blockReasonMessage?: string;
+    };
+    readonly usageMetadata?: UsageMetadata;
+    readonly modelVersion?: string;
+    readonly responseId?: string;
+}
+export interface Metadata {
+    readonly usage?: UsageMetadata;
+    readonly finishReason?: string;
+    readonly modelVersion?: string;
+    readonly responseId?: string;
+}
+export declare const track: <State extends Metadata>(state: State, chunk: Chunk) => State;
+export declare const blocked: (name: string, chunk: Chunk, frame: string) => AIError | undefined;
+export declare const usage: (usage: UsageMetadata | undefined) => MediaUsage | undefined;
+export declare const providerMetadata: (state: Metadata) => ProviderMetadata;
+export declare const path: (model: string, mode: MediaProtocol.Mode) => string;
+export declare const frames: (bytes: Stream.Stream<Uint8Array, AIError>, mode: MediaProtocol.Mode) => Stream.Stream<string, AIError, never>;
+export declare const mediaPart: (route: string, asset: Media.Asset) => Effect.Effect<{
+    readonly fileData: {
+        readonly mimeType: string;
+        readonly fileUri: string;
+    };
+} | {
+    readonly inlineData: {
+        readonly mimeType: string;
+        readonly data: string;
+    };
+}, AIError>;
+export * as GeminiGenerateContent from "./gemini-generate-content.js";

package/dist/protocols/utils/gemini-generate-content.js

@@ -0,0 +1,65 @@
+import { Effect, Schema } from "effect";
+import { Framing } from "../../route/framing.js";
+import { AIError, ContentPolicyError, ProviderID } from "../../schema/index.js";
+import { ProviderShared } from "../shared.js";
+import { MediaInput } from "./media-input.js";
+const PROVIDER = ProviderID.make("google");
+const UsageMetadata = Schema.Struct({
+    promptTokenCount: Schema.optional(Schema.Number),
+    candidatesTokenCount: Schema.optional(Schema.Number),
+    totalTokenCount: Schema.optional(Schema.Number),
+});
+export const chunk = (part) => Schema.Struct({
+    candidates: Schema.optional(Schema.Array(Schema.Struct({
+        content: Schema.optional(Schema.Struct({ parts: Schema.optional(Schema.Array(part)) })),
+        finishReason: Schema.optional(Schema.String),
+    }))),
+    promptFeedback: Schema.optional(Schema.Struct({
+        blockReason: Schema.optional(Schema.String),
+        blockReasonMessage: Schema.optional(Schema.String),
+    })),
+    usageMetadata: Schema.optional(UsageMetadata),
+    modelVersion: Schema.optional(Schema.String),
+    responseId: Schema.optional(Schema.String),
+});
+export const track = (state, chunk) => ({
+    ...state,
+    usage: chunk.usageMetadata ?? state.usage,
+    finishReason: chunk.candidates?.[0]?.finishReason ?? state.finishReason,
+    modelVersion: chunk.modelVersion ?? state.modelVersion,
+    responseId: chunk.responseId ?? state.responseId,
+});
+export const blocked = (name, chunk, frame) => {
+    const feedback = chunk.promptFeedback;
+    if (feedback?.blockReason === undefined)
+        return undefined;
+    return new AIError({
+        reason: new ContentPolicyError({
+            message: `${name} blocked the request (${feedback.blockReason})${feedback.blockReasonMessage === undefined ? "" : `: ${feedback.blockReasonMessage}`}`,
+            body: frame,
+        }),
+    });
+};
+export const usage = (usage) => usage === undefined
+    ? undefined
+    : {
+        type: "tokens",
+        input: usage.promptTokenCount,
+        output: usage.candidatesTokenCount,
+        total: ProviderShared.totalTokens(usage.promptTokenCount, usage.candidatesTokenCount, usage.totalTokenCount),
+        details: { google: usage },
+    };
+export const providerMetadata = (state) => ({
+    google: { finishReason: state.finishReason, modelVersion: state.modelVersion, responseId: state.responseId },
+});
+export const path = (model, mode) => mode === "stream" ? `/models/${model}:streamGenerateContent?alt=sse` : `/models/${model}:generateContent`;
+// `generateContent` answers with one document shaped exactly like a streamed chunk, so it is a single frame.
+export const frames = (bytes, mode) => mode === "stream" ? Framing.sse.frame(bytes) : Framing.document.frame(bytes);
+// Gemini does not fetch public URLs; inline payloads and Gemini Files references are the accepted inputs.
+export const mediaPart = (route, asset) => {
+    const fileUri = MediaInput.refID(asset, PROVIDER);
+    if (fileUri !== undefined)
+        return Effect.succeed({ fileData: { mimeType: asset.mediaType, fileUri } });
+    return ProviderShared.requireInlineMedia(route, asset).pipe(Effect.map((media) => ({ inlineData: { mimeType: media.mime, data: media.base64 } })));
+};
+export * as GeminiGenerateContent from "./gemini-generate-content.js";

package/dist/protocols/utils/gemini-json-schema.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from "../../schema/index.js";
+export declare const normalize: (schema: JsonSchema) => JsonSchema;
+export * as GeminiJsonSchema from "./gemini-json-schema.js";