@opencode/ai 0.0.0-dev-20120 → 0.0.0-dev-20123

package/dist/protocols/cartesia-speech.js

@@ -3,13 +3,11 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { Framing } from "../route/framing.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { AIError, ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { AIError, mergeJsonRecords } from "../schema/index.js";
 import { SpeechModel } from "../speech.js";
 import { ProviderShared, optionalNull } from "./shared.js";
 import { SpeechStream } from "./utils/speech-stream.js";
-const ADAPTER = "cartesia-speech";
-const NAME = "Cartesia";
-const PROVIDER = ProviderID.make("cartesia");
+const route = MediaProtocol.identity({ id: "cartesia-speech", name: "Cartesia", provider: "cartesia" });
 export const DEFAULT_BASE_URL = "https://api.cartesia.ai";
 export const API_VERSION = "2026-08-14";
 export const BYTES_PATH = "/tts/bytes";
@@ -33,7 +31,7 @@ const SseEvent = Schema.Struct({
     message: Schema.optional(Schema.String),
     error_code: optionalNull(Schema.String),
 });
-const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, SseEvent);
+const decodeEvent = route.decodeFrame(SseEvent);
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
@@ -45,9 +43,9 @@ const outputFormat = Effect.fn("CartesiaSpeech.outputFormat")(function* (request
     const format = request.format ?? (sse ? "pcm" : "mp3");
     const container = CONTAINERS[format];
     if (container === undefined)
-        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} supports the pcm, wav, and mp3 formats, not "${format}"`);
+        return yield* route.unsupported("media.format", `${route.name} supports the pcm, wav, and mp3 formats, not "${format}"`);
     if (sse && container !== "raw")
-        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} streams and timestamps only raw PCM; request format "pcm" instead of "${format}"`);
+        return yield* route.unsupported("media.format", `${route.name} streams and timestamps only raw PCM; request format "pcm" instead of "${format}"`);
     const sampleRate = request.providerOptions?.sampleRate ?? DEFAULT_SAMPLE_RATE;
     if (container === "mp3")
         return { container, sample_rate: sampleRate, bit_rate: request.providerOptions?.bitRate ?? DEFAULT_BIT_RATE };
@@ -56,7 +54,7 @@ const outputFormat = Effect.fn("CartesiaSpeech.outputFormat")(function* (request
 const fromRequest = Effect.fn("CartesiaSpeech.fromRequest")(function* (request) {
     const voice = SpeechStream.voiceID(request.voice);
     if (voice === undefined)
-        return yield* ProviderShared.invalidRequest(`${NAME} requires a voice id; pass it as \`voice\``);
+        return yield* ProviderShared.invalidRequest(`${route.name} requires a voice id; pass it as \`voice\``);
     const { sampleRate: _sampleRate, bitRate: _bitRate, encoding: _encoding, ...native } = request.providerOptions ?? {};
     return MediaProtocol.json(mergeJsonRecords({
         model_id: request.model.id,
@@ -84,7 +82,7 @@ const onEvent = Effect.fn("CartesiaSpeech.onEvent")(function* (state, frame) {
     if (event.type === "error")
         return yield* new AIError({
             reason: classifyProviderFailure({
-                message: `${NAME} stream failed${event.title === undefined ? "" : ` (${event.title})`}: ${event.message ?? "unknown error"}`,
+                message: `${route.name} stream failed${event.title === undefined ? "" : ` (${event.title})`}: ${event.message ?? "unknown error"}`,
                 status: event.status_code,
                 rawBody: frame,
             }),
@@ -93,18 +91,16 @@ const onEvent = Effect.fn("CartesiaSpeech.onEvent")(function* (state, frame) {
 });
 const finish = Effect.fn("CartesiaSpeech.finish")(function* (state, context) {
     if (usesSse(context.request) && !state.done)
-        return yield* MediaProtocol.incomplete(ADAPTER);
+        return yield* route.incomplete();
     const format = yield* outputFormat(context.request);
-    return yield* SpeechStream.finish(ADAPTER, state, format.container === "raw"
+    return yield* SpeechStream.finish(route, state, format.container === "raw"
         ? SpeechStream.pcm(format.encoding, format.sample_rate)
         : SpeechStream.container(format.container, format.sample_rate));
 });
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["instructions"],
     body: { from: fromRequest },
     frames: (bytes, context) => (usesSse(context.request) ? Framing.sse.frame(bytes) : bytes),
@@ -113,8 +109,6 @@ export const protocol = MediaProtocol.stream({
     finish,
 });
 export const model = (input) => SpeechModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
     protocol,
     baseURL: DEFAULT_BASE_URL,
     headers: { "Cartesia-Version": API_VERSION },

package/dist/protocols/deepgram-speech.d.ts

@@ -1,14 +1,14 @@
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 import { SpeechModel, type SpeechRequestFor } from "../speech.js";
 import { SpeechStream } from "./utils/speech-stream.js";
 export declare const DEFAULT_BASE_URL = "https://api.deepgram.com";
 export declare const PATH = "/v1/speak";
-export type DeepgramSpeechString<Known extends string> = Known | (string & {});
-export type DeepgramEncoding = DeepgramSpeechString<"linear16" | "mulaw" | "alaw" | "mp3" | "opus" | "flac" | "aac">;
+export type DeepgramEncoding = OpenString<"linear16" | "mulaw" | "alaw" | "mp3" | "opus" | "flac" | "aac">;
 export type DeepgramSpeechOptions = {
     readonly encoding?: DeepgramEncoding;
-    readonly container?: DeepgramSpeechString<"wav" | "ogg" | "none">;
+    readonly container?: OpenString<"wav" | "ogg" | "none">;
     readonly sampleRate?: number;
     readonly bitRate?: number;
     readonly mip_opt_out?: boolean;

package/dist/protocols/deepgram-speech.js

@@ -1,13 +1,11 @@
 import { Effect } from "effect";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { SpeechModel } from "../speech.js";
 import { MediaInput } from "./utils/media-input.js";
 import { SpeechStream } from "./utils/speech-stream.js";
-const ADAPTER = "deepgram-speech";
-const NAME = "Deepgram";
-const PROVIDER = ProviderID.make("deepgram");
+const route = MediaProtocol.identity({ id: "deepgram-speech", name: "Deepgram", provider: "deepgram" });
 export const DEFAULT_BASE_URL = "https://api.deepgram.com";
 export const PATH = "/v1/speak";
 // ---------------------------------------------------------------------------
@@ -30,7 +28,7 @@ const audioFormat = (request) => {
 };
 const queryParameters = (request) => {
     const { encoding: _encoding, container: _container, sampleRate, bitRate, ...native } = request.providerOptions ?? {};
-    return MediaInput.query(ADAPTER, {
+    return MediaInput.query(route.id, {
         ...native,
         model: request.model.id,
         ...audioFormat(request),
@@ -43,7 +41,7 @@ const fromRequest = Effect.fn("DeepgramSpeech.fromRequest")(function* (request)
     if (request.format !== undefined &&
         FORMATS[request.format] === undefined &&
         request.providerOptions?.encoding === undefined)
-        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} has no encoding for format "${request.format}"; pass providerOptions.encoding`);
+        return yield* route.unsupported("media.format", `${route.name} has no encoding for format "${request.format}"; pass providerOptions.encoding`);
     return MediaProtocol.json(mergeJsonRecords({ text: request.text }, request.http?.body) ?? {}, yield* queryParameters(request));
 });
 // ---------------------------------------------------------------------------
@@ -61,7 +59,7 @@ const finish = (state, context) => {
     const encoding = HEADERLESS_ENCODINGS[format.encoding ?? ""];
     const requestID = headers["dg-request-id"];
     const modelName = headers["dg-model-name"];
-    return SpeechStream.finish(ADAPTER, state, {
+    return SpeechStream.finish(route, state, {
         ...(format.container === "none" && encoding !== undefined
             ? SpeechStream.pcm(encoding, SpeechStream.sampleRate(mediaType), mediaType)
             : // Deepgram's default encoding is MP3; WAV is a container around any encoding.
@@ -75,9 +73,7 @@ const finish = (state, context) => {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["voice", "language", "instructions", "timestamps"],
     body: { from: fromRequest },
     frames: (bytes) => bytes,
@@ -85,7 +81,7 @@ export const protocol = MediaProtocol.stream({
     step: (state, frame) => Effect.succeed(SpeechStream.delta(state, frame)),
     finish,
 });
-export const model = (input) => SpeechModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const model = (input) => SpeechModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
 export const DeepgramSpeech = {
     protocol,
     model,

package/dist/protocols/deepgram-transcription.d.ts

@@ -1,5 +1,6 @@
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 import { TranscriptionModel, TranscriptionResponse, type TranscriptionRequestFor } from "../transcription.js";
 export declare const DEFAULT_BASE_URL = "https://api.deepgram.com";
 export declare const PATH = "/v1/listen";
@@ -10,7 +11,7 @@ export type DeepgramTranscriptionOptions = {
     readonly utterances?: boolean;
     readonly detect_language?: boolean | ReadonlyArray<string>;
     readonly keyterm?: ReadonlyArray<string>;
-    readonly diarize_model?: "latest" | "v1" | "v2" | (string & {});
+    readonly diarize_model?: OpenString<"latest" | "v1" | "v2">;
     readonly filler_words?: boolean;
     readonly numerals?: boolean;
     readonly mip_opt_out?: boolean;

package/dist/protocols/deepgram-transcription.js

@@ -1,13 +1,11 @@
 import { Effect, Schema } from "effect";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
 import { ProviderShared } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "deepgram-transcription";
-const NAME = "Deepgram";
-const PROVIDER = ProviderID.make("deepgram");
+const route = MediaProtocol.identity({ id: "deepgram-transcription", name: "Deepgram", provider: "deepgram" });
 export const DEFAULT_BASE_URL = "https://api.deepgram.com";
 export const PATH = "/v1/listen";
 // ---------------------------------------------------------------------------
@@ -40,7 +38,7 @@ const ListenResponse = Schema.Struct({
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
-const query = (request) => MediaInput.query(ADAPTER, mergeJsonRecords({
+const query = (request) => MediaInput.query(route.id, mergeJsonRecords({
     model: request.model.id,
     smart_format: true,
     language: request.language,
@@ -55,14 +53,14 @@ const fromRequest = Effect.fn("DeepgramTranscription.fromRequest")(function* (re
     if (url !== undefined)
         return MediaProtocol.json(mergeJsonRecords({ url }, request.http?.body) ?? {}, yield* query(request));
     if (request.http?.body !== undefined)
-        return yield* ProviderShared.invalidRequest(`${NAME} sends inline audio as the raw body, so http.body cannot apply`);
-    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+        return yield* ProviderShared.invalidRequest(`${route.name} sends inline audio as the raw body, so http.body cannot apply`);
+    const audio = yield* MediaInput.inlineBytes(route.id, request.audio);
     return MediaProtocol.binary(audio, request.audio.mediaType, yield* query(request));
 });
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeListen = MediaProtocol.decodeJson(ADAPTER, NAME, ListenResponse);
+const decodeListen = route.decodeJson(ListenResponse);
 const speaker = (value) => (value === undefined ? undefined : String(value));
 const wordText = (word) => word.punctuated_word ?? word.word;
 // Utterances split on pauses, not speakers: the v2 diarizer labels a whole utterance with one speaker even when its
@@ -79,7 +77,7 @@ const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(functio
     const channel = output.value.results.channels[0];
     const alternative = channel?.alternatives?.[0];
     if (alternative === undefined)
-        return yield* output.invalid(`${NAME} returned no transcript`);
+        return yield* output.invalid(`${route.name} returned no transcript`);
     const duration = output.value.metadata?.duration;
     const requestID = output.value.metadata?.request_id;
     return new TranscriptionResponse({
@@ -115,14 +113,12 @@ const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(functio
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.inline({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.inline(route, {
     unsupported: ["prompt", "speakers"],
     body: { from: fromRequest },
     response: { decode: decodeResponse },
 });
-export const model = (input) => TranscriptionModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const model = (input) => TranscriptionModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
 export const DeepgramTranscription = {
     protocol,
     model,

package/dist/protocols/elevenlabs-speech.d.ts

@@ -1,11 +1,11 @@
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 import { SpeechModel, type SpeechRequestFor } from "../speech.js";
 import { SpeechStream } from "./utils/speech-stream.js";
 export declare const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
 export declare const PATH = "/v1/text-to-speech";
-export type ElevenLabsSpeechString<Known extends string> = Known | (string & {});
-export type ElevenLabsOutputFormat = ElevenLabsSpeechString<"mp3_22050_32" | "mp3_24000_48" | "mp3_44100_32" | "mp3_44100_64" | "mp3_44100_96" | "mp3_44100_128" | "mp3_44100_192" | "pcm_8000" | "pcm_16000" | "pcm_22050" | "pcm_24000" | "pcm_32000" | "pcm_44100" | "pcm_48000" | "wav_8000" | "wav_16000" | "wav_22050" | "wav_24000" | "wav_32000" | "wav_44100" | "wav_48000" | "ulaw_8000" | "alaw_8000" | "opus_48000_32" | "opus_48000_64" | "opus_48000_96" | "opus_48000_128" | "opus_48000_192">;
+export type ElevenLabsOutputFormat = OpenString<"mp3_22050_32" | "mp3_24000_48" | "mp3_44100_32" | "mp3_44100_64" | "mp3_44100_96" | "mp3_44100_128" | "mp3_44100_192" | "pcm_8000" | "pcm_16000" | "pcm_22050" | "pcm_24000" | "pcm_32000" | "pcm_44100" | "pcm_48000" | "wav_8000" | "wav_16000" | "wav_22050" | "wav_24000" | "wav_32000" | "wav_44100" | "wav_48000" | "ulaw_8000" | "alaw_8000" | "opus_48000_32" | "opus_48000_64" | "opus_48000_96" | "opus_48000_128" | "opus_48000_192">;
 export type ElevenLabsSpeechOptions = {
     readonly outputFormat?: ElevenLabsOutputFormat;
     readonly voice_settings?: {
@@ -15,7 +15,7 @@ export type ElevenLabsSpeechOptions = {
         readonly use_speaker_boost?: boolean;
     };
     readonly seed?: number;
-    readonly apply_text_normalization?: ElevenLabsSpeechString<"auto" | "on" | "off">;
+    readonly apply_text_normalization?: OpenString<"auto" | "on" | "off">;
 } & Record<string, unknown>;
 export type Request = SpeechRequestFor<ElevenLabsSpeechOptions>;
 export declare const protocol: MediaProtocol.Streamed<Request, {

package/dist/protocols/elevenlabs-speech.js

@@ -2,13 +2,11 @@ import { Effect, Schema } from "effect";
 import { Framing } from "../route/framing.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { SpeechModel } from "../speech.js";
 import { ProviderShared, optionalNull } from "./shared.js";
 import { SpeechStream } from "./utils/speech-stream.js";
-const ADAPTER = "elevenlabs-speech";
-const NAME = "ElevenLabs";
-const PROVIDER = ProviderID.make("elevenlabs");
+const route = MediaProtocol.identity({ id: "elevenlabs-speech", name: "ElevenLabs", provider: "elevenlabs" });
 export const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
 export const PATH = "/v1/text-to-speech";
 // ---------------------------------------------------------------------------
@@ -23,7 +21,7 @@ const TimestampedAudio = Schema.Struct({
     audio_base64: Schema.Uint8ArrayFromBase64,
     alignment: optionalNull(Alignment),
 });
-const decodeRecord = MediaProtocol.decodeFrame(ADAPTER, NAME, TimestampedAudio);
+const decodeRecord = route.decodeFrame(TimestampedAudio);
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
@@ -37,14 +35,14 @@ const OUTPUT_FORMATS = {
 const outputFormat = Effect.fn("ElevenLabsSpeech.outputFormat")(function* (request) {
     const format = request.providerOptions?.outputFormat ?? OUTPUT_FORMATS[request.format ?? "mp3"];
     if (format === undefined)
-        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} has no default output format for "${request.format}"; pass providerOptions.outputFormat`);
+        return yield* route.unsupported("media.format", `${route.name} has no default output format for "${request.format}"; pass providerOptions.outputFormat`);
     if (request.mode === "stream" && format.startsWith("wav_"))
-        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} streams mp3, pcm, opus, ulaw, and alaw but not "${format}"; use generate for WAV`);
+        return yield* route.unsupported("media.format", `${route.name} streams mp3, pcm, opus, ulaw, and alaw but not "${format}"; use generate for WAV`);
     return format;
 });
 const fromRequest = Effect.fn("ElevenLabsSpeech.fromRequest")(function* (request) {
     if (request.voice === undefined)
-        return yield* ProviderShared.invalidRequest(`${NAME} requires a voice id; pass it as \`voice\``);
+        return yield* ProviderShared.invalidRequest(`${route.name} requires a voice id; pass it as \`voice\``);
     const { outputFormat: _outputFormat, ...native } = request.providerOptions ?? {};
     return MediaProtocol.json(mergeJsonRecords({
         text: request.text,
@@ -84,7 +82,7 @@ const describeOutput = (format) => {
 };
 const finish = Effect.fn("ElevenLabsSpeech.finish")(function* (state, context) {
     const requestID = context.http.headers["request-id"];
-    return yield* SpeechStream.finish(ADAPTER, state, {
+    return yield* SpeechStream.finish(route, state, {
         ...describeOutput(yield* outputFormat(context.request)),
         // `character-cost` is billed credits, not a character count (3 for 20 characters on `eleven_flash_v2_5`).
         usage: SpeechStream.headerUsage("credits", context.http.headers["character-cost"]),
@@ -94,9 +92,7 @@ const finish = Effect.fn("ElevenLabsSpeech.finish")(function* (state, context) {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["instructions"],
     body: { from: fromRequest },
     frames: (bytes, context) => {
@@ -108,7 +104,7 @@ export const protocol = MediaProtocol.stream({
     step: SpeechStream.step(onRecord),
     finish,
 });
-export const model = (input) => SpeechModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => path(request) }, input);
+export const model = (input) => SpeechModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => path(request) }, input);
 export const ElevenLabsSpeech = {
     protocol,
     model,

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

@@ -1,8 +1,9 @@
 import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 export type FalImageOptions = {
-    readonly image_size?: "square_hd" | "square" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9" | (string & {});
+    readonly image_size?: OpenString<"square_hd" | "square" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9">;
     readonly enable_safety_checker?: boolean;
 } & Record<string, unknown>;
 export type Request = ImageRequestFor<FalImageOptions>;

package/dist/protocols/fal-images.js

@@ -3,13 +3,11 @@ import { ImageModel, ImageResponse } from "../image.js";
 import { Media } from "../media.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared, optionalNull } from "./shared.js";
 import { FalQueue } from "./utils/fal-queue.js";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "fal-images";
-const NAME = "fal Images";
-const PROVIDER = ProviderID.make("fal");
+const route = MediaProtocol.identity({ id: "fal-images", name: "fal Images", provider: "fal" });
 // ---------------------------------------------------------------------------
 // 2. Response schema
 // ---------------------------------------------------------------------------
@@ -33,30 +31,24 @@ const sizing = (model) => {
         return "image_size";
     return undefined;
 };
-const unsupported = (model, field, message) => ProviderShared.unsupportedOperation({
-    operation: `media.${field}`,
-    provider: PROVIDER,
-    route: ADAPTER,
-    message: `${model} ${message}`,
-});
 const validate = (request) => {
     const id = request.model.id;
     const field = sizing(id);
     if (request.size !== undefined && request.aspectRatio !== undefined)
-        return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts either size or aspectRatio, not both`));
+        return Effect.fail(ProviderShared.invalidRequest(`${route.name} accepts either size or aspectRatio, not both`));
     if (request.size !== undefined && field === "aspect_ratio")
-        return Effect.fail(unsupported(id, "size", "sizes by aspectRatio"));
+        return Effect.fail(route.unsupported("media.size", `${id} sizes by aspectRatio`));
     if (request.aspectRatio !== undefined && field === "image_size")
-        return Effect.fail(unsupported(id, "aspectRatio", "sizes by size (image_size)"));
+        return Effect.fail(route.unsupported("media.aspectRatio", `${id} sizes by size (image_size)`));
     if ((request.images?.length ?? 0) > 1 && !isEdit(id))
-        return Effect.fail(unsupported(id, "images", "takes one image_url; use an /edit endpoint for several images"));
+        return Effect.fail(route.unsupported("media.images", `${id} takes one image_url; use an /edit endpoint for several images`));
     return Effect.void;
 };
 // `/edit` endpoints take an `image_urls` list; image-to-image, fill, and Ultra take one `image_url` (beside `mask_url`).
 const isEdit = (model) => model.endsWith("/edit");
 const fromRequest = Effect.fn("FalImages.fromRequest")(function* (request) {
     yield* validate(request);
-    const images = yield* Effect.forEach(request.images ?? [], (image) => FalQueue.mediaUrl(image, NAME));
+    const images = yield* Effect.forEach(request.images ?? [], (image) => FalQueue.mediaUrl(image, route.name));
     const edit = isEdit(request.model.id);
     return MediaProtocol.json(mergeJsonRecords({
         prompt: request.prompt,
@@ -67,18 +59,18 @@ const fromRequest = Effect.fn("FalImages.fromRequest")(function* (request) {
         output_format: request.format,
         image_urls: edit && images.length > 0 ? images : undefined,
         image_url: edit ? undefined : images[0],
-        mask_url: request.mask === undefined ? undefined : yield* FalQueue.mediaUrl(request.mask, NAME),
+        mask_url: request.mask === undefined ? undefined : yield* FalQueue.mediaUrl(request.mask, route.name),
     }, request.providerOptions, request.http?.body) ?? {});
 });
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeQueueResult = MediaProtocol.decodeJson(ADAPTER, NAME, QueueResult);
+const decodeQueueResult = route.decodeJson(QueueResult);
 const decodeResult = Effect.fn("FalImages.decodeResult")(function* (response, context) {
     const output = yield* decodeQueueResult(response);
     const { images, seed, has_nsfw_concepts, ...rest } = output.value;
     if (images.length === 0)
-        return yield* output.invalid(`${NAME} returned no images`);
+        return yield* output.invalid(`${route.name} returned no images`);
     // With the safety checker on, flagged images come back blacked out rather than omitted.
     const flagged = (has_nsfw_concepts ?? []).flatMap((value, index) => (value ? [index] : []));
     return new ImageResponse({
@@ -88,26 +80,21 @@ const decodeResult = Effect.fn("FalImages.decodeResult")(function* (response, co
         })),
         notices: flagged.length === 0
             ? undefined
-            : flagged.map((index) => ({ type: "moderated", message: `${NAME} flagged image ${index} as NSFW` })),
+            : flagged.map((index) => ({
+                type: "moderated",
+                message: `${route.name} flagged image ${index} as NSFW`,
+            })),
         providerMetadata: { fal: { requestId: context.token.requestID, seed: seed ?? undefined, ...rest } },
     });
 });
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = FalQueue.protocol({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = FalQueue.protocol(route, {
     from: fromRequest,
     decodeResult,
 });
-export const model = (input) => ImageModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
-    protocol,
-    baseURL: FalQueue.DEFAULT_BASE_URL,
-    path: ({ request }) => `/${request.model.id}`,
-}, input);
+export const model = (input) => ImageModel.fromRoute({ protocol, baseURL: FalQueue.DEFAULT_BASE_URL, path: ({ request }) => `/${request.model.id}` }, input);
 export const FalImages = {
     protocol,
     model,

package/dist/protocols/fal-video.d.ts

@@ -1,14 +1,14 @@
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
-export type FalVideoString<Known extends string> = Known | (string & {});
 /**
  * Provider-native input. fal video endpoints are model-specific: `duration` is a string enum whose values differ per
  * model (`"8s"` for Veo, `"5"` for Kling), and last-frame fields are named per model (`end_image_url`,
  * `last_frame_url`, `tail_image_url`), so those pass through here instead of lowering from common fields.
  */
 export type FalVideoOptions = {
-    readonly duration?: FalVideoString<"4s" | "6s" | "8s" | "5" | "10">;
+    readonly duration?: OpenString<"4s" | "6s" | "8s" | "5" | "10">;
 } & Record<string, unknown>;
 export type Request = VideoRequestFor<FalVideoOptions>;
 export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {

package/dist/protocols/fal-video.js

@@ -2,13 +2,11 @@ import { Effect, Schema } from "effect";
 import { Media } from "../media.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { VideoModel, VideoResponse } from "../video.js";
-import { ProviderShared, optionalNull } from "./shared.js";
+import { optionalNull } from "./shared.js";
 import { FalQueue } from "./utils/fal-queue.js";
-const ADAPTER = "fal-video";
-const NAME = "fal Video";
-const PROVIDER = ProviderID.make("fal");
+const route = MediaProtocol.identity({ id: "fal-video", name: "fal Video", provider: "fal" });
 // ---------------------------------------------------------------------------
 // 2. Response schema
 // ---------------------------------------------------------------------------
@@ -26,14 +24,9 @@ const QueueResult = Schema.StructWithRest(Schema.Struct({
 // ---------------------------------------------------------------------------
 const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request) {
     if (request.frames?.last !== undefined)
-        return yield* ProviderShared.unsupportedOperation({
-            operation: "video.frames.last",
-            provider: PROVIDER,
-            route: ADAPTER,
-            message: `${NAME} names the last frame per model; pass it through providerOptions (e.g. end_image_url) instead of frames.last`,
-        });
-    const imageUrl = request.frames?.first === undefined ? undefined : yield* FalQueue.mediaUrl(request.frames.first, NAME);
-    const videoUrl = request.video === undefined ? undefined : yield* FalQueue.mediaUrl(request.video, NAME);
+        return yield* route.unsupported("video.frames.last", `${route.name} names the last frame per model; pass it through providerOptions (e.g. end_image_url) instead of frames.last`);
+    const imageUrl = request.frames?.first === undefined ? undefined : yield* FalQueue.mediaUrl(request.frames.first, route.name);
+    const videoUrl = request.video === undefined ? undefined : yield* FalQueue.mediaUrl(request.video, route.name);
     return MediaProtocol.json(mergeJsonRecords({
         prompt: request.prompt,
         negative_prompt: request.negativePrompt,
@@ -48,7 +41,7 @@ const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request) {
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeQueueResult = MediaProtocol.decodeJson(ADAPTER, NAME, QueueResult);
+const decodeQueueResult = route.decodeJson(QueueResult);
 const decodeResult = Effect.fn("FalVideo.decodeResult")(function* (response, context) {
     const output = yield* decodeQueueResult(response);
     const { video, seed, ...rest } = output.value;
@@ -68,20 +61,12 @@ const decodeResult = Effect.fn("FalVideo.decodeResult")(function* (response, con
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = FalQueue.protocol({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = FalQueue.protocol(route, {
     unsupported: ["n", "durationSeconds", "references"],
     from: fromRequest,
     decodeResult,
 });
-export const model = (input) => VideoModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
-    protocol,
-    baseURL: FalQueue.DEFAULT_BASE_URL,
-    path: ({ request }) => `/${request.model.id}`,
-}, input);
+export const model = (input) => VideoModel.fromRoute({ protocol, baseURL: FalQueue.DEFAULT_BASE_URL, path: ({ request }) => `/${request.model.id}` }, input);
 export const FalVideo = {
     protocol,
     model,