@opencode/ai 0.0.0-dev-20039 → 0.0.0-dev-20041

package/dist/protocols/google-speech.js

@@ -0,0 +1,122 @@
+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 { AIError, ContentPolicyError, ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { SpeechModel } from "../speech.js";
+import { ProviderShared } from "./shared.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+const ADAPTER = "google-speech";
+const NAME = "Google Speech";
+const PROVIDER = ProviderID.make("google");
+export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const DEFAULT_SAMPLE_RATE = 24000;
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const GenerateContentChunk = Schema.Struct({
+    candidates: Schema.optional(Schema.Array(Schema.Struct({
+        content: Schema.optional(Schema.Struct({
+            parts: Schema.optional(Schema.Array(Schema.Struct({
+                text: Schema.optional(Schema.String),
+                inlineData: Schema.optional(Schema.Struct({ mimeType: Schema.String, data: Schema.Uint8ArrayFromBase64 })),
+            }))),
+        })),
+        finishReason: Schema.optional(Schema.String),
+    }))),
+    promptFeedback: Schema.optional(Schema.Struct({ blockReason: Schema.optional(Schema.String), blockReasonMessage: Schema.optional(Schema.String) })),
+    usageMetadata: Schema.optional(Schema.Struct({
+        promptTokenCount: Schema.optional(Schema.Number),
+        candidatesTokenCount: Schema.optional(Schema.Number),
+        totalTokenCount: Schema.optional(Schema.Number),
+    })),
+    modelVersion: Schema.optional(Schema.String),
+    responseId: Schema.optional(Schema.String),
+});
+const decodeChunk = MediaProtocol.decodeFrame(ADAPTER, NAME, GenerateContentChunk);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const fromRequest = Effect.fn("GoogleSpeech.fromRequest")(function* (request) {
+    if (request.format !== undefined && request.format !== "pcm")
+        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} only returns raw PCM; request format "pcm" or omit it, then wrap the samples yourself`);
+    const voiceName = SpeechStream.voiceID(request.voice);
+    return MediaProtocol.json(mergeJsonRecords({
+        contents: [{ role: "user", parts: [{ text: request.text }] }],
+        generationConfig: mergeJsonRecords({
+            responseModalities: ["AUDIO"],
+            speechConfig: {
+                voiceConfig: voiceName === undefined ? undefined : { prebuiltVoiceConfig: { voiceName } },
+                languageCode: request.language,
+            },
+        }, request.providerOptions),
+    }, request.http?.body) ?? {});
+});
+// Only `gemini-3.1-flash-tts-preview` and later stream; earlier TTS models reject `streamGenerateContent`.
+const path = (request) => request.mode === "stream"
+    ? `/models/${request.model.id}:streamGenerateContent?alt=sse`
+    : `/models/${request.model.id}:generateContent`;
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const step = Effect.fn("GoogleSpeech.step")(function* (state, frame) {
+    const chunk = yield* decodeChunk(frame);
+    const blockReason = chunk.promptFeedback?.blockReason;
+    if (blockReason !== undefined)
+        return yield* new AIError({
+            reason: new ContentPolicyError({
+                message: `${NAME} blocked the prompt (${blockReason})${chunk.promptFeedback?.blockReasonMessage === undefined ? "" : `: ${chunk.promptFeedback.blockReasonMessage}`}`,
+                body: frame,
+            }),
+        });
+    const candidate = chunk.candidates?.[0];
+    const audio = (candidate?.content?.parts ?? []).flatMap((part) => part.inlineData === undefined ? [] : [part.inlineData]);
+    const next = {
+        ...state,
+        mimeType: state.mimeType ?? audio[0]?.mimeType,
+        usage: chunk.usageMetadata ?? state.usage,
+        finishReason: candidate?.finishReason ?? state.finishReason,
+        modelVersion: chunk.modelVersion ?? state.modelVersion,
+        responseId: chunk.responseId ?? state.responseId,
+    };
+    return [next, audio.flatMap((part) => SpeechStream.delta(next, part.data)[1])];
+});
+const finish = (state) => {
+    const usage = state.usage;
+    const sampleRate = SpeechStream.sampleRate(state.mimeType) ?? DEFAULT_SAMPLE_RATE;
+    return SpeechStream.finish(ADAPTER, state, {
+        ...SpeechStream.pcm("pcm_s16le", sampleRate, state.mimeType ?? `audio/L16;codec=pcm;rate=${sampleRate}`),
+        usage: usage === undefined
+            ? undefined
+            : {
+                type: "tokens",
+                input: usage.promptTokenCount,
+                output: usage.candidatesTokenCount,
+                total: ProviderShared.totalTokens(usage.promptTokenCount, usage.candidatesTokenCount, usage.totalTokenCount),
+                details: { google: usage },
+            },
+        providerMetadata: {
+            google: { finishReason: state.finishReason, modelVersion: state.modelVersion, responseId: state.responseId },
+        },
+        detail: state.finishReason === undefined ? undefined : `finish reason: ${state.finishReason}`,
+    });
+};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["instructions", "speed", "timestamps"],
+    body: { from: fromRequest },
+    // `generateContent` answers with one document shaped exactly like a streamed chunk, so it is a single frame.
+    frames: (bytes, context) => context.request.mode === "stream" ? Framing.sse.frame(bytes) : Framing.document.frame(bytes),
+    initial: () => ({ chunks: [] }),
+    step,
+    finish,
+});
+export const model = (input) => SpeechModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => path(request) }, input);
+export const GoogleSpeech = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,116 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { type MediaUsage } 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.openai.com/v1";
+export declare const PATH = "/audio/speech";
+export type OpenAISpeechOptions = Record<string, unknown>;
+export type Request = SpeechRequestFor<OpenAISpeechOptions>;
+interface State extends SpeechStream.Audio {
+    readonly done: boolean;
+    readonly usage?: MediaUsage;
+}
+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<OpenAISpeechOptions>;
+export declare const OpenAISpeech: {
+    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<OpenAISpeechOptions>;
+};
+export {};

package/dist/protocols/openai-speech.js

@@ -0,0 +1,98 @@
+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 { SpeechModel } from "../speech.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+const ADAPTER = "openai-speech";
+const NAME = "OpenAI Speech";
+const PROVIDER = ProviderID.make("openai");
+export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export const PATH = "/audio/speech";
+/** `pcm` is raw 24 kHz, 16-bit signed little-endian mono samples without a header. */
+const PCM_SAMPLE_RATE = 24000;
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const SpeechStreamEvent = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("speech.audio.delta"), audio: Schema.Uint8ArrayFromBase64 }),
+    Schema.Struct({
+        type: Schema.Literal("speech.audio.done"),
+        usage: Schema.optional(Schema.Struct({
+            input_tokens: Schema.optional(Schema.Number),
+            output_tokens: Schema.optional(Schema.Number),
+            total_tokens: Schema.optional(Schema.Number),
+        })),
+    }),
+]);
+const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, SpeechStreamEvent);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+// `sse` is not supported for `tts-1` or `tts-1-hd`; those models stream the raw audio body instead.
+const supportsSse = (model) => !/^tts-1(-hd)?(-|$)/.test(model);
+const fromRequest = Effect.fn("OpenAISpeech.fromRequest")(function* (request) {
+    return MediaProtocol.json(mergeJsonRecords({
+        model: request.model.id,
+        input: request.text,
+        voice: request.voice,
+        instructions: request.instructions,
+        response_format: request.format,
+        speed: request.speed,
+        stream_format: request.mode === "stream" && supportsSse(request.model.id) ? "sse" : undefined,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const isSse = (body) => body.type === "json" && body.value.stream_format === "sse";
+const onEvent = Effect.fn("OpenAISpeech.onEvent")(function* (state, frame) {
+    const event = yield* decodeEvent(frame);
+    if (event.type === "speech.audio.delta")
+        return SpeechStream.delta(state, event.audio);
+    const usage = event.usage;
+    return [
+        {
+            ...state,
+            done: true,
+            usage: usage === undefined
+                ? undefined
+                : {
+                    type: "tokens",
+                    input: usage.input_tokens,
+                    output: usage.output_tokens,
+                    total: usage.total_tokens,
+                    details: { openai: usage },
+                },
+        },
+        [],
+    ];
+});
+const finish = (state, context) => {
+    if (isSse(context.body) && !state.done)
+        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+    const format = context.request.format ?? "mp3";
+    return SpeechStream.finish(ADAPTER, state, {
+        ...(format === "pcm" ? SpeechStream.pcm("pcm_s16le", PCM_SAMPLE_RATE) : SpeechStream.container(format)),
+        usage: state.usage,
+    });
+};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["language", "timestamps"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => (isSse(context.body) ? 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, path: PATH }, input);
+export const OpenAISpeech = {
+    protocol,
+    model,
+};

package/dist/protocols/utils/speech-stream.d.ts

@@ -0,0 +1,49 @@
+import { Effect } from "effect";
+import { Media } from "../../media.js";
+import type { AIError, MediaUsage, ProviderID, ProviderMetadata } from "../../schema/index.js";
+import { type SpeechEvent, type SpeechVoice } from "../../speech.js";
+export interface Audio {
+    /** Appended in place: the route creates fresh state for each response through `initial`. */
+    readonly chunks: Array<Uint8Array>;
+}
+export type StepResult<State> = readonly [State, ReadonlyArray<SpeechEvent>];
+/** Empty chunks (keep-alive records) emit nothing. */
+export declare const delta: <State extends Audio>(state: State, chunk: Uint8Array) => StepResult<State>;
+export declare const step: <State extends Audio>(onRecord: (state: State, frame: string) => Effect.Effect<StepResult<State>, AIError>) => (state: State, frame: string | Uint8Array) => Effect.Effect<StepResult<State>, AIError, never>;
+export declare const timestamps: (texts: ReadonlyArray<string>, starts: ReadonlyArray<number>, ends: ReadonlyArray<number>) => ReadonlyArray<SpeechEvent>;
+export declare const voiceID: (voice: SpeechVoice | undefined) => string | undefined;
+export declare const container: (format: string, sampleRate?: number) => {
+    mediaType: string;
+    info: {
+        format: string;
+        sampleRate: number | undefined;
+    };
+};
+declare const PCM_MEDIA_TYPES: {
+    readonly pcm_s16le: "audio/pcm";
+    readonly pcm_f32le: "audio/pcm";
+    readonly pcm_mulaw: "audio/mulaw";
+    readonly pcm_alaw: "audio/alaw";
+};
+export type PcmEncoding = keyof typeof PCM_MEDIA_TYPES;
+export declare const pcm: (encoding: PcmEncoding, sampleRate: number | undefined, mediaType?: string) => {
+    mediaType: string;
+    info: {
+        format: string;
+        encoding: "pcm_s16le" | "pcm_f32le" | "pcm_mulaw" | "pcm_alaw";
+        sampleRate: number | undefined;
+        channels: number;
+    };
+};
+export declare const sampleRate: (mediaType: string | undefined) => number | undefined;
+export declare const unsupportedFormat: (provider: ProviderID, route: string, message: string) => AIError;
+/** A declared `mediaType` wins over sniffing: headerless PCM can start with bytes that look like an MPEG frame sync. */
+export declare const finish: (route: string, state: Audio, output: {
+    readonly mediaType: string | undefined;
+    readonly info?: Media.Info;
+    readonly usage?: MediaUsage;
+    readonly providerMetadata?: ProviderMetadata;
+    readonly detail?: string;
+}) => Effect.Effect<ReadonlyArray<SpeechEvent>, AIError>;
+export declare const headerUsage: (type: "characters" | "credits", value: string | undefined) => MediaUsage | undefined;
+export * as SpeechStream from "./speech-stream.js";

package/dist/protocols/utils/speech-stream.js

@@ -0,0 +1,67 @@
+import { Effect } from "effect";
+import { Media } from "../../media.js";
+import { MediaProtocol } from "../../route/media-protocol.js";
+import { SpeechAudioDeltaEvent, SpeechFinishEvent, SpeechTimestampsEvent, } from "../../speech.js";
+import { concatBytes } from "../../utils/bytes.js";
+import { ProviderShared } from "../shared.js";
+/** Empty chunks (keep-alive records) emit nothing. */
+export const delta = (state, chunk) => {
+    if (chunk.length === 0)
+        return [state, []];
+    state.chunks.push(chunk);
+    return [state, [SpeechAudioDeltaEvent.make({ chunk })]];
+};
+export const step = (onRecord) => (state, frame) => typeof frame === "string" ? onRecord(state, frame) : Effect.succeed(delta(state, frame));
+export const timestamps = (texts, starts, ends) => texts.length === 0
+    ? []
+    : [
+        SpeechTimestampsEvent.make({
+            items: texts.map((text, index) => ({ text, startSeconds: starts[index] ?? 0, endSeconds: ends[index] ?? 0 })),
+        }),
+    ];
+export const voiceID = (voice) => (typeof voice === "object" ? voice.id : voice);
+const CONTAINER_MEDIA_TYPES = {
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    opus: "audio/ogg",
+    aac: "audio/aac",
+    flac: "audio/flac",
+};
+export const container = (format, sampleRate) => ({
+    mediaType: CONTAINER_MEDIA_TYPES[format],
+    info: { format, sampleRate },
+});
+const PCM_MEDIA_TYPES = {
+    pcm_s16le: "audio/pcm",
+    pcm_f32le: "audio/pcm",
+    pcm_mulaw: "audio/mulaw",
+    pcm_alaw: "audio/alaw",
+};
+export const pcm = (encoding, sampleRate, mediaType) => ({
+    mediaType: mediaType ?? PCM_MEDIA_TYPES[encoding],
+    info: { format: "pcm", encoding, sampleRate, channels: 1 },
+});
+export const sampleRate = (mediaType) => {
+    const rate = /rate=(\d+)/i.exec(mediaType ?? "")?.[1];
+    return rate === undefined ? undefined : Number(rate);
+};
+export const unsupportedFormat = (provider, route, message) => ProviderShared.unsupportedOperation({ operation: "media.format", provider, route, message });
+/** A declared `mediaType` wins over sniffing: headerless PCM can start with bytes that look like an MPEG frame sync. */
+export const finish = (route, state, output) => {
+    if (state.chunks.length === 0)
+        return Effect.fail(MediaProtocol.frameError(route, `The provider returned no audio${output.detail === undefined ? "" : ` (${output.detail})`}`));
+    return Effect.succeed([
+        SpeechFinishEvent.make({
+            audio: Media.bytes(concatBytes(state.chunks), output.mediaType, { info: output.info }),
+            usage: output.usage,
+            providerMetadata: output.providerMetadata,
+        }),
+    ]);
+};
+export const headerUsage = (type, value) => {
+    const amount = Number(value);
+    if (!Number.isFinite(amount))
+        return undefined;
+    return type === "credits" ? { type, credits: amount } : { type, characters: amount };
+};
+export * as SpeechStream from "./speech-stream.js";

package/dist/providers/cartesia.d.ts

@@ -0,0 +1,24 @@
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { CartesiaEncoding, CartesiaSpeechOptions } from "../protocols/cartesia-speech.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/cartesia-speech.js").CartesiaSpeechOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/cartesia-speech.js").CartesiaSpeechOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/cartesia-speech.js").CartesiaSpeechOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/cartesia-speech.js").CartesiaSpeechOptions>;

package/dist/providers/cartesia.js

@@ -0,0 +1,22 @@
+import { AuthOptions } from "../route/auth-options.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { CartesiaSpeech, DEFAULT_BASE_URL } from "../protocols/cartesia-speech.js";
+export const id = ProviderID.make("cartesia");
+const baseURL = DEFAULT_BASE_URL;
+const auth = (options) => AuthOptions.bearer(options, "CARTESIA_API_KEY");
+export const configure = (input = {}) => {
+    const speech = (modelID) => CartesiaSpeech.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return {
+        id,
+        speech,
+        configure,
+    };
+};
+export const provider = configure();
+export const speech = provider.speech;

package/dist/providers/deepgram.d.ts

@@ -0,0 +1,24 @@
+import type { ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { DeepgramEncoding, DeepgramSpeechOptions } from "../protocols/deepgram-speech.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/deepgram-speech.js").DeepgramSpeechOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/deepgram-speech.js").DeepgramSpeechOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/deepgram-speech.js").DeepgramSpeechOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/deepgram-speech.js").DeepgramSpeechOptions>;

package/dist/providers/deepgram.js

@@ -0,0 +1,28 @@
+import { Auth } from "../route/auth.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { DEFAULT_BASE_URL, DeepgramSpeech } from "../protocols/deepgram-speech.js";
+export const id = ProviderID.make("deepgram");
+const baseURL = DEFAULT_BASE_URL;
+const auth = (options) => {
+    if ("auth" in options && options.auth)
+        return options.auth;
+    return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+        .orElse(Auth.config("DEEPGRAM_API_KEY"))
+        .pipe(Auth.scheme("Token"));
+};
+export const configure = (input = {}) => {
+    const speech = (modelID) => DeepgramSpeech.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return {
+        id,
+        speech,
+        configure,
+    };
+};
+export const provider = configure();
+export const speech = provider.speech;

package/dist/providers/elevenlabs.d.ts

@@ -0,0 +1,24 @@
+import type { ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, type ModelID } from "../schema/index.js";
+export type { ElevenLabsOutputFormat, ElevenLabsSpeechOptions } from "../protocols/elevenlabs-speech.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/elevenlabs-speech.js").ElevenLabsSpeechOptions>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/elevenlabs-speech.js").ElevenLabsSpeechOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/elevenlabs-speech.js").ElevenLabsSpeechOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/elevenlabs-speech.js").ElevenLabsSpeechOptions>;

package/dist/providers/elevenlabs.js

@@ -0,0 +1,28 @@
+import { Auth } from "../route/auth.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { DEFAULT_BASE_URL, ElevenLabsSpeech } from "../protocols/elevenlabs-speech.js";
+export const id = ProviderID.make("elevenlabs");
+const baseURL = DEFAULT_BASE_URL;
+const auth = (options) => {
+    if ("auth" in options && options.auth)
+        return options.auth;
+    return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+        .orElse(Auth.config("ELEVENLABS_API_KEY"))
+        .pipe(Auth.header("xi-api-key"));
+};
+export const configure = (input = {}) => {
+    const speech = (modelID) => ElevenLabsSpeech.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+    return {
+        id,
+        speech,
+        configure,
+    };
+};
+export const provider = configure();
+export const speech = provider.speech;

package/dist/providers/google.d.ts

@@ -4,6 +4,7 @@ import type { ProviderPackage } from "../provider-package.js";
 import { type ModelID } from "../schema/index.js";
 import { Gemini } from "../protocols/gemini.js";
 export type { GoogleImageOptions } from "../protocols/google-images.js";
+export type { GoogleSpeechOptions } from "../protocols/google-speech.js";
 export type { GoogleVideoOptions } from "../protocols/google-video.js";
 export type GeminiOptionsInput = Gemini.OptionsInput;
 export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
@@ -106,6 +107,7 @@ export declare const configure: (input?: Config) => {
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
     video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/google-speech.js").GoogleSpeechOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
@@ -113,14 +115,17 @@ export declare const provider: {
     model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
     image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
     video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
+    speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/google-speech.js").GoogleSpeechOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
         model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
         image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
         video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
+        speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/google-speech.js").GoogleSpeechOptions>;
         configure: /*elided*/ any;
     };
 };
 export declare const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"];
 export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
 export declare const video: (modelID: string | ModelID) => import("../video.js").VideoModel<import("../protocols/google-video.js").GoogleVideoOptions>;
+export declare const speech: (modelID: string | ModelID) => import("../speech.js").SpeechModel<import("../protocols/google-speech.js").GoogleSpeechOptions>;