@opencode/ai 2.0.14 → 2.0.16

package/dist/protocols/shared.js

@@ -1,9 +1,9 @@
-import { Buffer } from "node:buffer";
 import { Tool } from "@opencode/schema/tool";
 import { Effect, Option, Schema, Stream } from "effect";
 import * as Sse from "effect/unstable/encoding/Sse";
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
-import { InvalidProviderOutputError, InvalidRequestError, UnsupportedOperationError, AIError, HttpContext, LLMRequest, Message, ToolDefinition, } from "../schema/index.js";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Media } from "../media.js";
+import { InvalidProviderOutputError, InvalidRequestError, UnsupportedOperationError, AIError, LLMRequest, Message, ToolDefinition, } from "../schema/index.js";
 import { isRecord } from "../utils/record.js";
 export { isRecord };
 export const Json = Schema.fromJsonString(Schema.Unknown);
@@ -126,17 +126,44 @@ export const wrappedSystemUpdate = Effect.fn("ProviderShared.wrappedSystemUpdate
  * routes: `Invalid JSON input for <route> tool call <name>`.
  */
 export const parseToolInput = (route, name, raw) => parseJson(route, raw || "{}", `Invalid JSON input for ${route} tool call ${name}`);
-export const normalizeMedia = (part) => {
-    const mime = part.mediaType.toLowerCase();
-    if (typeof part.data !== "string") {
-        const base64 = Buffer.from(part.data).toString("base64");
-        return { mime, base64, dataUrl: `data:${mime};base64,${base64}` };
-    }
-    if (!part.data.startsWith("data:"))
-        return { mime, base64: part.data, dataUrl: `data:${mime};base64,${part.data}` };
-    return { mime, base64: part.data.slice(part.data.indexOf(",") + 1), dataUrl: part.data };
+/** Inline view or a typed `InvalidRequest` for routes that cannot fetch URLs or dereference provider refs. */
+export const requireInlineMedia = (route, asset) => {
+    const inline = asset.inline();
+    return inline ? Effect.succeed(inline) : Effect.fail(inlineRequired(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.
+ */
+export const toolFileMedia = (item) => {
+    const parsed = Media.parseDataUrl(item.uri);
+    const asset = parsed
+        ? Media.from({ ...parsed.source, mediaType: item.mime })
+        : /^https?:\/\//.test(item.uri)
+            ? Media.url(item.uri, { mediaType: item.mime })
+            : Media.base64(item.uri, item.mime);
+    return Message.media(asset, { filename: item.name });
 };
-export const normalizeToolFile = (part) => normalizeMedia({ type: "media", mediaType: part.mime, data: part.uri, filename: part.name });
 export const trimBaseUrl = (value) => value.replace(/\/+$/, "");
 export const toolResultText = (part) => {
     if (part.result.type === "text")
@@ -164,11 +191,11 @@ 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 events. `[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`.
+ * 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`.
  */
 export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Stream.decodeText(), Stream.mapAccumEffect(() => {
     const output = [];
@@ -186,6 +213,13 @@ export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Str
     return [state, state.output.splice(0)];
 })), Stream.filter((event) => (events === undefined || events.has(event.event)) &&
     event.data.length > 0 &&
+    // Some OpenAI-compatible proxies serialize an empty flush as a bare
+    // `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.
@@ -241,23 +275,6 @@ export const flattenToolRequest = (request) => {
             : LLMRequest.update(request, { messages }),
     };
 };
-export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (route, name, response) {
-    const http = new HttpContext({ url: response.request.url, status: response.status, headers: response.headers });
-    const body = yield* response.text.pipe(Effect.mapError((cause) => new AIError({
-        reason: new InvalidProviderOutputError({
-            route,
-            message: `Failed to read the ${name} response`,
-            http,
-            cause,
-        }),
-    })));
-    return {
-        body,
-        invalid: (message, cause) => new AIError({
-            reason: new InvalidProviderOutputError({ route, message, body, http, cause }),
-        }),
-    };
-});
 export const matchToolChoice = (route, toolChoice, cases) => Effect.gen(function* () {
     if (toolChoice.type === "auto")
         return cases.auto();

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

@@ -23,9 +23,8 @@ export declare const DocumentBlock: Schema.Struct<{
 }>;
 export type DocumentBlock = Schema.Schema.Type<typeof DocumentBlock>;
 export declare const lower: (part: {
-    readonly data: string | Uint8Array<ArrayBufferLike>;
     readonly type: "media";
-    readonly mediaType: string;
+    readonly media: import("../../media.js").Asset;
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
@@ -45,7 +44,7 @@ export declare const lower: (part: {
     };
 }[] | ({
     readonly document: {
-        readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+        readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
         readonly name: string;
         readonly source: {
             readonly bytes: string;

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

@@ -62,7 +62,7 @@ function documentName(filename, names) {
     return name;
 }
 const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part) {
-    const media = ProviderShared.normalizeMedia(part);
+    const media = yield* ProviderShared.requireInlineMedia("Bedrock Converse", part.media);
     const bytes = yield* Effect.fromResult(Encoding.decodeBase64(media.base64)).pipe(Effect.mapError((cause) => ProviderShared.invalidRequest("Bedrock Converse media data must be valid base64", cause)));
     return Encoding.encodeBase64(bytes);
 });
@@ -72,13 +72,13 @@ const mediaBase64 = Effect.fn("BedrockMedia.mediaBase64")(function* (part) {
 // get an image-specific error so the caller knows it's a format-support issue,
 // not a kind-detection issue.
 export const lower = Effect.fn("BedrockMedia.lower")(function* (part, documentNames) {
-    const mime = part.mediaType.toLowerCase();
+    const mime = part.media.mediaType.toLowerCase();
     const imageFormat = IMAGE_FORMATS[mime];
     if (imageFormat) {
         return [{ image: { format: imageFormat, source: { bytes: yield* mediaBase64(part) } } }];
     }
     if (mime.startsWith("image/"))
-        return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.mediaType}`);
+        return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.media.mediaType}`);
     const documentFormat = DOCUMENT_FORMATS[mime];
     if (documentFormat) {
         const name = documentName(part.filename, documentNames);
@@ -92,6 +92,6 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part, documentNa
             ]
             : [block];
     }
-    return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`);
+    return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.media.mediaType}`);
 });
 export * as BedrockMedia from "./bedrock-media.js";

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