@effect-uai/core 0.5.2 → 0.6.0

package/src/testing/MockSandbox.ts

@@ -0,0 +1,342 @@
+import { Array as Arr, Data, Effect, Layer, Ref, Stream } from "effect"
+import {
+  ExecEvent,
+  Sandbox,
+  SandboxCustomImage,
+  SandboxHostnameAllowlist,
+  SandboxKernelSession,
+  SandboxPauseResume,
+  SandboxPortExposure,
+  SandboxPty,
+  SandboxSecretInjection,
+  SandboxSnapshots,
+  SandboxVolumes,
+  type CommonCreateRequest,
+  type CommonExecRequest,
+  type CommonSpawnRequest,
+  type ExecResult,
+  type FileEntry,
+  type ProcessHandle,
+  SandboxId,
+  type SandboxInstance,
+  type SandboxRef,
+  type SandboxService,
+  SnapshotId,
+  VolumeId,
+} from "../sandbox/Sandbox.js"
+import * as SandboxError from "../sandbox/SandboxError.js"
+
+// ---------------------------------------------------------------------------
+// Call log
+// ---------------------------------------------------------------------------
+
+/**
+ * One entry per side-effecting method call. Tests filter via
+ * `Call.$is(...)` / `Call.$match`.
+ */
+export type Call = Data.TaggedEnum<{
+  Create: { readonly request: CommonCreateRequest }
+  Attach: { readonly id: SandboxId }
+  Destroy: { readonly id: SandboxId }
+  Exec: { readonly id: SandboxId; readonly request: CommonExecRequest }
+  ExecStream: { readonly id: SandboxId; readonly request: CommonExecRequest }
+  Spawn: { readonly id: SandboxId; readonly request: CommonSpawnRequest }
+  FileRead: { readonly id: SandboxId; readonly path: string }
+  FileWrite: {
+    readonly id: SandboxId
+    readonly path: string
+    readonly contents: Uint8Array | string
+  }
+  FileRemove: { readonly id: SandboxId; readonly path: string }
+  FileMkdir: { readonly id: SandboxId; readonly path: string }
+  FileList: { readonly id: SandboxId; readonly path: string }
+  FileExists: { readonly id: SandboxId; readonly path: string }
+  ExposePort: { readonly id: SandboxId; readonly port: number }
+  SnapshotCreate: { readonly id: SandboxId; readonly name?: string }
+  SnapshotDestroy: { readonly id: SnapshotId }
+  VolumeCreate: { readonly name: string; readonly quotaBytes?: number }
+  VolumeDestroy: { readonly id: VolumeId }
+}>
+
+export const Call = Data.taggedEnum<Call>()
+
+export type MockSandboxRecorder = {
+  readonly calls: ReadonlyArray<Call>
+}
+
+// ---------------------------------------------------------------------------
+// Script
+// ---------------------------------------------------------------------------
+
+/**
+ * What this mock should hand back per call. Each method has its own
+ * scripted queue and a sensible default when the queue is empty.
+ * The filesystem is an in-memory mutable map seeded by `files`.
+ */
+export type MockSandboxScript = {
+  readonly id?: string
+  readonly execs?: ReadonlyArray<ExecResult>
+  readonly streams?: ReadonlyArray<ReadonlyArray<ExecEvent>>
+  readonly spawns?: ReadonlyArray<ProcessHandle>
+  readonly files?: Readonly<Record<string, Uint8Array | string>>
+  readonly sandboxes?: ReadonlyArray<SandboxRef>
+  readonly snapshots?: ReadonlyArray<{ readonly id: SnapshotId; readonly name?: string }>
+  readonly volumes?: ReadonlyArray<{ readonly id: VolumeId; readonly name: string }>
+  readonly portUrl?: (port: number) => string
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const defaultExec: ExecResult = { exitCode: 0, stdout: "", stderr: "", durationMs: 0 }
+
+const toBytes = (contents: Uint8Array | string) =>
+  typeof contents === "string" ? new TextEncoder().encode(contents) : contents
+
+const seedFs = (files: MockSandboxScript["files"]) =>
+  new Map(Object.entries(files ?? {}).map(([k, v]) => [k, toBytes(v)]))
+
+const exhausted = (method: string, scripted: number, attempt: number) =>
+  new SandboxError.SandboxInvalidRequest({
+    provider: "mock",
+    reason: `MockSandbox exhausted: ${scripted} ${method}(s) scripted, but call ${attempt} was made`,
+  })
+
+const consume = <A>(
+  cursor: Ref.Ref<number>,
+  scripted: ReadonlyArray<A>,
+  onMiss: (attempt: number) => Effect.Effect<A, SandboxError.SandboxError>,
+) =>
+  Ref.getAndUpdate(cursor, (n) => n + 1).pipe(
+    Effect.flatMap((i) => (i < scripted.length ? Effect.succeed(scripted[i]!) : onMiss(i + 1))),
+  )
+
+// ---------------------------------------------------------------------------
+// Service builder
+// ---------------------------------------------------------------------------
+
+const buildInstance = (
+  id: SandboxId,
+  script: MockSandboxScript,
+  fs: Ref.Ref<Map<string, Uint8Array>>,
+  execCursor: Ref.Ref<number>,
+  streamCursor: Ref.Ref<number>,
+  spawnCursor: Ref.Ref<number>,
+  record: (call: Call) => Effect.Effect<void>,
+): SandboxInstance => ({
+  id,
+
+  exec: (request) =>
+    record(Call.Exec({ id, request })).pipe(
+      Effect.andThen(consume(execCursor, script.execs ?? [], () => Effect.succeed(defaultExec))),
+    ),
+
+  execStream: (request) =>
+    Stream.unwrap(
+      record(Call.ExecStream({ id, request })).pipe(
+        Effect.andThen(
+          consume(streamCursor, script.streams ?? [], () =>
+            Effect.succeed<ReadonlyArray<ExecEvent>>([
+              ExecEvent.Complete({ exitCode: 0, durationMs: 0 }),
+            ]),
+          ),
+        ),
+        Effect.map(
+          (events) =>
+            Stream.fromIterable(events) as Stream.Stream<ExecEvent, SandboxError.SandboxError>,
+        ),
+      ),
+    ),
+
+  spawn: (request) =>
+    record(Call.Spawn({ id, request })).pipe(
+      Effect.andThen(
+        consume(spawnCursor, script.spawns ?? [], (n) =>
+          Effect.fail(exhausted("spawn", (script.spawns ?? []).length, n)),
+        ),
+      ),
+      Effect.tap((handle) => Effect.addFinalizer(() => Effect.orDie(handle.kill))),
+    ),
+
+  files: {
+    read: (path) =>
+      record(Call.FileRead({ id, path })).pipe(
+        Effect.andThen(Ref.get(fs)),
+        Effect.flatMap((map) =>
+          map.has(path)
+            ? Effect.succeed(map.get(path)!)
+            : Effect.fail(
+                new SandboxError.SandboxExecFailed({
+                  provider: "mock",
+                  reason: `ENOENT: ${path}`,
+                  raw: undefined,
+                }),
+              ),
+        ),
+      ),
+
+    write: (path, contents) =>
+      record(Call.FileWrite({ id, path, contents })).pipe(
+        Effect.andThen(Ref.update(fs, (m) => new Map(m).set(path, toBytes(contents)))),
+      ),
+
+    remove: (path) =>
+      record(Call.FileRemove({ id, path })).pipe(
+        Effect.andThen(
+          Ref.update(fs, (m) => {
+            const next = new Map(m)
+            next.delete(path)
+            return next
+          }),
+        ),
+      ),
+
+    mkdir: (path) => record(Call.FileMkdir({ id, path })),
+
+    list: (path) =>
+      record(Call.FileList({ id, path })).pipe(
+        Effect.andThen(Ref.get(fs)),
+        Effect.map((map) => {
+          const prefix = path.endsWith("/") ? path : `${path}/`
+          const out: Array<FileEntry> = []
+          for (const k of map.keys()) {
+            if (k.startsWith(prefix)) out.push({ path: k, kind: "file" })
+          }
+          return out
+        }),
+      ),
+
+    exists: (path) =>
+      record(Call.FileExists({ id, path })).pipe(
+        Effect.andThen(Ref.get(fs)),
+        Effect.map((map) => map.has(path)),
+      ),
+  },
+})
+
+const buildService = (
+  script: MockSandboxScript,
+  record: (call: Call) => Effect.Effect<void>,
+): SandboxService => {
+  const id = SandboxId(script.id ?? "mock-sandbox")
+
+  const acquireInstance = (sandboxId: SandboxId, onClose: Effect.Effect<void>) =>
+    Effect.gen(function* () {
+      const fs = yield* Ref.make(seedFs(script.files))
+      const execCursor = yield* Ref.make(0)
+      const streamCursor = yield* Ref.make(0)
+      const spawnCursor = yield* Ref.make(0)
+      yield* Effect.addFinalizer(() => onClose)
+      return buildInstance(sandboxId, script, fs, execCursor, streamCursor, spawnCursor, record)
+    })
+
+  return {
+    create: (request) =>
+      record(Call.Create({ request })).pipe(
+        Effect.andThen(acquireInstance(id, record(Call.Destroy({ id })))),
+      ),
+
+    attach: (sandboxId) =>
+      record(Call.Attach({ id: sandboxId })).pipe(
+        // Attach detaches on scope close (no destroy).
+        Effect.andThen(acquireInstance(sandboxId, Effect.void)),
+      ),
+
+    list: Effect.succeed(script.sandboxes ?? []),
+
+    destroy: (sandboxId) => record(Call.Destroy({ id: sandboxId })),
+
+    snapshots: {
+      create: (_from, name) =>
+        record(
+          name === undefined ? Call.SnapshotCreate({ id }) : Call.SnapshotCreate({ id, name }),
+        ).pipe(
+          Effect.as(SnapshotId(`mock-snapshot-${name ?? Math.random().toString(36).slice(2, 8)}`)),
+        ),
+      destroy: (sid) => record(Call.SnapshotDestroy({ id: sid })),
+      list: Effect.succeed(script.snapshots ?? []),
+    },
+
+    volumes: {
+      create: (name, options) =>
+        record(
+          options?.quotaBytes === undefined
+            ? Call.VolumeCreate({ name })
+            : Call.VolumeCreate({ name, quotaBytes: options.quotaBytes }),
+        ).pipe(Effect.as(VolumeId(`mock-volume-${name}`))),
+      destroy: (vid) => record(Call.VolumeDestroy({ id: vid })),
+      list: Effect.succeed(script.volumes ?? []),
+    },
+
+    ports: {
+      expose: (instance, port) =>
+        record(Call.ExposePort({ id: instance.id, port })).pipe(
+          Effect.as({ url: (script.portUrl ?? ((p) => `http://mock.local:${p}`))(port) }),
+        ),
+    },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Recorder
+// ---------------------------------------------------------------------------
+
+const makeRecorderUnsafe = () => {
+  const ref = Ref.makeUnsafe<ReadonlyArray<Call>>([])
+  return {
+    record: (call: Call) => Ref.update(ref, Arr.append(call)),
+    recorder: Ref.get(ref).pipe(Effect.map((calls): MockSandboxRecorder => ({ calls }))),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+const allCapabilities = Layer.mergeAll(
+  Layer.succeed(SandboxHostnameAllowlist, undefined),
+  Layer.succeed(SandboxSecretInjection, undefined),
+  Layer.succeed(SandboxSnapshots, undefined),
+  Layer.succeed(SandboxPauseResume, undefined),
+  Layer.succeed(SandboxVolumes, undefined),
+  Layer.succeed(SandboxKernelSession, undefined),
+  Layer.succeed(SandboxPty, undefined),
+  Layer.succeed(SandboxCustomImage, undefined),
+  Layer.succeed(SandboxPortExposure, undefined),
+)
+
+/**
+ * Layer that registers a `MockSandbox` against the `Sandbox` tag, with
+ * every capability marker shipped — use when the code under test
+ * exercises any of them.
+ */
+export const layer = (script: MockSandboxScript = {}) => {
+  const { record, recorder } = makeRecorderUnsafe()
+  return {
+    layer: Layer.merge(Layer.succeed(Sandbox, buildService(script, record)), allCapabilities),
+    recorder,
+  }
+}
+
+/**
+ * Layer with the `Sandbox` service but no capability markers. Use to
+ * verify that consumers calling `Sandbox.snapshot` / `createVolume` /
+ * etc. fail at `Effect.provide` with a type error.
+ */
+export const layerWithoutCapabilities = (script: MockSandboxScript = {}) => {
+  const { record, recorder } = makeRecorderUnsafe()
+  return {
+    layer: Layer.succeed(Sandbox, buildService(script, record)),
+    recorder,
+  }
+}
+
+/** Bare service value + recorder. Use with `Effect.provideService`. */
+export const make = (script: MockSandboxScript = {}) => {
+  const { record, recorder } = makeRecorderUnsafe()
+  return {
+    service: buildService(script, record),
+    recorder,
+  }
+}

package/src/testing/MockSpeechSynthesizer.ts

@@ -2,17 +2,21 @@ 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 CommonSynthesizeDialogueRequest,
   type CommonSynthesizeRequest,
+  MultiSpeakerTts,
+  SpeechSynthesizer,
   type SpeechSynthesizerService,
+  TtsIncrementalText,
 } from "../speech-synthesizer/SpeechSynthesizer.js"
 
 export type MockSynthesizerRecorder = {
   readonly synthesizeCalls: ReadonlyArray<CommonSynthesizeRequest>
   readonly streamSynthesisCalls: ReadonlyArray<CommonSynthesizeRequest>
   readonly streamSynthesisFromCalls: ReadonlyArray<CommonStreamSynthesizeRequest>
+  readonly synthesizeDialogueCalls: ReadonlyArray<CommonSynthesizeDialogueRequest>
+  readonly streamSynthesizeDialogueCalls: ReadonlyArray<CommonSynthesizeDialogueRequest>
 }
 
 export type MockSynthesizerScript = {
@@ -22,32 +26,40 @@ export type MockSynthesizerScript = {
   readonly streamSynthesisChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>
   /** One chunk-list per `streamSynthesisFrom` call, consumed in order. */
   readonly streamSynthesisFromChunks?: ReadonlyArray<ReadonlyArray<AudioChunk>>
+  /** One blob per `synthesizeDialogue` call, consumed in order. */
+  readonly dialogueBlobs?: ReadonlyArray<AudioBlob>
+  /** One chunk-list per `streamSynthesizeDialogue` call, consumed in order. */
+  readonly streamSynthesizeDialogueChunks?: 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>
-  },
-) =>
+type Record = {
+  readonly synthesize: (req: CommonSynthesizeRequest) => Effect.Effect<void>
+  readonly streamSynthesis: (req: CommonSynthesizeRequest) => Effect.Effect<void>
+  readonly streamSynthesisFrom: (req: CommonStreamSynthesizeRequest) => Effect.Effect<void>
+  readonly synthesizeDialogue: (req: CommonSynthesizeDialogueRequest) => Effect.Effect<void>
+  readonly streamSynthesizeDialogue: (req: CommonSynthesizeDialogueRequest) => Effect.Effect<void>
+}
+
+const exhausted = (label: string, scripted: number, call: number): AiError.AiError =>
+  new AiError.InvalidRequest({
+    provider: "mock",
+    raw: `MockSpeechSynthesizer exhausted: ${scripted} ${label} scripted, but call ${call} was made`,
+  })
+
+const makeService = (script: MockSynthesizerScript, record: Record) =>
   Effect.gen(function* () {
     const bCursor = yield* Ref.make(0)
     const ssCursor = yield* Ref.make(0)
     const ssfCursor = yield* Ref.make(0)
+    const sdCursor = yield* Ref.make(0)
+    const ssdCursor = 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`,
-            })
-          }
+          if (i >= scripted.length) return yield* exhausted("blobs", scripted.length, i + 1)
           return scripted[i]!
         }),
       streamSynthesis: (request) =>
@@ -57,12 +69,7 @@ const makeService = (
             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.fail(exhausted("streamSynthesis lists", scripted.length, i + 1))
             }
             return Stream.fromIterable(scripted[i]!)
           }),
@@ -77,87 +84,140 @@ const makeService = (
             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`,
-                }),
+              const fail: Stream.Stream<AudioChunk, AiError.AiError | E, R> = Stream.fail(
+                exhausted("streamSynthesisFrom lists", scripted.length, i + 1),
               )
-              return exhausted
+              return fail
             }
-            // 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]!)))
           }),
         ),
+      synthesizeDialogue: (request) =>
+        Effect.gen(function* () {
+          yield* record.synthesizeDialogue(request)
+          const i = yield* Ref.getAndUpdate(sdCursor, (n) => n + 1)
+          const scripted = script.dialogueBlobs ?? []
+          if (i >= scripted.length) {
+            return yield* exhausted("dialogueBlobs", scripted.length, i + 1)
+          }
+          return scripted[i]!
+        }),
+      streamSynthesizeDialogue: (request) =>
+        Stream.unwrap(
+          Effect.gen(function* () {
+            yield* record.streamSynthesizeDialogue(request)
+            const i = yield* Ref.getAndUpdate(ssdCursor, (n) => n + 1)
+            const scripted = script.streamSynthesizeDialogueChunks ?? []
+            if (i >= scripted.length) {
+              return Stream.fail(
+                exhausted("streamSynthesizeDialogue lists", scripted.length, i + 1),
+              )
+            }
+            return Stream.fromIterable(scripted[i]!)
+          }),
+        ),
     }
     return service
   })
 
+type CallBuffers = {
+  readonly bCalls: Ref.Ref<ReadonlyArray<CommonSynthesizeRequest>>
+  readonly ssCalls: Ref.Ref<ReadonlyArray<CommonSynthesizeRequest>>
+  readonly ssfCalls: Ref.Ref<ReadonlyArray<CommonStreamSynthesizeRequest>>
+  readonly sdCalls: Ref.Ref<ReadonlyArray<CommonSynthesizeDialogueRequest>>
+  readonly ssdCalls: Ref.Ref<ReadonlyArray<CommonSynthesizeDialogueRequest>>
+}
+
+const newBuffers = (): CallBuffers => ({
+  bCalls: Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([]),
+  ssCalls: Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeRequest>>([]),
+  ssfCalls: Ref.makeUnsafe<ReadonlyArray<CommonStreamSynthesizeRequest>>([]),
+  sdCalls: Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeDialogueRequest>>([]),
+  ssdCalls: Ref.makeUnsafe<ReadonlyArray<CommonSynthesizeDialogueRequest>>([]),
+})
+
+const recordFor = (b: CallBuffers): Record => ({
+  synthesize: (req) => Ref.update(b.bCalls, (xs) => [...xs, req]),
+  streamSynthesis: (req) => Ref.update(b.ssCalls, (xs) => [...xs, req]),
+  streamSynthesisFrom: (req) => Ref.update(b.ssfCalls, (xs) => [...xs, req]),
+  synthesizeDialogue: (req) => Ref.update(b.sdCalls, (xs) => [...xs, req]),
+  streamSynthesizeDialogue: (req) => Ref.update(b.ssdCalls, (xs) => [...xs, req]),
+})
+
+const recorderEffect = (b: CallBuffers): Effect.Effect<MockSynthesizerRecorder> =>
+  Effect.gen(function* () {
+    const synthesizeCalls = yield* Ref.get(b.bCalls)
+    const streamSynthesisCalls = yield* Ref.get(b.ssCalls)
+    const streamSynthesisFromCalls = yield* Ref.get(b.ssfCalls)
+    const synthesizeDialogueCalls = yield* Ref.get(b.sdCalls)
+    const streamSynthesizeDialogueCalls = yield* Ref.get(b.ssdCalls)
+    return {
+      synthesizeCalls,
+      streamSynthesisCalls,
+      streamSynthesisFromCalls,
+      synthesizeDialogueCalls,
+      streamSynthesizeDialogueCalls,
+    }
+  })
+
 /**
- * Layer providing the `SpeechSynthesizer` service AND the
- * `TtsIncrementalText` capability marker. Use for the common case
- * where code under test exercises `streamSynthesisFrom`.
+ * Layer providing `SpeechSynthesizer` plus both capability markers
+ * (`TtsIncrementalText` and `MultiSpeakerTts`). Use for the common case
+ * where code under test exercises any of the optional methods.
  */
 export const layer = (
   script: MockSynthesizerScript,
 ): {
-  readonly layer: Layer.Layer<SpeechSynthesizer | TtsIncrementalText>
+  readonly layer: Layer.Layer<SpeechSynthesizer | TtsIncrementalText | MultiSpeakerTts>
   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 buffers = newBuffers()
+  const synthesizerLayer = Layer.effect(SpeechSynthesizer, makeService(script, recordFor(buffers)))
+  const live = Layer.mergeAll(
+    synthesizerLayer,
+    Layer.succeed(TtsIncrementalText, undefined),
+    Layer.succeed(MultiSpeakerTts, undefined),
   )
-  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 }
-    }),
-  }
+  return { layer: live, recorder: recorderEffect(buffers) }
 }
 
 /**
  * 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.
+ * provider without incremental-text-in support (e.g. OpenAI). Calls to
+ * `streamSynthesisFrom` in code under test should be a compile-time
+ * error. `MultiSpeakerTts` is still provided.
  */
 export const layerWithoutIncremental = (
   script: MockSynthesizerScript,
 ): {
-  readonly layer: Layer.Layer<SpeechSynthesizer>
+  readonly layer: Layer.Layer<SpeechSynthesizer | MultiSpeakerTts>
+  readonly recorder: Effect.Effect<MockSynthesizerRecorder>
+} => {
+  const buffers = newBuffers()
+  const live = Layer.merge(
+    Layer.effect(SpeechSynthesizer, makeService(script, recordFor(buffers))),
+    Layer.succeed(MultiSpeakerTts, undefined),
+  )
+  return { layer: live, recorder: recorderEffect(buffers) }
+}
+
+/**
+ * Variant that omits the `MultiSpeakerTts` marker — simulates a
+ * provider without multi-speaker dialogue support (e.g. OpenAI,
+ * Inworld). Calls to `synthesizeDialogue` /
+ * `streamSynthesizeDialogue` in code under test should be a
+ * compile-time error.
+ */
+export const layerWithoutMultiSpeaker = (
+  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 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]),
-    }),
+  const buffers = newBuffers()
+  const live = Layer.merge(
+    Layer.effect(SpeechSynthesizer, makeService(script, recordFor(buffers))),
+    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 }
-    }),
-  }
+  return { layer: live, recorder: recorderEffect(buffers) }
 }