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

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,90 @@
+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 { 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 queryValue = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : undefined;
+const queryParameters = (request) => {
+    const format = request.format === undefined ? undefined : FORMATS[request.format];
+    const { encoding, container, sampleRate, bitRate, ...native } = request.providerOptions ?? {};
+    return Object.fromEntries(Object.entries({
+        ...native,
+        model: request.model.id,
+        encoding: encoding ?? format?.encoding,
+        container: container ?? format?.container,
+        sample_rate: sampleRate,
+        bit_rate: bitRate,
+        speed: request.speed,
+    }).flatMap(([key, value]) => {
+        const text = queryValue(value);
+        return text === undefined ? [] : [[key, text]];
+    }));
+};
+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) ?? {}, 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 query = queryParameters(context.request);
+    const encoding = HEADERLESS_ENCODINGS[query.encoding ?? ""];
+    const requestID = headers["dg-request-id"];
+    const modelName = headers["dg-model-name"];
+    return SpeechStream.finish(ADAPTER, state, {
+        ...(query.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: query.container === "wav" ? "wav" : (query.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/elevenlabs-speech.d.ts

@@ -0,0 +1,122 @@
+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.elevenlabs.io";
+export declare const PATH = "/v1/text-to-speech";
+export type ElevenLabsSpeechString<Known extends string> = Known | (string & {});
+export type ElevenLabsOutputFormat = ElevenLabsSpeechString<"mp3_22050_32" | "mp3_24000_48" | "mp3_44100_32" | "mp3_44100_64" | "mp3_44100_96" | "mp3_44100_128" | "mp3_44100_192" | "pcm_8000" | "pcm_16000" | "pcm_22050" | "pcm_24000" | "pcm_32000" | "pcm_44100" | "pcm_48000" | "wav_8000" | "wav_16000" | "wav_22050" | "wav_24000" | "wav_32000" | "wav_44100" | "wav_48000" | "ulaw_8000" | "alaw_8000" | "opus_48000_32" | "opus_48000_64" | "opus_48000_96" | "opus_48000_128" | "opus_48000_192">;
+export type 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?: ElevenLabsSpeechString<"auto" | "on" | "off">;
+} & Record<string, unknown>;
+export type Request = SpeechRequestFor<ElevenLabsSpeechOptions>;
+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>, SpeechStream.Audio>;
+export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<ElevenLabsSpeechOptions>;
+export declare const ElevenLabsSpeech: {
+    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>, SpeechStream.Audio>;
+    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<ElevenLabsSpeechOptions>;
+};

package/dist/protocols/elevenlabs-speech.js

@@ -0,0 +1,115 @@
+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 { ProviderShared, optionalNull } from "./shared.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+const ADAPTER = "elevenlabs-speech";
+const NAME = "ElevenLabs";
+const PROVIDER = ProviderID.make("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 = MediaProtocol.decodeFrame(ADAPTER, NAME, 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* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} has no default output format for "${request.format}"; pass providerOptions.outputFormat`);
+    if (request.mode === "stream" && format.startsWith("wav_"))
+        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} streams mp3, pcm, opus, ulaw, and alaw but not "${format}"; use generate for WAV`);
+    return format;
+});
+const fromRequest = Effect.fn("ElevenLabsSpeech.fromRequest")(function* (request) {
+    if (request.voice === undefined)
+        return yield* ProviderShared.invalidRequest(`${NAME} requires a voice id; pass it as \`voice\``);
+    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(ADAPTER, 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({
+    id: ADAPTER,
+    name: NAME,
+    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({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => path(request) }, input);
+export const ElevenLabsSpeech = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,160 @@
+import { Schema } from "effect";
+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://generativelanguage.googleapis.com/v1beta";
+/** Style is directed in the text itself, and `speechConfig.multiSpeakerVoiceConfig` excludes `voice`. */
+export type GoogleSpeechOptions = {
+    readonly temperature?: number;
+    readonly seed?: number;
+    readonly speechConfig?: {
+        readonly multiSpeakerVoiceConfig?: {
+            readonly speakerVoiceConfigs: ReadonlyArray<{
+                readonly speaker: string;
+                readonly voiceConfig: {
+                    readonly prebuiltVoiceConfig: {
+                        readonly voiceName: string;
+                    };
+                };
+            }>;
+        };
+    };
+} & Record<string, unknown>;
+export type Request = SpeechRequestFor<GoogleSpeechOptions>;
+declare const GenerateContentChunk: Schema.Struct<{
+    readonly candidates: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly content: Schema.optional<Schema.Struct<{
+            readonly parts: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly text: Schema.optional<Schema.String>;
+                readonly inlineData: Schema.optional<Schema.Struct<{
+                    readonly mimeType: Schema.String;
+                    readonly data: Schema.Uint8ArrayFromBase64;
+                }>>;
+            }>>>;
+        }>>;
+        readonly finishReason: Schema.optional<Schema.String>;
+    }>>>;
+    readonly promptFeedback: Schema.optional<Schema.Struct<{
+        readonly blockReason: Schema.optional<Schema.String>;
+        readonly blockReasonMessage: Schema.optional<Schema.String>;
+    }>>;
+    readonly usageMetadata: Schema.optional<Schema.Struct<{
+        readonly promptTokenCount: Schema.optional<Schema.Number>;
+        readonly candidatesTokenCount: Schema.optional<Schema.Number>;
+        readonly totalTokenCount: Schema.optional<Schema.Number>;
+    }>>;
+    readonly modelVersion: Schema.optional<Schema.String>;
+    readonly responseId: Schema.optional<Schema.String>;
+}>;
+type GenerateContentChunk = Schema.Schema.Type<typeof GenerateContentChunk>;
+interface State extends SpeechStream.Audio {
+    readonly mimeType?: string;
+    readonly usage?: GenerateContentChunk["usageMetadata"];
+    readonly finishReason?: string;
+    readonly modelVersion?: string;
+    readonly responseId?: string;
+}
+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, State>;
+export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<GoogleSpeechOptions>;
+export declare const GoogleSpeech: {
+    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, State>;
+    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<GoogleSpeechOptions>;
+};
+export {};