@effect-uai/google 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,289 +1,5 @@
-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
+import { t as codec_exports } from "./codec.mjs";
+import { t as Gemini_exports } from "./Gemini.mjs";
+import { t as GeminiEmbedding_exports } from "./GeminiEmbedding.mjs";
+import "./models.mjs";
+export { Gemini_exports as Gemini, GeminiEmbedding_exports as GeminiEmbedding, codec_exports as codec };

package/dist/models.d.mts

@@ -0,0 +1,27 @@
+//#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 & {});
+/**
+ * Known Gemini embedding model identifiers.
+ *
+ * - `gemini-embedding-2` — natively multimodal (text, image, audio, video,
+ *   PDF). Does *not* honour the `taskType` field; instead prepend a task
+ *   instruction to the text yourself.
+ * - `gemini-embedding-001` — text-only, supports the full `taskType` enum
+ *   (`RETRIEVAL_QUERY` / `RETRIEVAL_DOCUMENT` / classification / etc.).
+ *
+ * The `(string & {})` tail accepts any string so newly-released models
+ * work without an SDK update.
+ *
+ * Reference: https://ai.google.dev/gemini-api/docs/embeddings
+ */
+type GoogleEmbeddingModel = "gemini-embedding-2" | "gemini-embedding-001" | (string & {});
+//#endregion
+export { GoogleEmbeddingModel, GoogleModel };
+//# sourceMappingURL=models.d.mts.map

package/dist/models.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;AAOA;;;;;AA0BA;KA1BY,WAAA;;;;;;;;;;;;;;;KA0BA,oBAAA"}

package/dist/models.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/google",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Google Gemini provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -20,6 +20,12 @@
     "url": "https://github.com/betalyra/effect-uai",
     "directory": "packages/providers/google"
   },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
   "type": "module",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
@@ -27,25 +33,27 @@
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
+    },
+    "./Gemini": {
+      "types": "./dist/Gemini.d.mts",
+      "import": "./dist/Gemini.mjs"
+    },
+    "./GeminiEmbedding": {
+      "types": "./dist/GeminiEmbedding.d.mts",
+      "import": "./dist/GeminiEmbedding.mjs"
     }
   },
-  "files": [
-    "dist",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
   "publishConfig": {
     "access": "public"
   },
-  "peerDependencies": {
-    "effect": "4.0.0-beta.57",
-    "@effect-uai/core": "^0.2.0"
-  },
   "devDependencies": {
     "effect": "4.0.0-beta.57",
     "typescript": "^6.0.3",
-    "@effect-uai/core": "0.2.0"
+    "@effect-uai/core": "0.3.0"
+  },
+  "peerDependencies": {
+    "@effect-uai/core": ">=0.2.0 <1",
+    "effect": "4.0.0-beta.57"
   },
   "scripts": {
     "build": "tsdown",

package/src/Gemini.ts

@@ -32,7 +32,7 @@ export type ProviderEvent = WireChunk
 // Public types
 // ---------------------------------------------------------------------------
 
-export interface GeminiRequest extends Omit<CommonRequest, "model"> {
+export type GeminiRequest = Omit<CommonRequest, "model"> & {
   /**
    * Narrows `CommonRequest.model` (`string`) to the typed `GoogleModel`
    * literal union for autocomplete.
@@ -46,7 +46,7 @@ export interface GeminiRequest extends Omit<CommonRequest, "model"> {
   readonly thinkingBudget?: number
 }
 
-export interface GeminiService {
+export type GeminiService = {
   /**
    * Stream the provider's native event vocabulary (post-SSE-decode). For
    * Gemini, each event is a full `GenerateContentResponse` chunk. Use this
@@ -79,7 +79,7 @@ export class Gemini extends Context.Service<Gemini, GeminiService>()(
   "@betalyra/effect-uai/providers/google/Gemini",
 ) {}
 
-export interface Config {
+export type Config = {
   readonly apiKey: Redacted.Redacted
   readonly baseUrl?: string
 }