@effect-uai/google 0.1.0 → 0.3.0

package/dist/codec.d.mts

@@ -0,0 +1,107 @@
+import { Option, Schema } from "effect";
+import { Turn } 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;
+  };
+};
+type RequestContent = {
+  readonly role: "user" | "model";
+  readonly parts: ReadonlyArray<RequestPart>;
+};
+type RequestSystemInstruction = {
+  readonly parts: ReadonlyArray<{
+    readonly text: string;
+  }>;
+};
+type ThinkingConfig = {
+  readonly thinkingBudget: number;
+};
+type 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>;
+};
+type RequestBody = {
+  readonly contents: ReadonlyArray<RequestContent>;
+  readonly systemInstruction?: RequestSystemInstruction;
+  readonly generationConfig?: GenerationConfig;
+};
+declare const buildRequestBody: (history: ReadonlyArray<Item>, generationConfig: Option.Option<GenerationConfig>) => RequestBody;
+type 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;
+};
+type 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
+export { Accumulator, ChunkPart, ChunkResult, GenerationConfig, RequestBody, ThinkingConfig, WireChunk, accumulatorToTurn, buildRequestBody, emptyAccumulator, ingestChunk, codec_d_exports as t };
+//# sourceMappingURL=codec.d.mts.map

package/dist/codec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.mts","names":[],"sources":["../src/codec.ts"],"mappings":";;;;;;;;cAwCa,SAAA,EAAS,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;KAIV,SAAA,UAAmB,SAAA,CAAU,IAAA;AAAA,KAMpC,WAAA;EAAA,SACU,IAAA;AAAA;EAAA,SACA,UAAA;IAAA,SAAuB,QAAA;IAAA,SAA2B,IAAA;EAAA;AAAA;AAAA,KAE5D,cAAA;EAAA,SACM,IAAA;EAAA,SACA,KAAA,EAAO,aAAA,CAAc,WAAA;AAAA;AAAA,KAG3B,wBAAA;EAAA,SACM,KAAA,EAAO,aAAA;IAAA,SAAyB,IAAA;EAAA;AAAA;AAAA,KAG/B,cAAA;EAAA,SACD,cAAA;AAAA;AAAA,KAGC,gBAAA;EAAA,SACD,WAAA;EAAA,SACA,eAAA;EAAA,SACA,IAAA;EAAA,SACA,cAAA,GAAiB,cAAA,EA/BN;EAAA,SAiCX,gBAAA,WAjCW;EAAA,SAmCX,kBAAA,GAAqB,MAAA;AAAA;AAAA,KAGpB,WAAA;EAAA,SACD,QAAA,EAAU,aAAA,CAAc,cAAA;EAAA,SACxB,iBAAA,GAAoB,wBAAA;EAAA,SACpB,gBAAA,GAAmB,gBAAA;AAAA;AAAA,cAqEjB,gBAAA,GACX,OAAA,EAAS,aAAA,CAAc,IAAA,GACvB,gBAAA,EAAkB,MAAA,CAAO,MAAA,CAAO,gBAAA,MAC/B,WAAA;AAAA,KA6BS,WAAA;EAAA,SACD,IAAA;EAAA,SACA,SAAA;EAAA,SACA,YAAA,EAAc,MAAA,CAAO,MAAA;EAAA,SACrB,KAAA;IAAA,SACE,YAAA;IAAA,SACA,aAAA;IAAA,SACA,YAAA;IAAA,SACA,oBAAA;MAAA,SAAkC,aAAA;IAAA;IAAA,SAClC,qBAAA;MAAA,SAAmC,gBAAA;IAAA;EAAA;AAAA;AAAA,cAInC,gBAAA,EAAkB,WAAA;;;;;;KAYnB,SAAA;EAAA,SACG,IAAA;EAAA,SAAuB,IAAA;AAAA;EAAA,SACvB,IAAA;EAAA,SAA4B,IAAA;AAAA;AAAA,KAE/B,WAAA;EAAA,SACD,WAAA,EAAa,WAAA;EAAA,SACb,KAAA,EAAO,aAAA,CAAc,SAAA;EAAA,SACrB,QAAA;AAAA;AAAA,cA2CE,WAAA,GAAe,GAAA,EAAK,WAAA,EAAa,KAAA,EAAO,SAAA,KAAY,WAAA;AAAA,cAepD,iBAAA,GAAqB,GAAA,EAAK,WAAA,KAAc,IAAA"}

package/dist/codec.mjs

@@ -0,0 +1,151 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { Array, Encoding, Match, Option, Result, Schema, pipe } from "effect";
+//#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(Match.discriminatorsExhaustive("type")({
+	input_text: (b) => b.text,
+	input_image: () => "",
+	output_text: (b) => b.text,
+	refusal: (b) => b.text
+}));
+const messageText = (message) => message.content.map(blockText).join("");
+/**
+* Gemini's `inlineData` form expects a base64 payload. URL-form images
+* would need to go through Gemini's Files API (upload then `fileData`
+* with the returned URI); pre-uploading isn't free, so we skip those for
+* now and document as a follow-up.
+*/
+const imageSourceToParts = Match.type().pipe(Match.tag("url", () => []), Match.tag("base64", (s) => [{ inlineData: {
+	mimeType: s.mimeType,
+	data: s.base64
+} }]), Match.tag("bytes", (s) => [{ inlineData: {
+	mimeType: s.mimeType,
+	data: Encoding.encodeBase64(s.bytes)
+} }]), Match.exhaustive);
+const blockToParts = Match.type().pipe(Match.discriminatorsExhaustive("type")({
+	input_text: (b) => b.text.length === 0 ? [] : [{ text: b.text }],
+	input_image: (b) => imageSourceToParts(b.source),
+	output_text: (b) => b.text.length === 0 ? [] : [{ text: b.text }],
+	refusal: () => []
+}));
+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
+export { WireChunk, accumulatorToTurn, buildRequestBody, emptyAccumulator, ingestChunk, codec_exports as t };
+
+//# sourceMappingURL=codec.mjs.map

package/dist/codec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.mjs","names":["Arr"],"sources":["../src/codec.ts"],"sourcesContent":["import { Array as Arr, Encoding, Match, Option, Result, Schema, pipe } from \"effect\"\nimport type { ContentBlock, InputImage, Item, Message } from \"@effect-uai/core/Items\"\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\ntype RequestContent = {\n  readonly role: \"user\" | \"model\"\n  readonly parts: ReadonlyArray<RequestPart>\n}\n\ntype RequestSystemInstruction = {\n  readonly parts: ReadonlyArray<{ readonly text: string }>\n}\n\nexport type ThinkingConfig = {\n  readonly thinkingBudget: number\n}\n\nexport type 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 type RequestBody = {\n  readonly contents: ReadonlyArray<RequestContent>\n  readonly systemInstruction?: RequestSystemInstruction\n  readonly generationConfig?: GenerationConfig\n}\n\nconst blockText = Match.type<ContentBlock>().pipe(\n  Match.discriminatorsExhaustive(\"type\")({\n    input_text: (b) => b.text,\n    input_image: () => \"\",\n    output_text: (b) => b.text,\n    refusal: (b) => b.text,\n  }),\n)\n\nconst messageText = (message: Message): string => message.content.map(blockText).join(\"\")\n\n/**\n * Gemini's `inlineData` form expects a base64 payload. URL-form images\n * would need to go through Gemini's Files API (upload then `fileData`\n * with the returned URI); pre-uploading isn't free, so we skip those for\n * now and document as a follow-up.\n */\nconst imageSourceToParts = Match.type<InputImage[\"source\"]>().pipe(\n  Match.tag(\"url\", (): ReadonlyArray<RequestPart> => []),\n  Match.tag(\n    \"base64\",\n    (s): ReadonlyArray<RequestPart> => [{ inlineData: { mimeType: s.mimeType, data: s.base64 } }],\n  ),\n  Match.tag(\n    \"bytes\",\n    (s): ReadonlyArray<RequestPart> => [\n      { inlineData: { mimeType: s.mimeType, data: Encoding.encodeBase64(s.bytes) } },\n    ],\n  ),\n  Match.exhaustive,\n)\n\nconst blockToParts = Match.type<ContentBlock>().pipe(\n  Match.discriminatorsExhaustive(\"type\")({\n    input_text: (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),\n    input_image: (b): ReadonlyArray<RequestPart> => imageSourceToParts(b.source),\n    output_text: (b): ReadonlyArray<RequestPart> => (b.text.length === 0 ? [] : [{ text: b.text }]),\n    // Refusals are assistant-side content; they don't round-trip into Gemini's\n    // request body as parts. Skip.\n    refusal: (): ReadonlyArray<RequestPart> => [],\n  }),\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 type 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 type 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"],"mappings":"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"}

package/dist/index.d.mts

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