@effect-uai/core 0.3.0 → 0.5.0

package/src/loop/Loop.ts

@@ -18,14 +18,17 @@
  * `Loop.nextAfter` / `Loop.stopAfter` helpers to terminate cleanly.
  */
 import {
+  Array as Arr,
   Cause,
   Channel,
   Data,
   Effect,
   Exit,
   Function,
+  Match,
   Option,
   Ref,
+  Result,
   Scope,
   Stream,
   SubscriptionRef,
@@ -40,12 +43,22 @@ import { isTurnComplete, type Turn, type TurnEvent } from "../domain/Turn.js"
 /**
  * The tagged union a body emits per pull. `Value` carries a payload that
  * flows downstream. `Next` ends the current iteration and continues with a
- * new state. `Stop` ends the loop entirely.
+ * new state. `Stop` ends the loop entirely with no carried state.
+ * `StopWith` also ends the loop but carries a final state that `loopFrom`
+ * will thread to the next input and `loopWithState` will write to its
+ * `SubscriptionRef` before the loop ends. Plain `loop` has no next
+ * iteration to apply it to and treats `StopWith` like `Stop`.
+ *
+ * `Stop` is intentionally `{}` so the bare `stopEvent` / `stop` helpers
+ * don't constrain `S` from a body's stream type — every body has a `Stop`
+ * variant in its union, and forcing `S` to flow through it would break
+ * inference whenever the body never uses `next` / `stopWith`.
  */
 export type Event<A, S> = Data.TaggedEnum<{
   Value: { readonly value: A }
   Next: { readonly state: S }
   Stop: {}
+  StopWith: { readonly state: S }
 }>
 
 interface EventDef extends Data.TaggedEnum.WithGenerics<2> {
@@ -60,9 +73,21 @@ export const value = <A>(a: A): Event<A, never> => Event.Value({ value: a })
 /** End the current iteration and continue with a new state. */
 export const next = <S>(state: S): Event<never, S> => Event.Next({ state })
 
-/** The terminal `Stop` event. Use `stop` (the Stream) to end a loop body. */
+/**
+ * The terminal `Stop` event with no carried state. Use `stop` (the Stream)
+ * to end a loop body without communicating a final state.
+ */
 export const stopEvent: Event<never, never> = Event.Stop()
 
+/**
+ * Terminal event that ends the loop AND carries a final state. For
+ * `loopFrom` this is the natural "this input is done, here's the state to
+ * carry forward to the next input" signal — symmetric with `next(s)` but
+ * ending the inner loop instead of continuing it. For `loopWithState` the
+ * carried state is written to the `SubscriptionRef` before the loop ends.
+ */
+export const stopWith = <S>(state: S): Event<never, S> => Event.StopWith({ state })
+
 /**
  * A single-element stream that ends the loop. Return this from a body when
  * there's nothing else to emit; equivalent to `stopAfter(Stream.empty)` but
@@ -74,22 +99,47 @@ export const stop: Stream.Stream<Event<never, never>> = Stream.succeed(stopEvent
  * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the
  * iteration with `next(state)`. Common shape for "stream this turn's
  * deltas, then continue with updated history."
+ *
+ * Dual: data-first `nextAfter(stream, state)` and data-last
+ * `stream.pipe(nextAfter(state))` both work.
  */
-export const nextAfter = <S, A, E, R>(
-  stream: Stream.Stream<A, E, R>,
-  state: S,
-): Stream.Stream<Event<A, S>, E, R> =>
-  Stream.concat(Stream.map(stream, value), Stream.fromIterable([next(state)]))
+export const nextAfter: {
+  <S>(state: S): <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<Event<A, S>, E, R>
+  <S, A, E, R>(stream: Stream.Stream<A, E, R>, state: S): Stream.Stream<Event<A, S>, E, R>
+} = Function.dual(
+  2,
+  <S, A, E, R>(stream: Stream.Stream<A, E, R>, state: S): Stream.Stream<Event<A, S>, E, R> =>
+    Stream.concat(Stream.map(stream, value), Stream.fromIterable([next(state)])),
+)
 
 /**
  * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate the
  * loop. Common shape for "stream this turn's deltas, then we're done."
+ *
+ * Unary on the stream — already pipe-compatible via `stream.pipe(stopAfter)`.
  */
 export const stopAfter = <A, E, R>(
   stream: Stream.Stream<A, E, R>,
 ): Stream.Stream<Event<A, never>, E, R> =>
   Stream.concat(Stream.map(stream, value), Stream.fromIterable([stopEvent]))
 
+/**
+ * Pipe a raw `Stream<A>` into the loop's emit shape, then terminate with
+ * `stopWith(state)`. The natural "emit final outputs, advance state, end
+ * this input's inner loop" shape for `loopFrom`.
+ *
+ * Dual: data-first `stopWithAfter(stream, state)` and data-last
+ * `stream.pipe(stopWithAfter(state))` both work.
+ */
+export const stopWithAfter: {
+  <S>(state: S): <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<Event<A, S>, E, R>
+  <S, A, E, R>(stream: Stream.Stream<A, E, R>, state: S): Stream.Stream<Event<A, S>, E, R>
+} = Function.dual(
+  2,
+  <S, A, E, R>(stream: Stream.Stream<A, E, R>, state: S): Stream.Stream<Event<A, S>, E, R> =>
+    Stream.concat(Stream.map(stream, value), Stream.fromIterable([stopWith(state)])),
+)
+
 /**
  * General `nextAfter` variant: drain `stream` to the consumer, fold elements
  * into an accumulator, and at end-of-stream emit one `next(build(finalAcc))`.
@@ -97,26 +147,44 @@ export const stopAfter = <A, E, R>(
  * Subsumes `nextAfter` when state is constant (`reduce: (s, _) => s`,
  * `build: (s) => s`). Used by `Toolkit.continueWith` to collect tool
  * results and build next state without exposing a Ref to recipes.
+ *
+ * Dual: data-first `nextAfterFold(stream, initial, reduce, build)` and
+ * data-last `stream.pipe(nextAfterFold(initial, reduce, build))` both work.
  */
-export const nextAfterFold = <A, B, S, E, R>(
-  stream: Stream.Stream<A, E, R>,
-  initial: B,
-  reduce: (acc: B, a: A) => B,
-  build: (b: B) => S,
-): Stream.Stream<Event<A, S>, E, R> =>
-  Stream.unwrap(
-    Effect.gen(function* () {
-      const ref = yield* Ref.make(initial)
-      const tapped = stream.pipe(
-        Stream.tap((a) => Ref.update(ref, (acc) => reduce(acc, a))),
-        Stream.map(value),
-      )
-      const continuation = Stream.fromEffect(
-        Ref.get(ref).pipe(Effect.map((acc) => next(build(acc)))),
-      )
-      return tapped.pipe(Stream.concat(continuation))
-    }),
-  )
+export const nextAfterFold: {
+  <A, B, S>(
+    initial: B,
+    reduce: (acc: B, a: A) => B,
+    build: (b: B) => S,
+  ): <E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<Event<A, S>, E, R>
+  <A, B, S, E, R>(
+    stream: Stream.Stream<A, E, R>,
+    initial: B,
+    reduce: (acc: B, a: A) => B,
+    build: (b: B) => S,
+  ): Stream.Stream<Event<A, S>, E, R>
+} = Function.dual(
+  4,
+  <A, B, S, E, R>(
+    stream: Stream.Stream<A, E, R>,
+    initial: B,
+    reduce: (acc: B, a: A) => B,
+    build: (b: B) => S,
+  ): Stream.Stream<Event<A, S>, E, R> =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const ref = yield* Ref.make(initial)
+        const tapped = stream.pipe(
+          Stream.tap((a) => Ref.update(ref, (acc) => reduce(acc, a))),
+          Stream.map(value),
+        )
+        const continuation = Stream.fromEffect(
+          Ref.get(ref).pipe(Effect.map((acc) => next(build(acc)))),
+        )
+        return tapped.pipe(Stream.concat(continuation))
+      }),
+    ),
+)
 
 // ---------------------------------------------------------------------------
 // onTurnComplete - turn-aware stream operator for loop bodies
@@ -125,7 +193,7 @@ export const nextAfterFold = <A, B, S, E, R>(
 /**
  * Lift a provider's `Stream<TurnEvent>` into a loop body's `Stream<Event<TurnEvent | A, S>>`.
  * Each delta passes through as `value(delta)` (including the terminal
- * `turn_complete`, so the consumer sees turn boundaries naturally). Once
+ * `TurnComplete`, so the consumer sees turn boundaries naturally). Once
  * the terminal arrives, `then(turn)` runs and its returned stream of loop
  * events (typically tool outputs followed by `next(state)` or `stop`) is
  * concatenated.
@@ -133,16 +201,28 @@ export const nextAfterFold = <A, B, S, E, R>(
  * Pre-pipe transforms (`Stream.tap` / `Stream.map` / `Stream.filter`) on
  * the raw delta stream cover anything an `emit`-style callback would do.
  *
- * If the upstream ends without a `turn_complete`, the resulting stream
+ * If the upstream ends without a `TurnComplete`, the resulting stream
  * fails with `AiError.IncompleteTurn`. Catch it via `Stream.catchTag` if
  * you want to recover.
+ *
+ * Dual: data-first `onTurnComplete(deltas, then)` and data-last
+ * `deltas.pipe(onTurnComplete(then))` both work.
  */
-export const onTurnComplete =
+export const onTurnComplete: {
   <S, A, E2 = never, R2 = never>(
     then: (turn: Turn) => Effect.Effect<Stream.Stream<Event<A, S>, E2, R2>, E2, R2>,
-  ) =>
-  <E, R>(
+  ): <E, R>(
+    deltas: Stream.Stream<TurnEvent, E, R>,
+  ) => Stream.Stream<Event<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>
+  <S, A, E, R, E2 = never, R2 = never>(
     deltas: Stream.Stream<TurnEvent, E, R>,
+    then: (turn: Turn) => Effect.Effect<Stream.Stream<Event<A, S>, E2, R2>, E2, R2>,
+  ): Stream.Stream<Event<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2>
+} = Function.dual(
+  2,
+  <S, A, E, R, E2, R2>(
+    deltas: Stream.Stream<TurnEvent, E, R>,
+    then: (turn: Turn) => Effect.Effect<Stream.Stream<Event<A, S>, E2, R2>, E2, R2>,
   ): Stream.Stream<Event<TurnEvent | A, S>, E | E2 | IncompleteTurn, R | R2> =>
     Stream.unwrap(
       Effect.gen(function* () {
@@ -158,14 +238,15 @@ export const onTurnComplete =
         const continuation = Stream.unwrap(
           Effect.gen(function* () {
             const opt = yield* Ref.get(turnRef)
-            if (Option.isNone(opt)) return yield* Effect.fail(new IncompleteTurn({}))
+            if (Option.isNone(opt)) return yield* new IncompleteTurn({})
             return yield* then(opt.value)
           }),
         )
 
         return Stream.concat(events, continuation)
       }),
-    )
+    ),
+)
 
 // ---------------------------------------------------------------------------
 // Internal helpers
@@ -192,17 +273,18 @@ const closeBody = <S, A, E, R>(
  */
 const partitionChunk = <A, S>(
   chunk: ReadonlyArray<Event<A, S>>,
-): { readonly values: Array<A>; readonly decision: Event<A, S> | undefined } => {
-  const values: Array<A> = []
-  for (let i = 0; i < chunk.length; i++) {
-    const event = chunk[i]!
-    if (event._tag === "Value") {
-      values.push(event.value)
-    } else {
-      return { values, decision: event }
-    }
+): {
+  readonly values: ReadonlyArray<A>
+  readonly decision: Option.Option<Event<A, S>>
+} => {
+  const [valueEvents, rest] = Arr.span(
+    chunk,
+    (e): e is Event<A, S> & { _tag: "Value" } => e._tag === "Value",
+  )
+  return {
+    values: valueEvents.map((e) => e.value),
+    decision: Arr.head(rest),
   }
-  return { values, decision: undefined }
 }
 
 // ---------------------------------------------------------------------------
@@ -283,17 +365,20 @@ export const loop: {
 
               const { values, decision } = partitionChunk(chunk)
 
-              if (decision !== undefined) {
+              if (Option.isSome(decision)) {
                 yield* closeActive(active, Exit.void)
-                if (decision._tag === "Stop") {
+                if (decision.value._tag === "Stop" || decision.value._tag === "StopWith") {
+                  // `loop` has no next iteration to apply StopWith's state to;
+                  // the state lands in `loopFrom`'s outer ref or
+                  // `loopWithState`'s SubscriptionRef via their taps.
                   done = true
-                } else if (decision._tag === "Next") {
-                  state = decision.state
+                } else if (decision.value._tag === "Next") {
+                  state = decision.value.state
                 }
               }
 
               // Emit the values seen so far if any. Chunks from a Stream pull
-              // are non-empty, so when `decision === undefined` every event was
+              // are non-empty, so when `decision` is `None` every event was
               // a `Value` and `values` is non-empty here. With a decision and
               // no preceding values, fall through to the next iteration.
               if (isNonEmpty(values)) return values
@@ -306,6 +391,91 @@ export const loop: {
     ),
 )
 
+// ---------------------------------------------------------------------------
+// loopFrom - stream-driven sibling of loop. One input item runs a full
+// multi-turn inner loop.
+// ---------------------------------------------------------------------------
+
+type LoopFromBody<S, I, A, E, R> = (
+  state: S,
+  input: I,
+) => Stream.Stream<Event<A, S>, E, R> | Effect.Effect<Stream.Stream<Event<A, S>, E, R>, E, R>
+
+/**
+ * Input-driven sibling of `loop`. For each item pulled from the input
+ * stream, runs an inner seed-driven `loop` whose body is
+ * `(s) => body(s, item)`. State is threaded across input items.
+ *
+ * **Per-input semantics — the body emits standard `Event<A, S>`:**
+ *   - `value(a)`: emit `a` downstream
+ *   - `next(s)`: re-run the body with the SAME input and new state `s`
+ *     (multi-turn within one input — e.g. multiple model turns + tool
+ *     calls for one document)
+ *   - `stop`: end this input's inner loop, advance to the next input
+ *     (state preserved)
+ *   - body stream ending without a decision: same as `stop` (advance)
+ *
+ * **Outer termination:** the input stream ending. To halt programmatically
+ * from within, end the input stream upstream (`Stream.takeWhile`, a
+ * `SubscriptionRef` gate, etc.). Reserving `stop` for per-item
+ * advancement is what makes the common "stream of documents, multi-turn
+ * conversation per document" shape readable.
+ *
+ * Dual: data-first `loopFrom(input, initial, body)` and data-last
+ * `input.pipe(loopFrom(initial, body))` both work.
+ */
+export const loopFrom: {
+  <S, I, A, E, R>(
+    initial: S,
+    body: LoopFromBody<S, I, A, E, R>,
+  ): <EI, RI>(input: Stream.Stream<I, EI, RI>) => Stream.Stream<A, E | EI, R | RI>
+  <S, I, A, E, R, EI, RI>(
+    input: Stream.Stream<I, EI, RI>,
+    initial: S,
+    body: LoopFromBody<S, I, A, E, R>,
+  ): Stream.Stream<A, E | EI, R | RI>
+} = Function.dual(
+  3,
+  <S, I, A, E, R, EI, RI>(
+    input: Stream.Stream<I, EI, RI>,
+    initial: S,
+    body: LoopFromBody<S, I, A, E, R>,
+  ): Stream.Stream<A, E | EI, R | RI> =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const stateRef = yield* Ref.make<S>(initial)
+        return input.pipe(
+          Stream.flatMap((item) =>
+            Stream.unwrap(
+              Effect.gen(function* () {
+                const state = yield* Ref.get(stateRef)
+                // Capture Next states (and stopWith's final state) into the
+                // outer ref so the LAST state seen in this input's inner
+                // loop is what the next input starts from.
+                const wrappedBody = (s: S) => {
+                  const result = body(s, item)
+                  const stream = Effect.isEffect(result) ? Stream.unwrap(result) : result
+                  return stream.pipe(
+                    Stream.tap((event) =>
+                      Match.value(event).pipe(
+                        Match.tags({
+                          Next: (e) => Ref.set(stateRef, e.state),
+                          StopWith: (e) => Ref.set(stateRef, e.state),
+                        }),
+                        Match.orElse(() => Effect.void),
+                      ),
+                    ),
+                  )
+                }
+                return loop(state, wrappedBody)
+              }),
+            ),
+          ),
+        )
+      }),
+    ),
+)
+
 // ---------------------------------------------------------------------------
 // loopWithState - same body protocol, plus a live state observable.
 // ---------------------------------------------------------------------------
@@ -343,7 +513,13 @@ export const loopWithState = <S, A, E, R>(
     const tap = (stream: Stream.Stream<Event<A, S>, E, R>): Stream.Stream<Event<A, S>, E, R> =>
       stream.pipe(
         Stream.tap((event) =>
-          event._tag === "Next" ? SubscriptionRef.set(stateRef, event.state) : Effect.void,
+          Match.value(event).pipe(
+            Match.tags({
+              Next: (e) => SubscriptionRef.set(stateRef, e.state),
+              StopWith: (e) => SubscriptionRef.set(stateRef, e.state),
+            }),
+            Match.orElse(() => Effect.void),
+          ),
         ),
       )
 

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