@opencode/ai 2.0.15 → 2.0.17

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

@@ -0,0 +1,135 @@
+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 DeepgramEncoding = OpenString<"linear16" | "mulaw" | "alaw" | "mp3" | "opus" | "flac" | "aac">;
+export type DeepgramSpeechOptions = {
+    readonly encoding?: DeepgramEncoding;
+    readonly container?: OpenString<"wav" | "ogg" | "none">;
+    readonly sampleRate?: number;
+    readonly bitRate?: number;
+    readonly mip_opt_out?: boolean;
+    readonly tag?: string;
+} & 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>;
+} | {
+    readonly type: "timestamps";
+    readonly items: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+    }[];
+} | {
+    readonly type: "finish";
+    readonly audio: import("../media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly usage?: {
+        readonly type: "tokens";
+        readonly input?: number | undefined;
+        readonly output?: number | undefined;
+        readonly total?: number | undefined;
+        readonly details?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "seconds";
+        readonly seconds: number;
+    } | {
+        readonly type: "characters";
+        readonly characters: number;
+    } | {
+        readonly type: "credits";
+        readonly credits: number;
+    } | {
+        readonly type: "compute";
+        readonly seconds: number;
+    } | undefined;
+    readonly notices?: readonly {
+        readonly type: "other" | "moderated" | "filtered";
+        readonly message: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    }[] | undefined;
+}, Uint8Array<ArrayBufferLike>, SpeechStream.Audio>;
+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>;
+    } | {
+        readonly type: "timestamps";
+        readonly items: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+        }[];
+    } | {
+        readonly type: "finish";
+        readonly audio: import("../media.js").Asset;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly usage?: {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "seconds";
+            readonly seconds: number;
+        } | {
+            readonly type: "characters";
+            readonly characters: number;
+        } | {
+            readonly type: "credits";
+            readonly credits: number;
+        } | {
+            readonly type: "compute";
+            readonly seconds: number;
+        } | undefined;
+        readonly notices?: readonly {
+            readonly type: "other" | "moderated" | "filtered";
+            readonly message: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }[] | undefined;
+    }, Uint8Array<ArrayBufferLike>, SpeechStream.Audio>;
+    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<DeepgramSpeechOptions>;
+};

package/dist/protocols/deepgram-speech.js

@@ -0,0 +1,91 @@
+import { Effect } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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 route = MediaProtocol.identity({ id: "deepgram-speech", name: "Deepgram", provider: "deepgram" });
+export const DEFAULT_BASE_URL = "https://api.deepgram.com";
+export const PATH = "/v1/speak";
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const FORMATS = {
+    mp3: { encoding: "mp3" },
+    wav: { encoding: "linear16", container: "wav" },
+    pcm: { encoding: "linear16", container: "none" },
+    opus: { encoding: "opus" },
+    flac: { encoding: "flac" },
+    aac: { encoding: "aac" },
+};
+const audioFormat = (request) => {
+    const format = request.format === undefined ? undefined : FORMATS[request.format];
+    return {
+        encoding: request.providerOptions?.encoding ?? format?.encoding,
+        container: request.providerOptions?.container ?? format?.container,
+    };
+};
+const queryParameters = (request) => {
+    const { encoding: _encoding, container: _container, sampleRate, bitRate, ...native } = request.providerOptions ?? {};
+    return MediaInput.query(route.id, {
+        ...native,
+        model: request.model.id,
+        ...audioFormat(request),
+        sample_rate: sampleRate,
+        bit_rate: bitRate,
+        speed: request.speed,
+    });
+};
+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* 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));
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const HEADERLESS_ENCODINGS = {
+    linear16: "pcm_s16le",
+    mulaw: "pcm_mulaw",
+    alaw: "pcm_alaw",
+};
+const finish = (state, context) => {
+    const headers = context.http.headers;
+    const mediaType = headers["content-type"];
+    const format = audioFormat(context.request);
+    const encoding = HEADERLESS_ENCODINGS[format.encoding ?? ""];
+    const requestID = headers["dg-request-id"];
+    const modelName = headers["dg-model-name"];
+    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.
+                { mediaType, info: { format: format.container === "wav" ? "wav" : (format.encoding ?? "mp3") } }),
+        usage: SpeechStream.headerUsage("characters", headers["dg-char-count"]),
+        providerMetadata: requestID === undefined && modelName === undefined
+            ? undefined
+            : { deepgram: { requestId: requestID, modelName } },
+    });
+};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+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({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const DeepgramSpeech = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,26 @@
+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";
+export type DeepgramTranscriptionOptions = {
+    readonly smart_format?: boolean;
+    readonly punctuate?: boolean;
+    readonly paragraphs?: boolean;
+    readonly utterances?: boolean;
+    readonly detect_language?: boolean | ReadonlyArray<string>;
+    readonly keyterm?: ReadonlyArray<string>;
+    readonly diarize_model?: OpenString<"latest" | "v1" | "v2">;
+    readonly filler_words?: boolean;
+    readonly numerals?: boolean;
+    readonly mip_opt_out?: boolean;
+    readonly tag?: string | ReadonlyArray<string>;
+} & Record<string, unknown>;
+export type Request = TranscriptionRequestFor<DeepgramTranscriptionOptions>;
+export declare const protocol: MediaProtocol.Inline<Request, TranscriptionResponse>;
+export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<DeepgramTranscriptionOptions>;
+export declare const DeepgramTranscription: {
+    readonly protocol: MediaProtocol.Inline<Request, TranscriptionResponse>;
+    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<DeepgramTranscriptionOptions>;
+};

package/dist/protocols/deepgram-transcription.js

@@ -0,0 +1,125 @@
+import { Effect, Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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 route = MediaProtocol.identity({ id: "deepgram-transcription", name: "Deepgram", provider: "deepgram" });
+export const DEFAULT_BASE_URL = "https://api.deepgram.com";
+export const PATH = "/v1/listen";
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+const Word = Schema.Struct({
+    word: Schema.String,
+    start: Schema.Number,
+    end: Schema.Number,
+    confidence: Schema.optional(Schema.Number),
+    speaker: Schema.optional(Schema.Number),
+    punctuated_word: Schema.optional(Schema.String),
+});
+const ListenResponse = Schema.Struct({
+    metadata: Schema.optional(Schema.Struct({ request_id: Schema.optional(Schema.String), duration: Schema.optional(Schema.Number) })),
+    results: Schema.Struct({
+        channels: Schema.Array(Schema.Struct({
+            alternatives: Schema.optional(Schema.Array(Schema.Struct({ transcript: Schema.String, words: Schema.optional(Schema.Array(Word)) }))),
+            detected_language: Schema.optional(Schema.String),
+        })),
+        utterances: Schema.optional(Schema.Array(Schema.Struct({
+            start: Schema.Number,
+            end: Schema.Number,
+            transcript: Schema.String,
+            speaker: Schema.optional(Schema.Number),
+            words: Schema.optional(Schema.Array(Word)),
+        }))),
+    }),
+});
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const query = (request) => MediaInput.query(route.id, mergeJsonRecords({
+    model: request.model.id,
+    smart_format: true,
+    language: request.language,
+    // Deepgram assumes English unless asked to detect, unlike the other routes' auto-detection.
+    detect_language: request.language === undefined ? true : undefined,
+    // `diarize=true` is deprecated in favor of choosing a diarization model.
+    diarize_model: request.diarize === true ? "latest" : undefined,
+    utterances: request.diarize === true || request.timestamps === "segment" ? true : undefined,
+}, request.providerOptions) ?? {});
+const fromRequest = Effect.fn("DeepgramTranscription.fromRequest")(function* (request) {
+    const url = ProviderShared.mediaUrl(request.audio);
+    if (url !== undefined)
+        return MediaProtocol.json(mergeJsonRecords({ url }, request.http?.body) ?? {}, yield* query(request));
+    if (request.http?.body !== undefined)
+        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 = 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
+// words change speaker, so segments split each utterance at speaker changes.
+const speakerTurns = (words) => words.reduce((turns, word) => {
+    const last = turns.at(-1);
+    if (last === undefined || last[0].speaker !== word.speaker)
+        return [...turns, [word]];
+    last.push(word);
+    return turns;
+}, []);
+const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(function* (response) {
+    const output = yield* decodeListen(response);
+    const channel = output.value.results.channels[0];
+    const alternative = channel?.alternatives?.[0];
+    if (alternative === undefined)
+        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({
+        text: alternative.transcript,
+        segments: output.value.results.utterances?.flatMap((utterance) => utterance.words === undefined || utterance.words.length === 0
+            ? [
+                {
+                    text: utterance.transcript,
+                    startSeconds: utterance.start,
+                    endSeconds: utterance.end,
+                    speaker: speaker(utterance.speaker),
+                },
+            ]
+            : speakerTurns(utterance.words).map((turn) => ({
+                text: turn.map(wordText).join(" "),
+                startSeconds: turn[0].start,
+                endSeconds: turn[turn.length - 1].end,
+                speaker: speaker(turn[0].speaker),
+            }))),
+        words: alternative.words?.map((word) => ({
+            text: wordText(word),
+            startSeconds: word.start,
+            endSeconds: word.end,
+            speaker: speaker(word.speaker),
+            confidence: word.confidence,
+        })),
+        language: channel?.detected_language?.toLowerCase(),
+        durationSeconds: duration,
+        usage: duration === undefined ? undefined : { type: "seconds", seconds: duration },
+        providerMetadata: requestID === undefined ? undefined : { deepgram: { requestId: requestID } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline(route, {
+    unsupported: ["prompt", "speakers"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+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

@@ -0,0 +1,138 @@
+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 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?: {
+        readonly stability?: number;
+        readonly similarity_boost?: number;
+        readonly style?: number;
+        readonly use_speaker_boost?: boolean;
+    };
+    readonly seed?: number;
+    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>;
+} | {
+    readonly type: "timestamps";
+    readonly items: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+    }[];
+} | {
+    readonly type: "finish";
+    readonly audio: import("../media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly usage?: {
+        readonly type: "tokens";
+        readonly input?: number | undefined;
+        readonly output?: number | undefined;
+        readonly total?: number | undefined;
+        readonly details?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "seconds";
+        readonly seconds: number;
+    } | {
+        readonly type: "characters";
+        readonly characters: number;
+    } | {
+        readonly type: "credits";
+        readonly credits: number;
+    } | {
+        readonly type: "compute";
+        readonly seconds: number;
+    } | undefined;
+    readonly notices?: readonly {
+        readonly type: "other" | "moderated" | "filtered";
+        readonly message: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    }[] | undefined;
+}, string | Uint8Array<ArrayBufferLike>, SpeechStream.Audio>;
+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>;
+    } | {
+        readonly type: "timestamps";
+        readonly items: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+        }[];
+    } | {
+        readonly type: "finish";
+        readonly audio: import("../media.js").Asset;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        readonly usage?: {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "seconds";
+            readonly seconds: number;
+        } | {
+            readonly type: "characters";
+            readonly characters: number;
+        } | {
+            readonly type: "credits";
+            readonly credits: number;
+        } | {
+            readonly type: "compute";
+            readonly seconds: number;
+        } | undefined;
+        readonly notices?: readonly {
+            readonly type: "other" | "moderated" | "filtered";
+            readonly message: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }[] | undefined;
+    }, string | Uint8Array<ArrayBufferLike>, SpeechStream.Audio>;
+    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<ElevenLabsSpeechOptions>;
+};

package/dist/protocols/elevenlabs-speech.js

@@ -0,0 +1,111 @@
+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 { mergeJsonRecords } from "../schema/index.js";
+import { SpeechModel } from "../speech.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+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";
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const Alignment = Schema.Struct({
+    characters: Schema.Array(Schema.String),
+    character_start_times_seconds: Schema.Array(Schema.Number),
+    character_end_times_seconds: Schema.Array(Schema.Number),
+});
+const TimestampedAudio = Schema.Struct({
+    audio_base64: Schema.Uint8ArrayFromBase64,
+    alignment: optionalNull(Alignment),
+});
+const decodeRecord = route.decodeFrame(TimestampedAudio);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const OUTPUT_FORMATS = {
+    mp3: "mp3_44100_128",
+    pcm: "pcm_24000",
+    wav: "wav_24000",
+    opus: "opus_48000_64",
+};
+/** WAV is served only by the non-streaming endpoints. */
+const outputFormat = Effect.fn("ElevenLabsSpeech.outputFormat")(function* (request) {
+    const format = request.providerOptions?.outputFormat ?? OUTPUT_FORMATS[request.format ?? "mp3"];
+    if (format === undefined)
+        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* 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(`${route.name} requires a voice id; pass it as \`voice\``);
+    const { outputFormat: _outputFormat, ...native } = request.providerOptions ?? {};
+    return MediaProtocol.json(mergeJsonRecords({
+        text: request.text,
+        model_id: request.model.id,
+        language_code: request.language,
+        voice_settings: request.speed === undefined ? undefined : { speed: request.speed },
+    }, native, request.http?.body) ?? {}, { output_format: yield* outputFormat(request) });
+});
+const path = (request) => `${PATH}/${encodeURIComponent(SpeechStream.voiceID(request.voice) ?? "")}${request.mode === "stream" ? "/stream" : ""}${request.timestamps === true ? "/with-timestamps" : ""}`;
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const onRecord = Effect.fn("ElevenLabsSpeech.onRecord")(function* (state, frame) {
+    const record = yield* decodeRecord(frame);
+    const [next, events] = SpeechStream.delta(state, record.audio_base64);
+    const alignment = record.alignment;
+    if (!alignment)
+        return [next, events];
+    return [
+        next,
+        [
+            ...events,
+            ...SpeechStream.timestamps(alignment.characters, alignment.character_start_times_seconds, alignment.character_end_times_seconds),
+        ],
+    ];
+});
+const PCM_CODECS = {
+    pcm: "pcm_s16le",
+    ulaw: "pcm_mulaw",
+    alaw: "pcm_alaw",
+};
+const describeOutput = (format) => {
+    const [codec = format, rate] = format.split("_");
+    const sampleRate = rate === undefined ? undefined : Number(rate);
+    const encoding = PCM_CODECS[codec];
+    return encoding === undefined ? SpeechStream.container(codec, sampleRate) : SpeechStream.pcm(encoding, sampleRate);
+};
+const finish = Effect.fn("ElevenLabsSpeech.finish")(function* (state, context) {
+    const requestID = context.http.headers["request-id"];
+    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"]),
+        providerMetadata: requestID === undefined ? undefined : { elevenlabs: { requestId: requestID } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream(route, {
+    unsupported: ["instructions"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => {
+        if (context.request.timestamps !== true)
+            return bytes;
+        return context.request.mode === "stream" ? Framing.lines.frame(bytes) : Framing.document.frame(bytes);
+    },
+    initial: () => ({ chunks: [] }),
+    step: SpeechStream.step(onRecord),
+    finish,
+});
+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

@@ -0,0 +1,25 @@
+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?: 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>;
+export declare const protocol: MediaProtocol.Queued<Request, ImageResponse, {
+    readonly requestID: string;
+    readonly statusURL: string;
+    readonly responseURL: string;
+    readonly cancelURL: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<FalImageOptions>;
+export declare const FalImages: {
+    readonly protocol: MediaProtocol.Queued<Request, ImageResponse, {
+        readonly requestID: string;
+        readonly statusURL: string;
+        readonly responseURL: string;
+        readonly cancelURL: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<FalImageOptions>;
+};