@effect-uai/core 0.3.0 → 0.5.0

package/src/testing/MockMusicGenerator.ts

@@ -0,0 +1,168 @@
+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* 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 }
+    }),
+  }
+}

package/src/testing/MockProvider.ts

@@ -1,8 +1,8 @@
-import { Duration, Effect, Layer, Ref, Schedule, Stream } from "effect"
+import { Array as Arr, Duration, Effect, Layer, Match, Option, Ref, Schedule, Stream } from "effect"
 import * as AiError from "../domain/AiError.js"
-import type { Item } from "../domain/Items.js"
+import { type Item, isOutputText } from "../domain/Items.js"
 import { LanguageModel, type LanguageModelService } from "../language-model/LanguageModel.js"
-import type { Turn, TurnEvent } from "../domain/Turn.js"
+import { type Turn, TurnEvent } from "../domain/Turn.js"
 
 export type MockOptions = {
   /**
@@ -13,46 +13,48 @@ export type MockOptions = {
   readonly deltaInterval?: Duration.Input
 }
 
+export type Call = {
+  readonly history: ReadonlyArray<Item>
+  readonly turn: Turn
+}
+
 /**
  * A scripted mock provider. Pre-canned `Turn` outputs are returned in order,
  * one per call to `streamTurn`. Each scripted turn is split into synthetic
- * deltas (text → tool_call_start → tool_call_args_delta → ... → turn_complete)
+ * deltas (text → ToolCallStart → ToolCallArgsDelta → ... → TurnComplete)
  * so streaming consumers can see realistic delta shapes.
  */
 export type MockRecorder = {
-  readonly calls: ReadonlyArray<{
-    readonly history: ReadonlyArray<Item>
-    readonly turn: Turn
-  }>
+  readonly calls: ReadonlyArray<Call>
 }
 
-const turnToDeltas = (turn: Turn): ReadonlyArray<TurnEvent> => {
-  const deltas: TurnEvent[] = []
-  for (const item of turn.items) {
-    if (item.type === "message" && item.role === "assistant") {
-      for (const block of item.content) {
-        if (block.type === "output_text") {
-          deltas.push({ type: "text_delta", text: block.text })
-        }
-      }
-    } else if (item.type === "function_call") {
-      deltas.push({
-        type: "tool_call_start",
-        call_id: item.call_id,
-        name: item.name,
-      })
-      deltas.push({
-        type: "tool_call_args_delta",
-        call_id: item.call_id,
-        delta: item.arguments,
-      })
-    } else if (item.type === "reasoning" && item.summary !== undefined) {
-      deltas.push({ type: "reasoning_delta", text: item.summary, kind: "summary" })
-    }
-  }
-  deltas.push({ type: "turn_complete", turn })
-  return deltas
-}
+// ---------------------------------------------------------------------------
+// Pure projection: Turn → ReadonlyArray<TurnEvent>
+// ---------------------------------------------------------------------------
+
+const itemToDeltas: (item: Item) => ReadonlyArray<TurnEvent> = Match.type<Item>().pipe(
+  Match.discriminators("type")({
+    message: (m): ReadonlyArray<TurnEvent> =>
+      m.role === "assistant"
+        ? m.content.filter(isOutputText).map((b) => TurnEvent.TextDelta({ text: b.text }))
+        : [],
+    function_call: (fc) => [
+      TurnEvent.ToolCallStart({ call_id: fc.call_id, name: fc.name }),
+      TurnEvent.ToolCallArgsDelta({ call_id: fc.call_id, delta: fc.arguments }),
+    ],
+    function_call_output: () => [],
+    reasoning: (r) =>
+      r.summary !== undefined
+        ? [TurnEvent.ReasoningDelta({ text: r.summary, kind: "summary" as const })]
+        : [],
+  }),
+  Match.exhaustive,
+)
+
+const turnToDeltas = (turn: Turn): ReadonlyArray<TurnEvent> => [
+  ...turn.items.flatMap(itemToDeltas),
+  TurnEvent.TurnComplete({ turn }),
+]
 
 const pacedDeltas = (turn: Turn, options?: MockOptions): Stream.Stream<TurnEvent> => {
   const base = Stream.fromIterable(turnToDeltas(turn))
@@ -61,101 +63,120 @@ const pacedDeltas = (turn: Turn, options?: MockOptions): Stream.Stream<TurnEvent
     : base.pipe(Stream.schedule(Schedule.spaced(options.deltaInterval)))
 }
 
-const makeService = (
+// ---------------------------------------------------------------------------
+// Canonical service factory. One implementation; sync/Layer/recorder
+// variants below are just different ways to wire the cursor + record hook.
+// ---------------------------------------------------------------------------
+
+const exhausted = (n: number, attempt: number): AiError.AiError =>
+  new AiError.InvalidRequest({
+    provider: "mock",
+    raw: `MockProvider exhausted: ${n} turns scripted, but call ${attempt} was made`,
+  })
+
+const noRecord = (_: Call): Effect.Effect<void> => Effect.void
+
+const buildService = (
   scriptedTurns: ReadonlyArray<Turn>,
-  options?: MockOptions,
-  recordCall?: (history: ReadonlyArray<Item>, turn: Turn) => Effect.Effect<void>,
-) =>
-  Effect.gen(function* () {
-    const cursor = yield* Ref.make(0)
-    return LanguageModel.of({
-      streamTurn: (request) =>
-        Stream.unwrap(
-          Effect.gen(function* () {
-            const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1)
-            if (i >= scriptedTurns.length) {
-              return Stream.fail(
-                new AiError.InvalidRequest({
-                  provider: "mock",
-                  raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`,
-                }),
-              )
-            }
-            const turn = scriptedTurns[i]!
-            if (recordCall !== undefined) {
-              yield* recordCall(request.history, turn)
-            }
-            return pacedDeltas(turn, options)
-          }),
+  options: MockOptions | undefined,
+  cursor: Ref.Ref<number>,
+  record: (call: Call) => Effect.Effect<void>,
+): LanguageModelService => ({
+  streamTurn: (request) =>
+    Stream.unwrap(
+      Ref.getAndUpdate(cursor, (n) => n + 1).pipe(
+        Effect.flatMap(
+          (i): Effect.Effect<Stream.Stream<TurnEvent, AiError.AiError>> =>
+            Option.match(Arr.get(scriptedTurns, i), {
+              onNone: () => Effect.succeed(Stream.fail(exhausted(scriptedTurns.length, i + 1))),
+              onSome: (turn) =>
+                record({ history: request.history, turn }).pipe(
+                  Effect.as(pacedDeltas(turn, options)),
+                ),
+            }),
         ),
-    })
-  })
+      ),
+    ),
+})
+
+// ---------------------------------------------------------------------------
+// Recorder handle. Unsafe Ref is local: it backs both the `record` write
+// hook (called inside the service) and the `recorder` read effect (called
+// by the test). Both close over the same cell.
+// ---------------------------------------------------------------------------
+
+type RecorderHandle = {
+  readonly record: (call: Call) => Effect.Effect<void>
+  readonly recorder: Effect.Effect<MockRecorder>
+}
 
+const makeRecorderUnsafe = (): RecorderHandle => {
+  const ref = Ref.makeUnsafe<ReadonlyArray<Call>>([])
+  return {
+    record: (call) => Ref.update(ref, Arr.append(call)),
+    recorder: Ref.get(ref).pipe(Effect.map((calls): MockRecorder => ({ calls }))),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Layer that registers a `MockProvider` against the `LanguageModel` tag.
+ * Calls beyond the scripted turn count fail with `InvalidRequest`.
+ */
 export const layer = (
   scriptedTurns: ReadonlyArray<Turn>,
   options?: MockOptions,
-): Layer.Layer<LanguageModel> => Layer.effect(LanguageModel, makeService(scriptedTurns, options))
+): Layer.Layer<LanguageModel> =>
+  Layer.effect(
+    LanguageModel,
+    Ref.make(0).pipe(
+      Effect.map((cursor) => buildService(scriptedTurns, options, cursor, noRecord)),
+    ),
+  )
 
 /**
- * Synchronous constructor that returns the `LanguageModelService` value
- * directly, plus a recorder. Use this when you want to swap models
- * mid-stream via `Effect.provideService` instead of providing one model
- * for the whole program via `Layer`.
+ * Like `layer`, but also exposes a recorder that captures every call
+ * (history + returned turn).
  */
-export const make = (
+export const layerWithRecorder = (
   scriptedTurns: ReadonlyArray<Turn>,
   options?: MockOptions,
 ): {
-  readonly service: LanguageModelService
+  readonly layer: Layer.Layer<LanguageModel>
   readonly recorder: Effect.Effect<MockRecorder>
 } => {
-  const cursor = Ref.makeUnsafe(0)
-  const callsRef = Ref.makeUnsafe<ReadonlyArray<{ history: ReadonlyArray<Item>; turn: Turn }>>([])
-  const service: LanguageModelService = {
-    streamTurn: (request) =>
-      Stream.unwrap(
-        Effect.gen(function* () {
-          const i = yield* Ref.getAndUpdate(cursor, (n) => n + 1)
-          if (i >= scriptedTurns.length) {
-            return Stream.fail(
-              new AiError.InvalidRequest({
-                provider: "mock",
-                raw: `MockProvider exhausted: ${scriptedTurns.length} turns scripted, but call ${i + 1} was made`,
-              }),
-            )
-          }
-          const turn = scriptedTurns[i]!
-          yield* Ref.update(callsRef, (xs) => [...xs, { history: request.history, turn }])
-          return pacedDeltas(turn, options)
-        }),
-      ),
-  }
+  const { record, recorder } = makeRecorderUnsafe()
   return {
-    service,
-    recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls }))),
+    layer: Layer.effect(
+      LanguageModel,
+      Ref.make(0).pipe(
+        Effect.map((cursor) => buildService(scriptedTurns, options, cursor, record)),
+      ),
+    ),
+    recorder,
   }
 }
 
 /**
- * Same as `layer`, but also exposes a recorder that captures every call
- * (history + returned turn).
+ * Build the `LanguageModelService` value directly (no Layer), plus a
+ * recorder. Use this when you want to swap models mid-program via
+ * `Effect.provideService` instead of providing one model for the whole
+ * program via `Layer`.
  */
-export const layerWithRecorder = (
+export const make = (
   scriptedTurns: ReadonlyArray<Turn>,
   options?: MockOptions,
 ): {
-  readonly layer: Layer.Layer<LanguageModel>
+  readonly service: LanguageModelService
   readonly recorder: Effect.Effect<MockRecorder>
 } => {
-  const callsRef = Ref.makeUnsafe<ReadonlyArray<{ history: ReadonlyArray<Item>; turn: Turn }>>([])
-  const live = Layer.effect(
-    LanguageModel,
-    makeService(scriptedTurns, options, (history, turn) =>
-      Ref.update(callsRef, (xs) => [...xs, { history, turn }]),
-    ),
-  )
+  const cursor = Ref.makeUnsafe(0)
+  const { record, recorder } = makeRecorderUnsafe()
   return {
-    layer: live,
-    recorder: Ref.get(callsRef).pipe(Effect.map((calls) => ({ calls }))),
+    service: buildService(scriptedTurns, options, cursor, record),
+    recorder,
   }
 }

package/src/testing/MockSpeechSynthesizer.ts

@@ -0,0 +1,163 @@
+import { Effect, Layer, Ref, Stream } from "effect"
+import type { AudioBlob, AudioChunk } from "../domain/Audio.js"
+import * as AiError from "../domain/AiError.js"
+import {
+  SpeechSynthesizer,
+  TtsIncrementalText,
+  type CommonStreamSynthesizeRequest,
+  type CommonSynthesizeRequest,
+  type SpeechSynthesizerService,
+} from "../speech-synthesizer/SpeechSynthesizer.js"
+
+export type MockSynthesizerRecorder = {
+  readonly synthesizeCalls: ReadonlyArray<CommonSynthesizeRequest>
+  readonly streamSynthesisCalls: ReadonlyArray<CommonSynthesizeRequest>
+  readonly streamSynthesisFromCalls: ReadonlyArray<CommonStreamSynthesizeRequest>
+}
+
+export type MockSynthesizerScript = {
+  /** One blob per `synthesize` call, consumed in order. */
+  readonly blobs?: ReadonlyArray<AudioBlob>
+  /** One chunk-list per `streamSynthesis` call, consumed in order. */
+  readonly streamSynthesisChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>
+  /** One chunk-list per `streamSynthesisFrom` call, consumed in order. */
+  readonly streamSynthesisFromChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>
+}
+
+const makeService = (
+  script: MockSynthesizerScript,
+  record: {
+    readonly synthesize: (req: CommonSynthesizeRequest) => Effect.Effect<void>
+    readonly streamSynthesis: (req: CommonSynthesizeRequest) => Effect.Effect<void>
+    readonly streamSynthesisFrom: (req: CommonStreamSynthesizeRequest) => Effect.Effect<void>
+  },
+) =>
+  Effect.gen(function* () {
+    const bCursor = yield* Ref.make(0)
+    const ssCursor = yield* Ref.make(0)
+    const ssfCursor = yield* Ref.make(0)
+    const service: SpeechSynthesizerService = {
+      synthesize: (request) =>
+        Effect.gen(function* () {
+          yield* record.synthesize(request)
+          const i = yield* Ref.getAndUpdate(bCursor, (n) => n + 1)
+          const scripted = script.blobs ?? []
+          if (i >= scripted.length) {
+            return yield* new AiError.InvalidRequest({
+              provider: "mock",
+              raw: `MockSpeechSynthesizer exhausted: ${scripted.length} blobs scripted, but call ${i + 1} was made`,
+            })
+          }
+          return scripted[i]!
+        }),
+      streamSynthesis: (request) =>
+        Stream.unwrap(
+          Effect.gen(function* () {
+            yield* record.streamSynthesis(request)
+            const i = yield* Ref.getAndUpdate(ssCursor, (n) => n + 1)
+            const scripted = script.streamSynthesisChunks ?? []
+            if (i >= scripted.length) {
+              return Stream.fail(
+                new AiError.InvalidRequest({
+                  provider: "mock",
+                  raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesis lists scripted, but call ${i + 1} was made`,
+                }),
+              )
+            }
+            return Stream.fromIterable(scripted[i]!)
+          }),
+        ),
+      streamSynthesisFrom: <E, R>(
+        textIn: Stream.Stream<string, E, R>,
+        request: CommonStreamSynthesizeRequest,
+      ): Stream.Stream<AudioChunk, AiError.AiError | E, R> =>
+        Stream.unwrap(
+          Effect.gen(function* () {
+            yield* record.streamSynthesisFrom(request)
+            const i = yield* Ref.getAndUpdate(ssfCursor, (n) => n + 1)
+            const scripted = script.streamSynthesisFromChunks ?? []
+            if (i >= scripted.length) {
+              const exhausted: Stream.Stream<AudioChunk, AiError.AiError | E, R> = Stream.fail(
+                new AiError.InvalidRequest({
+                  provider: "mock",
+                  raw: `MockSpeechSynthesizer exhausted: ${scripted.length} streamSynthesisFrom lists scripted, but call ${i + 1} was made`,
+                }),
+              )
+              return exhausted
+            }
+            // Drain the input text fully before emitting scripted audio chunks,
+            // so consumers can assert on what text was pushed.
+            return Stream.drain(textIn).pipe(Stream.concat(Stream.fromIterable(scripted[i]!)))
+          }),
+        ),
+    }
+    return service
+  })
+
+/**
+ * Layer providing the `SpeechSynthesizer` service AND the
+ * `TtsIncrementalText` capability marker. Use for the common case
+ * where code under test exercises `streamSynthesisFrom`.
+ */
+export const layer = (
+  script: MockSynthesizerScript,
+): {
+  readonly layer: Layer.Layer<SpeechSynthesizer | TtsIncrementalText>
+  readonly recorder: Effect.Effect<MockSynthesizerRecorder>
+} => {
+  const bCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])
+  const ssCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])
+  const ssfCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamSynthesizeRequest>>([])
+  const synthesizerLayer = Layer.effect(
+    SpeechSynthesizer,
+    makeService(script, {
+      synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),
+      streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),
+      streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req]),
+    }),
+  )
+  const live = Layer.merge(synthesizerLayer, Layer.succeed(TtsIncrementalText, undefined))
+  return {
+    layer: live,
+    recorder: Effect.gen(function* () {
+      const synthesizeCalls = yield* Ref.get(bCalls)
+      const streamSynthesisCalls = yield* Ref.get(ssCalls)
+      const streamSynthesisFromCalls = yield* Ref.get(ssfCalls)
+      return { synthesizeCalls, streamSynthesisCalls, streamSynthesisFromCalls }
+    }),
+  }
+}
+
+/**
+ * Variant that omits the `TtsIncrementalText` marker — simulates a
+ * provider without incremental-text-in support (e.g. OpenAI, AWS
+ * Polly non-Generative). Calls to `streamSynthesisFrom` in code under
+ * test should be a compile-time error.
+ */
+export const layerWithoutIncremental = (
+  script: MockSynthesizerScript,
+): {
+  readonly layer: Layer.Layer<SpeechSynthesizer>
+  readonly recorder: Effect.Effect<MockSynthesizerRecorder>
+} => {
+  const bCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])
+  const ssCalls = Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([])
+  const ssfCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamSynthesizeRequest>>([])
+  const live = Layer.effect(
+    SpeechSynthesizer,
+    makeService(script, {
+      synthesize: (req) => Ref.update(bCalls, (xs) => [...xs, req]),
+      streamSynthesis: (req) => Ref.update(ssCalls, (xs) => [...xs, req]),
+      streamSynthesisFrom: (req) => Ref.update(ssfCalls, (xs) => [...xs, req]),
+    }),
+  )
+  return {
+    layer: live,
+    recorder: Effect.gen(function* () {
+      const synthesizeCalls = yield* Ref.get(bCalls)
+      const streamSynthesisCalls = yield* Ref.get(ssCalls)
+      const streamSynthesisFromCalls = yield* Ref.get(ssfCalls)
+      return { synthesizeCalls, streamSynthesisCalls, streamSynthesisFromCalls }
+    }),
+  }
+}