@effect-uai/google 0.3.0 → 0.4.0

package/src/LyriaGenerator.ts

@@ -0,0 +1,394 @@
+import {
+  Array as Arr,
+  Context,
+  Effect,
+  Encoding,
+  Layer,
+  Match,
+  Option,
+  Redacted,
+  Result,
+  Schema,
+  Stream,
+} from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import * as AiError from "@effect-uai/core/AiError"
+import type { AudioChunk, AudioFormat } from "@effect-uai/core/Audio"
+import type {
+  CommonGenerateMusicRequest,
+  CommonStreamGenerateMusicRequest,
+  MusicResult,
+  MusicSessionInput,
+  WeightedPrompt,
+} from "@effect-uai/core/Music"
+import { MusicGenerator, type MusicGeneratorService } from "@effect-uai/core/MusicGenerator"
+import type { LyriaModel } from "./models.js"
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/**
+ * Lyria-typed generate request. Narrows `model` to `LyriaModel`. The
+ * Lyria sync API (`generateContent`) accepts only `audio/mp3` and
+ * `audio/wav` output; `bpm`, `scale`, `instrumental` etc. on the
+ * `CommonGenerateMusicRequest` are flattened into the prompt text
+ * because the public API does not expose them as structured fields.
+ */
+export type LyriaGenerateRequest = Omit<CommonGenerateMusicRequest, "model"> & {
+  readonly model: LyriaModel
+}
+
+export type LyriaGeneratorService = {
+  readonly generate: (request: LyriaGenerateRequest) => Effect.Effect<MusicResult, AiError.AiError>
+  readonly streamGeneration: (
+    request: LyriaGenerateRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError>
+  readonly streamGenerationFrom: <E, R>(
+    input: Stream.Stream<MusicSessionInput, E, R>,
+    request: CommonStreamGenerateMusicRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError | E, R>
+}
+
+export class LyriaGenerator extends Context.Service<LyriaGenerator, LyriaGeneratorService>()(
+  "@betalyra/effect-uai/providers/google/LyriaGenerator",
+) {}
+
+export type Config = {
+  readonly apiKey: Redacted.Redacted
+  readonly baseUrl?: string
+}
+
+// ---------------------------------------------------------------------------
+// Codec — request → prompt text + response_format
+// ---------------------------------------------------------------------------
+
+export type LyriaResponseMimeType = "audio/mp3" | "audio/wav"
+
+export const containerToMimeType: (
+  container: AudioFormat["container"],
+) => Effect.Effect<LyriaResponseMimeType, AiError.AiError> = Match.type<
+  AudioFormat["container"]
+>().pipe(
+  Match.when("mp3", () => Effect.succeed<LyriaResponseMimeType>("audio/mp3")),
+  Match.when("wav", () => Effect.succeed<LyriaResponseMimeType>("audio/wav")),
+  Match.whenOr("ogg", "opus", "flac", "aac", "webm", "raw", (c) =>
+    Effect.fail(
+      new AiError.Unsupported({
+        provider: "lyria",
+        capability: "outputFormat",
+        reason: `Lyria 3 only produces audio/mp3 or audio/wav; ${c} is not available. Use container: "mp3" or "wav".`,
+      }),
+    ),
+  ),
+  Match.exhaustive,
+)
+
+/**
+ * Is this a Lyria 3 Clip model variant? Clip is fixed at 30 s MP3 — it
+ * does not accept a `responseFormat` on `generationConfig` (the live
+ * API rejects unknown fields, despite what the docs imply). Pro
+ * accepts the documented `responseFormat` knob.
+ */
+const isClipModel = (model: string): boolean => model.includes("clip")
+
+export const realizedFormat: (mime: LyriaResponseMimeType) => AudioFormat =
+  Match.type<LyriaResponseMimeType>().pipe(
+    Match.when(
+      "audio/mp3",
+      (): AudioFormat => ({ container: "mp3", encoding: "mp3", sampleRate: 44100, channels: 2 }),
+    ),
+    Match.when(
+      "audio/wav",
+      (): AudioFormat => ({
+        container: "wav",
+        encoding: "pcm_s16le",
+        sampleRate: 44100,
+        channels: 2,
+      }),
+    ),
+    Match.exhaustive,
+  )
+
+/**
+ * Collapse `prompts | WeightedPrompt[]` into a single prompt string and
+ * splice in non-structural hints (`lyrics`, `bpm`, `scale`,
+ * `instrumental`, `durationSeconds`). The Lyria 3 sync API only takes
+ * one text part — every condition lives inline.
+ */
+export const buildPrompt = (request: CommonGenerateMusicRequest): string => {
+  const promptText = Match.value(request.prompts).pipe(
+    Match.when(Match.string, (s) => s),
+    Match.orElse((ws: ReadonlyArray<WeightedPrompt>) =>
+      Arr.map(ws, (w) =>
+        w.weight !== undefined && w.weight !== 1 ? `${w.text} (weight ${w.weight})` : w.text,
+      ).join(". "),
+    ),
+  )
+  const hints = Arr.getSomes([
+    request.instrumental === true ? Option.some("Instrumental only — no vocals.") : Option.none(),
+    request.bpm !== undefined ? Option.some(`BPM: ${request.bpm}.`) : Option.none(),
+    request.scale !== undefined ? Option.some(`Key/scale: ${request.scale}.`) : Option.none(),
+    request.durationSeconds !== undefined
+      ? Option.some(`Target duration: ${request.durationSeconds}s.`)
+      : Option.none(),
+  ])
+  const lyricsBlock =
+    request.lyrics !== undefined && request.instrumental !== true
+      ? `\n\nLyrics:\n${request.lyrics}`
+      : ""
+  return [promptText, ...hints].join(" ") + lyricsBlock
+}
+
+// ---------------------------------------------------------------------------
+// Wire response schema — just enough to find audio + optional lyrics text
+// ---------------------------------------------------------------------------
+
+const InlineData = Schema.Struct({
+  mimeType: Schema.optional(Schema.String),
+  data: Schema.String,
+})
+
+const Part = Schema.Struct({
+  text: Schema.optional(Schema.String),
+  inlineData: Schema.optional(InlineData),
+})
+
+const Content = Schema.Struct({
+  parts: Schema.optional(Schema.Array(Part)),
+})
+
+const Candidate = Schema.Struct({
+  content: Schema.optional(Content),
+})
+
+const Wire = Schema.Struct({
+  candidates: Schema.optional(Schema.Array(Candidate)),
+})
+
+const decodeWire = Schema.decodeUnknownEffect(Wire)
+
+// ---------------------------------------------------------------------------
+// HTTP plumbing
+// ---------------------------------------------------------------------------
+
+const baseUrl = (cfg: Config): string =>
+  cfg.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta"
+
+const transportFailure = (cause: unknown): AiError.AiError =>
+  new AiError.Unavailable({ provider: "lyria", raw: cause })
+
+const httpStatusError: (status: number, body: string) => AiError.AiError = (status, body) =>
+  Match.value(status).pipe(
+    Match.when(
+      429,
+      (): AiError.AiError => new AiError.RateLimited({ provider: "lyria", raw: body }),
+    ),
+    Match.whenOr(
+      408,
+      504,
+      (): AiError.AiError => new AiError.Timeout({ provider: "lyria", raw: body }),
+    ),
+    Match.when(
+      401,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "lyria", subtype: "auth", raw: body }),
+    ),
+    Match.when(
+      403,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "lyria", subtype: "permission", raw: body }),
+    ),
+    Match.when(
+      402,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "lyria", subtype: "billing", raw: body }),
+    ),
+    Match.when(
+      (n) => n >= 500,
+      (n): AiError.AiError => new AiError.Unavailable({ provider: "lyria", status: n, raw: body }),
+    ),
+    Match.orElse(
+      (): AiError.AiError => new AiError.InvalidRequest({ provider: "lyria", raw: body }),
+    ),
+  )
+
+const decodeBase64ToBytes = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>
+  Result.match(Encoding.decodeBase64(b64), {
+    onSuccess: Effect.succeed,
+    onFailure: (cause) =>
+      Effect.fail(new AiError.InvalidRequest({ provider: "lyria", param: "audio", raw: cause })),
+  })
+
+/**
+ * Find the first inline-data audio part and the concatenated text parts
+ * from a Wire response.
+ */
+const extractParts = (
+  wire: typeof Wire.Type,
+): { readonly inline?: typeof InlineData.Type; readonly text?: string } => {
+  const allParts = (wire.candidates ?? []).flatMap((c) => c.content?.parts ?? [])
+  const inline = allParts.find((p) => p.inlineData !== undefined)?.inlineData
+  const textParts = allParts.flatMap((p) => (p.text !== undefined ? [p.text] : []))
+  const text = textParts.length === 0 ? undefined : textParts.join("\n")
+  return {
+    ...(inline !== undefined && { inline }),
+    ...(text !== undefined && { text }),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Service implementation
+// ---------------------------------------------------------------------------
+
+const generateImpl =
+  (cfg: Config) =>
+  (
+    request: LyriaGenerateRequest,
+  ): Effect.Effect<MusicResult, AiError.AiError, HttpClient.HttpClient> =>
+    Effect.gen(function* () {
+      const client = yield* HttpClient.HttpClient
+      const requestedContainer = (request.outputFormat?.container ??
+        "mp3") satisfies AudioFormat["container"]
+      const mimeType = yield* containerToMimeType(requestedContainer)
+      // Clip is fixed 30 s mp3 — reject wav up front rather than sending
+      // a `responseFormat` that the live API ignores or rejects.
+      if (isClipModel(request.model) && mimeType === "audio/wav") {
+        return yield* Effect.fail(
+          new AiError.Unsupported({
+            provider: "lyria",
+            capability: "outputFormat",
+            reason: `lyria-3-clip-preview is fixed at audio/mp3. Use lyria-3-pro-preview for audio/wav output.`,
+          }),
+        )
+      }
+      const promptText = buildPrompt(request)
+      const body = isClipModel(request.model)
+        ? { contents: [{ parts: [{ text: promptText }] }] }
+        : {
+            contents: [{ parts: [{ text: promptText }] }],
+            generationConfig: {
+              responseModalities: ["AUDIO", "TEXT"],
+              responseFormat: { audio: { mimeType } },
+            },
+          }
+      const httpRequest = HttpClientRequest.post(
+        `${baseUrl(cfg)}/models/${request.model}:generateContent`,
+      ).pipe(
+        HttpClientRequest.setHeader("x-goog-api-key", Redacted.value(cfg.apiKey)),
+        HttpClientRequest.bodyJsonUnsafe(body),
+      )
+      const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
+      if (response.status >= 400) {
+        const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+        return yield* Effect.fail(httpStatusError(response.status, text))
+      }
+      const json = yield* response.json.pipe(Effect.mapError(transportFailure))
+      const wire = yield* decodeWire(json).pipe(
+        Effect.mapError(
+          (cause): AiError.AiError =>
+            new AiError.GenerationFailed({ provider: "lyria", raw: cause }),
+        ),
+      )
+      const { inline, text } = extractParts(wire)
+      if (inline === undefined) {
+        // No audio came back. Most common cause: Lyria filtered the prompt
+        // (named-artist references, copyrighted lyrics, etc.). Surface the
+        // full response body — text parts, finish reasons, prompt-feedback
+        // blocks — so the caller can see why.
+        return yield* Effect.fail(
+          new AiError.GenerationFailed({
+            provider: "lyria",
+            raw: {
+              message: "Lyria response had no inlineData audio part.",
+              hint: "Likely a prompt-filter rejection. Lyria filters references to real artists / copyrighted song lyrics. Rephrase with descriptive style language instead of artist names.",
+              textParts: text,
+              response: json,
+            },
+          }),
+        )
+      }
+      const bytes = yield* decodeBase64ToBytes(inline.data)
+      return {
+        format: realizedFormat(mimeType),
+        bytes,
+        ...(text !== undefined && { lyrics: text }),
+        watermark: { kind: "synthid" },
+      } satisfies MusicResult
+    })
+
+const streamGenerationImpl =
+  (cfg: Config) =>
+  (
+    request: LyriaGenerateRequest,
+  ): Stream.Stream<AudioChunk, AiError.AiError, HttpClient.HttpClient> =>
+    Stream.unwrap(
+      Effect.map(generateImpl(cfg)(request), (result) =>
+        Stream.succeed<AudioChunk>({ bytes: result.bytes }),
+      ),
+    )
+
+/**
+ * Lyria 3 sync has no bidirectional session at the wire level — that's
+ * Lyria RealTime (Phase 1b, separate Layer). The provider Layer here
+ * also does NOT register `MusicInteractiveSession`, so callers using
+ * `MusicGenerator.streamGenerationFrom` against only this Layer get a
+ * compile-time error before this runtime fallback ever fires.
+ */
+const streamGenerationFromUnsupported = <E, R>(
+  _input: Stream.Stream<MusicSessionInput, E, R>,
+  _request: CommonStreamGenerateMusicRequest,
+): Stream.Stream<AudioChunk, AiError.AiError | E, R> => {
+  const fail: Stream.Stream<AudioChunk, AiError.AiError | E, R> = Stream.fail(
+    new AiError.Unsupported({
+      provider: "lyria",
+      capability: "streamGenerationFrom",
+      reason:
+        "Lyria 3 sync does not support bidirectional sessions. Use the Lyria RealTime Layer (WebSocket BidiGenerateMusic) for interactive mid-session prompts.",
+    }),
+  )
+  return fail
+}
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+export const make = (
+  cfg: Config,
+): Effect.Effect<LyriaGeneratorService, never, HttpClient.HttpClient> =>
+  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+    generate: (request) =>
+      generateImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+    streamGeneration: (request) =>
+      streamGenerationImpl(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client)),
+    streamGenerationFrom: streamGenerationFromUnsupported,
+  }))
+
+/**
+ * Layer that registers both the provider-specific `LyriaGenerator` tag
+ * and the generic `MusicGenerator` tag.
+ *
+ * Does NOT register the `MusicInteractiveSession` capability marker —
+ * Lyria 3 sync has no bidirectional session at the wire level. Code
+ * calling `MusicGenerator.streamGenerationFrom` will fail to typecheck
+ * against this Layer alone, which is the intended UX.
+ */
+export const layer = (
+  cfg: Config,
+): Layer.Layer<LyriaGenerator | MusicGenerator, never, HttpClient.HttpClient> =>
+  Layer.merge(
+    Layer.effect(LyriaGenerator, make(cfg)),
+    Layer.effect(
+      MusicGenerator,
+      Effect.map(
+        make(cfg),
+        (s): MusicGeneratorService => ({
+          generate: (req: CommonGenerateMusicRequest) => s.generate(req as LyriaGenerateRequest),
+          streamGeneration: (req: CommonStreamGenerateMusicRequest) =>
+            s.streamGeneration(req as LyriaGenerateRequest),
+          streamGenerationFrom: s.streamGenerationFrom,
+        }),
+      ),
+    ),
+  )

package/src/geminiSpeechCodec.test.ts

@@ -0,0 +1,56 @@
+import { Effect, Encoding } from "effect"
+import { describe, expect, it } from "vitest"
+import type { AudioSource } from "@effect-uai/core/Audio"
+import { audioSourceToInlineData, wrapPcmAsWav } from "./geminiSpeechCodec.js"
+
+describe("audioSourceToInlineData", () => {
+  it("encodes a `bytes` source to base64 with its MIME type", async () => {
+    const original = new Uint8Array([0xde, 0xad, 0xbe, 0xef])
+    const source: AudioSource = { _tag: "bytes", bytes: original, mimeType: "audio/wav" }
+    const inline = await Effect.runPromise(audioSourceToInlineData(source))
+    expect(inline.mimeType).toBe("audio/wav")
+    expect(inline.data).toBe(Encoding.encodeBase64(original))
+  })
+
+  it("passes a `base64` source through unchanged", async () => {
+    const b64 = Encoding.encodeBase64(new Uint8Array([1, 2, 3]))
+    const source: AudioSource = { _tag: "base64", base64: b64, mimeType: "audio/mp3" }
+    const inline = await Effect.runPromise(audioSourceToInlineData(source))
+    expect(inline.mimeType).toBe("audio/mp3")
+    expect(inline.data).toBe(b64)
+  })
+
+  it("fails InvalidRequest for a URL source", async () => {
+    const source: AudioSource = { _tag: "url", url: "https://x/y.mp3", mimeType: "audio/mp3" }
+    const exit = await Effect.runPromiseExit(audioSourceToInlineData(source))
+    expect(exit._tag).toBe("Failure")
+    if (exit._tag === "Failure") {
+      expect(JSON.stringify(exit.cause)).toContain("InvalidRequest")
+      expect(JSON.stringify(exit.cause)).toContain("Files API")
+    }
+  })
+})
+
+describe("wrapPcmAsWav", () => {
+  it("produces a 44-byte RIFF/WAVE header for 16-bit mono PCM at 24 kHz", () => {
+    const pcm = new Uint8Array([0x00, 0x01, 0x00, 0x02])
+    const wav = wrapPcmAsWav(pcm, 24000, 1, 16)
+    expect(wav.length).toBe(44 + pcm.length)
+    const ascii = (start: number, len: number) =>
+      String.fromCharCode(...Array.from(wav.slice(start, start + len)))
+    expect(ascii(0, 4)).toBe("RIFF")
+    expect(ascii(8, 4)).toBe("WAVE")
+    expect(ascii(12, 4)).toBe("fmt ")
+    expect(ascii(36, 4)).toBe("data")
+    // RIFF chunk size = total - 8
+    const view = new DataView(wav.buffer)
+    expect(view.getUint32(4, true)).toBe(wav.length - 8)
+    expect(view.getUint16(20, true)).toBe(1) // PCM
+    expect(view.getUint16(22, true)).toBe(1) // mono
+    expect(view.getUint32(24, true)).toBe(24000) // sample rate
+    expect(view.getUint16(34, true)).toBe(16) // bits per sample
+    expect(view.getUint32(40, true)).toBe(pcm.length) // data size
+    // Payload preserved
+    expect(Array.from(wav.slice(44))).toEqual(Array.from(pcm))
+  })
+})

package/src/geminiSpeechCodec.ts

@@ -0,0 +1,137 @@
+import { Effect, Encoding, Match, Result } from "effect"
+import * as AiError from "@effect-uai/core/AiError"
+import type { AudioSource } from "@effect-uai/core/Audio"
+
+/**
+ * Shared codec helpers for Gemini speech endpoints. The TTS and STT
+ * variants both ride on `:generateContent`, so the audio-in / audio-out
+ * shapes are siblings.
+ */
+
+const urlNotSupported: AiError.AiError = new AiError.InvalidRequest({
+  provider: "gemini",
+  param: "audio",
+  raw: 'Gemini inline audio does not accept URL sources. Either fetch the URL yourself and pass `{ _tag: "bytes", bytes, mimeType }`, or upload via the Files API and pass a `fileData` URI (not yet wired here).',
+})
+
+/** Wire shape for an inline-audio part on `generateContent`. */
+export type InlineAudioData = {
+  readonly mimeType: string
+  readonly data: string
+}
+
+/**
+ * Encode any `AudioSource` into the `inlineData` shape expected by
+ * Gemini's `generateContent`. URL variants are rejected with
+ * `InvalidRequest` — Files API upload is a separate flow.
+ *
+ * Caller is responsible for keeping the total request body under
+ * 20 MB. Beyond that, Gemini's Files API is the only path.
+ */
+export const audioSourceToInlineData: (
+  audio: AudioSource,
+) => Effect.Effect<InlineAudioData, AiError.AiError> = Match.type<AudioSource>().pipe(
+  Match.tag("bytes", (a) =>
+    Effect.succeed<InlineAudioData>({
+      mimeType: a.mimeType,
+      data: Encoding.encodeBase64(a.bytes),
+    }),
+  ),
+  Match.tag("base64", (a) =>
+    Effect.succeed<InlineAudioData>({ mimeType: a.mimeType, data: a.base64 }),
+  ),
+  Match.tag("url", () => Effect.fail(urlNotSupported)),
+  Match.exhaustive,
+)
+
+/** Decode a base64-encoded audio payload into bytes. */
+export const decodeBase64Audio = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>
+  Result.match(Encoding.decodeBase64(b64), {
+    onSuccess: Effect.succeed,
+    onFailure: (cause) =>
+      Effect.fail(new AiError.InvalidRequest({ provider: "gemini", param: "audio", raw: cause })),
+  })
+
+/**
+ * Wrap a raw 16-bit signed little-endian PCM buffer in a standard 44-byte
+ * RIFF/WAVE header. Gemini TTS returns PCM-only — for playback or for
+ * round-tripping into Gemini transcription (which accepts wav, not raw
+ * PCM), the bytes need a container.
+ */
+export const wrapPcmAsWav = (
+  pcm: Uint8Array,
+  sampleRate: number,
+  channels: number,
+  bitsPerSample = 16,
+): Uint8Array => {
+  const dataSize = pcm.length
+  const blockAlign = (channels * bitsPerSample) / 8
+  const byteRate = sampleRate * blockAlign
+  const totalSize = 44 + dataSize
+  const buffer = new ArrayBuffer(totalSize)
+  const view = new DataView(buffer)
+  const writeAscii = (offset: number, s: string): void => {
+    for (let i = 0; i < s.length; i++) view.setUint8(offset + i, s.charCodeAt(i))
+  }
+  writeAscii(0, "RIFF")
+  view.setUint32(4, totalSize - 8, true)
+  writeAscii(8, "WAVE")
+  writeAscii(12, "fmt ")
+  view.setUint32(16, 16, true)
+  view.setUint16(20, 1, true)
+  view.setUint16(22, channels, true)
+  view.setUint32(24, sampleRate, true)
+  view.setUint32(28, byteRate, true)
+  view.setUint16(32, blockAlign, true)
+  view.setUint16(34, bitsPerSample, true)
+  writeAscii(36, "data")
+  view.setUint32(40, dataSize, true)
+  new Uint8Array(buffer, 44, dataSize).set(pcm)
+  return new Uint8Array(buffer)
+}
+
+/**
+ * HTTP status → typed `AiError`. Shared between synthesizer and
+ * transcriber.
+ */
+export const httpStatusError: (status: number, body: string) => AiError.AiError = (status, body) =>
+  Match.value(status).pipe(
+    Match.when(
+      429,
+      (): AiError.AiError => new AiError.RateLimited({ provider: "gemini", raw: body }),
+    ),
+    Match.whenOr(
+      408,
+      504,
+      (): AiError.AiError => new AiError.Timeout({ provider: "gemini", raw: body }),
+    ),
+    Match.when(
+      401,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "gemini", subtype: "auth", raw: body }),
+    ),
+    Match.when(
+      403,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "gemini", subtype: "permission", raw: body }),
+    ),
+    Match.when(
+      402,
+      (): AiError.AiError =>
+        new AiError.AuthFailed({ provider: "gemini", subtype: "billing", raw: body }),
+    ),
+    Match.when(
+      413,
+      (): AiError.AiError => new AiError.ContextLengthExceeded({ provider: "gemini", raw: body }),
+    ),
+    Match.when(
+      (n) => n >= 500,
+      (n): AiError.AiError => new AiError.Unavailable({ provider: "gemini", status: n, raw: body }),
+    ),
+    Match.orElse(
+      (): AiError.AiError => new AiError.InvalidRequest({ provider: "gemini", raw: body }),
+    ),
+  )
+
+export const transportFailure = (cause: unknown): AiError.AiError =>
+  new AiError.Unavailable({ provider: "gemini", raw: cause })

package/src/index.ts

@@ -1,4 +1,7 @@
 export * as Gemini from "./Gemini.js"
 export * as GeminiEmbedding from "./GeminiEmbedding.js"
+export * as GeminiSynthesizer from "./GeminiSynthesizer.js"
+export * as GeminiTranscriber from "./GeminiTranscriber.js"
+export * as LyriaGenerator from "./LyriaGenerator.js"
 export * as codec from "./codec.js"
 export * from "./models.js"

package/src/models.ts

@@ -31,6 +31,90 @@ export type GoogleModel =
  *
  * Reference: https://ai.google.dev/gemini-api/docs/embeddings
  */
+/**
+ * Known Gemini TTS model identifiers. `(string & {})` tail keeps
+ * autocomplete on the literals while still accepting any string.
+ *
+ * Reference: https://ai.google.dev/gemini-api/docs/speech-generation
+ */
+export type GeminiTtsModel =
+  | "gemini-2.5-flash-preview-tts"
+  | "gemini-2.5-pro-preview-tts"
+  | "gemini-3.1-flash-tts-preview"
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (string & {})
+
+/**
+ * Known Gemini models that accept audio input via `inlineData` /
+ * `fileData` on `generateContent`. Used by `GeminiTranscriber` —
+ * transcription is prompt-driven on top of these models, not a
+ * dedicated endpoint.
+ *
+ * Reference: https://ai.google.dev/gemini-api/docs/audio
+ */
+export type GeminiSttModel =
+  | "gemini-3-flash-preview"
+  | "gemini-3.1-pro-preview"
+  | "gemini-3.1-flash-lite-preview"
+  | "gemini-2.5-flash"
+  | "gemini-2.5-pro"
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (string & {})
+
+/**
+ * 30 prebuilt voice names for Gemini TTS. No custom-voice / cloning path
+ * is exposed on this surface, so the tail is stock-only (no
+ * `(string & {})` escape).
+ *
+ * Reference: https://ai.google.dev/gemini-api/docs/speech-generation
+ */
+export type GeminiVoiceName =
+  | "Zephyr"
+  | "Puck"
+  | "Charon"
+  | "Kore"
+  | "Fenrir"
+  | "Leda"
+  | "Orus"
+  | "Aoede"
+  | "Callirrhoe"
+  | "Autonoe"
+  | "Enceladus"
+  | "Iapetus"
+  | "Umbriel"
+  | "Algieba"
+  | "Despina"
+  | "Erinome"
+  | "Algenib"
+  | "Rasalgethi"
+  | "Laomedeia"
+  | "Achernar"
+  | "Alnilam"
+  | "Schedar"
+  | "Gacrux"
+  | "Pulcherrima"
+  | "Achird"
+  | "Zubenelgenubi"
+  | "Vindemiatrix"
+  | "Sadachbia"
+  | "Sadaltager"
+  | "Sulafat"
+
+/**
+ * Known Lyria (music generation) model identifiers. `(string & {})` tail
+ * keeps autocomplete on the literals while still accepting any string.
+ *
+ * - `lyria-3-clip-preview` — fixed 30s output, MP3 only.
+ * - `lyria-3-pro-preview` — up to a couple of minutes, MP3 or WAV.
+ *
+ * Reference: https://ai.google.dev/gemini-api/docs/music-generation
+ */
+export type LyriaModel =
+  | "lyria-3-clip-preview"
+  | "lyria-3-pro-preview"
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (string & {})
+
 export type GoogleEmbeddingModel =
   | "gemini-embedding-2"
   | "gemini-embedding-001"