@opencode/ai 2.0.16 → 2.0.17

package/dist/protocols/bfl-images.js

@@ -3,21 +3,27 @@ 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 { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "bfl-images";
-const NAME = "Black Forest Labs";
-const PROVIDER = ProviderID.make("black-forest-labs");
+const route = MediaProtocol.identity({ id: "bfl-images", name: "Black Forest Labs", provider: "black-forest-labs" });
 export const DEFAULT_BASE_URL = "https://api.bfl.ai";
 // ---------------------------------------------------------------------------
 // 2. Token and response schemas
 // ---------------------------------------------------------------------------
-/** Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. */
-export const Token = Schema.Struct({ id: Schema.String, pollingURL: Schema.String });
+/**
+ * Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. BFL reports the
+ * credit cost on submit, so it rides on the token; it is optional so tokens persisted before it existed still decode.
+ */
+export const Token = Schema.Struct({
+    id: Schema.String,
+    pollingURL: Schema.String,
+    cost: Schema.optionalKey(Schema.Number),
+});
 const StartResponse = Schema.Struct({
     id: Schema.String,
     polling_url: Schema.String,
+    cost: optionalNull(Schema.Number),
 });
 const Result = Schema.Struct({
     id: Schema.String,
@@ -52,31 +58,25 @@ const capabilities = (model) => {
         return { sizing: "dimensions", imageField: "input_image", maxImages: 4, mask: false };
     return { sizing: "dimensions", imageField: "input_image", maxImages: 8, mask: false };
 };
-const unsupported = (model, field, message) => ProviderShared.unsupportedOperation({
-    operation: `media.${field}`,
-    provider: PROVIDER,
-    route: ADAPTER,
-    message: `${model} ${message}`,
-});
 const validate = (request, model) => {
     const id = request.model.id;
     const images = request.images?.length ?? 0;
     if (request.n !== undefined && request.n > 1)
-        return Effect.fail(unsupported(id, "n", "generates one image per request; call it once per image"));
+        return Effect.fail(route.unsupported("media.n", `${id} generates one image per request; call it once per image`));
     if (request.size !== undefined && model.sizing !== "dimensions")
-        return Effect.fail(unsupported(id, "size", "does not take size (width and height)"));
+        return Effect.fail(route.unsupported("media.size", `${id} does not take size (width and height)`));
     if (request.aspectRatio !== undefined && model.sizing !== "aspectRatio")
-        return Effect.fail(unsupported(id, "aspectRatio", "does not take aspectRatio"));
+        return Effect.fail(route.unsupported("media.aspectRatio", `${id} does not take aspectRatio`));
     if (images > model.maxImages)
-        return Effect.fail(unsupported(id, "images", `takes at most ${model.maxImages} images`));
+        return Effect.fail(route.unsupported("media.images", `${id} takes at most ${model.maxImages} images`));
     if (request.mask !== undefined && !model.mask)
-        return Effect.fail(unsupported(id, "mask", "does not inpaint; use flux-pro-1.0-fill"));
+        return Effect.fail(route.unsupported("media.mask", `${id} does not inpaint; use flux-pro-1.0-fill`));
     return Effect.void;
 };
 const imageInput = (asset) => {
     const value = asset.inline()?.base64 ?? ProviderShared.mediaUrl(asset);
     if (value === undefined)
-        return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts inline images or https URLs`));
+        return Effect.fail(ProviderShared.invalidRequest(`${route.name} accepts inline images or https URLs`));
     return Effect.succeed(value);
 };
 const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (request) {
@@ -100,11 +100,15 @@ const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (re
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
-    token: { id: value.id, pollingURL: value.polling_url },
+const decodeStart = route.decodeStarted(StartResponse, (value) => ({
+    token: {
+        id: value.id,
+        pollingURL: value.polling_url,
+        ...(value.cost === undefined || value.cost === null ? {} : { cost: value.cost }),
+    },
     snapshot: { id: value.id, status: "queued" },
 }));
-const decodeDocument = MediaProtocol.decodeJson(ADAPTER, NAME, Result);
+const decodeDocument = route.decodeJson(Result);
 const decodeStatus = Effect.fn("BlackForestLabsImages.decodeStatus")(function* (response, context) {
     const output = yield* decodeDocument(response);
     return { id: context.token.id, status: yield* MediaProtocol.status(STATUS, output.value.status, output) };
@@ -114,16 +118,20 @@ const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (
     const document = output.value;
     const status = yield* MediaProtocol.status(STATUS, document.status, output);
     if (isModerated(document.status))
-        return yield* output.contentPolicy(`${NAME} moderated the generation`);
+        return yield* output.contentPolicy(`${route.name} moderated the generation`);
     if (status === "failed" || status === "expired")
-        return yield* output.ended(status, `${NAME} generation ${context.token.id} ended with ${document.status}`);
-    if (status !== "completed" || document.result === undefined || document.result === null)
-        return yield* output.invalid(`${NAME} generation ${context.token.id} has no result`);
+        return yield* output.ended(status, `${route.name} generation ${context.token.id} ended with ${document.status}`);
+    if (status !== "completed")
+        return yield* output.pending(context.token.id);
+    if (document.result === undefined || document.result === null)
+        return yield* output.invalid(`${route.name} generation ${context.token.id} has no result`);
     const { sample, seed, prompt, ...rest } = document.result;
+    // A settled `cost` on the result supersedes the submit-time cost carried on the token.
+    const cost = document.cost ?? context.token.cost;
     return new ImageResponse({
         // `sample` is a signed URL that expires 10 minutes after the result is ready, so it is downloaded now.
         images: [yield* context.materialize(Media.url(sample))],
-        usage: document.cost === undefined || document.cost === null ? undefined : { type: "credits", credits: document.cost },
+        usage: cost === undefined ? undefined : { type: "credits", credits: cost },
         providerMetadata: {
             bfl: { id: context.token.id, seed: seed ?? undefined, prompt: prompt ?? undefined, ...rest },
         },
@@ -132,21 +140,13 @@ const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.queued({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.queued(route, {
     token: Token,
     start: { body: { from: fromRequest }, decode: decodeStart },
     status: { path: (token) => token.pollingURL, decode: decodeStatus },
     result: { path: (token) => token.pollingURL, decode: decodeResult },
 });
-export const model = (input) => ImageModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
-    protocol,
-    baseURL: DEFAULT_BASE_URL,
-    path: ({ request }) => `/v1/${request.model.id}`,
-}, input);
+export const model = (input) => ImageModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => `/v1/${request.model.id}` }, input);
 export const BlackForestLabsImages = {
     protocol,
     model,

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

@@ -1,12 +1,12 @@
 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.cartesia.ai";
 export declare const API_VERSION = "2026-08-14";
 export declare const BYTES_PATH = "/tts/bytes";
 export declare const SSE_PATH = "/tts/sse";
-export type CartesiaSpeechString<Known extends string> = Known | (string & {});
 export type CartesiaEncoding = SpeechStream.PcmEncoding;
 export type CartesiaSpeechOptions = {
     readonly sampleRate?: 8000 | 16000 | 22050 | 24000 | 44100 | 48000;
@@ -14,7 +14,7 @@ export type CartesiaSpeechOptions = {
     readonly encoding?: CartesiaEncoding;
     readonly generation_config?: {
         readonly volume?: number;
-        readonly emotion?: CartesiaSpeechString<"neutral" | "calm" | "angry" | "content" | "sad" | "scared">;
+        readonly emotion?: OpenString<"neutral" | "calm" | "angry" | "content" | "sad" | "scared">;
     };
     readonly pronunciation_dict_id?: string;
 } & Record<string, unknown>;
@@ -23,6 +23,14 @@ interface State extends SpeechStream.Audio {
     readonly done: boolean;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -74,6 +82,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<CartesiaSpeechOptions>;
 export declare const CartesiaSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {

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;
@@ -16,6 +16,14 @@ export type DeepgramSpeechOptions = {
 } & Record<string, unknown>;
 export type Request = SpeechRequestFor<DeepgramSpeechOptions>;
 export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -67,6 +75,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<DeepgramSpeechOptions>;
 export declare const DeepgramSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {

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),
@@ -40,10 +38,13 @@ const queryParameters = (request) => {
     });
 };
 const fromRequest = Effect.fn("DeepgramSpeech.fromRequest")(function* (request) {
+    // Not in `unsupported`: that list would also reject `timestamps: false`, which asks for nothing.
+    if (request.timestamps === true)
+        return yield* route.unsupported("media.timestamps", `${route.name} does not return timestamps`);
     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 +62,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,17 +76,15 @@ const finish = (state, context) => {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
-    unsupported: ["voice", "language", "instructions", "timestamps"],
+export const protocol = MediaProtocol.stream(route, {
+    unsupported: ["voice", "language", "instructions"],
     body: { from: fromRequest },
     frames: (bytes) => bytes,
     initial: () => ({ chunks: [] }),
     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,10 +15,18 @@ 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, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -70,6 +78,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<ElevenLabsSpeechOptions>;
 export declare const ElevenLabsSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {

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