@effect-uai/google 0.12.0 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/google",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Google Gemini provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -59,13 +59,13 @@
     "access": "public"
   },
   "devDependencies": {
-    "effect": "4.0.0-beta.94",
-    "typescript": "^6.0.3",
-    "@effect-uai/core": "0.12.0"
+    "effect": "4.0.0-rc.111",
+    "typescript": "^7.0.2",
+    "@effect-uai/core": "0.12.1"
   },
   "peerDependencies": {
     "@effect-uai/core": ">=0.2.0 <1",
-    "effect": ">=4.0.0-beta.94 <5.0.0"
+    "effect": ">=4.0.0-rc.111 <5.0.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/Gemini.ts

@@ -330,13 +330,10 @@ export const layer = (
   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),
-        turn: (request) => s.turn(request as GeminiRequest),
-      }),
-    ),
+    Effect.map(make(cfg), (s): LanguageModelService => ({
+      streamTurn: (request) => s.streamTurn(request as GeminiRequest),
+      turn: (request) => s.turn(request as GeminiRequest),
+    })),
   )
   return Layer.merge(typed, generic)
 }

package/src/GeminiEmbedding.ts

@@ -121,21 +121,16 @@ const urlRejected = (param: string): AiError.AiError =>
  */
 const imageSourceToPart = (param: string) =>
   Match.type<ImageSource>().pipe(
-    Match.tag(
-      "base64",
-      (s): Effect.Effect<WirePart, AiError.AiError> =>
-        Effect.succeed({ inlineData: { mimeType: s.mimeType, data: s.base64 } }),
+    Match.tag("base64", (s): Effect.Effect<WirePart, AiError.AiError> =>
+      Effect.succeed({ inlineData: { mimeType: s.mimeType, data: s.base64 } }),
     ),
-    Match.tag(
-      "bytes",
-      (s): Effect.Effect<WirePart, AiError.AiError> =>
-        Effect.succeed({
-          inlineData: { mimeType: s.mimeType, data: Encoding.encodeBase64(s.bytes) },
-        }),
+    Match.tag("bytes", (s): Effect.Effect<WirePart, AiError.AiError> =>
+      Effect.succeed({
+        inlineData: { mimeType: s.mimeType, data: Encoding.encodeBase64(s.bytes) },
+      }),
     ),
-    Match.tag(
-      "url",
-      (): Effect.Effect<WirePart, AiError.AiError> => Effect.fail(urlRejected(param)),
+    Match.tag("url", (): Effect.Effect<WirePart, AiError.AiError> =>
+      Effect.fail(urlRejected(param)),
     ),
     Match.exhaustive,
   )
@@ -291,12 +286,10 @@ const embedImpl =
         postJson(cfg, `${baseUrl(cfg)}/models/${request.model}:embedContent`, body),
       ),
       Effect.flatMap(decodeSingle),
-      Effect.map(
-        (decoded): EmbedResponse => ({
-          embedding: valuesToEmbedding(decoded.embedding.values),
-          usage: emptyUsage,
-        }),
-      ),
+      Effect.map((decoded): EmbedResponse => ({
+        embedding: valuesToEmbedding(decoded.embedding.values),
+        usage: emptyUsage,
+      })),
     )
 
 const embedManyImpl =
@@ -309,12 +302,10 @@ const embedManyImpl =
         postJson(cfg, `${baseUrl(cfg)}/models/${request.model}:batchEmbedContents`, body),
       ),
       Effect.flatMap(decodeBatch),
-      Effect.map(
-        (decoded): EmbedManyResponse => ({
-          embeddings: decoded.embeddings.map((e) => valuesToEmbedding(e.values)),
-          usage: emptyUsage,
-        }),
-      ),
+      Effect.map((decoded): EmbedManyResponse => ({
+        embeddings: decoded.embeddings.map((e) => valuesToEmbedding(e.values)),
+        usage: emptyUsage,
+      })),
     )
 
 // ---------------------------------------------------------------------------
@@ -346,29 +337,26 @@ export const layer = (
   const typed = Layer.effect(GeminiEmbedding, make(cfg))
   const generic = Layer.effect(
     EmbeddingModel,
-    Effect.map(
-      make(cfg),
-      (s): EmbeddingModelService => ({
-        // Gemini's embed endpoints emit float32 only. Reject a non-float32
-        // `encoding` (bucket 1) so a float32 vector isn't handed back
-        // mislabeled as the requested type. `task` is left silent: it's a
-        // per-model gap (honored by gemini-embedding-001, ignored by
-        // gemini-embedding-2 server-side), and per capabilities.md §2.3 we
-        // don't maintain per-model tables; there's no wire error to translate.
-        embed: <E extends EmbedEncoding | undefined = undefined>(
-          req: Omit<CommonEmbedRequest, "encoding"> & { readonly encoding?: E },
-        ) =>
-          assertEncoding(req.encoding, ["float32"], "gemini").pipe(
-            Effect.andThen(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 },
-        ) =>
-          assertEncoding(req.encoding, ["float32"], "gemini").pipe(
-            Effect.andThen(s.embedMany(req as GeminiEmbedManyRequest)),
-          ) as Effect.Effect<EmbedManyResponse<E>, AiError.AiError>,
-      }),
-    ),
+    Effect.map(make(cfg), (s): EmbeddingModelService => ({
+      // Gemini's embed endpoints emit float32 only. Reject a non-float32
+      // `encoding` (bucket 1) so a float32 vector isn't handed back
+      // mislabeled as the requested type. `task` is left silent: it's a
+      // per-model gap (honored by gemini-embedding-001, ignored by
+      // gemini-embedding-2 server-side), and per capabilities.md §2.3 we
+      // don't maintain per-model tables; there's no wire error to translate.
+      embed: <E extends EmbedEncoding | undefined = undefined>(
+        req: Omit<CommonEmbedRequest, "encoding"> & { readonly encoding?: E },
+      ) =>
+        assertEncoding(req.encoding, ["float32"], "gemini").pipe(
+          Effect.andThen(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 },
+      ) =>
+        assertEncoding(req.encoding, ["float32"], "gemini").pipe(
+          Effect.andThen(s.embedMany(req as GeminiEmbedManyRequest)),
+        ) as Effect.Effect<EmbedManyResponse<E>, AiError.AiError>,
+    })),
   )
   return Layer.merge(typed, generic)
 }

package/src/GeminiSynthesizer.ts

@@ -222,21 +222,18 @@ const unsupportedStreamDialogue: SpeechSynthesizerService["streamSynthesizeDialo
 // ---------------------------------------------------------------------------
 
 export const make = (cfg: Config) =>
-  Effect.map(
-    HttpClient.HttpClient,
-    (client): GeminiSynthesizerService => ({
-      synthesize: (r) =>
-        synthesizeImpl(cfg)(r).pipe(Effect.provideService(HttpClient.HttpClient, client)),
-      streamSynthesis: (r) =>
-        Stream.fromEffect(synthesizeImpl(cfg)(r)).pipe(
-          Stream.map((b): AudioChunk => ({ bytes: b.bytes })),
-          Stream.provideService(HttpClient.HttpClient, client),
-        ),
-      streamSynthesisFrom: unsupportedStreamFrom,
-      synthesizeDialogue: unsupportedDialogue,
-      streamSynthesizeDialogue: unsupportedStreamDialogue,
-    }),
-  )
+  Effect.map(HttpClient.HttpClient, (client): GeminiSynthesizerService => ({
+    synthesize: (r) =>
+      synthesizeImpl(cfg)(r).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+    streamSynthesis: (r) =>
+      Stream.fromEffect(synthesizeImpl(cfg)(r)).pipe(
+        Stream.map((b): AudioChunk => ({ bytes: b.bytes })),
+        Stream.provideService(HttpClient.HttpClient, client),
+      ),
+    streamSynthesisFrom: unsupportedStreamFrom,
+    synthesizeDialogue: unsupportedDialogue,
+    streamSynthesizeDialogue: unsupportedStreamDialogue,
+  }))
 
 /**
  * Layer registers both `GeminiSynthesizer` and the generic
@@ -249,17 +246,13 @@ export const layer = (cfg: Config) =>
     Layer.effect(GeminiSynthesizer, make(cfg)),
     Layer.effect(
       SpeechSynthesizer,
-      Effect.map(
-        make(cfg),
-        (s): SpeechSynthesizerService => ({
-          synthesize: (req: CommonSynthesizeRequest) =>
-            s.synthesize(req as GeminiSynthesizeRequest),
-          streamSynthesis: (req: CommonSynthesizeRequest) =>
-            s.streamSynthesis(req as GeminiSynthesizeRequest),
-          streamSynthesisFrom: s.streamSynthesisFrom,
-          synthesizeDialogue: s.synthesizeDialogue,
-          streamSynthesizeDialogue: s.streamSynthesizeDialogue,
-        }),
-      ),
+      Effect.map(make(cfg), (s): SpeechSynthesizerService => ({
+        synthesize: (req: CommonSynthesizeRequest) => s.synthesize(req as GeminiSynthesizeRequest),
+        streamSynthesis: (req: CommonSynthesizeRequest) =>
+          s.streamSynthesis(req as GeminiSynthesizeRequest),
+        streamSynthesisFrom: s.streamSynthesisFrom,
+        synthesizeDialogue: s.synthesizeDialogue,
+        streamSynthesizeDialogue: s.streamSynthesizeDialogue,
+      })),
     ),
   )

package/src/GeminiTools.ts

@@ -77,12 +77,10 @@ const renderOne = (
       })
     : decodeConfig(tool.config).pipe(
         Result.map(configToWire),
-        Result.mapError(
-          (): ToolRenderError => ({
-            capability: "providerTool",
-            reason: `unrecognized Gemini provider tool config on "${tool.name}"`,
-          }),
-        ),
+        Result.mapError((): ToolRenderError => ({
+          capability: "providerTool",
+          reason: `unrecognized Gemini provider tool config on "${tool.name}"`,
+        })),
       )
 
 /**

package/src/GoogleDeepResearch.ts

@@ -217,27 +217,18 @@ const turnFromInteraction = (wire: WireInteraction): Turn => {
 export const jobStateOf = (wire: WireInteraction): ResearchState =>
   Match.value(wire.status ?? "").pipe(
     Match.whenOr("queued", "pending", (): ResearchState => ({ _tag: "Pending" })),
-    Match.whenOr(
-      "in_progress",
-      "running",
-      "processing",
-      (): ResearchState => ({ _tag: "Running" }),
-    ),
-    Match.whenOr(
-      "completed",
-      "succeeded",
-      (): ResearchState => ({ _tag: "Succeeded", result: turnFromInteraction(wire) }),
-    ),
-    Match.whenOr(
-      "failed",
-      "error",
-      "cancelled",
-      (): ResearchState => ({
-        _tag: "Failed",
-        ...(wire.error?.message != null && { reason: wire.error.message }),
-        raw: wire,
-      }),
-    ),
+    Match.whenOr("in_progress", "running", "processing", (): ResearchState => ({
+      _tag: "Running",
+    })),
+    Match.whenOr("completed", "succeeded", (): ResearchState => ({
+      _tag: "Succeeded",
+      result: turnFromInteraction(wire),
+    })),
+    Match.whenOr("failed", "error", "cancelled", (): ResearchState => ({
+      _tag: "Failed",
+      ...(wire.error?.message != null && { reason: wire.error.message }),
+      raw: wire,
+    })),
     Match.orElse((): ResearchState => ({ _tag: "Running" })),
   )
 

package/src/LyriaGenerator.ts

@@ -105,19 +105,18 @@ const isClipModel = (model: string): boolean => model.includes("clip")
 
 export const realizedFormat: (mime: LyriaResponseMimeType) => AudioFormat =
   Match.type<LyriaResponseMimeType>().pipe(
-    Match.when(
-      "audio/mp3",
-      (): AudioFormat => ({ container: "mp3", encoding: "mp3", sampleRate: 44100, channels: 2 }),
-    ),
-    Match.when(
-      "audio/wav",
-      (): AudioFormat => ({
-        container: "wav",
-        encoding: "pcm_s16le",
-        sampleRate: 44100,
-        channels: 2,
-      }),
-    ),
+    Match.when("audio/mp3", (): AudioFormat => ({
+      container: "mp3",
+      encoding: "mp3",
+      sampleRate: 44100,
+      channels: 2,
+    })),
+    Match.when("audio/wav", (): AudioFormat => ({
+      container: "wav",
+      encoding: "pcm_s16le",
+      sampleRate: 44100,
+      channels: 2,
+    })),
     Match.exhaustive,
   )
 
@@ -395,15 +394,12 @@ export const layer = (
     Layer.effect(LyriaGenerator, make(cfg)),
     Layer.effect(
       MusicGenerator,
-      Effect.map(
-        make(cfg),
-        (s): MusicGeneratorService => ({
-          generate: (req: CommonGenerateMusicRequest) =>
-            s.generate({ ...req, model: req.model as LyriaModel }),
-          streamGeneration: (req: CommonStreamGenerateMusicRequest) =>
-            s.streamGeneration({ ...req, model: req.model as LyriaModel }),
-          streamGenerationFrom: s.streamGenerationFrom,
-        }),
-      ),
+      Effect.map(make(cfg), (s): MusicGeneratorService => ({
+        generate: (req: CommonGenerateMusicRequest) =>
+          s.generate({ ...req, model: req.model as LyriaModel }),
+        streamGeneration: (req: CommonStreamGenerateMusicRequest) =>
+          s.streamGeneration({ ...req, model: req.model as LyriaModel }),
+        streamGenerationFrom: s.streamGenerationFrom,
+      })),
     ),
   )

package/src/codec.ts

@@ -218,16 +218,12 @@ const messageText = (message: Message): string => message.content.map(blockText)
  */
 const imageSourceToParts = Match.type<InputImage["source"]>().pipe(
   Match.tag("url", (): ReadonlyArray<RequestPart> => []),
-  Match.tag(
-    "base64",
-    (s): ReadonlyArray<RequestPart> => [{ inlineData: { mimeType: s.mimeType, data: s.base64 } }],
-  ),
-  Match.tag(
-    "bytes",
-    (s): ReadonlyArray<RequestPart> => [
-      { inlineData: { mimeType: s.mimeType, data: Encoding.encodeBase64(s.bytes) } },
-    ],
-  ),
+  Match.tag("base64", (s): ReadonlyArray<RequestPart> => [
+    { inlineData: { mimeType: s.mimeType, data: s.base64 } },
+  ]),
+  Match.tag("bytes", (s): ReadonlyArray<RequestPart> => [
+    { inlineData: { mimeType: s.mimeType, data: Encoding.encodeBase64(s.bytes) } },
+  ]),
   Match.exhaustive,
 )
 
@@ -434,7 +430,9 @@ const sanitizeSchema = (schema: unknown): unknown => {
   )
 }
 
-const toolDescriptorsToTools = (tools: ReadonlyArray<ToolDescriptor>): ReadonlyArray<RequestTool> =>
+const toolDescriptorsToTools = (
+  tools: ReadonlyArray<ToolDescriptor>,
+): ReadonlyArray<RequestTool> =>
   tools.length === 0
     ? []
     : [