@opencode/ai 2.0.14 → 2.0.16

package/dist/protocols/bfl-images.js

@@ -0,0 +1,153 @@
+import { Effect, Schema } from "effect";
+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 { 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");
+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 });
+const StartResponse = Schema.Struct({
+    id: Schema.String,
+    polling_url: Schema.String,
+});
+const Result = Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    result: optionalNull(Schema.StructWithRest(Schema.Struct({ sample: Schema.String, seed: optionalNull(Schema.Number), prompt: optionalNull(Schema.String) }), [Schema.Record(Schema.String, Schema.Unknown)])),
+    cost: optionalNull(Schema.Number),
+});
+const STATUS = {
+    Pending: "running",
+    Reasoning: "running",
+    Generating: "running",
+    Ready: "completed",
+    Error: "failed",
+    // Moderation is terminal; `decodeResult` reports it as a content-policy failure.
+    "Content Moderated": "failed",
+    "Request Moderated": "failed",
+    "Task not found": "expired",
+};
+const isModerated = (status) => status === "Content Moderated" || status === "Request Moderated";
+const capabilities = (model) => {
+    if (model.startsWith("flux-pro-1.0-fill"))
+        return { sizing: "none", imageField: "image", maxImages: 1, mask: true };
+    if (model.startsWith("flux-pro-1.0-expand"))
+        return { sizing: "none", imageField: "image", maxImages: 1, mask: false };
+    if (model.startsWith("flux-kontext"))
+        return { sizing: "aspectRatio", imageField: "input_image", maxImages: 4, mask: false };
+    if (model.startsWith("flux-pro-1.1-ultra"))
+        return { sizing: "aspectRatio", imageField: "image_prompt", maxImages: 1, mask: false };
+    if (model.startsWith("flux-pro-1.1") || model.startsWith("flux-dev"))
+        return { sizing: "dimensions", imageField: "image_prompt", maxImages: 1, mask: false };
+    if (model.startsWith("flux-2-klein"))
+        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"));
+    if (request.size !== undefined && model.sizing !== "dimensions")
+        return Effect.fail(unsupported(id, "size", "does not take size (width and height)"));
+    if (request.aspectRatio !== undefined && model.sizing !== "aspectRatio")
+        return Effect.fail(unsupported(id, "aspectRatio", "does not take aspectRatio"));
+    if (images > model.maxImages)
+        return Effect.fail(unsupported(id, "images", `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.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.succeed(value);
+};
+const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (request) {
+    const model = capabilities(request.model.id);
+    yield* validate(request, model);
+    const images = yield* Effect.forEach(request.images ?? [], imageInput);
+    const fields = images.map((image, index) => [
+        index === 0 ? model.imageField : `${model.imageField}_${index + 1}`,
+        image,
+    ]);
+    return MediaProtocol.json(mergeJsonRecords({
+        prompt: request.prompt,
+        ...(request.size === undefined ? {} : MediaInput.dimensions(request.size)),
+        aspect_ratio: request.aspectRatio,
+        seed: request.seed,
+        output_format: request.format,
+        mask: request.mask === undefined ? undefined : yield* imageInput(request.mask),
+        ...Object.fromEntries(fields),
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+    token: { id: value.id, pollingURL: value.polling_url },
+    snapshot: { id: value.id, status: "queued" },
+}));
+const decodeDocument = MediaProtocol.decodeJson(ADAPTER, NAME, 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) };
+});
+const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (response, context) {
+    const output = yield* decodeDocument(response);
+    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`);
+    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`);
+    const { sample, seed, prompt, ...rest } = document.result;
+    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 },
+        providerMetadata: {
+            bfl: { id: context.token.id, seed: seed ?? undefined, prompt: prompt ?? undefined, ...rest },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    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 BlackForestLabsImages = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,127 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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;
+    readonly bitRate?: 32000 | 64000 | 96000 | 128000 | 192000;
+    readonly encoding?: CartesiaEncoding;
+    readonly generation_config?: {
+        readonly volume?: number;
+        readonly emotion?: CartesiaSpeechString<"neutral" | "calm" | "angry" | "content" | "sad" | "scared">;
+    };
+    readonly pronunciation_dict_id?: string;
+} & Record<string, unknown>;
+export type Request = SpeechRequestFor<CartesiaSpeechOptions>;
+interface State extends SpeechStream.Audio {
+    readonly done: boolean;
+}
+export declare const protocol: MediaProtocol.Streamed<Request, {
+    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>, State>;
+export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<CartesiaSpeechOptions>;
+export declare const CartesiaSpeech: {
+    readonly protocol: MediaProtocol.Streamed<Request, {
+        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>, State>;
+    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<CartesiaSpeechOptions>;
+};
+export {};

package/dist/protocols/cartesia-speech.js

@@ -0,0 +1,126 @@
+import { Effect, Schema } from "effect";
+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 { 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");
+export const DEFAULT_BASE_URL = "https://api.cartesia.ai";
+export const API_VERSION = "2026-08-14";
+export const BYTES_PATH = "/tts/bytes";
+export const SSE_PATH = "/tts/sse";
+const DEFAULT_SAMPLE_RATE = 44100;
+const DEFAULT_BIT_RATE = 128000;
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+/** `phoneme_timestamps` and future record types are ignored. */
+const SseEvent = Schema.Struct({
+    type: Schema.String,
+    data: Schema.optional(Schema.Uint8ArrayFromBase64),
+    word_timestamps: Schema.optional(Schema.Struct({
+        words: Schema.Array(Schema.String),
+        start: Schema.Array(Schema.Number),
+        end: Schema.Array(Schema.Number),
+    })),
+    status_code: Schema.optional(Schema.Number),
+    title: Schema.optional(Schema.String),
+    message: Schema.optional(Schema.String),
+    error_code: optionalNull(Schema.String),
+});
+const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, SseEvent);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+/** Timestamps exist only on the SSE endpoint, so a `generate` that asks for them collects an SSE stream. */
+const usesSse = (request) => request.mode === "stream" || request.timestamps === true;
+const CONTAINERS = { pcm: "raw", wav: "wav", mp3: "mp3" };
+const outputFormat = Effect.fn("CartesiaSpeech.outputFormat")(function* (request) {
+    const sse = usesSse(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}"`);
+    if (sse && container !== "raw")
+        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${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 };
+    return { container, encoding: request.providerOptions?.encoding ?? "pcm_s16le", sample_rate: sampleRate };
+});
+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\``);
+    const { sampleRate: _sampleRate, bitRate: _bitRate, encoding: _encoding, ...native } = request.providerOptions ?? {};
+    return MediaProtocol.json(mergeJsonRecords({
+        model_id: request.model.id,
+        transcript: request.text,
+        voice,
+        output_format: yield* outputFormat(request),
+        language: request.language,
+        generation_config: request.speed === undefined ? undefined : { speed: request.speed },
+        add_timestamps: request.timestamps === true ? true : undefined,
+    }, native, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const onEvent = Effect.fn("CartesiaSpeech.onEvent")(function* (state, frame) {
+    const event = yield* decodeEvent(frame);
+    if (event.type === "chunk" && event.data !== undefined)
+        return SpeechStream.delta(state, event.data);
+    if (event.type === "timestamps" && event.word_timestamps !== undefined) {
+        const words = event.word_timestamps;
+        return [state, SpeechStream.timestamps(words.words, words.start, words.end)];
+    }
+    if (event.type === "done")
+        return [{ ...state, done: true }, []];
+    if (event.type === "error")
+        return yield* new AIError({
+            reason: classifyProviderFailure({
+                message: `${NAME} stream failed${event.title === undefined ? "" : ` (${event.title})`}: ${event.message ?? "unknown error"}`,
+                status: event.status_code,
+                rawBody: frame,
+            }),
+        });
+    return [state, []];
+});
+const finish = Effect.fn("CartesiaSpeech.finish")(function* (state, context) {
+    if (usesSse(context.request) && !state.done)
+        return yield* MediaProtocol.incomplete(ADAPTER);
+    const format = yield* outputFormat(context.request);
+    return yield* SpeechStream.finish(ADAPTER, 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,
+    unsupported: ["instructions"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => (usesSse(context.request) ? Framing.sse.frame(bytes) : bytes),
+    initial: () => ({ chunks: [], done: false }),
+    step: SpeechStream.step(onEvent),
+    finish,
+});
+export const model = (input) => SpeechModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    headers: { "Cartesia-Version": API_VERSION },
+    path: ({ request }) => (usesSse(request) ? SSE_PATH : BYTES_PATH),
+}, input);
+export const CartesiaSpeech = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,119 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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 DeepgramSpeechOptions = {
+    readonly encoding?: DeepgramEncoding;
+    readonly container?: DeepgramSpeechString<"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 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 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,92 @@
+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 { 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");
+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(ADAPTER, {
+        ...native,
+        model: request.model.id,
+        ...audioFormat(request),
+        sample_rate: sampleRate,
+        bit_rate: bitRate,
+        speed: request.speed,
+    });
+};
+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 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(ADAPTER, 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({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["voice", "language", "instructions", "timestamps"],
+    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 DeepgramSpeech = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,25 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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?: "latest" | "v1" | "v2" | (string & {});
+    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>;
+};