@effect-uai/core 0.3.0 → 0.4.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/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)
+  })
+})

package/src/speech-synthesizer/SpeechSynthesizer.ts

@@ -0,0 +1,131 @@
+import { Context, Effect, Function, Stream } from "effect"
+import * as AiError from "../domain/AiError.js"
+import type { AudioBlob, AudioChunk, AudioFormat } from "../domain/Audio.js"
+
+/**
+ * Cross-provider synthesis request. Provider-specific extensions
+ * (ElevenLabs `stability` / `similarity_boost`, Cartesia `emotion`,
+ * MiniMax `vol` / `pitch`, Azure SSML style tags) live on each
+ * provider's typed request which extends this and narrows `model` and
+ * `voiceId`.
+ */
+export type CommonSynthesizeRequest = {
+  readonly text: string
+  /** Model identifier. Each provider narrows. */
+  readonly model: string
+  /**
+   * Voice identifier. Per-provider request types narrow this to a
+   * typed literal union of stock voices + `(string & {})` escape for
+   * custom cloned voice IDs. Providers without custom-voice support
+   * (OpenAI, Deepgram Aura, AWS Polly) narrow to the stock-only union.
+   */
+  readonly voiceId: string
+  readonly outputFormat?: AudioFormat
+  readonly speed?: number
+  readonly languageCode?: string
+}
+
+/**
+ * Incremental-synthesis request — text arrives as `Stream<string>`.
+ * Gated by the `TtsIncrementalText` capability marker; only providers
+ * that ship the marker can be used.
+ *
+ * Multi-context features (Cartesia `context_id`, ElevenLabs `multi-
+ * stream-input`) are NOT exposed here — one logical utterance per
+ * call. Provider extensions can expose `forkContext` for that.
+ */
+export type CommonStreamSynthesizeRequest = Omit<CommonSynthesizeRequest, "text">
+
+export type SpeechSynthesizerService = {
+  /** One-shot. Full text in, full audio bytes out. Universally supported. */
+  readonly synthesize: (
+    request: CommonSynthesizeRequest,
+  ) => Effect.Effect<AudioBlob, AiError.AiError>
+  /**
+   * Full text in, audio chunks streamed out (chunked HTTP). Universally
+   * supported across providers that offer any streaming TTS at all.
+   */
+  readonly streamSynthesis: (
+    request: CommonSynthesizeRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError>
+  /**
+   * Incremental text in (as a Stream), audio chunks streamed out. The
+   * underlying WS connection is acquired on first pull and released
+   * when the output stream is finalized via `Stream.scoped`.
+   *
+   * Gated by the `TtsIncrementalText` capability marker on the top-
+   * level helper — providers without WS-style incremental input don't
+   * ship the marker, so calls fail at `Effect.provide` with a type
+   * error.
+   */
+  readonly streamSynthesisFrom: <E, R>(
+    textIn: Stream.Stream<string, E, R>,
+    request: CommonStreamSynthesizeRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError | E, R>
+}
+
+export class SpeechSynthesizer extends Context.Service<
+  SpeechSynthesizer,
+  SpeechSynthesizerService
+>()("@betalyra/effect-uai/SpeechSynthesizer") {}
+
+/**
+ * Capability marker — provided by provider layers whose
+ * `streamSynthesisFrom` is wired up at the wire level. OpenAI, Azure
+ * (wire), and AWS Polly non-Generative do not ship it. Calling
+ * `streamSynthesisFrom` while only one of those Layers is in scope
+ * fails at `Effect.provide` with a type error.
+ *
+ * Phantom — the value is `void`; providers register with
+ * `Layer.succeed(TtsIncrementalText, undefined)`.
+ */
+export class TtsIncrementalText extends Context.Service<TtsIncrementalText, void>()(
+  "@betalyra/effect-uai/capability/TtsIncrementalText",
+) {}
+
+/** One-shot synthesis. */
+export const synthesize = (
+  request: CommonSynthesizeRequest,
+): Effect.Effect<AudioBlob, AiError.AiError, SpeechSynthesizer> =>
+  Effect.flatMap(SpeechSynthesizer.asEffect(), (s) => s.synthesize(request))
+
+/** Full text in, audio chunks out. */
+export const streamSynthesis = (
+  request: CommonSynthesizeRequest,
+): Stream.Stream<AudioChunk, AiError.AiError, SpeechSynthesizer> =>
+  Stream.unwrap(Effect.map(SpeechSynthesizer.asEffect(), (s) => s.streamSynthesis(request)))
+
+/**
+ * Incremental synthesis. Dual-arity: pipeable (data-last) and direct
+ * (data-first). Requires `TtsIncrementalText` in R — providers without
+ * incremental-text-in support are a type error at provide time.
+ *
+ * @example
+ * ```ts
+ * const audio = LanguageModel.streamTurn(turnReq).pipe(
+ *   Stream.filterMap(Turn.toTextDelta),
+ *   SpeechSynthesizer.streamSynthesisFrom(synthReq),
+ * )
+ * ```
+ */
+export const streamSynthesisFrom: {
+  (
+    request: CommonStreamSynthesizeRequest,
+  ): <E, R>(
+    textIn: Stream.Stream<string, E, R>,
+  ) => Stream.Stream<AudioChunk, AiError.AiError | E, R | SpeechSynthesizer | TtsIncrementalText>
+  <E, R>(
+    textIn: Stream.Stream<string, E, R>,
+    request: CommonStreamSynthesizeRequest,
+  ): Stream.Stream<AudioChunk, AiError.AiError | E, R | SpeechSynthesizer | TtsIncrementalText>
+} = Function.dual(
+  2,
+  <E, R>(textIn: Stream.Stream<string, E, R>, request: CommonStreamSynthesizeRequest) =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const s = yield* SpeechSynthesizer.asEffect()
+        yield* TtsIncrementalText.asEffect()
+        return s.streamSynthesisFrom(textIn, request)
+      }),
+    ),
+)

package/src/streaming/JSONL.ts

@@ -79,6 +79,18 @@ export const parse =
       ),
     )
 
+/**
+ * Best-effort parse of a single JSON frame. Returns the parsed value or
+ * `undefined` on malformed input. Realtime WS adapters use this to skip
+ * non-JSON or partially-received frames silently rather than fail the
+ * entire session over one bad frame.
+ */
+export const parseSafe = (raw: string) =>
+  Effect.try({
+    try: () => JSON.parse(raw) as unknown,
+    catch: () => undefined,
+  }).pipe(Effect.orElseSucceed(() => undefined))
+
 const encoder = new TextEncoder()
 
 /**

package/src/testing/MockMusicGenerator.ts

@@ -0,0 +1,170 @@
+import { Effect, Layer, Ref, 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"
+import {
+  MusicGenerator,
+  MusicInteractiveSession,
+  type MusicGeneratorService,
+} from "../music-generator/MusicGenerator.js"
+
+export type MockMusicGeneratorRecorder = {
+  readonly generateCalls: ReadonlyArray<CommonGenerateMusicRequest>
+  readonly streamGenerationCalls: ReadonlyArray<CommonStreamGenerateMusicRequest>
+  readonly streamGenerationFromCalls: ReadonlyArray<CommonStreamGenerateMusicRequest>
+}
+
+export type MockMusicGeneratorScript = {
+  /** One result per `generate` call, consumed in order. */
+  readonly results?: ReadonlyArray<MusicResult>
+  /** One chunk-list per `streamGeneration` call, consumed in order. */
+  readonly streamGenerationChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>
+  /** One chunk-list per `streamGenerationFrom` call, consumed in order. */
+  readonly streamGenerationFromChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>
+}
+
+const makeService = (
+  script: MockMusicGeneratorScript,
+  record: {
+    readonly generate: (req: CommonGenerateMusicRequest) => Effect.Effect<void>
+    readonly streamGeneration: (req: CommonStreamGenerateMusicRequest) => Effect.Effect<void>
+    readonly streamGenerationFrom: (req: CommonStreamGenerateMusicRequest) => Effect.Effect<void>
+  },
+) =>
+  Effect.gen(function* () {
+    const gCursor = yield* Ref.make(0)
+    const sgCursor = yield* Ref.make(0)
+    const sgfCursor = yield* Ref.make(0)
+    const service: MusicGeneratorService = {
+      generate: (request) =>
+        Effect.gen(function* () {
+          yield* record.generate(request)
+          const i = yield* Ref.getAndUpdate(gCursor, (n) => n + 1)
+          const scripted = script.results ?? []
+          if (i >= scripted.length) {
+            return yield* Effect.fail(
+              new AiError.InvalidRequest({
+                provider: "mock",
+                raw: `MockMusicGenerator exhausted: ${scripted.length} results scripted, but call ${i + 1} was made`,
+              }),
+            )
+          }
+          return scripted[i]!
+        }),
+      streamGeneration: (request) =>
+        Stream.unwrap(
+          Effect.gen(function* () {
+            yield* record.streamGeneration(request)
+            const i = yield* Ref.getAndUpdate(sgCursor, (n) => n + 1)
+            const scripted = script.streamGenerationChunks ?? []
+            if (i >= scripted.length) {
+              return Stream.fail(
+                new AiError.InvalidRequest({
+                  provider: "mock",
+                  raw: `MockMusicGenerator exhausted: ${scripted.length} streamGeneration lists scripted, but call ${i + 1} was made`,
+                }),
+              )
+            }
+            return Stream.fromIterable(scripted[i]!)
+          }),
+        ),
+      streamGenerationFrom: <E, R>(
+        input: Stream.Stream<MusicSessionInput, E, R>,
+        request: CommonStreamGenerateMusicRequest,
+      ): Stream.Stream<AudioChunk, AiError.AiError | E, R> =>
+        Stream.unwrap(
+          Effect.gen(function* () {
+            yield* record.streamGenerationFrom(request)
+            const i = yield* Ref.getAndUpdate(sgfCursor, (n) => n + 1)
+            const scripted = script.streamGenerationFromChunks ?? []
+            if (i >= scripted.length) {
+              const exhausted: Stream.Stream<AudioChunk, AiError.AiError | E, R> = Stream.fail(
+                new AiError.InvalidRequest({
+                  provider: "mock",
+                  raw: `MockMusicGenerator exhausted: ${scripted.length} streamGenerationFrom lists scripted, but call ${i + 1} was made`,
+                }),
+              )
+              return exhausted
+            }
+            // Drain the input fully before emitting scripted audio chunks,
+            // so consumers can assert on what session messages were pushed.
+            return Stream.drain(input).pipe(Stream.concat(Stream.fromIterable(scripted[i]!)))
+          }),
+        ),
+    }
+    return service
+  })
+
+/**
+ * Layer providing the `MusicGenerator` service AND the
+ * `MusicInteractiveSession` capability marker. Use for the common case
+ * where code under test exercises `streamGenerationFrom`.
+ */
+export const layer = (
+  script: MockMusicGeneratorScript,
+): {
+  readonly layer: Layer.Layer<MusicGenerator | MusicInteractiveSession>
+  readonly recorder: Effect.Effect<MockMusicGeneratorRecorder>
+} => {
+  const gCalls = Ref.makeUnsafe<ReadonlyArray<CommonGenerateMusicRequest>>([])
+  const sgCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamGenerateMusicRequest>>([])
+  const sgfCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamGenerateMusicRequest>>([])
+  const generatorLayer = Layer.effect(
+    MusicGenerator,
+    makeService(script, {
+      generate: (req) => Ref.update(gCalls, (xs) => [...xs, req]),
+      streamGeneration: (req) => Ref.update(sgCalls, (xs) => [...xs, req]),
+      streamGenerationFrom: (req) => Ref.update(sgfCalls, (xs) => [...xs, req]),
+    }),
+  )
+  const live = Layer.merge(generatorLayer, Layer.succeed(MusicInteractiveSession, undefined))
+  return {
+    layer: live,
+    recorder: Effect.gen(function* () {
+      const generateCalls = yield* Ref.get(gCalls)
+      const streamGenerationCalls = yield* Ref.get(sgCalls)
+      const streamGenerationFromCalls = yield* Ref.get(sgfCalls)
+      return { generateCalls, streamGenerationCalls, streamGenerationFromCalls }
+    }),
+  }
+}
+
+/**
+ * Variant that omits the `MusicInteractiveSession` marker — simulates a
+ * provider without bidirectional support (Lyria 3 sync, ElevenLabs,
+ * Mureka, MiniMax, Stable Audio, Suno). Calls to
+ * `streamGenerationFrom` in code under test should be a compile-time
+ * error against this Layer alone.
+ */
+export const layerWithoutInteractive = (
+  script: MockMusicGeneratorScript,
+): {
+  readonly layer: Layer.Layer<MusicGenerator>
+  readonly recorder: Effect.Effect<MockMusicGeneratorRecorder>
+} => {
+  const gCalls = Ref.makeUnsafe<ReadonlyArray<CommonGenerateMusicRequest>>([])
+  const sgCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamGenerateMusicRequest>>([])
+  const sgfCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamGenerateMusicRequest>>([])
+  const live = Layer.effect(
+    MusicGenerator,
+    makeService(script, {
+      generate: (req) => Ref.update(gCalls, (xs) => [...xs, req]),
+      streamGeneration: (req) => Ref.update(sgCalls, (xs) => [...xs, req]),
+      streamGenerationFrom: (req) => Ref.update(sgfCalls, (xs) => [...xs, req]),
+    }),
+  )
+  return {
+    layer: live,
+    recorder: Effect.gen(function* () {
+      const generateCalls = yield* Ref.get(gCalls)
+      const streamGenerationCalls = yield* Ref.get(sgCalls)
+      const streamGenerationFromCalls = yield* Ref.get(sgfCalls)
+      return { generateCalls, streamGenerationCalls, streamGenerationFromCalls }
+    }),
+  }
+}