@effect-uai/core 0.2.0 → 0.4.0

package/src/math/Vector.ts

@@ -0,0 +1,138 @@
+/**
+ * Linear-algebra primitives for embedding vectors:
+ *
+ * - **Dense float32**: `dot`, `l2Norm`, `normalize`, `cosine`,
+ *   `euclidean`. Used for retrieval over single-vector embeddings.
+ * - **Sparse**: `sparseDot`, `sparseL2Norm`, `sparseCosine`. Used with
+ *   `SparseEmbedding`, e.g. Jina ELSER outputs.
+ * - **Multivector** (late-interaction): `maxSim`. Used with
+ *   `MultivectorEmbedding`, e.g. Jina v4 multivector / ColBERT.
+ *
+ * Hot loops are allocation-free; consumers can call these inside
+ * `.map()` over thousands of vectors without GC pressure. For
+ * GPU / SIMD / WASM-accelerated math at vector-DB scale, reach for a
+ * dedicated library - this module deliberately stays at the
+ * recipe-volume tier.
+ */
+import type { MultivectorEmbedding, SparseEmbedding } from "../embedding-model/Embedding.js"
+
+/** Inner / dot product. */
+export const dot = (a: Float32Array, b: Float32Array): number => {
+  let s = 0
+  const n = Math.min(a.length, b.length)
+  for (let i = 0; i < n; i++) s += a[i]! * b[i]!
+  return s
+}
+
+/** L2 norm (Euclidean magnitude). */
+export const l2Norm = (v: Float32Array): number => {
+  let s = 0
+  for (let i = 0; i < v.length; i++) s += v[i]! * v[i]!
+  return Math.sqrt(s)
+}
+
+/**
+ * L2-normalize to a unit vector. Allocates a new `Float32Array`. A zero
+ * vector returns zeros (no division-by-zero).
+ */
+export const normalize = (v: Float32Array): Float32Array => {
+  const n = l2Norm(v)
+  if (n === 0) return new Float32Array(v.length)
+  const out = new Float32Array(v.length)
+  for (let i = 0; i < v.length; i++) out[i] = v[i]! / n
+  return out
+}
+
+/**
+ * Cosine similarity. Range `[-1, 1]`; higher = more similar. Returns
+ * `NaN` if either vector has zero magnitude.
+ */
+export const cosine = (a: Float32Array, b: Float32Array): number => {
+  let d = 0
+  let na = 0
+  let nb = 0
+  const n = Math.min(a.length, b.length)
+  for (let i = 0; i < n; i++) {
+    const ai = a[i]!
+    const bi = b[i]!
+    d += ai * bi
+    na += ai * ai
+    nb += bi * bi
+  }
+  return d / (Math.sqrt(na) * Math.sqrt(nb))
+}
+
+/** Euclidean (L2) distance. */
+export const euclidean = (a: Float32Array, b: Float32Array): number => {
+  let s = 0
+  const n = Math.min(a.length, b.length)
+  for (let i = 0; i < n; i++) {
+    const d = a[i]! - b[i]!
+    s += d * d
+  }
+  return Math.sqrt(s)
+}
+
+// ---------------------------------------------------------------------------
+// Sparse vectors (Record<string, number>)
+// ---------------------------------------------------------------------------
+
+/** Inner product over the intersection of token keys. */
+export const sparseDot = (a: SparseEmbedding, b: SparseEmbedding): number => {
+  // Iterate the smaller map; lookup against the larger one. O(min(|a|, |b|)).
+  const aSize = Object.keys(a.weights).length
+  const bSize = Object.keys(b.weights).length
+  const [smaller, larger] = aSize <= bSize ? [a.weights, b.weights] : [b.weights, a.weights]
+  let s = 0
+  for (const token in smaller) {
+    const other = larger[token]
+    if (other !== undefined) s += smaller[token]! * other
+  }
+  return s
+}
+
+/** L2 norm of a sparse vector. */
+export const sparseL2Norm = (v: SparseEmbedding): number => {
+  let s = 0
+  for (const token in v.weights) {
+    const w = v.weights[token]!
+    s += w * w
+  }
+  return Math.sqrt(s)
+}
+
+/**
+ * Sparse cosine similarity. Range `[-1, 1]` (typically `[0, 1]` for
+ * learned-sparse encoders since weights are non-negative). Returns
+ * `NaN` if either vector has zero magnitude.
+ */
+export const sparseCosine = (a: SparseEmbedding, b: SparseEmbedding): number =>
+  sparseDot(a, b) / (sparseL2Norm(a) * sparseL2Norm(b))
+
+// ---------------------------------------------------------------------------
+// Multivector / late-interaction (ColBERT-style)
+// ---------------------------------------------------------------------------
+
+/**
+ * MaxSim score for late-interaction retrieval. For each *query* vector,
+ * find the maximum dot product with any *document* vector, then sum.
+ *
+ * Captures fine-grained relevance that single-vector cosine smears out:
+ * each query token finds its own best-matching document token.
+ *
+ * Cost: O(|q| × |d| × dim). Fine at recipe volume; for production-scale
+ * retrieval use a vector store with native multivector indexing
+ * (Vespa, Qdrant, PLAID).
+ */
+export const maxSim = (q: MultivectorEmbedding, d: MultivectorEmbedding): number => {
+  let total = 0
+  for (const qv of q.vectors) {
+    let best = -Infinity
+    for (const dv of d.vectors) {
+      const s = dot(qv, dv)
+      if (s > best) best = s
+    }
+    total += best
+  }
+  return total
+}

package/src/music-generator/MusicGenerator.test.ts

@@ -0,0 +1,170 @@
+import { Effect, Stream } from "effect"
+import { describe, expect, expectTypeOf, it } from "vitest"
+import type * as AiError from "../domain/AiError.js"
+import type { AudioChunk, AudioFormat } from "../domain/Audio.js"
+import { configInput, promptsInput, type MusicResult } from "../domain/Music.js"
+import * as MockMusicGenerator from "../testing/MockMusicGenerator.js"
+import * as MusicGenerator from "./MusicGenerator.js"
+
+const mp3Format: AudioFormat = {
+  container: "mp3",
+  encoding: "mp3",
+  sampleRate: 44100,
+  channels: 2,
+}
+
+const result: MusicResult = {
+  format: mp3Format,
+  bytes: new Uint8Array([0xff, 0xfb, 0x90, 0x00]),
+  durationSeconds: 30,
+  lyrics: "[Verse]\nhello\n",
+  watermark: { kind: "synthid" },
+}
+
+const chunk = (n: number): AudioChunk => ({ bytes: new Uint8Array([n]) })
+
+describe("MusicGenerator.generate", () => {
+  it("returns the scripted MusicResult", async () => {
+    const mock = MockMusicGenerator.layer({ results: [result] })
+    const program = MusicGenerator.generate({
+      model: "mock-music",
+      prompts: "upbeat indie pop",
+    })
+    const out = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(out.bytes).toEqual(result.bytes)
+    expect(out.durationSeconds).toBe(30)
+    expect(out.watermark?.kind).toBe("synthid")
+    expect(out.lyrics).toContain("[Verse]")
+  })
+
+  it("records the request shape on the recorder", async () => {
+    const mock = MockMusicGenerator.layer({ results: [result, result] })
+    const program = Effect.gen(function* () {
+      yield* MusicGenerator.generate({ model: "m", prompts: "techno" })
+      yield* MusicGenerator.generate({
+        model: "m",
+        prompts: [
+          { text: "synthwave", weight: 1.0 },
+          { text: "80s movie OST", weight: 0.4 },
+        ],
+        bpm: 120,
+        instrumental: true,
+      })
+      return yield* mock.recorder
+    })
+    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(rec.generateCalls.length).toBe(2)
+    expect(rec.generateCalls[1]!.bpm).toBe(120)
+    expect(rec.generateCalls[1]!.instrumental).toBe(true)
+    expect(Array.isArray(rec.generateCalls[1]!.prompts)).toBe(true)
+  })
+})
+
+describe("MusicGenerator.streamGeneration", () => {
+  it("emits scripted chunks", async () => {
+    const mock = MockMusicGenerator.layer({
+      streamGenerationChunks: [[chunk(1), chunk(2), chunk(3)]],
+    })
+    const program = Stream.runCollect(
+      MusicGenerator.streamGeneration({ model: "m", prompts: "ambient" }),
+    )
+    const out = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(out.map((c) => Array.from(c.bytes))).toEqual([[1], [2], [3]])
+  })
+})
+
+describe("MusicGenerator capability marker (compile-time)", () => {
+  const sgfReq: MusicGenerator.CommonStreamGenerateMusicRequest = {
+    model: "m",
+    prompts: "",
+  }
+
+  it("requires `MusicInteractiveSession` on the R channel of streamGenerationFrom", () => {
+    const inputs = Stream.fromIterable([promptsInput([{ text: "techno" }])])
+    const audio = inputs.pipe(MusicGenerator.streamGenerationFrom(sgfReq))
+    expectTypeOf(audio).toEqualTypeOf<
+      Stream.Stream<
+        AudioChunk,
+        AiError.AiError,
+        MusicGenerator.MusicGenerator | MusicGenerator.MusicInteractiveSession
+      >
+    >()
+  })
+
+  it("does NOT require `MusicInteractiveSession` for sync `generate`", () => {
+    const eff = MusicGenerator.generate({ model: "m", prompts: "ambient" })
+    expectTypeOf(eff).toEqualTypeOf<
+      Effect.Effect<MusicResult, AiError.AiError, MusicGenerator.MusicGenerator>
+    >()
+  })
+
+  it("does NOT require `MusicInteractiveSession` for `streamGeneration`", () => {
+    const audio = MusicGenerator.streamGeneration({ model: "m", prompts: "ambient" })
+    expectTypeOf(audio).toEqualTypeOf<
+      Stream.Stream<AudioChunk, AiError.AiError, MusicGenerator.MusicGenerator>
+    >()
+  })
+
+  it("a layer without the marker leaves `MusicInteractiveSession` unsatisfied in R", () => {
+    const noMarker = MockMusicGenerator.layerWithoutInteractive({})
+    const inputs = Stream.fromIterable([promptsInput([{ text: "techno" }])])
+    const audio = inputs.pipe(MusicGenerator.streamGenerationFrom(sgfReq))
+    const program = Stream.runDrain(audio).pipe(Effect.provide(noMarker.layer))
+    expectTypeOf(program).toEqualTypeOf<
+      Effect.Effect<void, AiError.AiError, MusicGenerator.MusicInteractiveSession>
+    >()
+  })
+
+  it("a full layer (with marker) clears R to never", () => {
+    const fullMock = MockMusicGenerator.layer({
+      streamGenerationFromChunks: [[]],
+    })
+    const inputs = Stream.fromIterable([promptsInput([{ text: "techno" }])])
+    const audio = inputs.pipe(MusicGenerator.streamGenerationFrom(sgfReq))
+    const program = Stream.runDrain(audio).pipe(Effect.provide(fullMock.layer))
+    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()
+  })
+})
+
+describe("MusicGenerator.streamGenerationFrom", () => {
+  const sgfReq: MusicGenerator.CommonStreamGenerateMusicRequest = {
+    model: "lyria-realtime-001",
+    prompts: "",
+  }
+
+  it("drains a session-input stream and emits scripted audio", async () => {
+    const mock = MockMusicGenerator.layer({
+      streamGenerationFromChunks: [[chunk(10), chunk(20)]],
+    })
+    const inputs = Stream.fromIterable([
+      promptsInput([{ text: "minimal techno", weight: 1.0 }]),
+      configInput({ bpm: 124 }),
+      promptsInput([
+        { text: "minimal techno", weight: 1.0 },
+        { text: "1980s synthwave", weight: 0.3 },
+      ]),
+    ])
+    const audio = inputs.pipe(MusicGenerator.streamGenerationFrom(sgfReq))
+    const out = await Effect.runPromise(Stream.runCollect(audio).pipe(Effect.provide(mock.layer)))
+    expect(out.map((c) => Array.from(c.bytes))).toEqual([[10], [20]])
+  })
+
+  it("records the request on the streamGenerationFrom call channel", async () => {
+    const mock = MockMusicGenerator.layer({
+      streamGenerationFromChunks: [[chunk(42)]],
+    })
+    const program = Effect.gen(function* () {
+      yield* Stream.runDrain(
+        Stream.fromIterable([promptsInput([{ text: "x" }])]).pipe(
+          MusicGenerator.streamGenerationFrom(sgfReq),
+        ),
+      )
+      return yield* mock.recorder
+    })
+    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(rec.streamGenerationFromCalls.length).toBe(1)
+    expect(rec.streamGenerationFromCalls[0]!.model).toBe("lyria-realtime-001")
+    expect(rec.generateCalls.length).toBe(0)
+    expect(rec.streamGenerationCalls.length).toBe(0)
+  })
+})

package/src/music-generator/MusicGenerator.ts

@@ -0,0 +1,123 @@
+import { Context, Effect, Function, Stream } from "effect"
+import * as AiError from "../domain/AiError.js"
+import type { AudioChunk } from "../domain/Audio.js"
+import type {
+  CommonGenerateMusicRequest,
+  CommonStreamGenerateMusicRequest,
+  MusicResult,
+  MusicSessionInput,
+} from "../domain/Music.js"
+
+export type {
+  CommonGenerateMusicRequest,
+  CommonStreamGenerateMusicRequest,
+  MusicResult,
+  MusicSessionInput,
+  WeightedPrompt,
+} from "../domain/Music.js"
+
+export type MusicGeneratorService = {
+  /**
+   * One-shot. Prompt in, full audio bytes out. Universally supported.
+   * Async/poll-based providers (Suno, Mureka) hide their poll loop
+   * inside the adapter — caller still sees a single `Effect`.
+   */
+  readonly generate: (
+    request: CommonGenerateMusicRequest,
+  ) => Effect.Effect<MusicResult, AiError.AiError>
+  /**
+   * Prompt in, audio chunks streamed out. Providers without a native
+   * chunked-output endpoint (Lyria 3 sync, Mureka, MiniMax, Stable
+   * Audio) emulate this by calling `generate` and emitting a single
+   * `AudioChunk` — first-class, no `Unsupported`.
+   */
+  readonly streamGeneration: (
+    request: CommonStreamGenerateMusicRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError>
+  /**
+   * Bidirectional session: a `Stream` of prompt-or-config updates flows
+   * in, a `Stream` of audio chunks flows out. The session WS / RPC is
+   * acquired on first pull and released when the output stream is
+   * finalized via `Stream.scoped`.
+   *
+   * Gated by the `MusicInteractiveSession` capability marker on the
+   * top-level helper — providers without bidirectional support don't
+   * ship the marker, so calls fail at `Effect.provide` with a type
+   * error.
+   */
+  readonly streamGenerationFrom: <E, R>(
+    input: Stream.Stream<MusicSessionInput, E, R>,
+    request: CommonStreamGenerateMusicRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError | E, R>
+}
+
+export class MusicGenerator extends Context.Service<MusicGenerator, MusicGeneratorService>()(
+  "@betalyra/effect-uai/MusicGenerator",
+) {}
+
+/**
+ * Capability marker — provided by provider layers whose
+ * `streamGenerationFrom` is wired up at the wire level. Currently only
+ * Lyria RealTime (via the BidiGenerateMusic WebSocket) ships it.
+ * Calling `streamGenerationFrom` while only a non-interactive Layer is
+ * in scope fails at `Effect.provide` with a type error.
+ *
+ * Phantom — the value is `void`; providers register with
+ * `Layer.succeed(MusicInteractiveSession, undefined)`.
+ */
+export class MusicInteractiveSession extends Context.Service<MusicInteractiveSession, void>()(
+  "@betalyra/effect-uai/capability/MusicInteractiveSession",
+) {}
+
+/** One-shot generation. */
+export const generate = (
+  request: CommonGenerateMusicRequest,
+): Effect.Effect<MusicResult, AiError.AiError, MusicGenerator> =>
+  Effect.flatMap(MusicGenerator.asEffect(), (s) => s.generate(request))
+
+/** Prompt in, audio chunks out. */
+export const streamGeneration = (
+  request: CommonStreamGenerateMusicRequest,
+): Stream.Stream<AudioChunk, AiError.AiError, MusicGenerator> =>
+  Stream.unwrap(Effect.map(MusicGenerator.asEffect(), (s) => s.streamGeneration(request)))
+
+/**
+ * Bidirectional generation. Dual-arity: pipeable (data-last) and
+ * direct (data-first). Requires `MusicInteractiveSession` in R —
+ * providers without bidirectional support are a type error at provide
+ * time.
+ *
+ * @example
+ * ```ts
+ * const audio = Stream.fromIterable([
+ *   Music.promptsInput([{ text: "minimal techno", weight: 1.0 }]),
+ *   Music.configInput({ bpm: 124 }),
+ * ]).pipe(
+ *   MusicGenerator.streamGenerationFrom({ model: "lyria-realtime-001", prompts: "" }),
+ * )
+ * ```
+ */
+export const streamGenerationFrom: {
+  (
+    request: CommonStreamGenerateMusicRequest,
+  ): <E, R>(
+    input: Stream.Stream<MusicSessionInput, E, R>,
+  ) => Stream.Stream<AudioChunk, AiError.AiError | E, R | MusicGenerator | MusicInteractiveSession>
+  <E, R>(
+    input: Stream.Stream<MusicSessionInput, E, R>,
+    request: CommonStreamGenerateMusicRequest,
+  ): Stream.Stream<AudioChunk, AiError.AiError | E, R | MusicGenerator | MusicInteractiveSession>
+} = Function.dual(
+  2,
+  <E, R>(
+    input: Stream.Stream<MusicSessionInput, E, R>,
+    request: CommonStreamGenerateMusicRequest,
+  ) =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const s = yield* MusicGenerator.asEffect()
+        yield* MusicInteractiveSession.asEffect()
+        return s.streamGenerationFrom(input, request)
+      }),
+    ),
+)

package/src/observability/Metrics.ts

@@ -38,7 +38,7 @@ export const timeToFirst =
       Effect.map(Option.map(({ elapsed }) => elapsed)),
     )
 
-export interface RatePoint<A> {
+export type RatePoint<A> = {
   readonly value: A
   readonly total: number
   readonly ratePerSecond: number

package/src/speech-synthesizer/SpeechSynthesizer.test.ts

@@ -0,0 +1,141 @@
+import { Effect, Stream } from "effect"
+import { describe, expect, expectTypeOf, it } from "vitest"
+import type * as AiError from "../domain/AiError.js"
+import type { AudioBlob, AudioChunk, AudioFormat } from "../domain/Audio.js"
+import * as MockSpeechSynthesizer from "../testing/MockSpeechSynthesizer.js"
+import * as SpeechSynthesizer from "./SpeechSynthesizer.js"
+
+const pcmFormat: AudioFormat = {
+  container: "raw",
+  encoding: "pcm_s16le",
+  sampleRate: 24000,
+}
+
+const blob: AudioBlob = {
+  format: pcmFormat,
+  bytes: new Uint8Array([0xde, 0xad, 0xbe, 0xef]),
+  durationSeconds: 0.5,
+}
+
+const chunk = (n: number): AudioChunk => ({ bytes: new Uint8Array([n]) })
+
+describe("SpeechSynthesizer.synthesize", () => {
+  it("returns the scripted AudioBlob", async () => {
+    const mock = MockSpeechSynthesizer.layer({ blobs: [blob] })
+    const program = SpeechSynthesizer.synthesize({
+      text: "hi",
+      model: "mock-tts",
+      voiceId: "stock-voice",
+    })
+    const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(result.bytes).toEqual(blob.bytes)
+    expect(result.durationSeconds).toBe(0.5)
+  })
+})
+
+describe("SpeechSynthesizer.streamSynthesis", () => {
+  it("emits scripted chunks for full-text-in streaming", async () => {
+    const mock = MockSpeechSynthesizer.layer({
+      streamSynthesisChunks: [[chunk(1), chunk(2), chunk(3)]],
+    })
+    const program = Stream.runCollect(
+      SpeechSynthesizer.streamSynthesis({
+        text: "hi",
+        model: "mock-tts",
+        voiceId: "stock-voice",
+      }),
+    )
+    const out = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(out.map((c) => Array.from(c.bytes))).toEqual([[1], [2], [3]])
+  })
+})
+
+describe("SpeechSynthesizer capability marker (compile-time)", () => {
+  const ssfReq: SpeechSynthesizer.CommonStreamSynthesizeRequest = {
+    model: "mock-tts",
+    voiceId: "v",
+  }
+
+  it("requires `TtsIncrementalText` on the R channel of streamSynthesisFrom", () => {
+    const tokens: Stream.Stream<string> = Stream.fromIterable(["a"])
+    const audio = tokens.pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq))
+    expectTypeOf(audio).toEqualTypeOf<
+      Stream.Stream<
+        AudioChunk,
+        AiError.AiError,
+        SpeechSynthesizer.SpeechSynthesizer | SpeechSynthesizer.TtsIncrementalText
+      >
+    >()
+  })
+
+  it("does NOT require `TtsIncrementalText` for sync `synthesize`", () => {
+    const eff = SpeechSynthesizer.synthesize({ text: "hi", model: "m", voiceId: "v" })
+    expectTypeOf(eff).toEqualTypeOf<
+      Effect.Effect<AudioBlob, AiError.AiError, SpeechSynthesizer.SpeechSynthesizer>
+    >()
+  })
+
+  it("does NOT require `TtsIncrementalText` for full-text `streamSynthesis`", () => {
+    const audio = SpeechSynthesizer.streamSynthesis({ text: "hi", model: "m", voiceId: "v" })
+    expectTypeOf(audio).toEqualTypeOf<
+      Stream.Stream<AudioChunk, AiError.AiError, SpeechSynthesizer.SpeechSynthesizer>
+    >()
+  })
+
+  it("a layer without the marker leaves `TtsIncrementalText` unsatisfied in R", () => {
+    const noMarker = MockSpeechSynthesizer.layerWithoutIncremental({})
+    const tokens: Stream.Stream<string> = Stream.fromIterable(["a"])
+    const audio = tokens.pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq))
+    const program = Stream.runDrain(audio).pipe(Effect.provide(noMarker.layer))
+    // `SpeechSynthesizer` is provided by the layer; `TtsIncrementalText` is not,
+    // so it remains in R — calling `Effect.runPromise(program)` would be a type
+    // error because runPromise requires `R = never`.
+    expectTypeOf(program).toEqualTypeOf<
+      Effect.Effect<void, AiError.AiError, SpeechSynthesizer.TtsIncrementalText>
+    >()
+  })
+
+  it("a full layer (with marker) clears R to never", () => {
+    const fullMock = MockSpeechSynthesizer.layer({
+      streamSynthesisFromChunks: [[]],
+    })
+    const tokens: Stream.Stream<string> = Stream.fromIterable(["a"])
+    const audio = tokens.pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq))
+    const program = Stream.runDrain(audio).pipe(Effect.provide(fullMock.layer))
+    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()
+  })
+})
+
+describe("SpeechSynthesizer.streamSynthesisFrom", () => {
+  const ssfReq: SpeechSynthesizer.CommonStreamSynthesizeRequest = {
+    model: "mock-tts",
+    voiceId: "stock-voice",
+  }
+
+  it("pipes an LLM-style text stream into audio chunks", async () => {
+    const mock = MockSpeechSynthesizer.layer({
+      streamSynthesisFromChunks: [[chunk(10), chunk(20)]],
+    })
+    const tokens = Stream.fromIterable(["Hello, ", "world."])
+    const audio = tokens.pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq))
+    const out = await Effect.runPromise(Stream.runCollect(audio).pipe(Effect.provide(mock.layer)))
+    expect(out.map((c) => Array.from(c.bytes))).toEqual([[10], [20]])
+  })
+
+  it("records the request on the streamSynthesisFrom call channel", async () => {
+    const mock = MockSpeechSynthesizer.layer({
+      streamSynthesisFromChunks: [[chunk(42)]],
+    })
+    const program = Effect.gen(function* () {
+      yield* Stream.runDrain(
+        Stream.fromIterable(["x"]).pipe(SpeechSynthesizer.streamSynthesisFrom(ssfReq)),
+      )
+      return yield* mock.recorder
+    })
+    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(rec.streamSynthesisFromCalls.length).toBe(1)
+    expect(rec.streamSynthesisFromCalls[0]!.voiceId).toBe("stock-voice")
+    expect(rec.synthesizeCalls.length).toBe(0)
+    expect(rec.streamSynthesisCalls.length).toBe(0)
+  })
+})