@opencode/ai 0.0.0-dev-20048 → 0.0.0-dev-20052

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

package/dist/protocols/deepgram-transcription.js

@@ -0,0 +1,129 @@
+import { Effect, Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
+import { ProviderShared } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "deepgram-transcription";
+const NAME = "Deepgram";
+const PROVIDER = ProviderID.make("deepgram");
+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(ADAPTER, 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(`${NAME} sends inline audio as the raw body, so http.body cannot apply`);
+    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+    return MediaProtocol.binary(audio, request.audio.mediaType, yield* query(request));
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeListen = MediaProtocol.decodeJson(ADAPTER, NAME, 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(`${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({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["prompt", "speakers"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const model = (input) => TranscriptionModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const DeepgramTranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/gemini.d.ts

@@ -206,11 +206,11 @@ export declare const protocol: Protocol<{
         readonly safetyRatings?: unknown;
     } | null | undefined;
     readonly usageMetadata?: {
-        readonly cachedContentTokenCount?: number | null | undefined;
-        readonly thoughtsTokenCount?: number | null | undefined;
         readonly promptTokenCount?: number | null | undefined;
         readonly candidatesTokenCount?: number | null | undefined;
         readonly totalTokenCount?: number | null | undefined;
+        readonly cachedContentTokenCount?: number | null | undefined;
+        readonly thoughtsTokenCount?: number | null | undefined;
     } | null | undefined;
 }, {
     route: string;

package/dist/protocols/gemini.js

@@ -9,6 +9,7 @@ import { AIError, LLMEvent, Usage, } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { Media } from "../media.js";
 import { JsonObject, knownString, lenient, optionalArray, optionalNull, ProviderShared } from "./shared.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { GeminiToolSchema } from "./utils/gemini-tool-schema.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
@@ -221,15 +222,10 @@ const lowerToolConfig = (toolChoice) => ProviderShared.matchToolChoice("Gemini",
     required: () => ({ functionCallingConfig: { mode: "ANY" } }),
     tool: (name) => ({ functionCallingConfig: { mode: "ANY", allowedFunctionNames: [name] } }),
 });
-// Gemini does not fetch public URLs; inline payloads and Gemini Files references are the accepted inputs.
 const lowerContentPart = Effect.fn("Gemini.lowerContentPart")(function* (part) {
     if (part.type === "text")
         return { text: part.text };
-    const source = part.media.source;
-    if (source.type === "ref" && source.provider === "google")
-        return { fileData: { mimeType: part.media.mediaType, fileUri: source.id } };
-    const media = yield* ProviderShared.requireInlineMedia("Gemini", part.media);
-    return { inlineData: { mimeType: media.mime, data: media.base64 } };
+    return yield* GeminiGenerateContent.mediaPart("Gemini", part.media);
 });
 const providerMetadata = (key, metadata) => ({ [key]: metadata });
 const thoughtSignature = (metadata, key) => {

package/dist/protocols/google-images.js

@@ -1,10 +1,10 @@
 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 } from "./shared.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { MediaInput } from "./utils/media-input.js";
 const ADAPTER = "google-images";
 const NAME = "Google Images";
@@ -61,18 +61,6 @@ const generationConfig = (request) => {
         thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
     }, native) ?? { responseModalities: ["IMAGE"] });
 };
-// Gemini does not fetch public URLs; inline payloads or Gemini Files references are the only accepted inputs.
-const imagePart = (asset) => {
-    const inline = asset.inline();
-    if (inline)
-        return Effect.succeed({ inlineData: { mimeType: inline.mime, data: inline.base64 } });
-    const id = MediaInput.refID(asset, PROVIDER);
-    if (id)
-        return Effect.succeed({ fileData: { mimeType: asset.mediaType, fileUri: id } });
-    if (asset.source.type === "ref")
-        return Effect.fail(ProviderShared.invalidRequest("Google generateContent requires Gemini file references rather than other providers' file IDs"));
-    return Effect.fail(ProviderShared.invalidRequest("Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file reference"));
-};
 const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request) {
     if (request.n !== undefined && request.n > 1)
         return yield* ProviderShared.unsupportedOperation({
@@ -81,7 +69,7 @@ const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request) {
             route: ADAPTER,
             message: `${NAME} generates one image per request; call it once per image instead of n=${request.n}`,
         });
-    const parts = yield* Effect.forEach(request.images ?? [], imagePart);
+    const parts = yield* Effect.forEach(request.images ?? [], (image) => GeminiGenerateContent.mediaPart(NAME, image));
     return MediaProtocol.json(mergeJsonRecords({
         contents: [{ role: "user", parts: [{ text: request.prompt }, ...parts] }],
         generationConfig: generationConfig(request),

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

@@ -1,7 +1,7 @@
-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 { GeminiGenerateContent } from "./utils/gemini-generate-content.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`. */
@@ -22,38 +22,8 @@ export type GoogleSpeechOptions = {
     };
 } & 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 {
+interface State extends SpeechStream.Audio, GeminiGenerateContent.Metadata {
     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";

package/dist/protocols/google-speech.js

@@ -1,10 +1,9 @@
 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 { ProviderID, mergeJsonRecords } from "../schema/index.js";
 import { SpeechModel } from "../speech.js";
-import { ProviderShared } from "./shared.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { SpeechStream } from "./utils/speech-stream.js";
 const ADAPTER = "google-speech";
 const NAME = "Google Speech";
@@ -14,25 +13,10 @@ 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 GenerateContentChunk = GeminiGenerateContent.chunk(Schema.Struct({
+    text: Schema.optional(Schema.String),
+    inlineData: Schema.optional(Schema.Struct({ mimeType: Schema.String, data: Schema.Uint8ArrayFromBase64 })),
+}));
 const decodeChunk = MediaProtocol.decodeFrame(ADAPTER, NAME, GenerateContentChunk);
 // ---------------------------------------------------------------------------
 // 5. Request body construction
@@ -52,52 +36,24 @@ const fromRequest = Effect.fn("GoogleSpeech.fromRequest")(function* (request) {
         }, 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,
-    };
+    const blocked = GeminiGenerateContent.blocked(NAME, chunk, frame);
+    if (blocked !== undefined)
+        return yield* blocked;
+    const audio = (chunk.candidates?.[0]?.content?.parts ?? []).flatMap((part) => part.inlineData === undefined ? [] : [part.inlineData]);
+    const next = { ...GeminiGenerateContent.track(state, chunk), mimeType: state.mimeType ?? audio[0]?.mimeType };
     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 },
-        },
+        usage: GeminiGenerateContent.usage(state.usage),
+        providerMetadata: GeminiGenerateContent.providerMetadata(state),
         detail: state.finishReason === undefined ? undefined : `finish reason: ${state.finishReason}`,
     });
 };
@@ -109,13 +65,19 @@ export const protocol = MediaProtocol.stream({
     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),
+    frames: (bytes, context) => GeminiGenerateContent.frames(bytes, context.request.mode),
     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 model = (input) => SpeechModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    // Only `gemini-3.1-flash-tts-preview` and later stream; earlier TTS models reject `streamGenerateContent`.
+    path: ({ request }) => GeminiGenerateContent.path(request.model.id, request.mode),
+}, input);
 export const GoogleSpeech = {
     protocol,
     model,

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

@@ -0,0 +1,173 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { TranscriptionModel, type TranscriptionRequestFor, type TranscriptionSegment, type TranscriptionWord } from "../transcription.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+/**
+ * Merged into `generationConfig`. The API rejects `customVocabulary` and `mode: "SMART"` alongside diarization or word
+ * timestamps.
+ */
+export type GoogleTranscriptionOptions = {
+    readonly audioTranscriptionConfig?: {
+        readonly mode?: "VERBATIM" | "SMART" | (string & {});
+        readonly customVocabulary?: ReadonlyArray<string>;
+        readonly languageCodes?: ReadonlyArray<string>;
+    };
+} & Record<string, unknown>;
+export type Request = TranscriptionRequestFor<GoogleTranscriptionOptions>;
+interface State extends GeminiGenerateContent.Metadata {
+    readonly text: string;
+    readonly segments: Array<TranscriptionSegment>;
+    readonly words: Array<TranscriptionWord>;
+}
+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: "text-delta";
+    readonly delta: string;
+} | {
+    readonly type: "segment";
+    readonly segment: {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+        readonly speaker?: string | undefined;
+    };
+} | {
+    readonly type: "finish";
+    readonly text: string;
+    readonly durationSeconds?: number | undefined;
+    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;
+    readonly language?: string | undefined;
+    readonly segments?: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+        readonly speaker?: string | undefined;
+    }[] | undefined;
+    readonly words?: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+        readonly speaker?: string | undefined;
+        readonly confidence?: number | undefined;
+    }[] | undefined;
+}, string, State>;
+export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<GoogleTranscriptionOptions>;
+export declare const GoogleTranscription: {
+    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: "text-delta";
+        readonly delta: string;
+    } | {
+        readonly type: "segment";
+        readonly segment: {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        };
+    } | {
+        readonly type: "finish";
+        readonly text: string;
+        readonly durationSeconds?: number | undefined;
+        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;
+        readonly language?: string | undefined;
+        readonly segments?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        }[] | undefined;
+        readonly words?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+            readonly confidence?: number | undefined;
+        }[] | undefined;
+    }, string, State>;
+    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<GoogleTranscriptionOptions>;
+};
+export {};