@opencode/ai 0.0.0-dev-20048 → 0.0.0-dev-20050

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

@@ -1,8 +1,12 @@
 import { Effect } from "effect";
 import { Media } from "../../media.js";
+import type { MediaProtocol } from "../../route/media-protocol.js";
 import type { AIError, ProviderID } from "../../schema/index.js";
 /** Owned bytes for multipart uploads; decodes `base64` sources and rejects remote sources. */
 export declare const inlineBytes: (route: string, asset: Media.Asset) => Effect.Effect<Uint8Array, AIError>;
+/** 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>;
 /** 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

@@ -10,6 +10,20 @@ export const inlineBytes = (route, asset) => {
         return Effect.fail(ProviderShared.inlineRequired(route, asset));
     return Effect.fromResult(Encoding.decodeBase64(inline.base64)).pipe(Effect.mapError((cause) => ProviderShared.invalidRequest(`${route} media contains invalid base64 data`, cause)));
 };
+/** Copied because `BlobPart` requires a plain `ArrayBuffer`. */
+export const blob = (data, mediaType) => {
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(data);
+    return new Blob([buffer], { type: mediaType });
+};
+const isScalar = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+export const query = (route, values) => {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    const invalid = entries.find(([, value]) => !isScalar(value) && !(Array.isArray(value) && value.every(isScalar)));
+    if (invalid !== undefined)
+        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)])));
+};
 /** 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/providers/assemblyai.d.ts

@@ -0,0 +1,25 @@
+import type { ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { AssemblyAITranscriptionOptions } from "../protocols/assemblyai-transcription.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    /** `https://api.eu.assemblyai.com` for the EU 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">;
+    transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/assemblyai-transcription.js").AssemblyAITranscriptionOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/assemblyai-transcription.js").AssemblyAITranscriptionOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/assemblyai-transcription.js").AssemblyAITranscriptionOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/assemblyai-transcription.js").AssemblyAITranscriptionOptions>;

package/dist/providers/assemblyai.js

@@ -0,0 +1,29 @@
+import { Auth } from "../route/auth.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { AssemblyAITranscription, DEFAULT_BASE_URL } from "../protocols/assemblyai-transcription.js";
+export const id = ProviderID.make("assemblyai");
+const baseURL = DEFAULT_BASE_URL;
+// The key is the whole `authorization` value, without a scheme.
+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("ASSEMBLYAI_API_KEY"))
+        .pipe(Auth.header("authorization"));
+};
+export const configure = (input = {}) => {
+    const transcription = (modelID) => AssemblyAITranscription.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return {
+        id,
+        transcription,
+        configure,
+    };
+};
+export const provider = configure();
+export const transcription = provider.transcription;

package/dist/providers/deepgram.d.ts

@@ -1,6 +1,7 @@
 import type { ProviderAuthOption } from "../route/auth-options.js";
 import { HttpOptions, type ModelID } from "../schema/index.js";
 export type { DeepgramEncoding, DeepgramSpeechOptions } from "../protocols/deepgram-speech.js";
+export type { DeepgramTranscriptionOptions } from "../protocols/deepgram-transcription.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
@@ -10,15 +11,19 @@ export type Config = ProviderAuthOption<"optional"> & {
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/deepgram-speech.js").DeepgramSpeechOptions>;
+    transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/deepgram-transcription.js").DeepgramTranscriptionOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/deepgram-speech.js").DeepgramSpeechOptions>;
+    transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/deepgram-transcription.js").DeepgramTranscriptionOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/deepgram-speech.js").DeepgramSpeechOptions>;
+        transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/deepgram-transcription.js").DeepgramTranscriptionOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/deepgram-speech.js").DeepgramSpeechOptions>;
+export declare const transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/deepgram-transcription.js").DeepgramTranscriptionOptions>;

package/dist/providers/deepgram.js

@@ -1,6 +1,7 @@
 import { Auth } from "../route/auth.js";
 import { HttpOptions, ProviderID } from "../schema/index.js";
 import { DEFAULT_BASE_URL, DeepgramSpeech } from "../protocols/deepgram-speech.js";
+import { DeepgramTranscription } from "../protocols/deepgram-transcription.js";
 export const id = ProviderID.make("deepgram");
 const baseURL = DEFAULT_BASE_URL;
 const auth = (options) => {
@@ -11,7 +12,7 @@ const auth = (options) => {
         .pipe(Auth.scheme("Token"));
 };
 export const configure = (input = {}) => {
-    const speech = (modelID) => DeepgramSpeech.model({
+    const media = (modelID) => ({
         id: modelID,
         auth: auth(input),
         baseURL: input.baseURL ?? baseURL,
@@ -20,9 +21,11 @@ export const configure = (input = {}) => {
     });
     return {
         id,
-        speech,
+        speech: (modelID) => DeepgramSpeech.model(media(modelID)),
+        transcription: (modelID) => DeepgramTranscription.model(media(modelID)),
         configure,
     };
 };
 export const provider = configure();
 export const speech = provider.speech;
+export const transcription = provider.transcription;

package/dist/providers/google.d.ts

@@ -5,6 +5,7 @@ import { type ModelID } from "../schema/index.js";
 import { Gemini } from "../protocols/gemini.js";
 export type { GoogleImageOptions } from "../protocols/google-images.js";
 export type { GoogleSpeechOptions } from "../protocols/google-speech.js";
+export type { GoogleTranscriptionOptions } from "../protocols/google-transcription.js";
 export type { GoogleVideoOptions } from "../protocols/google-video.js";
 export type GeminiOptionsInput = Gemini.OptionsInput;
 export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
@@ -108,6 +109,7 @@ export declare const configure: (input?: Config) => {
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
     video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
     speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/google-speech.js").GoogleSpeechOptions>;
+    transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/google-transcription.js").GoogleTranscriptionOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
@@ -116,12 +118,14 @@ export declare const provider: {
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
     video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
     speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/google-speech.js").GoogleSpeechOptions>;
+    transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/google-transcription.js").GoogleTranscriptionOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
         video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
         speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/google-speech.js").GoogleSpeechOptions>;
+        transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/google-transcription.js").GoogleTranscriptionOptions>;
         configure: /*elided*/ any;
     };
 };
@@ -129,3 +133,4 @@ export declare const model: ProviderPackage.Definition<Settings, Gemini.Provider
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
 export declare const video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
 export declare const speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/google-speech.js").GoogleSpeechOptions>;
+export declare const transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/google-transcription.js").GoogleTranscriptionOptions>;

package/dist/providers/google.js

@@ -3,6 +3,7 @@ import { HttpOptions, ProviderID, mergeHttpOptions } from "../schema/index.js";
 import { Gemini } from "../protocols/gemini.js";
 import { GoogleImages } from "../protocols/google-images.js";
 import { GoogleSpeech } from "../protocols/google-speech.js";
+import { GoogleTranscription } from "../protocols/google-transcription.js";
 import { GoogleVideo } from "../protocols/google-video.js";
 export const id = ProviderID.make("google");
 export const routes = [Gemini.route];
@@ -32,6 +33,7 @@ export const configure = (input = {}) => {
         image: (modelID) => GoogleImages.model(media(modelID)),
         video: (modelID) => GoogleVideo.model(media(modelID)),
         speech: (modelID) => GoogleSpeech.model(media(modelID)),
+        transcription: (modelID) => GoogleTranscription.model(media(modelID)),
         configure,
     };
 };
@@ -46,3 +48,4 @@ export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOpti
 export const image = provider.image;
 export const video = provider.video;
 export const speech = provider.speech;
+export const transcription = provider.transcription;

package/dist/providers/index.d.ts

@@ -3,6 +3,7 @@ export * as Anthropic from "./anthropic.js";
 export * as AnthropicCompatible from "./anthropic-compatible.js";
 export * as AmazonBedrock from "./amazon-bedrock.js";
 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 Cartesia from "./cartesia.js";

package/dist/providers/index.js

@@ -3,6 +3,7 @@ export * as Anthropic from "./anthropic.js";
 export * as AnthropicCompatible from "./anthropic-compatible.js";
 export * as AmazonBedrock from "./amazon-bedrock.js";
 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 Cartesia from "./cartesia.js";

package/dist/providers/openai.d.ts

@@ -8,6 +8,7 @@ import { type OpenAIImageString } from "../protocols/openai-images.js";
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options.js";
 export type { OpenAIImageOptions } from "../protocols/openai-images.js";
 export type { OpenAISpeechOptions } from "../protocols/openai-speech.js";
+export type { OpenAITranscriptionOptions } from "../protocols/openai-transcription.js";
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export declare const routes: (Route<{
     readonly model: string;
@@ -374,6 +375,7 @@ export declare const configure: (input?: Config) => {
     chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
     speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/openai-speech.js").OpenAISpeechOptions>;
+    transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/openai-transcription.js").OpenAITranscriptionOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
@@ -389,6 +391,7 @@ export declare const provider: {
     chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
     speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/openai-speech.js").OpenAISpeechOptions>;
+    transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/openai-transcription.js").OpenAITranscriptionOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, {
@@ -402,6 +405,7 @@ export declare const provider: {
         chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, CompactionOperations | undefined>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
         speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/openai-speech.js").OpenAISpeechOptions>;
+        transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/openai-transcription.js").OpenAITranscriptionOptions>;
         configure: /*elided*/ any;
     };
 };
@@ -414,3 +418,4 @@ export declare const responses: (id: string | ModelID) => import("../schema/opti
 export declare const chat: (id: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, CompactionOperations | undefined>;
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/openai-images.js").OpenAIImageOptions>;
 export declare const speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/openai-speech.js").OpenAISpeechOptions>;
+export declare const transcription: (modelID: string | ModelID) => import("../transcription.js").TranscriptionModel<import("../protocols/openai-transcription.js").OpenAITranscriptionOptions>;

package/dist/providers/openai.js

@@ -5,6 +5,7 @@ import * as OpenAIResponses from "../protocols/openai-responses.js";
 import { withOpenAIOptions } from "./openai-options.js";
 import { OpenAIImages } from "../protocols/openai-images.js";
 import { OpenAISpeech } from "../protocols/openai-speech.js";
+import { OpenAITranscription } from "../protocols/openai-transcription.js";
 export const id = ProviderID.make("openai");
 export const routes = [OpenAIResponses.route, OpenAIChat.route];
 export const imageGeneration = (options = {}) => ToolDefinition.make({
@@ -54,6 +55,7 @@ export const configure = (input = {}) => {
     });
     const image = (modelID) => OpenAIImages.model(media(modelID));
     const speech = (modelID) => OpenAISpeech.model(media(modelID));
+    const transcription = (modelID) => OpenAITranscription.model(media(modelID));
     return {
         id,
         model: responses,
@@ -61,6 +63,7 @@ export const configure = (input = {}) => {
         chat,
         image,
         speech,
+        transcription,
         configure,
     };
 };
@@ -88,3 +91,4 @@ export const responses = provider.responses;
 export const chat = provider.chat;
 export const image = provider.image;
 export const speech = provider.speech;
+export const transcription = provider.transcription;

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

@@ -4,17 +4,28 @@ import type { Snapshot, Status } from "../generation.js";
 import { Media } from "../media.js";
 import type { AuthInput } from "./auth.js";
 import { AIError, HttpContext } from "../schema/index.js";
-/** JSON `query` is appended to the endpoint URL before the route and caller `http.query` overlays. */
+/** Array values become repeated parameters (`keyterm=a&keyterm=b`). */
+export type Query = Readonly<Record<string, string | ReadonlyArray<string>>>;
+/** `query` is appended to the endpoint URL before the route and caller `http.query` overlays. */
 export type Body = {
     readonly type: "json";
     readonly value: Record<string, unknown>;
-    readonly query?: Record<string, string>;
+    readonly query?: Query;
 } | {
     readonly type: "multipart";
     readonly value: FormData;
+} | {
+    readonly type: "binary";
+    readonly value: Uint8Array;
+    readonly contentType: string;
+    readonly query?: Query;
 };
-export declare const json: (value: Record<string, unknown>, query?: Record<string, string>) => Body;
+export declare const json: (value: Record<string, unknown>, query?: Query) => Body;
 export declare const multipart: (value: FormData) => Body;
+export declare const binary: (value: Uint8Array, contentType: string, query?: Query) => Body;
+export type Send = (path: string, body: Body) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
+/** Runs after unsupported-field rejection and before `body.from`, for providers that need an upload first. */
+export type Prepare<Request> = (request: Request, send: Send) => Effect.Effect<Request, AIError>;
 export interface DecodeContext<Request> {
     readonly request: Request;
     readonly body: Body;
@@ -63,6 +74,7 @@ export interface Queued<Request, Response, Token> {
     /** Serializable handle. `Generation.token` carries the encoded form so it can be persisted and resumed elsewhere. */
     readonly token: Schema.Codec<Token, unknown>;
     readonly start: {
+        readonly prepare?: Prepare<Request>;
         readonly body: {
             readonly from: (request: Request) => Effect.Effect<Body, AIError>;
         };

package/dist/route/media-protocol.js

@@ -8,6 +8,12 @@ export const json = (value, query) => ({
     query,
 });
 export const multipart = (value) => ({ type: "multipart", value });
+export const binary = (value, contentType, query) => ({
+    type: "binary",
+    value,
+    contentType,
+    query,
+});
 export const inline = (input) => ({
     kind: "inline",
     ...input,

package/dist/route/media.d.ts

@@ -25,6 +25,7 @@ export interface ModelInput {
 }
 /** One request, one response. */
 export interface Route<Request extends MediaRequest, Response> {
+    readonly kind: "inline";
     readonly id: string;
     readonly provider: ProviderID;
     readonly protocol: string;
@@ -32,6 +33,7 @@ export interface Route<Request extends MediaRequest, Response> {
 }
 /** Submit, then poll through the returned `Generation`. */
 export interface QueuedRoute<Request extends MediaRequest, Response> {
+    readonly kind: "queued";
     readonly id: string;
     readonly provider: ProviderID;
     readonly protocol: string;
@@ -41,6 +43,7 @@ export interface QueuedRoute<Request extends MediaRequest, Response> {
 }
 /** One request whose response parses into events; `generate` runs the same stream and collects it. */
 export interface StreamRoute<Request extends MediaRequest, Event, Response> {
+    readonly kind: "stream";
     readonly id: string;
     readonly provider: ProviderID;
     readonly protocol: string;
@@ -68,8 +71,8 @@ export interface StreamInput<Request extends MediaRequest, Event, Response, Fram
 /**
  * Compose an inline media protocol with an endpoint and auth into a runnable route. The route owns the transport
  * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field
- * rejection, URL and query rendering, auth headers, JSON vs multipart encoding, and handing responses back to the
- * protocol.
+ * rejection, URL and query rendering, auth headers, JSON, multipart, or binary encoding, and handing responses back
+ * to the protocol.
  */
 export declare const inline: <Request extends MediaRequest, Response>(input: InlineInput<Request, Response>) => Route<Request, Response>;
 /**

package/dist/route/media.js

@@ -11,12 +11,13 @@ import { sanitizeSurrogates } from "../utils/sanitize.js";
 /**
  * Compose an inline media protocol with an endpoint and auth into a runnable route. The route owns the transport
  * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field
- * rejection, URL and query rendering, auth headers, JSON vs multipart encoding, and handing responses back to the
- * protocol.
+ * rejection, URL and query rendering, auth headers, JSON, multipart, or binary encoding, and handing responses back
+ * to the protocol.
  */
 export const inline = (input) => {
     const transport = makeTransport(input);
     return {
+        kind: "inline",
         id: input.id,
         provider: transport.provider,
         protocol: input.protocol.id,
@@ -52,7 +53,7 @@ export const queued = (input) => {
         return route;
     };
     const start = Effect.fn("MediaRoute.start")(function* (request, execute) {
-        const submitted = yield* transport.submit(request, { unsupported: protocol.unsupported, from: protocol.start.body.from }, execute);
+        const submitted = yield* transport.submit(request, { unsupported: protocol.unsupported, prepare: protocol.start.prepare, from: protocol.start.body.from }, execute);
         const started = yield* protocol.start.decode(submitted.response, submitted.context);
         const route = generationRoute(started.token, submitted.context.request.http, execute);
         return new Generation(route, encodeToken(started.token), started.snapshot);
@@ -67,7 +68,7 @@ export const queued = (input) => {
         const route = generationRoute(token, transport.http(model), execute);
         return new Generation(route, encodeToken(token), yield* route.status);
     });
-    return { id: input.id, provider: transport.provider, protocol: protocol.id, start, resume };
+    return { kind: "queued", id: input.id, provider: transport.provider, protocol: protocol.id, start, resume };
 };
 /** Compose a streaming media protocol; `generate` runs the same stream in `generate` mode and folds it with `collect`. */
 export const stream = (input) => {
@@ -95,6 +96,7 @@ export const stream = (input) => {
         });
     }));
     return {
+        kind: "stream",
         id: input.id,
         provider: transport.provider,
         protocol: protocol.id,
@@ -109,11 +111,21 @@ const makeTransport = (input) => {
     const provider = ProviderID.make(input.provider);
     const routeHttp = input.headers === undefined ? undefined : new HttpOptions({ headers: input.headers });
     const authorize = Auth.toEffect(input.auth);
-    const withQuery = (url, query) => {
-        for (const [key, value] of Object.entries(query ?? {}))
-            url.searchParams.set(key, value);
-        return url;
-    };
+    const baseURL = (path) => new URL(`${ProviderShared.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`);
+    /** `auth` is only what `Auth` added, never deployment headers. */
+    const send = Effect.fn("MediaRoute.send")(function* (call, execute) {
+        const encoded = encode(call.body, call.headers);
+        const url = call.url.toString();
+        const headers = yield* authorize({
+            request: call.request,
+            method: call.method,
+            url,
+            body: encoded.text,
+            headers: encoded.headers,
+        });
+        const response = yield* execute(encoded.apply(HttpClientRequest.make(call.method)(url).pipe(HttpClientRequest.setHeaders(headers))));
+        return { response, auth: Object.fromEntries(Object.entries(headers).filter(([key]) => !(key in call.headers))) };
+    });
     return {
         provider,
         /** Route and model overlays; `start` additionally merges the request's own `http`. */
@@ -122,43 +134,53 @@ const makeTransport = (input) => {
         submit: Effect.fn("MediaRoute.submit")(function* (request, protocol, execute) {
             yield* rejectUnsupported(input.id, provider, request, protocol.unsupported);
             const http = mergeHttpOptions(routeHttp, request.model.http, request.http);
+            const headers = Headers.fromInput(http?.headers);
+            const prepared = protocol.prepare === undefined
+                ? request
+                : yield* protocol.prepare(request, (path, body) => send({ method: "POST", url: baseURL(path), headers, request, body }, execute).pipe(Effect.map((sent) => sent.response)));
             // Sanitize after merging so model-level overlays are covered; the model value is restored, not sanitized.
-            const resolved = { ...sanitizeSurrogates({ ...request, http }), model: request.model };
+            const resolved = { ...sanitizeSurrogates({ ...prepared, http }), model: request.model };
             const body = yield* protocol.from(resolved);
-            const url = withQuery(withQuery(Endpoint.render(input.endpoint, { request: resolved, body }), body.type === "json" ? body.query : undefined), http?.query);
-            const encoded = body.type === "json" ? ProviderShared.encodeJson(body.value) : "[multipart/form-data]";
-            const baseHeaders = Headers.fromInput(http?.headers);
-            const headers = yield* authorize({
-                request: resolved,
-                method: "POST",
-                url: url.toString(),
-                body: encoded,
-                // The HTTP client sets the multipart boundary; a caller-supplied content-type would corrupt it.
-                headers: body.type === "multipart" ? Headers.remove(baseHeaders, "content-type") : baseHeaders,
-            });
-            const transport = HttpClientRequest.post(url.toString()).pipe(HttpClientRequest.setHeaders(headers), body.type === "json"
-                ? HttpClientRequest.bodyText(encoded, "application/json")
-                : HttpClientRequest.bodyFormData(body.value));
-            const response = yield* execute(transport);
-            return { response, context: { request: resolved, body } };
+            const url = withQuery(withQuery(Endpoint.render(input.endpoint, { request: resolved, body }), body.type === "multipart" ? undefined : body.query), http?.query);
+            const sent = yield* send({ method: "POST", url, headers, request: resolved, body }, execute);
+            return { response: sent.response, context: { request: resolved, body } };
         }),
-        /**
-         * Bodiless follow-up call (status, result, cancel) with the same auth and headers as `submit`. `auth` is only
-         * what `Auth` added, so protocols can hand download credentials to output assets without deployment headers.
-         */
-        call: Effect.fn("MediaRoute.call")(function* (method, path, http, execute) {
+        /** Bodiless follow-up call (status, result, cancel) with the same auth and headers as `submit`. */
+        call: (method, path, http, execute) => {
             // Provider-issued absolute URLs (fal `status_url`) are used as-is; everything else resolves against the base.
-            const url = withQuery(/^https?:\/\//.test(path)
-                ? new URL(path)
-                : new URL(`${ProviderShared.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`), http?.query);
+            const url = withQuery(/^https?:\/\//.test(path) ? new URL(path) : baseURL(path), http?.query);
             for (const [key, value] of Object.entries(input.endpoint.query ?? {}))
                 url.searchParams.set(key, value);
-            const base = Headers.fromInput(http?.headers);
-            const headers = yield* authorize({ request: { http }, method, url: url.toString(), body: "", headers: base });
-            const response = yield* execute(HttpClientRequest.make(method)(url.toString()).pipe(HttpClientRequest.setHeaders(headers)));
-            const auth = Object.fromEntries(Object.entries(headers).filter(([key]) => !(key in base)));
-            return { response, auth };
-        }),
+            return send({ method, url, headers: Headers.fromInput(http?.headers), request: { http } }, execute);
+        },
+    };
+};
+const withQuery = (url, query) => {
+    for (const [key, value] of Object.entries(query ?? {})) {
+        url.searchParams.delete(key);
+        for (const item of typeof value === "string" ? [value] : value)
+            url.searchParams.append(key, item);
+    }
+    return url;
+};
+const encode = (body, headers) => {
+    if (body === undefined)
+        return { text: "", headers, apply: (request) => request };
+    if (body.type === "json") {
+        const text = ProviderShared.encodeJson(body.value);
+        return { text, headers, apply: HttpClientRequest.bodyText(text, "application/json") };
+    }
+    if (body.type === "binary")
+        return {
+            text: `[${body.contentType}]`,
+            headers,
+            apply: HttpClientRequest.bodyUint8Array(body.value, body.contentType),
+        };
+    return {
+        text: "[multipart/form-data]",
+        // The HTTP client sets the multipart boundary; a caller-supplied content-type would corrupt it.
+        headers: Headers.remove(headers, "content-type"),
+        apply: HttpClientRequest.bodyFormData(body.value),
     };
 };
 /** Common fields are never silently dropped: a present field the protocol declared unsupported fails typed. */