@effect-uai/core 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Low-level primitives (loop, conversation, items, tools, streaming codecs) for building AI agents with Effect.",
   "keywords": [
     "agents",
@@ -38,6 +38,10 @@
       "types": "./dist/domain/AiError.d.mts",
       "import": "./dist/domain/AiError.mjs"
     },
+    "./Audio": {
+      "types": "./dist/domain/Audio.d.mts",
+      "import": "./dist/domain/Audio.mjs"
+    },
     "./Image": {
       "types": "./dist/domain/Image.d.mts",
       "import": "./dist/domain/Image.mjs"
@@ -50,6 +54,14 @@
       "types": "./dist/domain/Media.d.mts",
       "import": "./dist/domain/Media.mjs"
     },
+    "./Music": {
+      "types": "./dist/domain/Music.d.mts",
+      "import": "./dist/domain/Music.mjs"
+    },
+    "./Transcript": {
+      "types": "./dist/domain/Transcript.d.mts",
+      "import": "./dist/domain/Transcript.mjs"
+    },
     "./Turn": {
       "types": "./dist/domain/Turn.d.mts",
       "import": "./dist/domain/Turn.mjs"
@@ -66,6 +78,18 @@
       "types": "./dist/language-model/LanguageModel.d.mts",
       "import": "./dist/language-model/LanguageModel.mjs"
     },
+    "./MusicGenerator": {
+      "types": "./dist/music-generator/MusicGenerator.d.mts",
+      "import": "./dist/music-generator/MusicGenerator.mjs"
+    },
+    "./SpeechSynthesizer": {
+      "types": "./dist/speech-synthesizer/SpeechSynthesizer.d.mts",
+      "import": "./dist/speech-synthesizer/SpeechSynthesizer.mjs"
+    },
+    "./Transcriber": {
+      "types": "./dist/transcriber/Transcriber.d.mts",
+      "import": "./dist/transcriber/Transcriber.mjs"
+    },
     "./Loop": {
       "types": "./dist/loop/Loop.d.mts",
       "import": "./dist/loop/Loop.mjs"
@@ -121,6 +145,18 @@
     "./testing/MockProvider": {
       "types": "./dist/testing/MockProvider.d.mts",
       "import": "./dist/testing/MockProvider.mjs"
+    },
+    "./testing/MockMusicGenerator": {
+      "types": "./dist/testing/MockMusicGenerator.d.mts",
+      "import": "./dist/testing/MockMusicGenerator.mjs"
+    },
+    "./testing/MockSpeechSynthesizer": {
+      "types": "./dist/testing/MockSpeechSynthesizer.d.mts",
+      "import": "./dist/testing/MockSpeechSynthesizer.mjs"
+    },
+    "./testing/MockTranscriber": {
+      "types": "./dist/testing/MockTranscriber.d.mts",
+      "import": "./dist/testing/MockTranscriber.mjs"
     }
   },
   "publishConfig": {

package/src/domain/AiError.ts

@@ -80,6 +80,26 @@ export class IncompleteTurn extends Data.TaggedError("IncompleteTurn")<{
   raw?: unknown
 }> {}
 
+/**
+ * The provider does not implement the requested capability for this
+ * specific request. Distinct from `InvalidRequest` (the request shape is
+ * malformed) and `AuthFailed` (the request was rejected).
+ *
+ * Reserved for request-data-dependent gaps where the provider supports
+ * the method in general but not for these inputs — e.g. Google's
+ * `streamSynthesisFrom` works only for Chirp 3 HD voices; calling it
+ * with a Neural2 voice ID fails `Unsupported`.
+ *
+ * Blanket provider-level gaps (e.g. OpenAI has no incremental-text-in
+ * TTS at all) are gated at compile time via capability marker tags
+ * (`TtsIncrementalText`, `SttStreaming`) on the R channel instead.
+ */
+export class Unsupported extends Data.TaggedError("Unsupported")<{
+  provider: string
+  capability: string
+  reason?: string
+}> {}
+
 export type AiError =
   | RateLimited
   | Unavailable
@@ -91,3 +111,4 @@ export type AiError =
   | Cancelled
   | IncompleteTurn
   | GenerationFailed
+  | Unsupported

package/src/domain/Audio.ts

@@ -0,0 +1,88 @@
+import type { MediaBase64, MediaBytes, MediaUrl } from "./Media.js"
+
+/**
+ * MIME types we care about across STT input and TTS output. Container-
+ * level only — sample rate / encoding flavours live on `AudioFormat`.
+ *
+ * Per-provider request types narrow this further. The `(string & {})`
+ * tail keeps autocomplete on the literals while still accepting any
+ * string, so unusual formats work without an SDK update.
+ */
+export type AudioMimeType =
+  | "audio/mpeg"
+  | "audio/wav"
+  | "audio/x-wav"
+  | "audio/ogg"
+  | "audio/opus"
+  | "audio/flac"
+  | "audio/aac"
+  | "audio/mp4"
+  | "audio/webm"
+  | "audio/L16"
+  | "audio/pcm"
+  | "audio/mulaw"
+  | "audio/alaw"
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (string & {})
+
+/**
+ * Audio at rest — instantiates `MediaSource` with the audio MIME union.
+ * Used for sync STT input.
+ *
+ * URL variant is best-effort: some providers (OpenAI, Cartesia, Azure
+ * short-audio) reject URL ingestion and the adapter must upload via the
+ * `bytes` or `base64` variant instead. Adapter layers reject unsupported
+ * shapes up front with `AiError.InvalidRequest`.
+ */
+export type AudioSource =
+  | MediaUrl<AudioMimeType>
+  | MediaBase64<AudioMimeType>
+  | MediaBytes<AudioMimeType>
+
+export const isAudioUrl = (s: AudioSource): s is MediaUrl<AudioMimeType> => s._tag === "url"
+export const isAudioBase64 = (s: AudioSource): s is MediaBase64<AudioMimeType> =>
+  s._tag === "base64"
+export const isAudioBytes = (s: AudioSource): s is MediaBytes<AudioMimeType> => s._tag === "bytes"
+
+/**
+ * Structural audio format. Used both as TTS output spec and as STT
+ * streaming-input declaration. Providers that use compound slugs
+ * (`mp3_44100_128`, `audio-16khz-128kbitrate-mono-mp3`,
+ * `aura-2-thalia-en`) are encoded at the adapter layer.
+ */
+export type AudioFormat = {
+  readonly container: "mp3" | "wav" | "ogg" | "opus" | "flac" | "aac" | "webm" | "raw"
+  readonly encoding:
+    | "pcm_s16le"
+    | "pcm_f32le"
+    | "pcm_mulaw"
+    | "pcm_alaw"
+    | "mp3"
+    | "opus"
+    | "vorbis"
+    | "flac"
+    | "aac"
+  readonly sampleRate: 8000 | 16000 | 22050 | 24000 | 32000 | 44100 | 48000
+  /** mp3 / opus only. */
+  readonly bitRate?: number
+  readonly channels?: 1 | 2
+}
+
+/**
+ * Streamed audio chunk. `bytes` carries the codec-encoded payload as
+ * declared on the stream's `AudioFormat`. No per-chunk timestamp here —
+ * providers that emit timing do so via `TranscriptEvent.words[]`.
+ */
+export type AudioChunk = {
+  readonly bytes: Uint8Array
+}
+
+/**
+ * Full audio result for sync TTS. Format mirrors the request; provider
+ * layers normalize.
+ */
+export type AudioBlob = {
+  readonly format: AudioFormat
+  readonly bytes: Uint8Array
+  readonly durationSeconds?: number
+}

package/src/domain/Music.ts

@@ -0,0 +1,121 @@
+import type { AudioBlob, AudioFormat } from "./Audio.js"
+
+/**
+ * Prompt fragment with a relative weight. Native to Lyria RealTime
+ * (`{ text, weight }` pairs blended in the model). Single-prompt
+ * providers (Suno, Mureka, MiniMax) flatten to text at the adapter
+ * layer.
+ */
+export type WeightedPrompt = {
+  readonly text: string
+  /** Default `1.0`. Range typically `[0, 1]`; provider-dependent. */
+  readonly weight?: number
+}
+
+/**
+ * Cross-provider music-generation request. Provider-specific extras
+ * (Lyria `mode`, ElevenLabs `composition_plan`, Suno custom-mode `title`,
+ * MiniMax `lyrics_optimizer`) live on each provider's typed request
+ * which extends this and narrows `model`.
+ */
+export type CommonGenerateMusicRequest = {
+  /** Model identifier. Each provider narrows. */
+  readonly model: string
+  /** Single prompt string or weighted-prompt list (blended where supported). */
+  readonly prompts: string | ReadonlyArray<WeightedPrompt>
+  /**
+   * Lyrics text, optionally with section tags like `[Verse]` / `[Chorus]` /
+   * `[Bridge]` / `[Outro]`. Ignored for instrumental-only providers or
+   * when `instrumental: true`.
+   */
+  readonly lyrics?: string
+  /** Target duration in seconds. Provider may treat as a hint or hard limit. */
+  readonly durationSeconds?: number
+  /** Beats per minute (60–200 typical). */
+  readonly bpm?: number
+  /**
+   * Musical key/mode hint. Provider-specific vocabulary (e.g. Lyria
+   * RealTime uses enum values like `"C_MAJOR"`, `"A_MINOR"`).
+   */
+  readonly scale?: string
+  /** Skip vocals / lyrics. */
+  readonly instrumental?: boolean
+  /** Preferred output format. Provider may override. */
+  readonly outputFormat?: AudioFormat
+}
+
+/**
+ * Streamed-output request. Same shape as the sync request — the
+ * streaming variant only differs in how the response is delivered.
+ */
+export type CommonStreamGenerateMusicRequest = CommonGenerateMusicRequest
+
+/**
+ * Bidirectional-session input. The user pushes one of these per
+ * change: a new prompt blend, a config delta, or a playback control.
+ * Lyria RealTime is the only provider currently surfacing these.
+ */
+export type MusicSessionInput =
+  | { readonly _tag: "prompts"; readonly prompts: ReadonlyArray<WeightedPrompt> }
+  | {
+      readonly _tag: "config"
+      readonly config: {
+        readonly bpm?: number
+        readonly scale?: string
+        readonly density?: number
+        readonly brightness?: number
+        readonly guidance?: number
+        readonly temperature?: number
+        readonly topK?: number
+        readonly seed?: number
+        readonly muteBass?: boolean
+        readonly muteDrums?: boolean
+        readonly onlyBassAndDrums?: boolean
+      }
+    }
+  | { readonly _tag: "control"; readonly action: "play" | "pause" | "stop" | "reset_context" }
+
+export const promptsInput = (prompts: ReadonlyArray<WeightedPrompt>): MusicSessionInput => ({
+  _tag: "prompts",
+  prompts,
+})
+
+export const configInput = (
+  config: (MusicSessionInput & { _tag: "config" })["config"],
+): MusicSessionInput => ({ _tag: "config", config })
+
+export const controlInput = (
+  action: (MusicSessionInput & { _tag: "control" })["action"],
+): MusicSessionInput => ({ _tag: "control", action })
+
+/**
+ * Sync-generation result. Extends `AudioBlob` with provider-side
+ * metadata that's common across music providers:
+ *
+ * - `songId` — Suno task id, ElevenLabs `song_id`, etc. Used for
+ *   back-reference (re-download, stem export, follow-up edits).
+ * - `lyrics` — generated lyrics when the model returned them (Lyria
+ *   text part, Mureka, Suno).
+ * - `sections` — structured section markers (Lyria optional JSON
+ *   structure response).
+ * - `watermark` — presence marker (Lyria SynthID is always set).
+ */
+export type MusicResult = AudioBlob & {
+  readonly songId?: string
+  readonly lyrics?: string
+  readonly sections?: ReadonlyArray<{
+    readonly label: string
+    readonly startSeconds: number
+    readonly endSeconds: number
+  }>
+  readonly watermark?: { readonly kind: string }
+}
+
+export const isPromptsInput = (
+  i: MusicSessionInput,
+): i is MusicSessionInput & { _tag: "prompts" } => i._tag === "prompts"
+export const isConfigInput = (i: MusicSessionInput): i is MusicSessionInput & { _tag: "config" } =>
+  i._tag === "config"
+export const isControlInput = (
+  i: MusicSessionInput,
+): i is MusicSessionInput & { _tag: "control" } => i._tag === "control"

package/src/domain/Transcript.ts

@@ -0,0 +1,83 @@
+/**
+ * Per-word timing + metadata. `confidence` and `speakerId` are optional
+ * because providers vary widely in what they emit and when (some only on
+ * final, some only with diarization enabled, some not at all).
+ */
+export type WordTimestamp = {
+  readonly text: string
+  readonly startSeconds: number
+  readonly endSeconds: number
+  readonly confidence?: number
+  readonly speakerId?: string
+  readonly languageCode?: string
+}
+
+/**
+ * Sync STT result. `raw` preserves the provider-specific response for
+ * consumers that need fields the common shape doesn't expose
+ * (alternatives, segments, NBest, audio events, etc.).
+ */
+export type TranscriptResult = {
+  readonly text: string
+  readonly languageCode?: string
+  readonly durationSeconds?: number
+  readonly words?: ReadonlyArray<WordTimestamp>
+  readonly raw?: unknown
+}
+
+/**
+ * Streaming STT event union. Collapses every provider's vocabulary into
+ * a small set; provider-specific shapes survive on `metadata.raw`.
+ *
+ * - `partial`: interim hypothesis. `stability` is Google-only.
+ * - `final`: committed transcript for the current utterance / segment.
+ * - `speech-started` / `utterance-ended`: VAD-derived boundaries. Not
+ *   all providers emit them (OpenAI Realtime, Google with
+ *   `voice_activity_events`, Deepgram with `vad_events`, AssemblyAI).
+ * - `audio-event`: non-speech label (`(laughter)`, `(music)`) — ElevenLabs only.
+ * - `metadata`: opaque server-side bookkeeping (request_id, model info).
+ * - `error`: non-fatal provider error mid-stream. Fatal errors surface
+ *   on the `Stream`'s error channel as `AiError.AiError`.
+ */
+export type TranscriptEvent =
+  | {
+      readonly _tag: "partial"
+      readonly text: string
+      readonly words?: ReadonlyArray<WordTimestamp>
+      readonly stability?: number
+    }
+  | {
+      readonly _tag: "final"
+      readonly text: string
+      readonly words?: ReadonlyArray<WordTimestamp>
+      readonly languageCode?: string
+    }
+  | { readonly _tag: "speech-started"; readonly atSeconds: number }
+  | { readonly _tag: "utterance-ended"; readonly atSeconds: number }
+  | {
+      readonly _tag: "audio-event"
+      readonly label: string
+      readonly startSeconds: number
+      readonly endSeconds: number
+    }
+  | { readonly _tag: "metadata"; readonly raw: unknown }
+  | { readonly _tag: "error"; readonly code?: string; readonly message: string }
+
+export const isPartial = (e: TranscriptEvent): e is Extract<TranscriptEvent, { _tag: "partial" }> =>
+  e._tag === "partial"
+export const isFinal = (e: TranscriptEvent): e is Extract<TranscriptEvent, { _tag: "final" }> =>
+  e._tag === "final"
+export const isSpeechStarted = (
+  e: TranscriptEvent,
+): e is Extract<TranscriptEvent, { _tag: "speech-started" }> => e._tag === "speech-started"
+export const isUtteranceEnded = (
+  e: TranscriptEvent,
+): e is Extract<TranscriptEvent, { _tag: "utterance-ended" }> => e._tag === "utterance-ended"
+export const isAudioEvent = (
+  e: TranscriptEvent,
+): e is Extract<TranscriptEvent, { _tag: "audio-event" }> => e._tag === "audio-event"
+export const isMetadata = (
+  e: TranscriptEvent,
+): e is Extract<TranscriptEvent, { _tag: "metadata" }> => e._tag === "metadata"
+export const isError = (e: TranscriptEvent): e is Extract<TranscriptEvent, { _tag: "error" }> =>
+  e._tag === "error"

package/src/index.ts

@@ -1,11 +1,17 @@
 export * as AiError from "./domain/AiError.js"
+export * as Audio from "./domain/Audio.js"
 export * as Image from "./domain/Image.js"
 export * as Items from "./domain/Items.js"
 export * as Media from "./domain/Media.js"
+export * as Music from "./domain/Music.js"
+export * as Transcript from "./domain/Transcript.js"
 export * as Turn from "./domain/Turn.js"
 export * as Embedding from "./embedding-model/Embedding.js"
 export * as EmbeddingModel from "./embedding-model/EmbeddingModel.js"
 export * as LanguageModel from "./language-model/LanguageModel.js"
+export * as MusicGenerator from "./music-generator/MusicGenerator.js"
+export * as SpeechSynthesizer from "./speech-synthesizer/SpeechSynthesizer.js"
+export * as Transcriber from "./transcriber/Transcriber.js"
 export * as Vector from "./math/Vector.js"
 export * as Loop from "./loop/Loop.js"
 export * as Tool from "./tool/Tool.js"

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