@effect-uai/core 0.3.0 → 0.4.0

package/src/testing/MockSpeechSynthesizer.ts

@@ -0,0 +1,165 @@
+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* Effect.fail(
+              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 }
+    }),
+  }
+}

package/src/testing/MockTranscriber.ts

@@ -0,0 +1,139 @@
+import { Effect, Layer, Ref, Stream } from "effect"
+import * as AiError from "../domain/AiError.js"
+import type { TranscriptEvent, TranscriptResult } from "../domain/Transcript.js"
+import {
+  SttStreaming,
+  Transcriber,
+  type CommonStreamTranscribeRequest,
+  type CommonTranscribeRequest,
+  type TranscriberService,
+} from "../transcriber/Transcriber.js"
+
+/**
+ * Recorder of every call made to the mock.
+ */
+export type MockTranscriberRecorder = {
+  readonly transcribeCalls: ReadonlyArray<CommonTranscribeRequest>
+  readonly streamCalls: ReadonlyArray<CommonStreamTranscribeRequest>
+}
+
+export type MockTranscriberScript = {
+  /** One result per `transcribe` call, consumed in order. */
+  readonly transcripts?: ReadonlyArray<TranscriptResult>
+  /** One event-list per `streamTranscriptionFrom` call, consumed in order. */
+  readonly streams?: ReadonlyArray<ReadonlyArray<TranscriptEvent>>
+}
+
+const makeService = (
+  script: MockTranscriberScript,
+  record: {
+    readonly transcribe: (req: CommonTranscribeRequest) => Effect.Effect<void>
+    readonly stream: (req: CommonStreamTranscribeRequest) => Effect.Effect<void>
+  },
+) =>
+  Effect.gen(function* () {
+    const tCursor = yield* Ref.make(0)
+    const sCursor = yield* Ref.make(0)
+    const service: TranscriberService = {
+      transcribe: (request) =>
+        Effect.gen(function* () {
+          yield* record.transcribe(request)
+          const i = yield* Ref.getAndUpdate(tCursor, (n) => n + 1)
+          const scripted = script.transcripts ?? []
+          if (i >= scripted.length) {
+            return yield* Effect.fail(
+              new AiError.InvalidRequest({
+                provider: "mock",
+                raw: `MockTranscriber exhausted: ${scripted.length} transcripts scripted, but call ${i + 1} was made`,
+              }),
+            )
+          }
+          return scripted[i]!
+        }),
+      streamTranscriptionFrom: <E, R>(
+        audioIn: Stream.Stream<Uint8Array, E, R>,
+        request: CommonStreamTranscribeRequest,
+      ): Stream.Stream<TranscriptEvent, AiError.AiError | E, R> =>
+        Stream.unwrap(
+          Effect.gen(function* () {
+            yield* record.stream(request)
+            const i = yield* Ref.getAndUpdate(sCursor, (n) => n + 1)
+            const scripted = script.streams ?? []
+            if (i >= scripted.length) {
+              const exhausted: Stream.Stream<TranscriptEvent, AiError.AiError | E, R> = Stream.fail(
+                new AiError.InvalidRequest({
+                  provider: "mock",
+                  raw: `MockTranscriber exhausted: ${scripted.length} streams scripted, but call ${i + 1} was made`,
+                }),
+              )
+              return exhausted
+            }
+            // Drain the input audio fully before emitting the scripted events,
+            // so consumers can assert on what bytes were pushed.
+            return Stream.drain(audioIn).pipe(Stream.concat(Stream.fromIterable(scripted[i]!)))
+          }),
+        ),
+    }
+    return service
+  })
+
+/**
+ * Returns a Layer that provides both the `Transcriber` service and the
+ * `SttStreaming` capability marker. Use when the code under test calls
+ * `streamTranscriptionFrom`.
+ */
+export const layer = (
+  script: MockTranscriberScript,
+): {
+  readonly layer: Layer.Layer<Transcriber | SttStreaming>
+  readonly recorder: Effect.Effect<MockTranscriberRecorder>
+} => {
+  const tCalls = Ref.makeUnsafe<ReadonlyArray<CommonTranscribeRequest>>([])
+  const sCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamTranscribeRequest>>([])
+  const transcriberLayer = Layer.effect(
+    Transcriber,
+    makeService(script, {
+      transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),
+      stream: (req) => Ref.update(sCalls, (xs) => [...xs, req]),
+    }),
+  )
+  const live = Layer.merge(transcriberLayer, Layer.succeed(SttStreaming, undefined))
+  return {
+    layer: live,
+    recorder: Effect.gen(function* () {
+      const transcribeCalls = yield* Ref.get(tCalls)
+      const streamCalls = yield* Ref.get(sCalls)
+      return { transcribeCalls, streamCalls }
+    }),
+  }
+}
+
+/**
+ * Variant that omits the `SttStreaming` marker — use to test that
+ * consumers calling `streamTranscriptionFrom` fail to compile against
+ * a non-streaming provider.
+ */
+export const layerSyncOnly = (
+  script: MockTranscriberScript,
+): {
+  readonly layer: Layer.Layer<Transcriber>
+  readonly recorder: Effect.Effect<MockTranscriberRecorder>
+} => {
+  const tCalls = Ref.makeUnsafe<ReadonlyArray<CommonTranscribeRequest>>([])
+  const sCalls = Ref.makeUnsafe<ReadonlyArray<CommonStreamTranscribeRequest>>([])
+  const live = Layer.effect(
+    Transcriber,
+    makeService(script, {
+      transcribe: (req) => Ref.update(tCalls, (xs) => [...xs, req]),
+      stream: (req) => Ref.update(sCalls, (xs) => [...xs, req]),
+    }),
+  )
+  return {
+    layer: live,
+    recorder: Effect.gen(function* () {
+      const transcribeCalls = yield* Ref.get(tCalls)
+      const streamCalls = yield* Ref.get(sCalls)
+      return { transcribeCalls, streamCalls }
+    }),
+  }
+}

package/src/transcriber/Transcriber.test.ts

@@ -0,0 +1,125 @@
+import { Effect, Stream } from "effect"
+import { describe, expect, expectTypeOf, it } from "vitest"
+import type * as AiError from "../domain/AiError.js"
+import type { TranscriptEvent, TranscriptResult } from "../domain/Transcript.js"
+import * as MockTranscriber from "../testing/MockTranscriber.js"
+import * as Transcriber from "./Transcriber.js"
+
+describe("Transcriber.transcribe", () => {
+  it("returns the scripted TranscriptResult", async () => {
+    const mock = MockTranscriber.layer({
+      transcripts: [{ text: "hello world", durationSeconds: 1.23 }],
+    })
+    const program = Transcriber.transcribe({
+      audio: { _tag: "bytes", bytes: new Uint8Array([0]), mimeType: "audio/wav" },
+      model: "mock-stt",
+    })
+    const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(result.text).toBe("hello world")
+    expect(result.durationSeconds).toBe(1.23)
+  })
+
+  it("records each transcribe call", async () => {
+    const mock = MockTranscriber.layer({
+      transcripts: [{ text: "a" }, { text: "b" }],
+    })
+    const program = Effect.gen(function* () {
+      yield* Transcriber.transcribe({
+        audio: { _tag: "bytes", bytes: new Uint8Array([1]), mimeType: "audio/wav" },
+        model: "m1",
+      })
+      yield* Transcriber.transcribe({
+        audio: { _tag: "bytes", bytes: new Uint8Array([2]), mimeType: "audio/wav" },
+        model: "m2",
+      })
+      return yield* mock.recorder
+    })
+    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(rec.transcribeCalls.map((c) => c.model)).toEqual(["m1", "m2"])
+  })
+})
+
+describe("Transcriber capability marker (compile-time)", () => {
+  const sttReq: Transcriber.CommonStreamTranscribeRequest = {
+    model: "mock-stt",
+    inputFormat: { container: "raw", encoding: "pcm_s16le", sampleRate: 16000 },
+  }
+
+  it("requires `SttStreaming` on the R channel of streamTranscriptionFrom", () => {
+    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])
+    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))
+    expectTypeOf(events).toEqualTypeOf<
+      Stream.Stream<
+        TranscriptEvent,
+        AiError.AiError,
+        Transcriber.Transcriber | Transcriber.SttStreaming
+      >
+    >()
+  })
+
+  it("does NOT require `SttStreaming` for sync `transcribe`", () => {
+    const eff = Transcriber.transcribe({
+      audio: { _tag: "bytes", bytes: new Uint8Array([0]), mimeType: "audio/wav" },
+      model: "m",
+    })
+    expectTypeOf(eff).toEqualTypeOf<
+      Effect.Effect<TranscriptResult, AiError.AiError, Transcriber.Transcriber>
+    >()
+  })
+
+  it("a sync-only layer leaves `SttStreaming` unsatisfied in R", () => {
+    const syncOnly = MockTranscriber.layerSyncOnly({})
+    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])
+    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))
+    const program = Stream.runDrain(events).pipe(Effect.provide(syncOnly.layer))
+    // `Transcriber` is provided by syncOnly.layer; `SttStreaming` is not.
+    expectTypeOf(program).toEqualTypeOf<
+      Effect.Effect<void, AiError.AiError, Transcriber.SttStreaming>
+    >()
+  })
+
+  it("a full layer (with marker) clears R to never", () => {
+    const fullMock = MockTranscriber.layer({ streams: [[]] })
+    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])
+    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))
+    const program = Stream.runDrain(events).pipe(Effect.provide(fullMock.layer))
+    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()
+  })
+})
+
+describe("Transcriber.streamTranscriptionFrom", () => {
+  const sttReq: Transcriber.CommonStreamTranscribeRequest = {
+    model: "mock-stt",
+    inputFormat: { container: "raw", encoding: "pcm_s16le", sampleRate: 16000 },
+  }
+
+  it("emits scripted events after draining the input audio stream", async () => {
+    const mock = MockTranscriber.layer({
+      streams: [
+        [
+          { _tag: "partial", text: "hello" },
+          { _tag: "final", text: "hello world" },
+        ],
+      ],
+    })
+    const audio = Stream.fromIterable([new Uint8Array([0, 1, 2]), new Uint8Array([3, 4, 5])])
+    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))
+    const collected = await Effect.runPromise(
+      Stream.runCollect(events).pipe(Effect.provide(mock.layer)),
+    )
+    expect(collected).toEqual([
+      { _tag: "partial", text: "hello" },
+      { _tag: "final", text: "hello world" },
+    ])
+  })
+
+  it("works data-first (direct call) as well as pipeable (data-last)", async () => {
+    const mock = MockTranscriber.layer({
+      streams: [[{ _tag: "final", text: "x" }]],
+    })
+    const audio = Stream.fromIterable([new Uint8Array([0])])
+    const events = Transcriber.streamTranscriptionFrom(audio, sttReq)
+    const out = await Effect.runPromise(Stream.runCollect(events).pipe(Effect.provide(mock.layer)))
+    expect(out).toEqual([{ _tag: "final", text: "x" }])
+  })
+})

package/src/transcriber/Transcriber.ts

@@ -0,0 +1,127 @@
+import { Context, Effect, Function, Stream } from "effect"
+import * as AiError from "../domain/AiError.js"
+import type { AudioFormat, AudioSource } from "../domain/Audio.js"
+import type { TranscriptEvent, TranscriptResult } from "../domain/Transcript.js"
+
+/**
+ * Cross-provider sync transcription request. Provider-specific
+ * extensions (Deepgram `keyterm[]`, ElevenLabs `diarize`, Google
+ * `adaptation`, …) live on each provider's typed request which extends
+ * this and narrows `model`.
+ */
+export type CommonTranscribeRequest = {
+  readonly audio: AudioSource
+  /** Model identifier. Each provider narrows to its typed literal union. */
+  readonly model: string
+  /** ISO-639-1 / BCP-47. Omit for autodetection (where supported). */
+  readonly language?: string
+  /**
+   * Vocab biasing. Single-string covers OpenAI/Whisper-style prompts;
+   * `terms[]` covers Deepgram `keyterm`, Google adaptation phrases, AWS
+   * `vocabularyName`. Providers ignore what they don't support.
+   */
+  readonly prompt?: string | { readonly terms: ReadonlyArray<string> }
+  readonly diarization?: boolean
+  readonly wordTimestamps?: boolean
+}
+
+/**
+ * Streaming-transcription request. `inputFormat` declares what the
+ * bytes in the input stream will look like — providers reject
+ * mismatches at stream startup with `AiError.InvalidRequest`.
+ */
+export type CommonStreamTranscribeRequest = Omit<CommonTranscribeRequest, "audio"> & {
+  readonly inputFormat: AudioFormat
+  readonly interimResults?: boolean
+  readonly vadEvents?: boolean
+}
+
+export type TranscriberService = {
+  /**
+   * One-shot transcription. Universal — AWS Transcribe (which has no
+   * native sync endpoint) emulates this by draining a streaming session
+   * internally.
+   */
+  readonly transcribe: (
+    request: CommonTranscribeRequest,
+  ) => Effect.Effect<TranscriptResult, AiError.AiError>
+  /**
+   * Live transcription as a Stream transformer. Consumes audio bytes
+   * from `audioIn`; emits `TranscriptEvent`s as they arrive. The
+   * underlying WS / gRPC connection is acquired on first pull and
+   * released when the output stream is finalized (success, failure, or
+   * interruption) via `Stream.scoped` — no explicit Scope handling at
+   * the call site.
+   *
+   * Gated by the `SttStreaming` capability marker on the top-level
+   * helper — providers without streaming-STT support don't ship the
+   * marker, so calls fail at `Effect.provide` with a type error.
+   */
+  readonly streamTranscriptionFrom: <E, R>(
+    audioIn: Stream.Stream<Uint8Array, E, R>,
+    request: CommonStreamTranscribeRequest,
+  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R>
+}
+
+export class Transcriber extends Context.Service<Transcriber, TranscriberService>()(
+  "@betalyra/effect-uai/Transcriber",
+) {}
+
+/**
+ * Capability marker — provided by provider layers whose
+ * `streamTranscriptionFrom` is wired up at the wire level. Azure does
+ * not ship it (streaming-STT is SDK-internal). Calling
+ * `streamTranscriptionFrom` while only Azure's Layer is in scope fails
+ * at `Effect.provide` with a type error, not at runtime.
+ *
+ * Phantom — the value is `void`; providers register with
+ * `Layer.succeed(SttStreaming, undefined)`.
+ */
+export class SttStreaming extends Context.Service<SttStreaming, void>()(
+  "@betalyra/effect-uai/capability/SttStreaming",
+) {}
+
+/** One-shot transcription. */
+export const transcribe = (
+  request: CommonTranscribeRequest,
+): Effect.Effect<TranscriptResult, AiError.AiError, Transcriber> =>
+  Effect.flatMap(Transcriber.asEffect(), (t) => t.transcribe(request))
+
+/**
+ * Live transcription. Dual-arity: pipeable (data-last) and direct
+ * (data-first). Requires `SttStreaming` in R — providers without
+ * streaming support are a type error at provide time.
+ *
+ * @example
+ * ```ts
+ * // Pipeable — composes with other Stream operators
+ * mic.frames.pipe(
+ *   Transcriber.streamTranscriptionFrom(req),
+ *   Stream.filter((e) => e._tag === "final"),
+ * )
+ *
+ * // Direct
+ * Transcriber.streamTranscriptionFrom(mic.frames, req)
+ * ```
+ */
+export const streamTranscriptionFrom: {
+  (
+    request: CommonStreamTranscribeRequest,
+  ): <E, R>(
+    audioIn: Stream.Stream<Uint8Array, E, R>,
+  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R | Transcriber | SttStreaming>
+  <E, R>(
+    audioIn: Stream.Stream<Uint8Array, E, R>,
+    request: CommonStreamTranscribeRequest,
+  ): Stream.Stream<TranscriptEvent, AiError.AiError | E, R | Transcriber | SttStreaming>
+} = Function.dual(
+  2,
+  <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest) =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const t = yield* Transcriber.asEffect()
+        yield* SttStreaming.asEffect()
+        return t.streamTranscriptionFrom(audioIn, request)
+      }),
+    ),
+)