@effect-uai/google 0.2.0 → 0.4.0

package/dist/index.mjs

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