@effect-uai/google 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Betalyra Sociedade Unipessoal Lda.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,42 @@
+# @effect-uai/google
+
+Google Gemini provider for [`@effect-uai/core`](https://www.npmjs.com/package/@effect-uai/core).
+
+Implements the `LanguageModel` contract against Google's Gemini API
+with SSE streaming.
+
+## Install
+
+```sh
+pnpm add @effect-uai/google @effect-uai/core effect
+```
+
+ESM-only. Requires `effect@4.x` and `@effect-uai/core` as peers.
+
+## Usage
+
+```ts
+import { Config, Effect, Layer } from "effect"
+import { FetchHttpClient } from "effect/unstable/http"
+import { layer as googleLayer } from "@effect-uai/google"
+
+const provider = Layer.unwrap(
+  Effect.gen(function* () {
+    const apiKey = yield* Config.redacted("GOOGLE_API_KEY")
+    return googleLayer({ apiKey })
+  }),
+)
+
+const layer = Layer.provide(provider, FetchHttpClient.layer)
+```
+
+The layer registers both the provider-typed `Gemini` tag and the
+generic `LanguageModel` tag.
+
+## Docs
+
+<https://effect-uai.betalyra.com/providers/gemini/>
+
+## License
+
+MIT

package/dist/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/index.d.mts

@@ -0,0 +1,214 @@
+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

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/codec.ts","../src/models.ts","../src/Gemini.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,289 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { Array, Context, Effect, Layer, Match, Option, Redacted, Result, Schema, Stream, pipe } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import * as AiError from "@effect-uai/core/AiError";
+import { LanguageModel } from "@effect-uai/core/LanguageModel";
+import { JsonParseError } from "@effect-uai/core/JSONL";
+import * as SSE from "@effect-uai/core/SSE";
+import { matchType } from "@effect-uai/core/Match";
+//#region src/codec.ts
+var codec_exports = /* @__PURE__ */ __exportAll({
+	WireChunk: () => WireChunk,
+	accumulatorToTurn: () => accumulatorToTurn,
+	buildRequestBody: () => buildRequestBody,
+	emptyAccumulator: () => emptyAccumulator,
+	ingestChunk: () => ingestChunk
+});
+const TextPart = Schema.Struct({
+	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.
+	*/
+	thought: Schema.optional(Schema.Boolean)
+});
+const Part = Schema.Union([TextPart]);
+const Content = Schema.Struct({
+	role: Schema.optional(Schema.String),
+	parts: Schema.optional(Schema.Array(Part))
+});
+const Candidate = Schema.Struct({
+	content: Schema.optional(Content),
+	finishReason: Schema.optional(Schema.String),
+	index: Schema.optional(Schema.Number)
+});
+const UsageMetadata = Schema.Struct({
+	promptTokenCount: Schema.optional(Schema.Number),
+	candidatesTokenCount: Schema.optional(Schema.Number),
+	totalTokenCount: Schema.optional(Schema.Number),
+	cachedContentTokenCount: Schema.optional(Schema.Number),
+	thoughtsTokenCount: Schema.optional(Schema.Number)
+});
+const WireChunk = Schema.Struct({
+	candidates: Schema.optional(Schema.Array(Candidate)),
+	usageMetadata: Schema.optional(UsageMetadata)
+});
+const blockText = Match.type().pipe(matchType("input_text", (b) => b.text), matchType("input_image", () => ""), matchType("output_text", (b) => b.text), matchType("refusal", (b) => b.text), Match.exhaustive);
+const messageText = (message) => message.content.map(blockText).join("");
+const blockToParts = Match.type().pipe(matchType("input_text", (b) => b.text.length === 0 ? [] : [{ text: b.text }]), matchType("input_image", (b) => b.source._tag === "base64" ? [{ inlineData: {
+	mimeType: b.source.media_type,
+	data: b.source.data
+} }] : []), matchType("output_text", (b) => b.text.length === 0 ? [] : [{ text: b.text }]), matchType("refusal", () => []), Match.exhaustive);
+const messageToContent = (message) => {
+	const parts = pipe(message.content, Array.flatMap(blockToParts));
+	if (parts.length === 0) return Result.failVoid;
+	return Match.value(message.role).pipe(Match.when("user", () => Result.succeed({
+		role: "user",
+		parts
+	})), Match.when("assistant", () => Result.succeed({
+		role: "model",
+		parts
+	})), Match.when("system", () => Result.failVoid), Match.exhaustive);
+};
+const systemMessageText = (message) => {
+	if (message.role !== "system") return Result.failVoid;
+	const text = messageText(message);
+	return text.length === 0 ? Result.failVoid : Result.succeed(text);
+};
+const messages = (history) => pipe(history, Array.filterMap((item) => item.type === "message" ? Result.succeed(item) : Result.failVoid));
+const buildRequestBody = (history, generationConfig) => {
+	const msgs = messages(history);
+	const systemTexts = pipe(msgs, Array.filterMap(systemMessageText));
+	return {
+		contents: pipe(msgs, Array.filterMap(messageToContent)),
+		...systemTexts.length > 0 && { systemInstruction: { parts: [{ text: systemTexts.join("\n") }] } },
+		...Option.match(generationConfig, {
+			onNone: () => ({}),
+			onSome: (cfg) => ({ generationConfig: cfg })
+		})
+	};
+};
+const finishReasonToStop = (reason) => Option.match(reason, {
+	onNone: () => "stop",
+	onSome: (r) => r === "MAX_TOKENS" ? "max_tokens" : "stop"
+});
+const emptyAccumulator = {
+	text: "",
+	reasoning: "",
+	finishReason: Option.none(),
+	usage: {}
+};
+const chunkParts = (chunk) => pipe(chunk.candidates?.[0]?.content?.parts ?? [], Array.filterMap((p) => p.text.length === 0 ? Result.failVoid : Result.succeed({
+	kind: p.thought === true ? "reasoning" : "text",
+	text: p.text
+})));
+const sumByKind = (parts, kind) => pipe(parts, Array.filterMap((p) => p.kind === kind ? Result.succeed(p.text) : Result.failVoid)).join("");
+const mergeUsage = (prev, next) => next === void 0 ? prev : {
+	...prev,
+	...next.promptTokenCount !== void 0 && { input_tokens: next.promptTokenCount },
+	...next.candidatesTokenCount !== void 0 && { output_tokens: next.candidatesTokenCount },
+	...next.totalTokenCount !== void 0 && { total_tokens: next.totalTokenCount },
+	...next.cachedContentTokenCount !== void 0 && { input_tokens_details: { cached_tokens: next.cachedContentTokenCount } },
+	...next.thoughtsTokenCount !== void 0 && { output_tokens_details: { reasoning_tokens: next.thoughtsTokenCount } }
+};
+const ingestChunk = (acc, chunk) => {
+	const parts = chunkParts(chunk);
+	const finishReason = Option.fromNullishOr(chunk.candidates?.[0]?.finishReason);
+	return {
+		parts,
+		finished: Option.isSome(finishReason),
+		accumulator: {
+			text: acc.text + sumByKind(parts, "text"),
+			reasoning: acc.reasoning + sumByKind(parts, "reasoning"),
+			finishReason: Option.orElse(finishReason, () => acc.finishReason),
+			usage: mergeUsage(acc.usage, chunk.usageMetadata)
+		}
+	};
+};
+const accumulatorToTurn = (acc) => ({
+	stop_reason: finishReasonToStop(acc.finishReason),
+	usage: { ...acc.usage },
+	items: [...acc.reasoning.length > 0 ? [{
+		type: "reasoning",
+		summary: acc.reasoning
+	}] : [], ...acc.text.length === 0 ? [] : [{
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "output_text",
+			text: acc.text
+		}]
+	}]]
+});
+//#endregion
+//#region src/Gemini.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.
+*/
+const ProviderEvent = WireChunk;
+/**
+* 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`.
+*/
+var Gemini = class extends Context.Service()("@betalyra/effect-uai/providers/google/Gemini") {};
+const buildGenerationConfig = (request) => {
+	const cfg = {
+		...request.temperature !== void 0 && { temperature: request.temperature },
+		...request.maxOutputTokens !== void 0 && { maxOutputTokens: request.maxOutputTokens },
+		...request.topP !== void 0 && { topP: request.topP },
+		...request.thinkingBudget !== void 0 && { thinkingConfig: { thinkingBudget: request.thinkingBudget } },
+		...request.structured !== void 0 && {
+			responseMimeType: "application/json",
+			responseJsonSchema: request.structured.schema["~standard"].jsonSchema.input({ target: "draft-2020-12" })
+		}
+	};
+	return Object.keys(cfg).length === 0 ? Option.none() : Option.some(cfg);
+};
+const decodeChunk = Schema.decodeUnknownEffect(WireChunk);
+/**
+* Parse one SSE event's `data` payload into a `WireChunk`. Unlike the other
+* providers, Gemini's wire vocabulary is non-discriminated (a single
+* permissive struct, all fields optional) - there's no natural shape for
+* an `_unknown` variant, so JSON parse / schema decode failures flow
+* through as transport errors rather than being silently dropped.
+*/
+const sseEventToChunk = (ev) => Effect.try({
+	try: () => JSON.parse(ev.data),
+	catch: (cause) => new JsonParseError({
+		line: ev.data,
+		cause
+	})
+}).pipe(Effect.flatMap(decodeChunk));
+const httpStatusError = (status, body) => {
+	const provider = "gemini";
+	const raw = body;
+	if (status === 429) return new AiError.RateLimited({
+		provider,
+		raw
+	});
+	if (status === 408 || status === 504) return new AiError.Timeout({
+		provider,
+		raw
+	});
+	if (status === 401) return new AiError.AuthFailed({
+		provider,
+		subtype: "auth",
+		raw
+	});
+	if (status === 403) return new AiError.AuthFailed({
+		provider,
+		subtype: "permission",
+		raw
+	});
+	if (status === 402) return new AiError.AuthFailed({
+		provider,
+		subtype: "billing",
+		raw
+	});
+	if (status === 413) return new AiError.ContextLengthExceeded({
+		provider,
+		raw
+	});
+	if (status >= 500) return new AiError.Unavailable({
+		provider,
+		status,
+		raw
+	});
+	return new AiError.InvalidRequest({
+		provider,
+		raw
+	});
+};
+const buildNativeStream = (cfg) => {
+	const baseUrl = cfg.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
+	return (request) => Stream.unwrap(Effect.gen(function* () {
+		const client = yield* HttpClient.HttpClient;
+		const url = `${baseUrl}/models/${request.model}:streamGenerateContent?alt=sse`;
+		const generationConfig = buildGenerationConfig(request);
+		const body = buildRequestBody(request.history, generationConfig);
+		const httpRequest = HttpClientRequest.post(url).pipe(HttpClientRequest.setHeader("x-goog-api-key", Redacted.value(cfg.apiKey)), HttpClientRequest.bodyJsonUnsafe(body), HttpClientRequest.accept("text/event-stream"));
+		const response = yield* client.execute(httpRequest).pipe(Effect.mapError((cause) => new AiError.Unavailable({
+			provider: "gemini",
+			raw: cause
+		})));
+		if (response.status >= 400) {
+			const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
+			return Stream.fail(httpStatusError(response.status, text));
+		}
+		return response.stream.pipe(Stream.mapError((cause) => new AiError.Unavailable({
+			provider: "gemini",
+			raw: cause
+		})), SSE.fromBytes, Stream.mapEffect((ev) => sseEventToChunk(ev).pipe(Effect.mapError((cause) => new AiError.Unavailable({
+			provider: "gemini",
+			raw: cause
+		})))));
+	}));
+};
+/**
+* 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.
+*/
+const toCanonical = (s) => s.pipe(Stream.mapAccum(() => emptyAccumulator, (acc, chunk) => {
+	const result = ingestChunk(acc, chunk);
+	const partDeltas = result.parts.map((p) => p.kind === "text" ? {
+		type: "text_delta",
+		text: p.text
+	} : {
+		type: "reasoning_delta",
+		text: p.text,
+		kind: "trace"
+	});
+	const deltas = result.finished ? [...partDeltas, {
+		type: "turn_complete",
+		turn: accumulatorToTurn(result.accumulator)
+	}] : partDeltas;
+	return [result.accumulator, deltas];
+}));
+/**
+* Build a `GeminiService` value. For Layer-based setup, prefer `layer`.
+*/
+const make = (cfg) => Effect.map(HttpClient.HttpClient.asEffect(), (client) => {
+	const streamNative = (request) => buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client));
+	return {
+		streamNative,
+		streamTurn: (request) => toCanonical(streamNative(request)),
+		toCanonical
+	};
+});
+/**
+* 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.
+*/
+const layer = (cfg) => {
+	const typed = Layer.effect(Gemini, make(cfg));
+	const generic = Layer.effect(LanguageModel, Effect.map(make(cfg), (s) => ({ streamTurn: (request) => s.streamTurn(request) })));
+	return Layer.merge(typed, generic);
+};
+//#endregion
+export { Gemini, ProviderEvent, codec_exports as codec, layer, make, toCanonical };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["Arr"],"sources":["../src/codec.ts","../src/Gemini.ts"],"sourcesContent":["import { Array as Arr, Match, Option, Result, Schema, pipe } from \"effect\"\nimport type { ContentBlock, Item, Message } from \"@effect-uai/core/Items\"\nimport { matchType } from \"@effect-uai/core/Match\"\nimport type { Turn } from \"@effect-uai/core/Turn\"\n\n// ---------------------------------------------------------------------------\n// Wire schemas - the subset of Gemini's streamGenerateContent payload we\n// consume. Reference: https://ai.google.dev/api/generate-content\n// ---------------------------------------------------------------------------\n\nconst TextPart = Schema.Struct({\n  text: Schema.String,\n  /**\n   * Gemini's flag for chain-of-thought parts. When `true`, the part is\n   * reasoning trace, not the model's user-facing answer. Maps onto\n   * `reasoning_delta { kind: \"trace\" }` in the canonical view.\n   */\n  thought: Schema.optional(Schema.Boolean),\n})\n\nconst Part = Schema.Union([TextPart])\n\nconst Content = Schema.Struct({\n  role: Schema.optional(Schema.String),\n  parts: Schema.optional(Schema.Array(Part)),\n})\n\nconst Candidate = Schema.Struct({\n  content: Schema.optional(Content),\n  finishReason: Schema.optional(Schema.String),\n  index: Schema.optional(Schema.Number),\n})\n\nconst UsageMetadata = Schema.Struct({\n  promptTokenCount: Schema.optional(Schema.Number),\n  candidatesTokenCount: Schema.optional(Schema.Number),\n  totalTokenCount: Schema.optional(Schema.Number),\n  cachedContentTokenCount: Schema.optional(Schema.Number),\n  thoughtsTokenCount: Schema.optional(Schema.Number),\n})\n\nexport const WireChunk = Schema.Struct({\n  candidates: Schema.optional(Schema.Array(Candidate)),\n  usageMetadata: Schema.optional(UsageMetadata),\n})\nexport type WireChunk = typeof WireChunk.Type\n\n// ---------------------------------------------------------------------------\n// History → request body\n// ---------------------------------------------------------------------------\n\ntype RequestPart =\n  | { readonly text: string }\n  | { readonly inlineData: { readonly mimeType: string; readonly data: string } }\n\ninterface RequestContent {\n  readonly role: \"user\" | \"model\"\n  readonly parts: ReadonlyArray<RequestPart>\n}\n\ninterface RequestSystemInstruction {\n  readonly parts: ReadonlyArray<{ readonly text: string }>\n}\n\nexport interface ThinkingConfig {\n  readonly thinkingBudget: number\n}\n\nexport interface GenerationConfig {\n  readonly temperature?: number\n  readonly maxOutputTokens?: number\n  readonly topP?: number\n  readonly thinkingConfig?: ThinkingConfig\n  /** Set together with `responseJsonSchema` to constrain output to JSON. */\n  readonly responseMimeType?: string\n  /** JSON Schema constraint on the output. */\n  readonly responseJsonSchema?: Record<string, unknown>\n}\n\nexport interface RequestBody {\n  readonly contents: ReadonlyArray<RequestContent>\n  readonly systemInstruction?: RequestSystemInstruction\n  readonly generationConfig?: GenerationConfig\n}\n\nconst blockText = Match.type<ContentBlock>().pipe(\n  matchType(\"input_text\", (b) => b.text),\n  matchType(\"input_image\", () => \"\"),\n  matchType(\"output_text\", (b) => b.text),\n  matchType(\"refusal\", (b) => b.text),\n  Match.exhaustive,\n)\n\nconst messageText = (message: Message): string => message.content.map(blockText).join(\"\")\n\nconst blockToParts = Match.type<ContentBlock>().pipe(\n  matchType(\n    \"input_text\",\n    (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),\n  ),\n  matchType(\n    \"input_image\",\n    (b): ReadonlyArray<RequestPart> =>\n      // Gemini's `fileData` form expects a pre-uploaded Files API URI, not an\n      // arbitrary HTTPS URL - we'd need to fetch + re-upload to support that.\n      // Skip URL-form images for now; document as a follow-up.\n      b.source._tag === \"base64\"\n        ? [{ inlineData: { mimeType: b.source.media_type, data: b.source.data } }]\n        : [],\n  ),\n  matchType(\n    \"output_text\",\n    (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),\n  ),\n  // Refusals are assistant-side content; they don't round-trip into Gemini's\n  // request body as parts. Skip.\n  matchType(\"refusal\", (): ReadonlyArray<RequestPart> => []),\n  Match.exhaustive,\n)\n\nconst messageToContent = (message: Message): Result.Result<RequestContent, void> => {\n  const parts = pipe(message.content, Arr.flatMap(blockToParts))\n  if (parts.length === 0) return Result.failVoid\n  return Match.value(message.role).pipe(\n    Match.when(\"user\", () => Result.succeed({ role: \"user\" as const, parts })),\n    Match.when(\"assistant\", () => Result.succeed({ role: \"model\" as const, parts })),\n    Match.when(\"system\", () => Result.failVoid),\n    Match.exhaustive,\n  )\n}\n\nconst systemMessageText = (message: Message): Result.Result<string, void> => {\n  if (message.role !== \"system\") return Result.failVoid\n  const text = messageText(message)\n  return text.length === 0 ? Result.failVoid : Result.succeed(text)\n}\n\nconst messages = (history: ReadonlyArray<Item>): ReadonlyArray<Message> =>\n  pipe(\n    history,\n    Arr.filterMap((item) => (item.type === \"message\" ? Result.succeed(item) : Result.failVoid)),\n  )\n\nexport const buildRequestBody = (\n  history: ReadonlyArray<Item>,\n  generationConfig: Option.Option<GenerationConfig>,\n): RequestBody => {\n  const msgs = messages(history)\n  const systemTexts = pipe(msgs, Arr.filterMap(systemMessageText))\n  const contents = pipe(msgs, Arr.filterMap(messageToContent))\n  return {\n    contents,\n    ...(systemTexts.length > 0 && {\n      systemInstruction: { parts: [{ text: systemTexts.join(\"\\n\") }] },\n    }),\n    ...Option.match(generationConfig, {\n      onNone: () => ({}),\n      onSome: (cfg) => ({ generationConfig: cfg }),\n    }),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Stream-level state - accumulate chunk text + final usage/finish.\n//\n// `Accumulator` is immutable; `ingestChunk` returns a fresh one per chunk.\n// Drive it via `Stream.mapAccum` in the consumer.\n// ---------------------------------------------------------------------------\n\nconst finishReasonToStop = (reason: Option.Option<string>): Turn[\"stop_reason\"] =>\n  Option.match(reason, {\n    onNone: () => \"stop\" as const,\n    onSome: (r) => (r === \"MAX_TOKENS\" ? (\"max_tokens\" as const) : (\"stop\" as const)),\n  })\n\nexport interface Accumulator {\n  readonly text: string\n  readonly reasoning: string\n  readonly finishReason: Option.Option<string>\n  readonly usage: {\n    readonly input_tokens?: number\n    readonly output_tokens?: number\n    readonly total_tokens?: number\n    readonly input_tokens_details?: { readonly cached_tokens?: number }\n    readonly output_tokens_details?: { readonly reasoning_tokens?: number }\n  }\n}\n\nexport const emptyAccumulator: Accumulator = {\n  text: \"\",\n  reasoning: \"\",\n  finishReason: Option.none(),\n  usage: {},\n}\n\n/**\n * One part's worth of streamable text: either the model's answer\n * (`kind: \"text\"`) or chain-of-thought (`kind: \"reasoning\"`). Emitted\n * in wire order so consumers can interleave faithfully.\n */\nexport type ChunkPart =\n  | { readonly kind: \"text\"; readonly text: string }\n  | { readonly kind: \"reasoning\"; readonly text: string }\n\nexport interface ChunkResult {\n  readonly accumulator: Accumulator\n  readonly parts: ReadonlyArray<ChunkPart>\n  readonly finished: boolean\n}\n\nconst chunkParts = (chunk: WireChunk): ReadonlyArray<ChunkPart> =>\n  pipe(\n    chunk.candidates?.[0]?.content?.parts ?? [],\n    Arr.filterMap((p) =>\n      p.text.length === 0\n        ? Result.failVoid\n        : Result.succeed({\n            kind: p.thought === true ? (\"reasoning\" as const) : (\"text\" as const),\n            text: p.text,\n          }),\n    ),\n  )\n\nconst sumByKind = (parts: ReadonlyArray<ChunkPart>, kind: ChunkPart[\"kind\"]): string =>\n  pipe(\n    parts,\n    Arr.filterMap((p) => (p.kind === kind ? Result.succeed(p.text) : Result.failVoid)),\n  ).join(\"\")\n\nconst mergeUsage = (\n  prev: Accumulator[\"usage\"],\n  next: WireChunk[\"usageMetadata\"],\n): Accumulator[\"usage\"] =>\n  next === undefined\n    ? prev\n    : {\n        ...prev,\n        ...(next.promptTokenCount !== undefined && { input_tokens: next.promptTokenCount }),\n        ...(next.candidatesTokenCount !== undefined && {\n          output_tokens: next.candidatesTokenCount,\n        }),\n        ...(next.totalTokenCount !== undefined && { total_tokens: next.totalTokenCount }),\n        ...(next.cachedContentTokenCount !== undefined && {\n          input_tokens_details: { cached_tokens: next.cachedContentTokenCount },\n        }),\n        ...(next.thoughtsTokenCount !== undefined && {\n          output_tokens_details: { reasoning_tokens: next.thoughtsTokenCount },\n        }),\n      }\n\nexport const ingestChunk = (acc: Accumulator, chunk: WireChunk): ChunkResult => {\n  const parts = chunkParts(chunk)\n  const finishReason = Option.fromNullishOr(chunk.candidates?.[0]?.finishReason)\n  return {\n    parts,\n    finished: Option.isSome(finishReason),\n    accumulator: {\n      text: acc.text + sumByKind(parts, \"text\"),\n      reasoning: acc.reasoning + sumByKind(parts, \"reasoning\"),\n      finishReason: Option.orElse(finishReason, () => acc.finishReason),\n      usage: mergeUsage(acc.usage, chunk.usageMetadata),\n    },\n  }\n}\n\nexport const accumulatorToTurn = (acc: Accumulator): Turn => ({\n  stop_reason: finishReasonToStop(acc.finishReason),\n  usage: { ...acc.usage },\n  items: [\n    ...(acc.reasoning.length > 0 ? [{ type: \"reasoning\" as const, summary: acc.reasoning }] : []),\n    ...(acc.text.length === 0\n      ? []\n      : [\n          {\n            type: \"message\" as const,\n            role: \"assistant\" as const,\n            content: [{ type: \"output_text\" as const, text: acc.text }],\n          },\n        ]),\n  ],\n})\n","import { Context, Effect, Layer, Option, Redacted, Schema, Stream } from \"effect\"\nimport { HttpClient, HttpClientRequest } from \"effect/unstable/http\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport {\n  type CommonRequest,\n  LanguageModel,\n  type LanguageModelService,\n} from \"@effect-uai/core/LanguageModel\"\nimport { JsonParseError } from \"@effect-uai/core/JSONL\"\nimport * as SSE from \"@effect-uai/core/SSE\"\nimport type { TurnEvent } from \"@effect-uai/core/Turn\"\nimport {\n  type GenerationConfig,\n  WireChunk,\n  accumulatorToTurn,\n  buildRequestBody,\n  emptyAccumulator,\n  ingestChunk,\n} from \"./codec.js\"\nimport type { GoogleModel } from \"./models.js\"\n\n/**\n * Gemini's native event vocabulary. Aliased from `WireChunk` so the public\n * surface matches `@effect-uai/responses` and `@effect-uai/anthropic`. Each\n * `ProviderEvent` is a full `GenerateContentResponse` chunk (not a per-field\n * delta) - that's how Gemini's SSE works.\n */\nexport const ProviderEvent = WireChunk\nexport type ProviderEvent = WireChunk\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\nexport interface GeminiRequest extends Omit<CommonRequest, \"model\"> {\n  /**\n   * Narrows `CommonRequest.model` (`string`) to the typed `GoogleModel`\n   * literal union for autocomplete.\n   */\n  readonly model: GoogleModel\n  /**\n   * Gemini 2.5 thinking budget. `0` disables thinking entirely (lowest\n   * latency); higher values let the model think longer. Forwarded as\n   * `generationConfig.thinkingConfig.thinkingBudget`.\n   */\n  readonly thinkingBudget?: number\n}\n\nexport interface GeminiService {\n  /**\n   * Stream the provider's native event vocabulary (post-SSE-decode). For\n   * Gemini, each event is a full `GenerateContentResponse` chunk. Use this\n   * when you need access to fields the canonical view doesn't surface\n   * (`thoughtSignature`, granular `safetyRatings`, etc.). For\n   * provider-portable code, use `streamTurn`.\n   */\n  readonly streamNative: (request: GeminiRequest) => Stream.Stream<ProviderEvent, AiError.AiError>\n  /**\n   * Stream canonical `TurnEvent`s. Implemented as\n   * `streamNative |> toCanonical`.\n   */\n  readonly streamTurn: (request: GeminiRequest) => Stream.Stream<TurnEvent, AiError.AiError>\n  /**\n   * Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.\n   * Threads a fresh `Accumulator` so chunk-level text/usage merging happens\n   * per stream.\n   */\n  readonly toCanonical: <E, R>(\n    s: Stream.Stream<ProviderEvent, E, R>,\n  ) => Stream.Stream<TurnEvent, E, R>\n}\n\n/**\n * Provider-typed service tag. Yield this when you want Gemini-specific\n * options (`thinkingBudget`); yield the generic `LanguageModel` tag for\n * provider-portable code. Both are registered by `layer`.\n */\nexport class Gemini extends Context.Service<Gemini, GeminiService>()(\n  \"@betalyra/effect-uai/providers/google/Gemini\",\n) {}\n\nexport interface Config {\n  readonly apiKey: Redacted.Redacted\n  readonly baseUrl?: string\n}\n\n// ---------------------------------------------------------------------------\n// Request body\n// ---------------------------------------------------------------------------\n\nconst buildGenerationConfig = (request: GeminiRequest): Option.Option<GenerationConfig> => {\n  const cfg: GenerationConfig = {\n    ...(request.temperature !== undefined && { temperature: request.temperature }),\n    ...(request.maxOutputTokens !== undefined && { maxOutputTokens: request.maxOutputTokens }),\n    ...(request.topP !== undefined && { topP: request.topP }),\n    ...(request.thinkingBudget !== undefined && {\n      thinkingConfig: { thinkingBudget: request.thinkingBudget },\n    }),\n    ...(request.structured !== undefined && {\n      responseMimeType: \"application/json\",\n      responseJsonSchema: request.structured.schema[\"~standard\"].jsonSchema.input({\n        target: \"draft-2020-12\",\n      }),\n    }),\n  }\n  return Object.keys(cfg).length === 0 ? Option.none() : Option.some(cfg)\n}\n\n// ---------------------------------------------------------------------------\n// SSE event → wire chunk\n// ---------------------------------------------------------------------------\n\nconst decodeChunk = Schema.decodeUnknownEffect(WireChunk)\n\n/**\n * Parse one SSE event's `data` payload into a `WireChunk`. Unlike the other\n * providers, Gemini's wire vocabulary is non-discriminated (a single\n * permissive struct, all fields optional) - there's no natural shape for\n * an `_unknown` variant, so JSON parse / schema decode failures flow\n * through as transport errors rather than being silently dropped.\n */\nconst sseEventToChunk = (ev: SSE.Event) =>\n  Effect.try({\n    try: () => JSON.parse(ev.data) as unknown,\n    catch: (cause) => new JsonParseError({ line: ev.data, cause }),\n  }).pipe(Effect.flatMap(decodeChunk))\n\n// ---------------------------------------------------------------------------\n// Service implementation\n// ---------------------------------------------------------------------------\n\nconst httpStatusError = (status: number, body: string): AiError.AiError => {\n  const provider = \"gemini\"\n  const raw = body\n  if (status === 429) return new AiError.RateLimited({ provider, raw })\n  if (status === 408 || status === 504) return new AiError.Timeout({ provider, raw })\n  if (status === 401) return new AiError.AuthFailed({ provider, subtype: \"auth\", raw })\n  if (status === 403) return new AiError.AuthFailed({ provider, subtype: \"permission\", raw })\n  if (status === 402) return new AiError.AuthFailed({ provider, subtype: \"billing\", raw })\n  if (status === 413) return new AiError.ContextLengthExceeded({ provider, raw })\n  if (status >= 500) return new AiError.Unavailable({ provider, status, raw })\n  return new AiError.InvalidRequest({ provider, raw })\n}\n\nconst buildNativeStream = (cfg: Config) => {\n  const baseUrl = cfg.baseUrl ?? \"https://generativelanguage.googleapis.com/v1beta\"\n  return (\n    request: GeminiRequest,\n  ): Stream.Stream<ProviderEvent, AiError.AiError, HttpClient.HttpClient> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const client = yield* HttpClient.HttpClient\n        const url = `${baseUrl}/models/${request.model}:streamGenerateContent?alt=sse`\n        const generationConfig = buildGenerationConfig(request)\n        const body = buildRequestBody(request.history, generationConfig)\n        const httpRequest = HttpClientRequest.post(url).pipe(\n          HttpClientRequest.setHeader(\"x-goog-api-key\", Redacted.value(cfg.apiKey)),\n          HttpClientRequest.bodyJsonUnsafe(body),\n          HttpClientRequest.accept(\"text/event-stream\"),\n        )\n        const response = yield* client\n          .execute(httpRequest)\n          .pipe(\n            Effect.mapError(\n              (cause): AiError.AiError =>\n                new AiError.Unavailable({ provider: \"gemini\", raw: cause }),\n            ),\n          )\n        if (response.status >= 400) {\n          const text = yield* response.text.pipe(Effect.orElseSucceed(() => \"\"))\n          return Stream.fail(httpStatusError(response.status, text))\n        }\n\n        return response.stream.pipe(\n          Stream.mapError(\n            (cause): AiError.AiError => new AiError.Unavailable({ provider: \"gemini\", raw: cause }),\n          ),\n          SSE.fromBytes,\n          Stream.mapEffect((ev) =>\n            sseEventToChunk(ev).pipe(\n              Effect.mapError(\n                (cause): AiError.AiError =>\n                  new AiError.Unavailable({ provider: \"gemini\", raw: cause }),\n              ),\n            ),\n          ),\n        )\n      }),\n    )\n}\n\n/**\n * Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.\n * Threads a fresh `Accumulator` so chunk-level text/usage merging works\n * across the run.\n */\nexport const toCanonical = <E, R>(\n  s: Stream.Stream<ProviderEvent, E, R>,\n): Stream.Stream<TurnEvent, E, R> =>\n  s.pipe(\n    Stream.mapAccum(\n      () => emptyAccumulator,\n      (acc, chunk) => {\n        const result = ingestChunk(acc, chunk)\n        const partDeltas = result.parts.map((p) =>\n          p.kind === \"text\"\n            ? { type: \"text_delta\" as const, text: p.text }\n            : { type: \"reasoning_delta\" as const, text: p.text, kind: \"trace\" as const },\n        )\n        const deltas = result.finished\n          ? [\n              ...partDeltas,\n              {\n                type: \"turn_complete\" as const,\n                turn: accumulatorToTurn(result.accumulator),\n              },\n            ]\n          : partDeltas\n        return [result.accumulator, deltas] as const\n      },\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// Constructors\n// ---------------------------------------------------------------------------\n\n/**\n * Build a `GeminiService` value. For Layer-based setup, prefer `layer`.\n */\nexport const make = (cfg: Config): Effect.Effect<GeminiService, never, HttpClient.HttpClient> =>\n  Effect.map(HttpClient.HttpClient.asEffect(), (client) => {\n    const streamNative: GeminiService[\"streamNative\"] = (request) =>\n      buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client))\n    return {\n      streamNative,\n      streamTurn: (request) => toCanonical(streamNative(request)),\n      toCanonical,\n    }\n  })\n\n/**\n * Layer that registers both the provider-specific `Gemini` tag and the\n * generic `LanguageModel` tag, sharing one underlying implementation.\n *\n * The generic tag accepts `CommonRequest`; the typed tag accepts the full\n * `GeminiRequest` surface.\n */\nexport const layer = (\n  cfg: Config,\n): Layer.Layer<Gemini | LanguageModel, never, HttpClient.HttpClient> => {\n  const typed = Layer.effect(Gemini, make(cfg))\n  const generic = Layer.effect(\n    LanguageModel,\n    Effect.map(\n      make(cfg),\n      (s): LanguageModelService => ({\n        streamTurn: (request) => s.streamTurn(request as GeminiRequest),\n      }),\n    ),\n  )\n  return Layer.merge(typed, generic)\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@effect-uai/google",
+  "version": "0.1.0",
+  "description": "Google Gemini provider for @effect-uai/core.",
+  "keywords": [
+    "ai",
+    "effect",
+    "gemini",
+    "google",
+    "llm"
+  ],
+  "homepage": "https://github.com/betalyra/effect-uai/tree/main/packages/providers/google",
+  "bugs": {
+    "url": "https://github.com/betalyra/effect-uai/issues"
+  },
+  "license": "MIT",
+  "author": "Betalyra",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/betalyra/effect-uai",
+    "directory": "packages/providers/google"
+  },
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-beta.57",
+    "@effect-uai/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "effect": "4.0.0-beta.57",
+    "typescript": "^6.0.3",
+    "@effect-uai/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/Gemini.ts

@@ -0,0 +1,263 @@
+import { Context, Effect, Layer, Option, Redacted, Schema, Stream } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import * as AiError from "@effect-uai/core/AiError"
+import {
+  type CommonRequest,
+  LanguageModel,
+  type LanguageModelService,
+} from "@effect-uai/core/LanguageModel"
+import { JsonParseError } from "@effect-uai/core/JSONL"
+import * as SSE from "@effect-uai/core/SSE"
+import type { TurnEvent } from "@effect-uai/core/Turn"
+import {
+  type GenerationConfig,
+  WireChunk,
+  accumulatorToTurn,
+  buildRequestBody,
+  emptyAccumulator,
+  ingestChunk,
+} from "./codec.js"
+import type { GoogleModel } from "./models.js"
+
+/**
+ * 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.
+ */
+export const ProviderEvent = WireChunk
+export type ProviderEvent = WireChunk
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+export 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
+}
+
+export 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>
+}
+
+/**
+ * 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`.
+ */
+export class Gemini extends Context.Service<Gemini, GeminiService>()(
+  "@betalyra/effect-uai/providers/google/Gemini",
+) {}
+
+export interface Config {
+  readonly apiKey: Redacted.Redacted
+  readonly baseUrl?: string
+}
+
+// ---------------------------------------------------------------------------
+// Request body
+// ---------------------------------------------------------------------------
+
+const buildGenerationConfig = (request: GeminiRequest): Option.Option<GenerationConfig> => {
+  const cfg: GenerationConfig = {
+    ...(request.temperature !== undefined && { temperature: request.temperature }),
+    ...(request.maxOutputTokens !== undefined && { maxOutputTokens: request.maxOutputTokens }),
+    ...(request.topP !== undefined && { topP: request.topP }),
+    ...(request.thinkingBudget !== undefined && {
+      thinkingConfig: { thinkingBudget: request.thinkingBudget },
+    }),
+    ...(request.structured !== undefined && {
+      responseMimeType: "application/json",
+      responseJsonSchema: request.structured.schema["~standard"].jsonSchema.input({
+        target: "draft-2020-12",
+      }),
+    }),
+  }
+  return Object.keys(cfg).length === 0 ? Option.none() : Option.some(cfg)
+}
+
+// ---------------------------------------------------------------------------
+// SSE event → wire chunk
+// ---------------------------------------------------------------------------
+
+const decodeChunk = Schema.decodeUnknownEffect(WireChunk)
+
+/**
+ * Parse one SSE event's `data` payload into a `WireChunk`. Unlike the other
+ * providers, Gemini's wire vocabulary is non-discriminated (a single
+ * permissive struct, all fields optional) - there's no natural shape for
+ * an `_unknown` variant, so JSON parse / schema decode failures flow
+ * through as transport errors rather than being silently dropped.
+ */
+const sseEventToChunk = (ev: SSE.Event) =>
+  Effect.try({
+    try: () => JSON.parse(ev.data) as unknown,
+    catch: (cause) => new JsonParseError({ line: ev.data, cause }),
+  }).pipe(Effect.flatMap(decodeChunk))
+
+// ---------------------------------------------------------------------------
+// Service implementation
+// ---------------------------------------------------------------------------
+
+const httpStatusError = (status: number, body: string): AiError.AiError => {
+  const provider = "gemini"
+  const raw = body
+  if (status === 429) return new AiError.RateLimited({ provider, raw })
+  if (status === 408 || status === 504) return new AiError.Timeout({ provider, raw })
+  if (status === 401) return new AiError.AuthFailed({ provider, subtype: "auth", raw })
+  if (status === 403) return new AiError.AuthFailed({ provider, subtype: "permission", raw })
+  if (status === 402) return new AiError.AuthFailed({ provider, subtype: "billing", raw })
+  if (status === 413) return new AiError.ContextLengthExceeded({ provider, raw })
+  if (status >= 500) return new AiError.Unavailable({ provider, status, raw })
+  return new AiError.InvalidRequest({ provider, raw })
+}
+
+const buildNativeStream = (cfg: Config) => {
+  const baseUrl = cfg.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta"
+  return (
+    request: GeminiRequest,
+  ): Stream.Stream<ProviderEvent, AiError.AiError, HttpClient.HttpClient> =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const client = yield* HttpClient.HttpClient
+        const url = `${baseUrl}/models/${request.model}:streamGenerateContent?alt=sse`
+        const generationConfig = buildGenerationConfig(request)
+        const body = buildRequestBody(request.history, generationConfig)
+        const httpRequest = HttpClientRequest.post(url).pipe(
+          HttpClientRequest.setHeader("x-goog-api-key", Redacted.value(cfg.apiKey)),
+          HttpClientRequest.bodyJsonUnsafe(body),
+          HttpClientRequest.accept("text/event-stream"),
+        )
+        const response = yield* client
+          .execute(httpRequest)
+          .pipe(
+            Effect.mapError(
+              (cause): AiError.AiError =>
+                new AiError.Unavailable({ provider: "gemini", raw: cause }),
+            ),
+          )
+        if (response.status >= 400) {
+          const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+          return Stream.fail(httpStatusError(response.status, text))
+        }
+
+        return response.stream.pipe(
+          Stream.mapError(
+            (cause): AiError.AiError => new AiError.Unavailable({ provider: "gemini", raw: cause }),
+          ),
+          SSE.fromBytes,
+          Stream.mapEffect((ev) =>
+            sseEventToChunk(ev).pipe(
+              Effect.mapError(
+                (cause): AiError.AiError =>
+                  new AiError.Unavailable({ provider: "gemini", raw: cause }),
+              ),
+            ),
+          ),
+        )
+      }),
+    )
+}
+
+/**
+ * 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.
+ */
+export const toCanonical = <E, R>(
+  s: Stream.Stream<ProviderEvent, E, R>,
+): Stream.Stream<TurnEvent, E, R> =>
+  s.pipe(
+    Stream.mapAccum(
+      () => emptyAccumulator,
+      (acc, chunk) => {
+        const result = ingestChunk(acc, chunk)
+        const partDeltas = result.parts.map((p) =>
+          p.kind === "text"
+            ? { type: "text_delta" as const, text: p.text }
+            : { type: "reasoning_delta" as const, text: p.text, kind: "trace" as const },
+        )
+        const deltas = result.finished
+          ? [
+              ...partDeltas,
+              {
+                type: "turn_complete" as const,
+                turn: accumulatorToTurn(result.accumulator),
+              },
+            ]
+          : partDeltas
+        return [result.accumulator, deltas] as const
+      },
+    ),
+  )
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a `GeminiService` value. For Layer-based setup, prefer `layer`.
+ */
+export const make = (cfg: Config): Effect.Effect<GeminiService, never, HttpClient.HttpClient> =>
+  Effect.map(HttpClient.HttpClient.asEffect(), (client) => {
+    const streamNative: GeminiService["streamNative"] = (request) =>
+      buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client))
+    return {
+      streamNative,
+      streamTurn: (request) => toCanonical(streamNative(request)),
+      toCanonical,
+    }
+  })
+
+/**
+ * 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.
+ */
+export const layer = (
+  cfg: Config,
+): Layer.Layer<Gemini | LanguageModel, never, HttpClient.HttpClient> => {
+  const typed = Layer.effect(Gemini, make(cfg))
+  const generic = Layer.effect(
+    LanguageModel,
+    Effect.map(
+      make(cfg),
+      (s): LanguageModelService => ({
+        streamTurn: (request) => s.streamTurn(request as GeminiRequest),
+      }),
+    ),
+  )
+  return Layer.merge(typed, generic)
+}

package/src/codec.ts

@@ -0,0 +1,281 @@
+import { Array as Arr, Match, Option, Result, Schema, pipe } from "effect"
+import type { ContentBlock, Item, Message } from "@effect-uai/core/Items"
+import { matchType } from "@effect-uai/core/Match"
+import type { Turn } from "@effect-uai/core/Turn"
+
+// ---------------------------------------------------------------------------
+// Wire schemas - the subset of Gemini's streamGenerateContent payload we
+// consume. Reference: https://ai.google.dev/api/generate-content
+// ---------------------------------------------------------------------------
+
+const TextPart = Schema.Struct({
+  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.
+   */
+  thought: Schema.optional(Schema.Boolean),
+})
+
+const Part = Schema.Union([TextPart])
+
+const Content = Schema.Struct({
+  role: Schema.optional(Schema.String),
+  parts: Schema.optional(Schema.Array(Part)),
+})
+
+const Candidate = Schema.Struct({
+  content: Schema.optional(Content),
+  finishReason: Schema.optional(Schema.String),
+  index: Schema.optional(Schema.Number),
+})
+
+const UsageMetadata = Schema.Struct({
+  promptTokenCount: Schema.optional(Schema.Number),
+  candidatesTokenCount: Schema.optional(Schema.Number),
+  totalTokenCount: Schema.optional(Schema.Number),
+  cachedContentTokenCount: Schema.optional(Schema.Number),
+  thoughtsTokenCount: Schema.optional(Schema.Number),
+})
+
+export const WireChunk = Schema.Struct({
+  candidates: Schema.optional(Schema.Array(Candidate)),
+  usageMetadata: Schema.optional(UsageMetadata),
+})
+export type WireChunk = typeof WireChunk.Type
+
+// ---------------------------------------------------------------------------
+// History → request body
+// ---------------------------------------------------------------------------
+
+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 }>
+}
+
+export interface ThinkingConfig {
+  readonly thinkingBudget: number
+}
+
+export 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>
+}
+
+export interface RequestBody {
+  readonly contents: ReadonlyArray<RequestContent>
+  readonly systemInstruction?: RequestSystemInstruction
+  readonly generationConfig?: GenerationConfig
+}
+
+const blockText = Match.type<ContentBlock>().pipe(
+  matchType("input_text", (b) => b.text),
+  matchType("input_image", () => ""),
+  matchType("output_text", (b) => b.text),
+  matchType("refusal", (b) => b.text),
+  Match.exhaustive,
+)
+
+const messageText = (message: Message): string => message.content.map(blockText).join("")
+
+const blockToParts = Match.type<ContentBlock>().pipe(
+  matchType(
+    "input_text",
+    (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),
+  ),
+  matchType(
+    "input_image",
+    (b): ReadonlyArray<RequestPart> =>
+      // Gemini's `fileData` form expects a pre-uploaded Files API URI, not an
+      // arbitrary HTTPS URL - we'd need to fetch + re-upload to support that.
+      // Skip URL-form images for now; document as a follow-up.
+      b.source._tag === "base64"
+        ? [{ inlineData: { mimeType: b.source.media_type, data: b.source.data } }]
+        : [],
+  ),
+  matchType(
+    "output_text",
+    (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),
+  ),
+  // Refusals are assistant-side content; they don't round-trip into Gemini's
+  // request body as parts. Skip.
+  matchType("refusal", (): ReadonlyArray<RequestPart> => []),
+  Match.exhaustive,
+)
+
+const messageToContent = (message: Message): Result.Result<RequestContent, void> => {
+  const parts = pipe(message.content, Arr.flatMap(blockToParts))
+  if (parts.length === 0) return Result.failVoid
+  return Match.value(message.role).pipe(
+    Match.when("user", () => Result.succeed({ role: "user" as const, parts })),
+    Match.when("assistant", () => Result.succeed({ role: "model" as const, parts })),
+    Match.when("system", () => Result.failVoid),
+    Match.exhaustive,
+  )
+}
+
+const systemMessageText = (message: Message): Result.Result<string, void> => {
+  if (message.role !== "system") return Result.failVoid
+  const text = messageText(message)
+  return text.length === 0 ? Result.failVoid : Result.succeed(text)
+}
+
+const messages = (history: ReadonlyArray<Item>): ReadonlyArray<Message> =>
+  pipe(
+    history,
+    Arr.filterMap((item) => (item.type === "message" ? Result.succeed(item) : Result.failVoid)),
+  )
+
+export const buildRequestBody = (
+  history: ReadonlyArray<Item>,
+  generationConfig: Option.Option<GenerationConfig>,
+): RequestBody => {
+  const msgs = messages(history)
+  const systemTexts = pipe(msgs, Arr.filterMap(systemMessageText))
+  const contents = pipe(msgs, Arr.filterMap(messageToContent))
+  return {
+    contents,
+    ...(systemTexts.length > 0 && {
+      systemInstruction: { parts: [{ text: systemTexts.join("\n") }] },
+    }),
+    ...Option.match(generationConfig, {
+      onNone: () => ({}),
+      onSome: (cfg) => ({ generationConfig: cfg }),
+    }),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Stream-level state - accumulate chunk text + final usage/finish.
+//
+// `Accumulator` is immutable; `ingestChunk` returns a fresh one per chunk.
+// Drive it via `Stream.mapAccum` in the consumer.
+// ---------------------------------------------------------------------------
+
+const finishReasonToStop = (reason: Option.Option<string>): Turn["stop_reason"] =>
+  Option.match(reason, {
+    onNone: () => "stop" as const,
+    onSome: (r) => (r === "MAX_TOKENS" ? ("max_tokens" as const) : ("stop" as const)),
+  })
+
+export 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 }
+  }
+}
+
+export const emptyAccumulator: Accumulator = {
+  text: "",
+  reasoning: "",
+  finishReason: Option.none(),
+  usage: {},
+}
+
+/**
+ * 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.
+ */
+export type ChunkPart =
+  | { readonly kind: "text"; readonly text: string }
+  | { readonly kind: "reasoning"; readonly text: string }
+
+export interface ChunkResult {
+  readonly accumulator: Accumulator
+  readonly parts: ReadonlyArray<ChunkPart>
+  readonly finished: boolean
+}
+
+const chunkParts = (chunk: WireChunk): ReadonlyArray<ChunkPart> =>
+  pipe(
+    chunk.candidates?.[0]?.content?.parts ?? [],
+    Arr.filterMap((p) =>
+      p.text.length === 0
+        ? Result.failVoid
+        : Result.succeed({
+            kind: p.thought === true ? ("reasoning" as const) : ("text" as const),
+            text: p.text,
+          }),
+    ),
+  )
+
+const sumByKind = (parts: ReadonlyArray<ChunkPart>, kind: ChunkPart["kind"]): string =>
+  pipe(
+    parts,
+    Arr.filterMap((p) => (p.kind === kind ? Result.succeed(p.text) : Result.failVoid)),
+  ).join("")
+
+const mergeUsage = (
+  prev: Accumulator["usage"],
+  next: WireChunk["usageMetadata"],
+): Accumulator["usage"] =>
+  next === undefined
+    ? prev
+    : {
+        ...prev,
+        ...(next.promptTokenCount !== undefined && { input_tokens: next.promptTokenCount }),
+        ...(next.candidatesTokenCount !== undefined && {
+          output_tokens: next.candidatesTokenCount,
+        }),
+        ...(next.totalTokenCount !== undefined && { total_tokens: next.totalTokenCount }),
+        ...(next.cachedContentTokenCount !== undefined && {
+          input_tokens_details: { cached_tokens: next.cachedContentTokenCount },
+        }),
+        ...(next.thoughtsTokenCount !== undefined && {
+          output_tokens_details: { reasoning_tokens: next.thoughtsTokenCount },
+        }),
+      }
+
+export const ingestChunk = (acc: Accumulator, chunk: WireChunk): ChunkResult => {
+  const parts = chunkParts(chunk)
+  const finishReason = Option.fromNullishOr(chunk.candidates?.[0]?.finishReason)
+  return {
+    parts,
+    finished: Option.isSome(finishReason),
+    accumulator: {
+      text: acc.text + sumByKind(parts, "text"),
+      reasoning: acc.reasoning + sumByKind(parts, "reasoning"),
+      finishReason: Option.orElse(finishReason, () => acc.finishReason),
+      usage: mergeUsage(acc.usage, chunk.usageMetadata),
+    },
+  }
+}
+
+export const accumulatorToTurn = (acc: Accumulator): Turn => ({
+  stop_reason: finishReasonToStop(acc.finishReason),
+  usage: { ...acc.usage },
+  items: [
+    ...(acc.reasoning.length > 0 ? [{ type: "reasoning" as const, summary: acc.reasoning }] : []),
+    ...(acc.text.length === 0
+      ? []
+      : [
+          {
+            type: "message" as const,
+            role: "assistant" as const,
+            content: [{ type: "output_text" as const, text: acc.text }],
+          },
+        ]),
+  ],
+})

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./Gemini.js"
+export * from "./models.js"
+export * as codec from "./codec.js"

package/src/models.ts

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+export 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"
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (string & {})