@effect-uai/google 0.11.0 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/google",
-  "version": "0.11.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.11.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.test.ts

@@ -0,0 +1,80 @@
+import { Schema } from "effect"
+import * as Turn from "@effect-uai/core/Turn"
+import { describe, expect, it } from "vitest"
+import { WireInteraction, jobStateOf } from "./GoogleDeepResearch.js"
+
+const decode = Schema.decodeUnknownSync(WireInteraction)
+
+// Extract the `Turn` from a completed interaction the way the service does.
+const turnOf = (raw: unknown): Turn.Turn => {
+  const state = jobStateOf(decode(raw))
+  if (state._tag !== "Succeeded") throw new Error(`expected Succeeded, got ${state._tag}`)
+  return state.result
+}
+
+describe("GoogleDeepResearch grounding", () => {
+  it("maps grounding chunks on a completed interaction to url_citation annotations", () => {
+    const turn = turnOf({
+      id: "int_1",
+      status: "completed",
+      outputs: [
+        {
+          type: "text",
+          text: "Report body [1][2].",
+          groundingMetadata: {
+            groundingChunks: [
+              {
+                web: {
+                  uri: "https://vertexaisearch.cloud.google.com/grounding-api-redirect/abc",
+                  title: "example.com",
+                },
+              },
+              {
+                web: { uri: "https://vertexaisearch.cloud.google.com/grounding-api-redirect/def" },
+              },
+            ],
+          },
+        },
+      ],
+    })
+    expect(Turn.assistantText(turn)).toBe("Report body [1][2].")
+    expect(Turn.citations(turn)).toEqual([
+      {
+        type: "url_citation",
+        url: "https://vertexaisearch.cloud.google.com/grounding-api-redirect/abc",
+        title: "example.com",
+      },
+      {
+        type: "url_citation",
+        url: "https://vertexaisearch.cloud.google.com/grounding-api-redirect/def",
+        title: "https://vertexaisearch.cloud.google.com/grounding-api-redirect/def",
+      },
+    ])
+  })
+
+  it("gathers and de-dupes grounding across interaction / output / step levels", () => {
+    const turn = turnOf({
+      id: "int_2",
+      status: "completed",
+      groundingMetadata: {
+        groundingChunks: [{ web: { uri: "https://a.example", title: "a" } }],
+      },
+      outputs: [{ type: "text", text: "Body." }],
+      steps: [
+        {
+          type: "research",
+          groundingMetadata: {
+            groundingChunks: [
+              { web: { uri: "https://a.example", title: "a" } },
+              { web: { uri: "https://b.example", title: "b" } },
+            ],
+          },
+        },
+      ],
+    })
+    expect(Turn.citations(turn).map((c) => c.type === "url_citation" && c.url)).toEqual([
+      "https://a.example",
+      "https://b.example",
+    ])
+  })
+})

package/src/GoogleDeepResearch.ts

@@ -1,6 +1,20 @@
-import { Context, Effect, Layer, Match, Redacted, Ref, Schema, Stream } from "effect"
+import {
+  Array as Arr,
+  Context,
+  Effect,
+  Layer,
+  Match,
+  Option,
+  Redacted,
+  Ref,
+  Result,
+  Schema,
+  Stream,
+  pipe,
+} from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import * as AiError from "@effect-uai/core/AiError"
+import type { Source } from "@effect-uai/core/Citation"
 import {
   DeepResearch,
   type DeepResearchService,
@@ -13,6 +27,7 @@ import * as Job from "@effect-uai/core/Job"
 import type { ResearchJobRef, ResearchRequest, ResearchState } from "@effect-uai/core/Research"
 import * as SSE from "@effect-uai/core/SSE"
 import { type Turn, TurnEvent } from "@effect-uai/core/Turn"
+import { GroundingMetadata, groundingToAnnotations } from "./codec.js"
 import type { GoogleDeepResearchModel } from "./models.js"
 
 // ---------------------------------------------------------------------------
@@ -61,23 +76,28 @@ const decodeSubmit = Schema.decodeUnknownEffect(WireSubmit)
 
 // A completed interaction's text lives at `outputs[].text` (SDK `outputs`) or,
 // in some doc examples, `steps[].content[].text`. Decode both defensively and
-// extract from whichever is populated. Citations are undocumented on this
-// preview surface, so none are mapped yet (the report text carries inline
-// `[n]` markers); enrich once a live response confirms the shape.
+// extract from whichever is populated. Grounding sources ride Google's
+// `groundingMetadata.groundingChunks[]`; this preview surface is undocumented,
+// so decode it at every plausible level (interaction / output / step) and map
+// whichever is populated onto `url_citation` annotations. The report text also
+// carries the sources as an inline `[n]` / `**Sources:**` list.
 const WireTextPart = Schema.Struct({
   type: Schema.optional(Schema.NullOr(Schema.String)),
   text: Schema.optional(Schema.NullOr(Schema.String)),
+  groundingMetadata: Schema.optional(Schema.NullOr(GroundingMetadata)),
 })
 const WireStep = Schema.Struct({
   type: Schema.optional(Schema.NullOr(Schema.String)),
   text: Schema.optional(Schema.NullOr(Schema.String)),
   content: Schema.optional(Schema.NullOr(Schema.Array(WireTextPart))),
+  groundingMetadata: Schema.optional(Schema.NullOr(GroundingMetadata)),
 })
 export const WireInteraction = Schema.Struct({
   id: Schema.optional(Schema.NullOr(Schema.String)),
   status: Schema.optional(Schema.NullOr(Schema.String)),
   outputs: Schema.optional(Schema.NullOr(Schema.Array(WireTextPart))),
   steps: Schema.optional(Schema.NullOr(Schema.Array(WireStep))),
+  groundingMetadata: Schema.optional(Schema.NullOr(GroundingMetadata)),
   error: Schema.optional(
     Schema.NullOr(
       Schema.Struct({
@@ -104,44 +124,111 @@ const reportText = (wire: WireInteraction): string => {
   return fromStep.length > 0 ? fromStep : (lastStep?.text ?? "")
 }
 
-const turnFromInteraction = (wire: WireInteraction): Turn => ({
-  items: [
-    {
-      type: "message",
-      role: "assistant",
-      content: [{ type: "output_text", text: reportText(wire) }],
-      providerData: wire,
-    },
-  ],
-  usage: {},
-  stop_reason: "stop",
+/**
+ * The subset of the domain `Citation.Source` this provider can populate.
+ * Declared here rather than derived from the wire schema, so the exported
+ * shape is ours and a wire change cannot silently alter it.
+ */
+const SourceSchema = Schema.Struct({
+  url: Schema.String,
+  title: Schema.optional(Schema.String),
+})
+
+/**
+ * The research trace: what the model did at each step and which sources it
+ * consulted there. The `Turn` keeps only the final report and the deduped
+ * union of all sources, so the per-step breakdown lives here or nowhere.
+ *
+ * Lands on `providerData.gemini`; read it with {@link researchDataOf}.
+ */
+export const GeminiResearchData = Schema.Struct({
+  steps: Schema.Array(
+    Schema.Struct({
+      text: Schema.String,
+      sources: Schema.Array(SourceSchema),
+    }),
+  ),
 })
+export type GeminiResearchData = typeof GeminiResearchData.Type
+
+const decodeResearchData = Schema.decodeUnknownResult(Schema.Struct({ gemini: GeminiResearchData }))
+
+/** Read this provider's data off an item, if it is there and ours. */
+export const researchDataOf = (item: Items.HistoryItem): Option.Option<GeminiResearchData> =>
+  pipe(
+    decodeResearchData(item.providerData),
+    Result.match({
+      onSuccess: (d) => Option.some(d.gemini),
+      onFailure: () => Option.none<GeminiResearchData>(),
+    }),
+  )
+
+const sourcesOf = (meta: GroundingMetadata | null | undefined): ReadonlyArray<Source> =>
+  (meta?.groundingChunks ?? []).flatMap((chunk) =>
+    chunk.web?.uri == null
+      ? []
+      : [{ url: chunk.web.uri, ...(chunk.web.title != null && { title: chunk.web.title }) }],
+  )
+
+// A step contributes to the trace if it said something or consulted something.
+const researchSteps = (wire: WireInteraction): GeminiResearchData["steps"] =>
+  (wire.steps ?? []).flatMap((step) => {
+    const text = textOfParts(step.content) || (step.text ?? "")
+    const sources = [
+      ...sourcesOf(step.groundingMetadata),
+      ...(step.content ?? []).flatMap((p) => sourcesOf(p.groundingMetadata)),
+    ]
+    return text.length === 0 && sources.length === 0 ? [] : [{ text, sources }]
+  })
+
+// Grounding can live at any level of the interaction envelope; gather it from
+// all three (interaction / output part / step) and let `groundingToAnnotations`
+// de-dupe by url.
+const interactionAnnotations = (wire: WireInteraction): ReadonlyArray<Items.Annotation> =>
+  groundingToAnnotations(
+    wire.groundingMetadata,
+    ...Arr.map(wire.outputs ?? [], (o) => o.groundingMetadata),
+    ...Arr.map(wire.steps ?? [], (s) => s.groundingMetadata),
+  )
+
+const turnFromInteraction = (wire: WireInteraction): Turn => {
+  const annotations = interactionAnnotations(wire)
+  return {
+    items: [
+      {
+        type: "message",
+        role: "assistant",
+        content: [
+          {
+            type: "output_text",
+            text: reportText(wire),
+            ...(annotations.length > 0 && { annotations }),
+          },
+        ],
+        providerData: { gemini: { steps: researchSteps(wire) } },
+      },
+    ],
+    usage: {},
+    stop_reason: "stop",
+  }
+}
 
 // Map the interaction status onto the generic `JobState`.
 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" })),
   )
 
@@ -226,6 +313,9 @@ const pollJob = (
       return yield* httpStatusError(response.status, text)
     }
     const json = yield* response.json.pipe(Effect.mapError(transportFailure))
+    // Preview surface: log the raw interaction so the (undocumented) grounding
+    // path can be confirmed against a live completed job at LOG_LEVEL=Debug.
+    yield* Effect.logDebug("google interactions poll response", { interaction: json })
     const wire = yield* decodeInteraction(json).pipe(Effect.mapError(transportFailure))
     return jobStateOf(wire)
   })
@@ -284,7 +374,7 @@ const completedTurn = (wire: WireInteraction | null | undefined, streamed: strin
             type: "message",
             role: "assistant",
             content: [{ type: "output_text", text: streamed }],
-            ...(wire != null && { providerData: wire }),
+            ...(wire != null && { providerData: { gemini: { steps: researchSteps(wire) } } }),
           },
         ],
         usage: {},

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,
+      })),
     ),
   )