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

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/media-input.d.ts

@@ -7,6 +7,10 @@ export declare const inlineBytes: (route: string, asset: Media.Asset) => Effect.
 /** Copied because `BlobPart` requires a plain `ArrayBuffer`. */
 export declare const blob: (data: Uint8Array, mediaType: string) => Blob;
 export declare const query: (route: string, values: Record<string, unknown>) => Effect.Effect<MediaProtocol.Query, AIError>;
+export declare const dimensions: (size: string) => {
+    width: number;
+    height: number;
+};
 /** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
 export declare const refID: (asset: Media.Asset, provider: ProviderID) => string | undefined;
 /** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */

package/dist/protocols/utils/media-input.js

@@ -24,6 +24,10 @@ export const query = (route, values) => {
         return Effect.fail(ProviderShared.invalidRequest(`${route} cannot send "${invalid[0]}" as a query parameter`));
     return Effect.succeed(Object.fromEntries(entries.map(([key, value]) => [key, Array.isArray(value) ? value.map(String) : String(value)])));
 };
+export const dimensions = (size) => {
+    const [width, height] = size.split("x").map(Number);
+    return { width, height };
+};
 /** Provider file handle when the ref belongs to this provider; refs from other providers are never forwarded. */
 export const refID = (asset, provider) => asset.source.type === "ref" && asset.source.provider === provider ? asset.source.id : undefined;
 /** Decode a provider's base64 output once into an owned `bytes` asset, sniffing the type when it is not declared. */

package/dist/provider-error.js

@@ -65,6 +65,7 @@ const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error"
 // emits `image_content_policy_violation` as the native code.
 const CONTENT_POLICY_CODES = new Set([
     "content_filter",
+    "content_moderation",
     "responsibleaipolicyviolation",
     "content_policy_violation",
     "image_content_policy_violation",
@@ -157,6 +158,8 @@ function providerCodes(value) {
     const exception = isRecord(decoded.exception) ? decoded.exception : undefined;
     return [
         decoded.code,
+        // Stability's `{ id, name, errors }` bodies carry the code in `name`.
+        Array.isArray(decoded.errors) ? decoded.name : undefined,
         decoded.error_type,
         error?.code,
         error?.type,

package/dist/providers/azure.d.ts

@@ -192,11 +192,11 @@ declare const responsesRoute: Route<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -532,11 +532,11 @@ export declare const routes: (Route<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;

package/dist/providers/black-forest-labs.d.ts

@@ -0,0 +1,25 @@
+import type { ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { BlackForestLabsImageOptions } from "../protocols/bfl-images.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    /** `https://api.eu.bfl.ai` or `https://api.us.bfl.ai` pin inference to one region. */
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/bfl-images.js").BlackForestLabsImageOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/bfl-images.js").BlackForestLabsImageOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/bfl-images.js").BlackForestLabsImageOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/bfl-images.js").BlackForestLabsImageOptions>;

package/dist/providers/black-forest-labs.js

@@ -0,0 +1,28 @@
+import { Auth } from "../route/auth.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { BlackForestLabsImages, DEFAULT_BASE_URL } from "../protocols/bfl-images.js";
+export const id = ProviderID.make("black-forest-labs");
+const baseURL = DEFAULT_BASE_URL;
+const auth = (options) => {
+    if ("auth" in options && options.auth)
+        return options.auth;
+    return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+        .orElse(Auth.config("BFL_API_KEY"))
+        .pipe(Auth.header("x-key"));
+};
+export const configure = (input = {}) => {
+    const image = (modelID) => BlackForestLabsImages.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return {
+        id,
+        image,
+        configure,
+    };
+};
+export const provider = configure();
+export const image = provider.image;

package/dist/providers/cloudflare-ai-gateway.d.ts

@@ -198,11 +198,11 @@ export declare const responsesRoute: import("../route/client.js").Route<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -1195,11 +1195,11 @@ export declare const routes: (import("../route/client.js").Route<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;

package/dist/providers/fal.d.ts

@@ -1,5 +1,6 @@
 import type { ProviderAuthOption } from "../route/auth-options.js";
 import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { FalImageOptions } from "../protocols/fal-images.js";
 export type { FalVideoOptions } from "../protocols/fal-video.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = ProviderAuthOption<"optional"> & {
@@ -9,16 +10,20 @@ export type Config = ProviderAuthOption<"optional"> & {
 };
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/fal-images.js").FalImageOptions>;
     video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/fal-video.js").FalVideoOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/fal-images.js").FalImageOptions>;
     video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/fal-video.js").FalVideoOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/fal-images.js").FalImageOptions>;
         video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/fal-video.js").FalVideoOptions>;
         configure: /*elided*/ any;
     };
 };
+export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/fal-images.js").FalImageOptions>;
 export declare const video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/fal-video.js").FalVideoOptions>;

package/dist/providers/fal.js

@@ -1,8 +1,10 @@
 import { Auth } from "../route/auth.js";
 import { HttpOptions, ProviderID } from "../schema/index.js";
-import { DEFAULT_BASE_URL, FalVideo } from "../protocols/fal-video.js";
+import { FalImages } from "../protocols/fal-images.js";
+import { FalVideo } from "../protocols/fal-video.js";
+import { FalQueue } from "../protocols/utils/fal-queue.js";
 export const id = ProviderID.make("fal");
-const baseURL = DEFAULT_BASE_URL;
+const baseURL = FalQueue.DEFAULT_BASE_URL;
 // fal authenticates with `Authorization: Key <FAL_KEY>` rather than a bearer token.
 const auth = (options) => {
     if ("auth" in options && options.auth)
@@ -12,7 +14,7 @@ const auth = (options) => {
         .pipe(Auth.scheme("Key"));
 };
 export const configure = (input = {}) => {
-    const video = (modelID) => FalVideo.model({
+    const media = (modelID) => ({
         id: modelID,
         auth: auth(input),
         baseURL: input.baseURL ?? baseURL,
@@ -21,9 +23,11 @@ export const configure = (input = {}) => {
     });
     return {
         id,
-        video,
+        image: (modelID) => FalImages.model(media(modelID)),
+        video: (modelID) => FalVideo.model(media(modelID)),
         configure,
     };
 };
 export const provider = configure();
+export const image = provider.image;
 export const video = provider.video;

package/dist/providers/index.d.ts

@@ -6,6 +6,7 @@ export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js";
 export * as AssemblyAI from "./assemblyai.js";
 export * as Azure from "./azure.js";
 export * as Baseten from "./baseten.js";
+export * as BlackForestLabs from "./black-forest-labs.js";
 export * as Cartesia from "./cartesia.js";
 export * as Cerebras from "./cerebras.js";
 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js";
@@ -31,7 +32,9 @@ export * as OpenAICompatible from "./openai-compatible.js";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
 export * as OpenCodeZen from "./opencode-zen.js";
 export * as OpenRouter from "./openrouter.js";
+export * as Replicate from "./replicate.js";
 export * as Runway from "./runway.js";
+export * as Stability from "./stability.js";
 export * as TogetherAI from "./togetherai.js";
 export * as TypeSafeAI from "./typesafe-ai.js";
 export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/index.js

@@ -6,6 +6,7 @@ export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js";
 export * as AssemblyAI from "./assemblyai.js";
 export * as Azure from "./azure.js";
 export * as Baseten from "./baseten.js";
+export * as BlackForestLabs from "./black-forest-labs.js";
 export * as Cartesia from "./cartesia.js";
 export * as Cerebras from "./cerebras.js";
 export * as CloudflareAIGateway from "./cloudflare-ai-gateway.js";
@@ -31,7 +32,9 @@ export * as OpenAICompatible from "./openai-compatible.js";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
 export * as OpenCodeZen from "./opencode-zen.js";
 export * as OpenRouter from "./openrouter.js";
+export * as Replicate from "./replicate.js";
 export * as Runway from "./runway.js";
+export * as Stability from "./stability.js";
 export * as TogetherAI from "./togetherai.js";
 export * as TypeSafeAI from "./typesafe-ai.js";
 export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/openai.d.ts

@@ -291,11 +291,11 @@ export declare const routes: (Route<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly partial_images?: number | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;

package/dist/providers/replicate.d.ts

@@ -0,0 +1,25 @@
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { ReplicateImageOptions } from "../protocols/replicate-images.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    /** `{ Prefer: "wait=60" }` holds the submission open until the prediction finishes (up to 60 seconds). */
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/replicate-images.js").ReplicateImageOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/replicate-images.js").ReplicateImageOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/replicate-images.js").ReplicateImageOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/replicate-images.js").ReplicateImageOptions>;

package/dist/providers/replicate.js

@@ -0,0 +1,22 @@
+import { AuthOptions } from "../route/auth-options.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { DEFAULT_BASE_URL, ReplicateImages } from "../protocols/replicate-images.js";
+export const id = ProviderID.make("replicate");
+const baseURL = DEFAULT_BASE_URL;
+const auth = (options) => AuthOptions.bearer(options, "REPLICATE_API_TOKEN");
+export const configure = (input = {}) => {
+    const image = (modelID) => ReplicateImages.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return {
+        id,
+        image,
+        configure,
+    };
+};
+export const provider = configure();
+export const image = provider.image;

package/dist/providers/stability.d.ts

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

package/dist/providers/stability.js

@@ -0,0 +1,23 @@
+import { AuthOptions } from "../route/auth-options.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { DEFAULT_BASE_URL, StabilityImages } from "../protocols/stability-images.js";
+export const id = ProviderID.make("stability");
+const baseURL = DEFAULT_BASE_URL;
+const auth = (options) => AuthOptions.bearer(options, "STABILITY_API_KEY");
+export const configure = (input = {}) => {
+    const deployment = {
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    };
+    return {
+        id,
+        image: (modelID) => StabilityImages.model({ ...deployment, id: modelID }),
+        upscale: () => StabilityImages.upscaleModel(deployment),
+        configure,
+    };
+};
+export const provider = configure();
+export const image = provider.image;
+export const upscale = provider.upscale;

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

@@ -52,11 +52,13 @@ export interface Started<Token> {
 }
 /**
  * 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).
+ * to output URLs that require the same credentials to download (Veo). `materialize` downloads an output through the
+ * route's executor, for URLs that expire too soon to hand back (BFL).
  */
 export interface PollContext<Token> {
     readonly token: Token;
     readonly auth: Record<string, string>;
+    readonly materialize: (asset: Media.Asset) => Effect.Effect<Media.Asset, AIError>;
 }
 /**
  * Submit, then poll. `start` posts the body to the route endpoint; `status`, `result`, and `cancel` are follow-up