@effect-uai/google 0.4.0 → 0.5.1

package/src/Gemini.ts

@@ -8,8 +8,9 @@ import {
 } 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 { TurnEvent } from "@effect-uai/core/Turn"
 import {
+  type ChunkPart,
   type GenerationConfig,
   WireChunk,
   accumulatorToTurn,
@@ -17,6 +18,7 @@ import {
   emptyAccumulator,
   ingestChunk,
 } from "./codec.js"
+import { Match } from "effect"
 import type { GoogleModel } from "./models.js"
 
 /**
@@ -119,11 +121,13 @@ const decodeChunk = Schema.decodeUnknownEffect(WireChunk)
  * an `_unknown` variant, so JSON parse / schema decode failures flow
  * through as transport errors rather than being silently dropped.
  */
+const parseJsonUnknown = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))
+
 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))
+  parseJsonUnknown(ev.data).pipe(
+    Effect.mapError((cause) => new JsonParseError({ line: ev.data, cause })),
+    Effect.flatMap(decodeChunk),
+  )
 
 // ---------------------------------------------------------------------------
 // Service implementation
@@ -152,7 +156,7 @@ const buildNativeStream = (cfg: Config) => {
         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 body = buildRequestBody(request.history, generationConfig, request.tools ?? [])
         const httpRequest = HttpClientRequest.post(url).pipe(
           HttpClientRequest.setHeader("x-goog-api-key", Redacted.value(cfg.apiKey)),
           HttpClientRequest.bodyJsonUnsafe(body),
@@ -194,6 +198,33 @@ const buildNativeStream = (cfg: Config) => {
  * Threads a fresh `Accumulator` so chunk-level text/usage merging works
  * across the run.
  */
+/**
+ * Map one `ChunkPart` to the `TurnEvent`(s) it produces. Function calls
+ * emit two events back-to-back since Gemini delivers args whole: a
+ * `tool_call_start` immediately followed by a `tool_call_args_delta` with
+ * the full JSON-encoded args. The `call_id` is the synthesized id from
+ * the accumulator (Gemini-3 wire id when present, `<name>_<index>` otherwise).
+ */
+const partToTurnEvents = (
+  part: ChunkPart,
+  callIdAt: (name: string, indexFromTail: number) => string,
+): ReadonlyArray<TurnEvent> =>
+  Match.value(part).pipe(
+    Match.discriminatorsExhaustive("kind")({
+      text: (p): ReadonlyArray<TurnEvent> => [TurnEvent.TextDelta({ text: p.text })],
+      reasoning: (p): ReadonlyArray<TurnEvent> => [
+        TurnEvent.ReasoningDelta({ text: p.text, kind: "trace" }),
+      ],
+      function_call: (p): ReadonlyArray<TurnEvent> => {
+        const call_id = callIdAt(p.name, 0)
+        return [
+          TurnEvent.ToolCallStart({ call_id, name: p.name }),
+          TurnEvent.ToolCallArgsDelta({ call_id, delta: JSON.stringify(p.args ?? {}) }),
+        ]
+      },
+    }),
+  )
+
 export const toCanonical = <E, R>(
   s: Stream.Stream<ProviderEvent, E, R>,
 ): Stream.Stream<TurnEvent, E, R> =>
@@ -202,19 +233,23 @@ export const toCanonical = <E, R>(
       () => 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 },
+        // The accumulator already contains the synthesized call_ids for any
+        // function_call parts in *this* chunk - they are the tail. Walk back
+        // by chunk-local function-call index to recover them.
+        const newCalls = result.parts.filter((p) => p.kind === "function_call")
+        const tailCalls = result.accumulator.functionCalls.slice(
+          result.accumulator.functionCalls.length - newCalls.length,
+        )
+        let consumedCalls = 0
+        const partDeltas: ReadonlyArray<TurnEvent> = result.parts.flatMap((p) =>
+          partToTurnEvents(p, () => {
+            const id = tailCalls[consumedCalls]?.callId ?? p.kind
+            consumedCalls += 1
+            return id
+          }),
         )
-        const deltas = result.finished
-          ? [
-              ...partDeltas,
-              {
-                type: "turn_complete" as const,
-                turn: accumulatorToTurn(result.accumulator),
-              },
-            ]
+        const deltas: ReadonlyArray<TurnEvent> = result.finished
+          ? [...partDeltas, TurnEvent.TurnComplete({ turn: accumulatorToTurn(result.accumulator) })]
           : partDeltas
         return [result.accumulator, deltas] as const
       },

package/src/GeminiEmbedding.ts

@@ -1,10 +1,16 @@
 import { Context, Effect, Encoding, Layer, Match, Redacted, Schema } from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import * as AiError from "@effect-uai/core/AiError"
-import type { Embedding, EmbedContentPart, EmbedInput, Usage } from "@effect-uai/core/Embedding"
+import type {
+  EmbedContentPart,
+  EmbedInput,
+  Float32Embedding,
+  Usage,
+} from "@effect-uai/core/Embedding"
 import {
   type CommonEmbedManyRequest,
   type CommonEmbedRequest,
+  type EmbedEncoding,
   EmbeddingModel,
   type EmbeddingModelService,
   type EmbedManyResponse,
@@ -209,7 +215,7 @@ const WireBatchResponse = Schema.Struct({
   embeddings: Schema.Array(WireEmbedding),
 })
 
-const valuesToEmbedding = (values: ReadonlyArray<number>): Embedding => ({
+const valuesToEmbedding = (values: ReadonlyArray<number>): Float32Embedding => ({
   _tag: "float32",
   vector: Float32Array.from(values),
 })
@@ -256,7 +262,7 @@ const postJson = (
     const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
     if (response.status >= 400) {
       const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
-      return yield* Effect.fail(httpStatusError(response.status, text))
+      return yield* httpStatusError(response.status, text)
     }
     return yield* response.json.pipe(Effect.mapError(transportFailure))
   })
@@ -342,8 +348,20 @@ export const layer = (
     Effect.map(
       make(cfg),
       (s): EmbeddingModelService => ({
-        embed: (req: CommonEmbedRequest) => s.embed(req as GeminiEmbedRequest),
-        embedMany: (req: CommonEmbedManyRequest) => s.embedMany(req as GeminiEmbedManyRequest),
+        // Gemini's endpoints only emit float32; the cast is sound for the
+        // 99% case. A caller who asks for `encoding: "int8"` via the
+        // generic tag gets the type they requested but the runtime returns
+        // float32 (Gemini ignores the field).
+        embed: <E extends EmbedEncoding | undefined = undefined>(
+          req: Omit<CommonEmbedRequest, "encoding"> & { readonly encoding?: E },
+        ) => s.embed(req as GeminiEmbedRequest) as Effect.Effect<EmbedResponse<E>, AiError.AiError>,
+        embedMany: <E extends EmbedEncoding | undefined = undefined>(
+          req: Omit<CommonEmbedManyRequest, "encoding"> & { readonly encoding?: E },
+        ) =>
+          s.embedMany(req as GeminiEmbedManyRequest) as Effect.Effect<
+            EmbedManyResponse<E>,
+            AiError.AiError
+          >,
       }),
     ),
   )

package/src/GeminiSynthesizer.ts

@@ -135,7 +135,7 @@ const synthesizeImpl = (cfg: Config) => (request: GeminiSynthesizeRequest) =>
     const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
     if (response.status >= 400) {
       const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
-      return yield* Effect.fail(httpStatusError(response.status, text))
+      return yield* httpStatusError(response.status, text)
     }
     const json = yield* response.json.pipe(Effect.mapError(transportFailure))
     const inline = yield* decodeWire(json).pipe(

package/src/GeminiTranscriber.ts

@@ -129,7 +129,7 @@ const transcribeImpl = (cfg: Config) => (request: GeminiTranscribeRequest) =>
     const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
     if (response.status >= 400) {
       const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
-      return yield* Effect.fail(httpStatusError(response.status, text))
+      return yield* httpStatusError(response.status, text)
     }
     const json = yield* response.json.pipe(Effect.mapError(transportFailure))
     const text = yield* decodeWire(json).pipe(

package/src/LyriaGenerator.ts

@@ -254,13 +254,11 @@ const generateImpl =
       // Clip is fixed 30 s mp3 — reject wav up front rather than sending
       // a `responseFormat` that the live API ignores or rejects.
       if (isClipModel(request.model) && mimeType === "audio/wav") {
-        return yield* Effect.fail(
-          new AiError.Unsupported({
-            provider: "lyria",
-            capability: "outputFormat",
-            reason: `lyria-3-clip-preview is fixed at audio/mp3. Use lyria-3-pro-preview for audio/wav output.`,
-          }),
-        )
+        return yield* new AiError.Unsupported({
+          provider: "lyria",
+          capability: "outputFormat",
+          reason: `lyria-3-clip-preview is fixed at audio/mp3. Use lyria-3-pro-preview for audio/wav output.`,
+        })
       }
       const promptText = buildPrompt(request)
       const body = isClipModel(request.model)
@@ -281,7 +279,7 @@ const generateImpl =
       const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
       if (response.status >= 400) {
         const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
-        return yield* Effect.fail(httpStatusError(response.status, text))
+        return yield* httpStatusError(response.status, text)
       }
       const json = yield* response.json.pipe(Effect.mapError(transportFailure))
       const wire = yield* decodeWire(json).pipe(
@@ -296,17 +294,15 @@ const generateImpl =
         // (named-artist references, copyrighted lyrics, etc.). Surface the
         // full response body — text parts, finish reasons, prompt-feedback
         // blocks — so the caller can see why.
-        return yield* Effect.fail(
-          new AiError.GenerationFailed({
-            provider: "lyria",
-            raw: {
-              message: "Lyria response had no inlineData audio part.",
-              hint: "Likely a prompt-filter rejection. Lyria filters references to real artists / copyrighted song lyrics. Rephrase with descriptive style language instead of artist names.",
-              textParts: text,
-              response: json,
-            },
-          }),
-        )
+        return yield* new AiError.GenerationFailed({
+          provider: "lyria",
+          raw: {
+            message: "Lyria response had no inlineData audio part.",
+            hint: "Likely a prompt-filter rejection. Lyria filters references to real artists / copyrighted song lyrics. Rephrase with descriptive style language instead of artist names.",
+            textParts: text,
+            response: json,
+          },
+        })
       }
       const bytes = yield* decodeBase64ToBytes(inline.data)
       return {