@effect-uai/google 0.2.0 → 0.4.0

package/dist/geminiSpeechCodec.d.mts

@@ -0,0 +1,37 @@
+import { Effect } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+import { AudioSource } from "@effect-uai/core/Audio";
+
+//#region src/geminiSpeechCodec.d.ts
+/** Wire shape for an inline-audio part on `generateContent`. */
+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.
+ */
+declare const audioSourceToInlineData: (audio: AudioSource) => Effect.Effect<InlineAudioData, AiError.AiError>;
+/** Decode a base64-encoded audio payload into bytes. */
+declare const decodeBase64Audio: (b64: string) => Effect.Effect<Uint8Array, AiError.AiError>;
+/**
+ * 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.
+ */
+declare const wrapPcmAsWav: (pcm: Uint8Array, sampleRate: number, channels: number, bitsPerSample?: number) => Uint8Array;
+/**
+ * HTTP status → typed `AiError`. Shared between synthesizer and
+ * transcriber.
+ */
+declare const httpStatusError: (status: number, body: string) => AiError.AiError;
+declare const transportFailure: (cause: unknown) => AiError.AiError;
+//#endregion
+export { InlineAudioData, audioSourceToInlineData, decodeBase64Audio, httpStatusError, transportFailure, wrapPcmAsWav };
+//# sourceMappingURL=geminiSpeechCodec.d.mts.map

package/dist/geminiSpeechCodec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geminiSpeechCodec.d.mts","names":[],"sources":["../src/geminiSpeechCodec.ts"],"mappings":";;;;;;KAiBY,eAAA;EAAA,SACD,QAAA;EAAA,SACA,IAAA;AAAA;;;AAWX;;;;;;cAAa,uBAAA,GACX,KAAA,EAAO,WAAA,KACJ,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,CAAQ,OAAA;;cAe/B,iBAAA,GAAqB,GAAA,aAAc,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,OAAA,CAAQ,OAAA;;;;;;;cAarE,YAAA,GACX,GAAA,EAAK,UAAA,EACL,UAAA,UACA,QAAA,UACA,aAAA,cACC,UAAA;;;AAlBH;;cAiDa,eAAA,GAAkB,MAAA,UAAgB,IAAA,aAAiB,OAAA,CAAQ,OAAA;AAAA,cAuC3D,gBAAA,GAAoB,KAAA,cAAiB,OAAA,CAAQ,OAAA"}

package/dist/geminiSpeechCodec.mjs

@@ -0,0 +1,110 @@
+import { Effect, Encoding, Match, Result } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+//#region src/geminiSpeechCodec.ts
+/**
+* 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 = 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)."
+});
+/**
+* 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.
+*/
+const audioSourceToInlineData = Match.type().pipe(Match.tag("bytes", (a) => Effect.succeed({
+	mimeType: a.mimeType,
+	data: Encoding.encodeBase64(a.bytes)
+})), Match.tag("base64", (a) => Effect.succeed({
+	mimeType: a.mimeType,
+	data: a.base64
+})), Match.tag("url", () => Effect.fail(urlNotSupported)), Match.exhaustive);
+/** Decode a base64-encoded audio payload into bytes. */
+const decodeBase64Audio = (b64) => 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.
+*/
+const wrapPcmAsWav = (pcm, sampleRate, channels, bitsPerSample = 16) => {
+	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, s) => {
+		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.
+*/
+const httpStatusError = (status, body) => Match.value(status).pipe(Match.when(429, () => new AiError.RateLimited({
+	provider: "gemini",
+	raw: body
+})), Match.whenOr(408, 504, () => new AiError.Timeout({
+	provider: "gemini",
+	raw: body
+})), Match.when(401, () => new AiError.AuthFailed({
+	provider: "gemini",
+	subtype: "auth",
+	raw: body
+})), Match.when(403, () => new AiError.AuthFailed({
+	provider: "gemini",
+	subtype: "permission",
+	raw: body
+})), Match.when(402, () => new AiError.AuthFailed({
+	provider: "gemini",
+	subtype: "billing",
+	raw: body
+})), Match.when(413, () => new AiError.ContextLengthExceeded({
+	provider: "gemini",
+	raw: body
+})), Match.when((n) => n >= 500, (n) => new AiError.Unavailable({
+	provider: "gemini",
+	status: n,
+	raw: body
+})), Match.orElse(() => new AiError.InvalidRequest({
+	provider: "gemini",
+	raw: body
+})));
+const transportFailure = (cause) => new AiError.Unavailable({
+	provider: "gemini",
+	raw: cause
+});
+//#endregion
+export { audioSourceToInlineData, decodeBase64Audio, httpStatusError, transportFailure, wrapPcmAsWav };
+
+//# sourceMappingURL=geminiSpeechCodec.mjs.map

package/dist/geminiSpeechCodec.mjs.map

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

package/dist/geminiSpeechCodec.test.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/geminiSpeechCodec.test.mjs

@@ -0,0 +1,78 @@
+import { i as it, n as globalExpect, r as describe } from "./dist-DMsg8YLb.mjs";
+import { audioSourceToInlineData, wrapPcmAsWav } from "./geminiSpeechCodec.mjs";
+import { Effect, Encoding } from "effect";
+//#region src/geminiSpeechCodec.test.ts
+describe("audioSourceToInlineData", () => {
+	it("encodes a `bytes` source to base64 with its MIME type", async () => {
+		const original = new Uint8Array([
+			222,
+			173,
+			190,
+			239
+		]);
+		const source = {
+			_tag: "bytes",
+			bytes: original,
+			mimeType: "audio/wav"
+		};
+		const inline = await Effect.runPromise(audioSourceToInlineData(source));
+		globalExpect(inline.mimeType).toBe("audio/wav");
+		globalExpect(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 = {
+			_tag: "base64",
+			base64: b64,
+			mimeType: "audio/mp3"
+		};
+		const inline = await Effect.runPromise(audioSourceToInlineData(source));
+		globalExpect(inline.mimeType).toBe("audio/mp3");
+		globalExpect(inline.data).toBe(b64);
+	});
+	it("fails InvalidRequest for a URL source", async () => {
+		const exit = await Effect.runPromiseExit(audioSourceToInlineData({
+			_tag: "url",
+			url: "https://x/y.mp3",
+			mimeType: "audio/mp3"
+		}));
+		globalExpect(exit._tag).toBe("Failure");
+		if (exit._tag === "Failure") {
+			globalExpect(JSON.stringify(exit.cause)).toContain("InvalidRequest");
+			globalExpect(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([
+			0,
+			1,
+			0,
+			2
+		]);
+		const wav = wrapPcmAsWav(pcm, 24e3, 1, 16);
+		globalExpect(wav.length).toBe(44 + pcm.length);
+		const ascii = (start, len) => String.fromCharCode(...Array.from(wav.slice(start, start + len)));
+		globalExpect(ascii(0, 4)).toBe("RIFF");
+		globalExpect(ascii(8, 4)).toBe("WAVE");
+		globalExpect(ascii(12, 4)).toBe("fmt ");
+		globalExpect(ascii(36, 4)).toBe("data");
+		const view = new DataView(wav.buffer);
+		globalExpect(view.getUint32(4, true)).toBe(wav.length - 8);
+		globalExpect(view.getUint16(20, true)).toBe(1);
+		globalExpect(view.getUint16(22, true)).toBe(1);
+		globalExpect(view.getUint32(24, true)).toBe(24e3);
+		globalExpect(view.getUint16(34, true)).toBe(16);
+		globalExpect(view.getUint32(40, true)).toBe(pcm.length);
+		globalExpect(Array.from(wav.slice(44))).toEqual(Array.from(pcm));
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=geminiSpeechCodec.test.mjs.map

package/dist/geminiSpeechCodec.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"geminiSpeechCodec.test.mjs","names":[],"sources":["../src/geminiSpeechCodec.test.ts"],"sourcesContent":["import { Effect, Encoding } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport type { AudioSource } from \"@effect-uai/core/Audio\"\nimport { audioSourceToInlineData, wrapPcmAsWav } from \"./geminiSpeechCodec.js\"\n\ndescribe(\"audioSourceToInlineData\", () => {\n  it(\"encodes a `bytes` source to base64 with its MIME type\", async () => {\n    const original = new Uint8Array([0xde, 0xad, 0xbe, 0xef])\n    const source: AudioSource = { _tag: \"bytes\", bytes: original, mimeType: \"audio/wav\" }\n    const inline = await Effect.runPromise(audioSourceToInlineData(source))\n    expect(inline.mimeType).toBe(\"audio/wav\")\n    expect(inline.data).toBe(Encoding.encodeBase64(original))\n  })\n\n  it(\"passes a `base64` source through unchanged\", async () => {\n    const b64 = Encoding.encodeBase64(new Uint8Array([1, 2, 3]))\n    const source: AudioSource = { _tag: \"base64\", base64: b64, mimeType: \"audio/mp3\" }\n    const inline = await Effect.runPromise(audioSourceToInlineData(source))\n    expect(inline.mimeType).toBe(\"audio/mp3\")\n    expect(inline.data).toBe(b64)\n  })\n\n  it(\"fails InvalidRequest for a URL source\", async () => {\n    const source: AudioSource = { _tag: \"url\", url: \"https://x/y.mp3\", mimeType: \"audio/mp3\" }\n    const exit = await Effect.runPromiseExit(audioSourceToInlineData(source))\n    expect(exit._tag).toBe(\"Failure\")\n    if (exit._tag === \"Failure\") {\n      expect(JSON.stringify(exit.cause)).toContain(\"InvalidRequest\")\n      expect(JSON.stringify(exit.cause)).toContain(\"Files API\")\n    }\n  })\n})\n\ndescribe(\"wrapPcmAsWav\", () => {\n  it(\"produces a 44-byte RIFF/WAVE header for 16-bit mono PCM at 24 kHz\", () => {\n    const pcm = new Uint8Array([0x00, 0x01, 0x00, 0x02])\n    const wav = wrapPcmAsWav(pcm, 24000, 1, 16)\n    expect(wav.length).toBe(44 + pcm.length)\n    const ascii = (start: number, len: number) =>\n      String.fromCharCode(...Array.from(wav.slice(start, start + len)))\n    expect(ascii(0, 4)).toBe(\"RIFF\")\n    expect(ascii(8, 4)).toBe(\"WAVE\")\n    expect(ascii(12, 4)).toBe(\"fmt \")\n    expect(ascii(36, 4)).toBe(\"data\")\n    // RIFF chunk size = total - 8\n    const view = new DataView(wav.buffer)\n    expect(view.getUint32(4, true)).toBe(wav.length - 8)\n    expect(view.getUint16(20, true)).toBe(1) // PCM\n    expect(view.getUint16(22, true)).toBe(1) // mono\n    expect(view.getUint32(24, true)).toBe(24000) // sample rate\n    expect(view.getUint16(34, true)).toBe(16) // bits per sample\n    expect(view.getUint32(40, true)).toBe(pcm.length) // data size\n    // Payload preserved\n    expect(Array.from(wav.slice(44))).toEqual(Array.from(pcm))\n  })\n})\n"],"mappings":";;;;AAKA,SAAS,iCAAiC;AACxC,IAAG,yDAAyD,YAAY;EACtE,MAAM,WAAW,IAAI,WAAW;GAAC;GAAM;GAAM;GAAM;GAAK,CAAC;EACzD,MAAM,SAAsB;GAAE,MAAM;GAAS,OAAO;GAAU,UAAU;GAAa;EACrF,MAAM,SAAS,MAAM,OAAO,WAAW,wBAAwB,OAAO,CAAC;AACvE,eAAO,OAAO,SAAS,CAAC,KAAK,YAAY;AACzC,eAAO,OAAO,KAAK,CAAC,KAAK,SAAS,aAAa,SAAS,CAAC;GACzD;AAEF,IAAG,8CAA8C,YAAY;EAC3D,MAAM,MAAM,SAAS,aAAa,IAAI,WAAW;GAAC;GAAG;GAAG;GAAE,CAAC,CAAC;EAC5D,MAAM,SAAsB;GAAE,MAAM;GAAU,QAAQ;GAAK,UAAU;GAAa;EAClF,MAAM,SAAS,MAAM,OAAO,WAAW,wBAAwB,OAAO,CAAC;AACvE,eAAO,OAAO,SAAS,CAAC,KAAK,YAAY;AACzC,eAAO,OAAO,KAAK,CAAC,KAAK,IAAI;GAC7B;AAEF,IAAG,yCAAyC,YAAY;EAEtD,MAAM,OAAO,MAAM,OAAO,eAAe,wBAAwB;GADnC,MAAM;GAAO,KAAK;GAAmB,UAAU;GACN,CAAC,CAAC;AACzE,eAAO,KAAK,KAAK,CAAC,KAAK,UAAU;AACjC,MAAI,KAAK,SAAS,WAAW;AAC3B,gBAAO,KAAK,UAAU,KAAK,MAAM,CAAC,CAAC,UAAU,iBAAiB;AAC9D,gBAAO,KAAK,UAAU,KAAK,MAAM,CAAC,CAAC,UAAU,YAAY;;GAE3D;EACF;AAEF,SAAS,sBAAsB;AAC7B,IAAG,2EAA2E;EAC5E,MAAM,MAAM,IAAI,WAAW;GAAC;GAAM;GAAM;GAAM;GAAK,CAAC;EACpD,MAAM,MAAM,aAAa,KAAK,MAAO,GAAG,GAAG;AAC3C,eAAO,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,OAAO;EACxC,MAAM,SAAS,OAAe,QAC5B,OAAO,aAAa,GAAG,MAAM,KAAK,IAAI,MAAM,OAAO,QAAQ,IAAI,CAAC,CAAC;AACnE,eAAO,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK,OAAO;AAChC,eAAO,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK,OAAO;AAChC,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,KAAK,OAAO;AACjC,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,KAAK,OAAO;EAEjC,MAAM,OAAO,IAAI,SAAS,IAAI,OAAO;AACrC,eAAO,KAAK,UAAU,GAAG,KAAK,CAAC,CAAC,KAAK,IAAI,SAAS,EAAE;AACpD,eAAO,KAAK,UAAU,IAAI,KAAK,CAAC,CAAC,KAAK,EAAE;AACxC,eAAO,KAAK,UAAU,IAAI,KAAK,CAAC,CAAC,KAAK,EAAE;AACxC,eAAO,KAAK,UAAU,IAAI,KAAK,CAAC,CAAC,KAAK,KAAM;AAC5C,eAAO,KAAK,UAAU,IAAI,KAAK,CAAC,CAAC,KAAK,GAAG;AACzC,eAAO,KAAK,UAAU,IAAI,KAAK,CAAC,CAAC,KAAK,IAAI,OAAO;AAEjD,eAAO,MAAM,KAAK,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC,QAAQ,MAAM,KAAK,IAAI,CAAC;GAC1D;EACF"}

package/dist/index.d.mts

@@ -1,214 +1,8 @@
-import { Context, Effect, Layer, Option, Redacted, Schema, Stream } from "effect";
-import { HttpClient } from "effect/unstable/http";
-import * as AiError from "@effect-uai/core/AiError";
-import { CommonRequest, LanguageModel } from "@effect-uai/core/LanguageModel";
-import { Turn, TurnEvent } from "@effect-uai/core/Turn";
-import { Item } from "@effect-uai/core/Items";
-
-//#region src/codec.d.ts
-declare namespace codec_d_exports {
-  export { Accumulator, ChunkPart, ChunkResult, GenerationConfig, RequestBody, ThinkingConfig, WireChunk, accumulatorToTurn, buildRequestBody, emptyAccumulator, ingestChunk };
-}
-declare const WireChunk: Schema.Struct<{
-  readonly candidates: Schema.optional<Schema.$Array<Schema.Struct<{
-    readonly content: Schema.optional<Schema.Struct<{
-      readonly role: Schema.optional<Schema.String>;
-      readonly parts: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly text: Schema.String;
-        /**
-         * Gemini's flag for chain-of-thought parts. When `true`, the part is
-         * reasoning trace, not the model's user-facing answer. Maps onto
-         * `reasoning_delta { kind: "trace" }` in the canonical view.
-         */
-        readonly thought: Schema.optional<Schema.Boolean>;
-      }>]>>>;
-    }>>;
-    readonly finishReason: Schema.optional<Schema.String>;
-    readonly index: Schema.optional<Schema.Number>;
-  }>>>;
-  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 cachedContentTokenCount: Schema.optional<Schema.Number>;
-    readonly thoughtsTokenCount: Schema.optional<Schema.Number>;
-  }>>;
-}>;
-type WireChunk = typeof WireChunk.Type;
-type RequestPart = {
-  readonly text: string;
-} | {
-  readonly inlineData: {
-    readonly mimeType: string;
-    readonly data: string;
-  };
-};
-interface RequestContent {
-  readonly role: "user" | "model";
-  readonly parts: ReadonlyArray<RequestPart>;
-}
-interface RequestSystemInstruction {
-  readonly parts: ReadonlyArray<{
-    readonly text: string;
-  }>;
-}
-interface ThinkingConfig {
-  readonly thinkingBudget: number;
-}
-interface GenerationConfig {
-  readonly temperature?: number;
-  readonly maxOutputTokens?: number;
-  readonly topP?: number;
-  readonly thinkingConfig?: ThinkingConfig;
-  /** Set together with `responseJsonSchema` to constrain output to JSON. */
-  readonly responseMimeType?: string;
-  /** JSON Schema constraint on the output. */
-  readonly responseJsonSchema?: Record<string, unknown>;
-}
-interface RequestBody {
-  readonly contents: ReadonlyArray<RequestContent>;
-  readonly systemInstruction?: RequestSystemInstruction;
-  readonly generationConfig?: GenerationConfig;
-}
-declare const buildRequestBody: (history: ReadonlyArray<Item>, generationConfig: Option.Option<GenerationConfig>) => RequestBody;
-interface Accumulator {
-  readonly text: string;
-  readonly reasoning: string;
-  readonly finishReason: Option.Option<string>;
-  readonly usage: {
-    readonly input_tokens?: number;
-    readonly output_tokens?: number;
-    readonly total_tokens?: number;
-    readonly input_tokens_details?: {
-      readonly cached_tokens?: number;
-    };
-    readonly output_tokens_details?: {
-      readonly reasoning_tokens?: number;
-    };
-  };
-}
-declare const emptyAccumulator: Accumulator;
-/**
- * One part's worth of streamable text: either the model's answer
- * (`kind: "text"`) or chain-of-thought (`kind: "reasoning"`). Emitted
- * in wire order so consumers can interleave faithfully.
- */
-type ChunkPart = {
-  readonly kind: "text";
-  readonly text: string;
-} | {
-  readonly kind: "reasoning";
-  readonly text: string;
-};
-interface ChunkResult {
-  readonly accumulator: Accumulator;
-  readonly parts: ReadonlyArray<ChunkPart>;
-  readonly finished: boolean;
-}
-declare const ingestChunk: (acc: Accumulator, chunk: WireChunk) => ChunkResult;
-declare const accumulatorToTurn: (acc: Accumulator) => Turn;
-//#endregion
-//#region src/models.d.ts
-/**
- * Known Gemini model identifiers (as of April 2026). The `(string & {})`
- * tail keeps autocomplete on the literals while still accepting any string,
- * so newly-released models work without an SDK update.
- *
- * Reference: https://ai.google.dev/gemini-api/docs/models
- */
-type GoogleModel = "gemini-3.1-pro-preview" | "gemini-3-flash-preview" | "gemini-3.1-flash-lite-preview" | "gemini-3.1-flash-live-preview" | "gemini-3.1-flash-tts-preview" | "gemini-2.5-pro" | "gemini-2.5-flash" | "gemini-2.5-flash-lite" | (string & {});
-//#endregion
-//#region src/Gemini.d.ts
-/**
- * Gemini's native event vocabulary. Aliased from `WireChunk` so the public
- * surface matches `@effect-uai/responses` and `@effect-uai/anthropic`. Each
- * `ProviderEvent` is a full `GenerateContentResponse` chunk (not a per-field
- * delta) - that's how Gemini's SSE works.
- */
-declare const ProviderEvent: Schema.Struct<{
-  readonly candidates: Schema.optional<Schema.$Array<Schema.Struct<{
-    readonly content: Schema.optional<Schema.Struct<{
-      readonly role: Schema.optional<Schema.String>;
-      readonly parts: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly text: Schema.String;
-        readonly thought: Schema.optional<Schema.Boolean>;
-      }>]>>>;
-    }>>;
-    readonly finishReason: Schema.optional<Schema.String>;
-    readonly index: Schema.optional<Schema.Number>;
-  }>>>;
-  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 cachedContentTokenCount: Schema.optional<Schema.Number>;
-    readonly thoughtsTokenCount: Schema.optional<Schema.Number>;
-  }>>;
-}>;
-type ProviderEvent = WireChunk;
-interface GeminiRequest extends Omit<CommonRequest, "model"> {
-  /**
-   * Narrows `CommonRequest.model` (`string`) to the typed `GoogleModel`
-   * literal union for autocomplete.
-   */
-  readonly model: GoogleModel;
-  /**
-   * Gemini 2.5 thinking budget. `0` disables thinking entirely (lowest
-   * latency); higher values let the model think longer. Forwarded as
-   * `generationConfig.thinkingConfig.thinkingBudget`.
-   */
-  readonly thinkingBudget?: number;
-}
-interface GeminiService {
-  /**
-   * Stream the provider's native event vocabulary (post-SSE-decode). For
-   * Gemini, each event is a full `GenerateContentResponse` chunk. Use this
-   * when you need access to fields the canonical view doesn't surface
-   * (`thoughtSignature`, granular `safetyRatings`, etc.). For
-   * provider-portable code, use `streamTurn`.
-   */
-  readonly streamNative: (request: GeminiRequest) => Stream.Stream<ProviderEvent, AiError.AiError>;
-  /**
-   * Stream canonical `TurnEvent`s. Implemented as
-   * `streamNative |> toCanonical`.
-   */
-  readonly streamTurn: (request: GeminiRequest) => Stream.Stream<TurnEvent, AiError.AiError>;
-  /**
-   * Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.
-   * Threads a fresh `Accumulator` so chunk-level text/usage merging happens
-   * per stream.
-   */
-  readonly toCanonical: <E, R>(s: Stream.Stream<ProviderEvent, E, R>) => Stream.Stream<TurnEvent, E, R>;
-}
-declare const Gemini_base: Context.ServiceClass<Gemini, "@betalyra/effect-uai/providers/google/Gemini", GeminiService>;
-/**
- * Provider-typed service tag. Yield this when you want Gemini-specific
- * options (`thinkingBudget`); yield the generic `LanguageModel` tag for
- * provider-portable code. Both are registered by `layer`.
- */
-declare class Gemini extends Gemini_base {}
-interface Config {
-  readonly apiKey: Redacted.Redacted;
-  readonly baseUrl?: string;
-}
-/**
- * Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.
- * Threads a fresh `Accumulator` so chunk-level text/usage merging works
- * across the run.
- */
-declare const toCanonical: <E, R>(s: Stream.Stream<ProviderEvent, E, R>) => Stream.Stream<TurnEvent, E, R>;
-/**
- * Build a `GeminiService` value. For Layer-based setup, prefer `layer`.
- */
-declare const make: (cfg: Config) => Effect.Effect<GeminiService, never, HttpClient.HttpClient>;
-/**
- * Layer that registers both the provider-specific `Gemini` tag and the
- * generic `LanguageModel` tag, sharing one underlying implementation.
- *
- * The generic tag accepts `CommonRequest`; the typed tag accepts the full
- * `GeminiRequest` surface.
- */
-declare const layer: (cfg: Config) => Layer.Layer<Gemini | LanguageModel, never, HttpClient.HttpClient>;
-//#endregion
-export { Config, Gemini, GeminiRequest, GeminiService, GoogleModel, ProviderEvent, codec_d_exports as codec, layer, make, toCanonical };
-//# sourceMappingURL=index.d.mts.map
+import { t as codec_d_exports } from "./codec.mjs";
+import { GeminiSttModel, GeminiTtsModel, GeminiVoiceName, GoogleEmbeddingModel, GoogleModel, LyriaModel } from "./models.mjs";
+import { t as Gemini_d_exports } from "./Gemini.mjs";
+import { t as GeminiEmbedding_d_exports } from "./GeminiEmbedding.mjs";
+import { t as GeminiSynthesizer_d_exports } from "./GeminiSynthesizer.mjs";
+import { t as GeminiTranscriber_d_exports } from "./GeminiTranscriber.mjs";
+import { t as LyriaGenerator_d_exports } from "./LyriaGenerator.mjs";
+export { Gemini_d_exports as Gemini, GeminiEmbedding_d_exports as GeminiEmbedding, GeminiSttModel, GeminiSynthesizer_d_exports as GeminiSynthesizer, GeminiTranscriber_d_exports as GeminiTranscriber, GeminiTtsModel, GeminiVoiceName, GoogleEmbeddingModel, GoogleModel, LyriaGenerator_d_exports as LyriaGenerator, LyriaModel, codec_d_exports as codec };