@effect-uai/inworld 0.16.0 → 0.18.0

package/dist/realtimeTts.mjs

@@ -1,9 +1,10 @@
 import { audioConfigFor, decodeAudioContent, defaultFormat } from "./codec.mjs";
 import { authedWsConstructor } from "./wsAuth.mjs";
-import { Effect, Queue, Schema, Stream } from "effect";
+import { Effect, Option, Predicate, Schema, Stream } from "effect";
 import * as AiError from "@effect-uai/core/AiError";
 import * as JSONL from "@effect-uai/core/JSONL";
-import * as Socket from "effect/unstable/socket/Socket";
+import * as Socket from "effect/socket/Socket";
+import * as WebSocketSession from "@effect-uai/core/WebSocketSession";
 //#region src/realtimeTts.ts
 /**
 * Inworld Realtime TTS — `wss://api.inworld.ai/tts/v1/voice:streamBidirectional`.
@@ -61,20 +62,24 @@ const ServerFrame = Schema.Struct({
 	error: Schema.optional(Schema.Unknown)
 });
 const decodeServerFrame = Schema.decodeUnknownEffect(ServerFrame);
-const handleServerFrame = (queue) => (raw) => Effect.gen(function* () {
+/** One raw text frame to at most one audio chunk; error frames are logged, not raised. */
+const frameToChunk = (raw) => Effect.gen(function* () {
 	const json = yield* JSONL.parseSafe(raw);
-	if (json === void 0) return;
+	if (json === void 0) return void 0;
 	const decoded = yield* decodeServerFrame(json).pipe(Effect.option);
-	if (decoded._tag === "None") return;
+	if (Option.isNone(decoded)) return void 0;
 	const frame = decoded.value;
 	if (frame.error !== void 0) {
 		yield* Effect.logWarning("[inworld-tts] server error frame", { error: frame.error });
 		return;
 	}
 	const audio = frame.result?.audioChunk?.audioContent;
-	if (audio === void 0 || audio === "") return;
+	if (audio === void 0 || audio === "") return void 0;
 	const bytes = yield* decodeAudioContent(audio).pipe(Effect.option);
-	if (bytes._tag === "Some") yield* Queue.offer(queue, { bytes: bytes.value });
+	return Option.match(bytes, {
+		onNone: () => void 0,
+		onSome: (b) => ({ bytes: b })
+	});
 });
 const streamSynthesis = (cfg) => (textIn, request) => Stream.unwrap(Effect.gen(function* () {
 	if (request.pronunciations !== void 0 && request.pronunciations.length > 0) return Stream.fail(new AiError.Unsupported({
@@ -83,16 +88,12 @@ const streamSynthesis = (cfg) => (textIn, request) => Stream.unwrap(Effect.gen(f
 		reason: "Inworld applies inline /ipa/ pronunciations on sync `synthesize` only; the incremental WS path streams text in chunks with no place to rewrite. Use `synthesize` for pronunciation overrides."
 	}));
 	const create = yield* createFrame(request);
-	const socket = yield* Socket.makeWebSocket(buildWsUrl(cfg), { closeCodeIsError: (code) => code !== 1e3 && code !== 1001 && code !== 1005 }).pipe(Effect.provideService(Socket.WebSocketConstructor, authedWsConstructor(cfg.apiKey)));
-	const queue = yield* Queue.bounded(64);
-	const write = yield* socket.writer;
-	yield* Effect.gen(function* () {
-		yield* write(create);
-		yield* Stream.runForEach(textIn, (text) => text.length === 0 ? Effect.void : write(sendTextFrame(text)));
-		yield* write(closeContextFrame);
-	}).pipe(Effect.ignore, Effect.forkScoped);
-	yield* socket.runString(handleServerFrame(queue)).pipe(Effect.ensuring(Queue.end(queue)), Effect.forkScoped);
-	return Stream.fromQueue(queue);
+	const socket = yield* Socket.makeWebSocket(buildWsUrl(cfg)).pipe(Effect.provideService(Socket.WebSocketConstructor, cfg.webSocket ?? authedWsConstructor(cfg.apiKey)));
+	const { write } = yield* socket.writer;
+	const asAiError = WebSocketSession.toAiError("inworld");
+	const chunks = Stream.fromPull(Socket.readerString(socket)).pipe(Stream.scoped, Stream.catchIf(WebSocketSession.isCleanClose, () => Stream.empty), Stream.mapError(asAiError), Stream.mapEffect(frameToChunk), Stream.filter(Predicate.isNotUndefined));
+	const outgoing = Stream.concat(Stream.make(create), Stream.concat(textIn.pipe(Stream.filter((text) => text.length > 0), Stream.map(sendTextFrame)), Stream.make(closeContextFrame))).pipe(Stream.mapEffect((frame) => Effect.mapError(write(frame), asAiError)));
+	return Stream.merge(chunks, Stream.drain(outgoing), { haltStrategy: "left" });
 }));
 //#endregion
 export { buildWsUrl, streamSynthesis };

package/dist/realtimeTts.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"realtimeTts.mjs","names":[],"sources":["../src/realtimeTts.ts"],"sourcesContent":["/**\n * Inworld Realtime TTS — `wss://api.inworld.ai/tts/v1/voice:streamBidirectional`.\n *\n * Auth: `Authorization: Basic <API_KEY>` on the WS upgrade header (matches\n * Inworld's own JS sample). The docs mention a `?Authorization=…` query\n * variant but the server rejects it in practice. Setting headers needs the\n * `ws` peer dep (Node/Bun); see `./wsAuth.ts`.\n *\n * Wire shape (single-context per call):\n *   client → server:\n *     `{ \"create\": { voiceId, modelId, audioConfig, ... } }`\n *     `{ \"send_text\": { \"text\": \"...\" } }`             (repeated)\n *     `{ \"close_context\": {} }`                        (text stream end)\n *   server → client:\n *     `{ \"result\": { \"contextCreated\": {...} } }`      (handshake ack)\n *     `{ \"result\": { \"audioChunk\": { \"audioContent\": \"<b64>\" } } }` (×N)\n *     `{ \"result\": { \"contextClosed\": {...} } }`       (final)\n *\n * Multi-context (`contextId`) is not surfaced here — one logical\n * utterance per call.\n */\nimport { Cause, Effect, Queue, Redacted, Schema, Stream } from \"effect\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport type { AudioChunk, AudioFormat } from \"@effect-uai/core/Audio\"\nimport * as JSONL from \"@effect-uai/core/JSONL\"\nimport type { CustomPronunciation } from \"@effect-uai/core/SpeechSynthesizer\"\nimport { audioConfigFor, decodeAudioContent, defaultFormat } from \"./codec.js\"\nimport type { InworldDeliveryMode, InworldTtsModel, InworldVoiceId } from \"./models.js\"\nimport { authedWsConstructor } from \"./wsAuth.js\"\n\nexport type Config = { readonly apiKey: Redacted.Redacted; readonly baseUrl?: string }\n\n/**\n * Incremental-text-in request. Mirrors the sync request minus `text` (which\n * comes from the input stream).\n */\nexport type StreamSynthesizeRequest = {\n  readonly model: InworldTtsModel\n  readonly voiceId: InworldVoiceId\n  readonly outputFormat?: AudioFormat\n  readonly languageCode?: string\n  readonly temperature?: number\n  readonly deliveryMode?: InworldDeliveryMode\n  readonly applyTextNormalization?: \"ON\" | \"OFF\"\n  readonly speed?: number\n  /** Carried from the Common request so the WS path can reject inline\n   *  pronunciations (no place to rewrite into a chunked text stream). */\n  readonly pronunciations?: ReadonlyArray<CustomPronunciation>\n}\n\n// ---------------------------------------------------------------------------\n// URL + frame builders\n// ---------------------------------------------------------------------------\n\nexport const buildWsUrl = (cfg: Config) => {\n  const wsBase = (cfg.baseUrl ?? \"https://api.inworld.ai\").replace(/^http/, \"ws\")\n  return `${wsBase}/tts/v1/voice:streamBidirectional`\n}\n\n// TTS WS uses snake_case outbound (per Inworld's own JS sample). The\n// camelCase helper from `codec.ts` is built for the REST/JSON sync paths;\n// rewire the field names here for the WS path. Server responses come back\n// camelCase regardless — see `ResultBody` below.\nconst audioConfigSnake = (request: StreamSynthesizeRequest) =>\n  Effect.map(audioConfigFor(request.outputFormat ?? defaultFormat, request.speed), (cfg) => ({\n    audio_encoding: cfg.audioEncoding,\n    ...(cfg.sampleRateHertz !== undefined && { sample_rate_hertz: cfg.sampleRateHertz }),\n    ...(cfg.bitRate !== undefined && { bit_rate: cfg.bitRate }),\n    ...(cfg.speakingRate !== undefined && { speaking_rate: cfg.speakingRate }),\n  }))\n\nconst createFrame = (request: StreamSynthesizeRequest) =>\n  Effect.map(audioConfigSnake(request), (audio_config) =>\n    JSON.stringify({\n      create: {\n        voice_id: request.voiceId,\n        model_id: request.model,\n        audio_config,\n        ...(request.languageCode !== undefined && { language: request.languageCode }),\n        ...(request.deliveryMode !== undefined && { delivery_mode: request.deliveryMode }),\n        ...(request.temperature !== undefined && { temperature: request.temperature }),\n        ...(request.applyTextNormalization !== undefined && {\n          apply_text_normalization: request.applyTextNormalization,\n        }),\n      },\n    }),\n  )\n\n// `flush_context: {}` inside `send_text` nudges the server to flush\n// pending audio promptly — matches the low-latency sample.\nconst sendTextFrame = (text: string) => JSON.stringify({ send_text: { text, flush_context: {} } })\nconst closeContextFrame = JSON.stringify({ close_context: {} })\n\n// ---------------------------------------------------------------------------\n// Wire schema (server → client)\n// ---------------------------------------------------------------------------\n\nconst ResultBody = Schema.Struct({\n  audioChunk: Schema.optional(Schema.Struct({ audioContent: Schema.String })),\n  contextCreated: Schema.optional(Schema.Unknown),\n  flushCompleted: Schema.optional(Schema.Unknown),\n  contextClosed: Schema.optional(Schema.Unknown),\n  status: Schema.optional(Schema.Unknown),\n})\n\nconst ServerFrame = Schema.Struct({\n  result: Schema.optional(ResultBody),\n  error: Schema.optional(Schema.Unknown),\n})\nconst decodeServerFrame = Schema.decodeUnknownEffect(ServerFrame)\n\nconst handleServerFrame = (queue: Queue.Queue<AudioChunk, Cause.Done>) => (raw: string) =>\n  Effect.gen(function* () {\n    const json = yield* JSONL.parseSafe(raw)\n    if (json === undefined) return\n    const decoded = yield* decodeServerFrame(json).pipe(Effect.option)\n    if (decoded._tag === \"None\") return\n    const frame = decoded.value\n    if (frame.error !== undefined) {\n      yield* Effect.logWarning(\"[inworld-tts] server error frame\", { error: frame.error })\n      return\n    }\n    const audio = frame.result?.audioChunk?.audioContent\n    if (audio === undefined || audio === \"\") return\n    const bytes = yield* decodeAudioContent(audio).pipe(Effect.option)\n    if (bytes._tag === \"Some\") yield* Queue.offer(queue, { bytes: bytes.value })\n  })\n\n// ---------------------------------------------------------------------------\n// Stream<string> → Stream<AudioChunk>\n// ---------------------------------------------------------------------------\n\nexport const streamSynthesis =\n  (cfg: Config) =>\n  <E, R>(\n    textIn: Stream.Stream<string, E, R>,\n    request: StreamSynthesizeRequest,\n  ): Stream.Stream<AudioChunk, AiError.AiError | E, R> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        // Inline pronunciations are load-bearing (bucket 1) but there is no\n        // single text to rewrite `/ipa/` into on a chunked stream. Reject\n        // rather than silently drop; use sync `synthesize` for overrides.\n        if (request.pronunciations !== undefined && request.pronunciations.length > 0) {\n          return Stream.fail(\n            new AiError.Unsupported({\n              provider: \"inworld\",\n              capability: \"pronunciations\",\n              reason:\n                \"Inworld applies inline /ipa/ pronunciations on sync `synthesize` only; the incremental WS path streams text in chunks with no place to rewrite. Use `synthesize` for pronunciation overrides.\",\n            }),\n          )\n        }\n        const create = yield* createFrame(request)\n        const socket = yield* Socket.makeWebSocket(buildWsUrl(cfg), {\n          // Effect's Socket treats all close codes as errors by default —\n          // whitelist standard clean-close codes (1000 / 1001 / 1005).\n          closeCodeIsError: (code) => code !== 1000 && code !== 1001 && code !== 1005,\n        }).pipe(Effect.provideService(Socket.WebSocketConstructor, authedWsConstructor(cfg.apiKey)))\n        const queue = yield* Queue.bounded<AudioChunk, Cause.Done>(64)\n        const write = yield* socket.writer\n\n        // Writer: BOS `create` → drain text as `send_text` → `close_context`.\n        // The reader fiber surfaces the remaining audio drained by the server\n        // post-close and shuts the queue when the WS upstream closes.\n        yield* Effect.gen(function* () {\n          yield* write(create)\n          yield* Stream.runForEach(textIn, (text) =>\n            text.length === 0 ? Effect.void : write(sendTextFrame(text)),\n          )\n          yield* write(closeContextFrame)\n        }).pipe(Effect.ignore, Effect.forkScoped)\n\n        // `Queue.end` flushes pending chunks then fails the next take with\n        // `Done` — clean stream end. `Queue.shutdown` would CLEAR queued items\n        // and interrupt pending takes (wrong for graceful teardown).\n        yield* socket\n          .runString(handleServerFrame(queue))\n          .pipe(Effect.ensuring(Queue.end(queue)), Effect.forkScoped)\n\n        return Stream.fromQueue(queue)\n      }),\n    )\n"],"mappings":"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"}
+{"version":3,"file":"realtimeTts.mjs","names":[],"sources":["../src/realtimeTts.ts"],"sourcesContent":["/**\n * Inworld Realtime TTS — `wss://api.inworld.ai/tts/v1/voice:streamBidirectional`.\n *\n * Auth: `Authorization: Basic <API_KEY>` on the WS upgrade header (matches\n * Inworld's own JS sample). The docs mention a `?Authorization=…` query\n * variant but the server rejects it in practice. Setting headers needs the\n * `ws` peer dep (Node/Bun); see `./wsAuth.ts`.\n *\n * Wire shape (single-context per call):\n *   client → server:\n *     `{ \"create\": { voiceId, modelId, audioConfig, ... } }`\n *     `{ \"send_text\": { \"text\": \"...\" } }`             (repeated)\n *     `{ \"close_context\": {} }`                        (text stream end)\n *   server → client:\n *     `{ \"result\": { \"contextCreated\": {...} } }`      (handshake ack)\n *     `{ \"result\": { \"audioChunk\": { \"audioContent\": \"<b64>\" } } }` (×N)\n *     `{ \"result\": { \"contextClosed\": {...} } }`       (final)\n *\n * Multi-context (`contextId`) is not surfaced here — one logical\n * utterance per call.\n */\nimport { Effect, Option, Predicate, Redacted, Schema, Stream } from \"effect\"\nimport * as Socket from \"effect/socket/Socket\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport type { AudioChunk, AudioFormat } from \"@effect-uai/core/Audio\"\nimport * as JSONL from \"@effect-uai/core/JSONL\"\nimport type { CustomPronunciation } from \"@effect-uai/core/SpeechSynthesizer\"\nimport * as WebSocketSession from \"@effect-uai/core/WebSocketSession\"\nimport { audioConfigFor, decodeAudioContent, defaultFormat } from \"./codec.js\"\nimport type { InworldDeliveryMode, InworldTtsModel, InworldVoiceId } from \"./models.js\"\nimport { authedWsConstructor } from \"./wsAuth.js\"\n\nexport type Config = {\n  readonly apiKey: Redacted.Redacted\n  readonly baseUrl?: string\n  /**\n   * Build the socket yourself, for a proxy or an in-memory transport. The\n   * default attaches the Basic auth header through the `ws` package.\n   */\n  readonly webSocket?: Socket.WebSocketConstructor[\"Service\"]\n}\n\n/**\n * Incremental-text-in request. Mirrors the sync request minus `text` (which\n * comes from the input stream).\n */\nexport type StreamSynthesizeRequest = {\n  readonly model: InworldTtsModel\n  readonly voiceId: InworldVoiceId\n  readonly outputFormat?: AudioFormat\n  readonly languageCode?: string\n  readonly temperature?: number\n  readonly deliveryMode?: InworldDeliveryMode\n  readonly applyTextNormalization?: \"ON\" | \"OFF\"\n  readonly speed?: number\n  /** Carried from the Common request so the WS path can reject inline\n   *  pronunciations (no place to rewrite into a chunked text stream). */\n  readonly pronunciations?: ReadonlyArray<CustomPronunciation>\n}\n\n// ---------------------------------------------------------------------------\n// URL + frame builders\n// ---------------------------------------------------------------------------\n\nexport const buildWsUrl = (cfg: Config) => {\n  const wsBase = (cfg.baseUrl ?? \"https://api.inworld.ai\").replace(/^http/, \"ws\")\n  return `${wsBase}/tts/v1/voice:streamBidirectional`\n}\n\n// TTS WS uses snake_case outbound (per Inworld's own JS sample). The\n// camelCase helper from `codec.ts` is built for the REST/JSON sync paths;\n// rewire the field names here for the WS path. Server responses come back\n// camelCase regardless — see `ResultBody` below.\nconst audioConfigSnake = (request: StreamSynthesizeRequest) =>\n  Effect.map(audioConfigFor(request.outputFormat ?? defaultFormat, request.speed), (cfg) => ({\n    audio_encoding: cfg.audioEncoding,\n    ...(cfg.sampleRateHertz !== undefined && { sample_rate_hertz: cfg.sampleRateHertz }),\n    ...(cfg.bitRate !== undefined && { bit_rate: cfg.bitRate }),\n    ...(cfg.speakingRate !== undefined && { speaking_rate: cfg.speakingRate }),\n  }))\n\nconst createFrame = (request: StreamSynthesizeRequest) =>\n  Effect.map(audioConfigSnake(request), (audio_config) =>\n    JSON.stringify({\n      create: {\n        voice_id: request.voiceId,\n        model_id: request.model,\n        audio_config,\n        ...(request.languageCode !== undefined && { language: request.languageCode }),\n        ...(request.deliveryMode !== undefined && { delivery_mode: request.deliveryMode }),\n        ...(request.temperature !== undefined && { temperature: request.temperature }),\n        ...(request.applyTextNormalization !== undefined && {\n          apply_text_normalization: request.applyTextNormalization,\n        }),\n      },\n    }),\n  )\n\n// `flush_context: {}` inside `send_text` nudges the server to flush\n// pending audio promptly — matches the low-latency sample.\nconst sendTextFrame = (text: string) => JSON.stringify({ send_text: { text, flush_context: {} } })\nconst closeContextFrame = JSON.stringify({ close_context: {} })\n\n// ---------------------------------------------------------------------------\n// Wire schema (server → client)\n// ---------------------------------------------------------------------------\n\nconst ResultBody = Schema.Struct({\n  audioChunk: Schema.optional(Schema.Struct({ audioContent: Schema.String })),\n  contextCreated: Schema.optional(Schema.Unknown),\n  flushCompleted: Schema.optional(Schema.Unknown),\n  contextClosed: Schema.optional(Schema.Unknown),\n  status: Schema.optional(Schema.Unknown),\n})\n\nconst ServerFrame = Schema.Struct({\n  result: Schema.optional(ResultBody),\n  error: Schema.optional(Schema.Unknown),\n})\nconst decodeServerFrame = Schema.decodeUnknownEffect(ServerFrame)\n\n/** One raw text frame to at most one audio chunk; error frames are logged, not raised. */\nconst frameToChunk = (raw: string): Effect.Effect<AudioChunk | undefined> =>\n  Effect.gen(function* () {\n    const json = yield* JSONL.parseSafe(raw)\n    if (json === undefined) return undefined\n    const decoded = yield* decodeServerFrame(json).pipe(Effect.option)\n    if (Option.isNone(decoded)) return undefined\n    const frame = decoded.value\n    if (frame.error !== undefined) {\n      yield* Effect.logWarning(\"[inworld-tts] server error frame\", { error: frame.error })\n      return undefined\n    }\n    const audio = frame.result?.audioChunk?.audioContent\n    if (audio === undefined || audio === \"\") return undefined\n    const bytes = yield* decodeAudioContent(audio).pipe(Effect.option)\n    return Option.match(bytes, {\n      onNone: () => undefined,\n      onSome: (b): AudioChunk => ({ bytes: b }),\n    })\n  })\n\n// ---------------------------------------------------------------------------\n// Stream<string> → Stream<AudioChunk>\n// ---------------------------------------------------------------------------\n\nexport const streamSynthesis =\n  (cfg: Config) =>\n  <E, R>(\n    textIn: Stream.Stream<string, E, R>,\n    request: StreamSynthesizeRequest,\n  ): Stream.Stream<AudioChunk, AiError.AiError | E, R> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        // Inline pronunciations are load-bearing (bucket 1) but there is no\n        // single text to rewrite `/ipa/` into on a chunked stream. Reject\n        // rather than silently drop; use sync `synthesize` for overrides.\n        if (request.pronunciations !== undefined && request.pronunciations.length > 0) {\n          return Stream.fail(\n            new AiError.Unsupported({\n              provider: \"inworld\",\n              capability: \"pronunciations\",\n              reason:\n                \"Inworld applies inline /ipa/ pronunciations on sync `synthesize` only; the incremental WS path streams text in chunks with no place to rewrite. Use `synthesize` for pronunciation overrides.\",\n            }),\n          )\n        }\n        const create = yield* createFrame(request)\n        const socket = yield* Socket.makeWebSocket(buildWsUrl(cfg)).pipe(\n          Effect.provideService(\n            Socket.WebSocketConstructor,\n            cfg.webSocket ?? authedWsConstructor(cfg.apiKey),\n          ),\n        )\n        const { write } = yield* socket.writer\n        const asAiError = WebSocketSession.toAiError(\"inworld\")\n\n        const chunks = Stream.fromPull(Socket.readerString(socket)).pipe(\n          Stream.scoped,\n          Stream.catchIf(WebSocketSession.isCleanClose, () => Stream.empty),\n          Stream.mapError(asAiError),\n          Stream.mapEffect(frameToChunk),\n          Stream.filter(Predicate.isNotUndefined),\n        )\n\n        const outgoing = Stream.concat(\n          Stream.make(create),\n          Stream.concat(\n            textIn.pipe(\n              Stream.filter((text) => text.length > 0),\n              Stream.map(sendTextFrame),\n            ),\n            Stream.make(closeContextFrame),\n          ),\n        ).pipe(Stream.mapEffect((frame) => Effect.mapError(write(frame), asAiError)))\n\n        // The server drains remaining audio after `close_context`, then closes.\n        return Stream.merge(chunks, Stream.drain(outgoing), { haltStrategy: \"left\" })\n      }),\n    )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,MAAa,cAAc,QAAgB;CAEzC,OAAO,IADS,IAAI,WAAW,yBAAA,CAA0B,QAAQ,SAAS,IAC3D,EAAE;AACnB;AAMA,MAAM,oBAAoB,YACxB,OAAO,IAAI,eAAe,QAAQ,gBAAgB,eAAe,QAAQ,KAAK,IAAI,SAAS;CACzF,gBAAgB,IAAI;CACpB,GAAI,IAAI,oBAAoB,KAAA,KAAa,EAAE,mBAAmB,IAAI,gBAAgB;CAClF,GAAI,IAAI,YAAY,KAAA,KAAa,EAAE,UAAU,IAAI,QAAQ;CACzD,GAAI,IAAI,iBAAiB,KAAA,KAAa,EAAE,eAAe,IAAI,aAAa;AAC1E,EAAE;AAEJ,MAAM,eAAe,YACnB,OAAO,IAAI,iBAAiB,OAAO,IAAI,iBACrC,KAAK,UAAU,EACb,QAAQ;CACN,UAAU,QAAQ;CAClB,UAAU,QAAQ;CAClB;CACA,GAAI,QAAQ,iBAAiB,KAAA,KAAa,EAAE,UAAU,QAAQ,aAAa;CAC3E,GAAI,QAAQ,iBAAiB,KAAA,KAAa,EAAE,eAAe,QAAQ,aAAa;CAChF,GAAI,QAAQ,gBAAgB,KAAA,KAAa,EAAE,aAAa,QAAQ,YAAY;CAC5E,GAAI,QAAQ,2BAA2B,KAAA,KAAa,EAClD,0BAA0B,QAAQ,uBACpC;AACF,EACF,CAAC,CACH;AAIF,MAAM,iBAAiB,SAAiB,KAAK,UAAU,EAAE,WAAW;CAAE;CAAM,eAAe,CAAC;AAAE,EAAE,CAAC;AACjG,MAAM,oBAAoB,KAAK,UAAU,EAAE,eAAe,CAAC,EAAE,CAAC;AAM9D,MAAM,aAAa,OAAO,OAAO;CAC/B,YAAY,OAAO,SAAS,OAAO,OAAO,EAAE,cAAc,OAAO,OAAO,CAAC,CAAC;CAC1E,gBAAgB,OAAO,SAAS,OAAO,OAAO;CAC9C,gBAAgB,OAAO,SAAS,OAAO,OAAO;CAC9C,eAAe,OAAO,SAAS,OAAO,OAAO;CAC7C,QAAQ,OAAO,SAAS,OAAO,OAAO;AACxC,CAAC;AAED,MAAM,cAAc,OAAO,OAAO;CAChC,QAAQ,OAAO,SAAS,UAAU;CAClC,OAAO,OAAO,SAAS,OAAO,OAAO;AACvC,CAAC;AACD,MAAM,oBAAoB,OAAO,oBAAoB,WAAW;;AAGhE,MAAM,gBAAgB,QACpB,OAAO,IAAI,aAAa;CACtB,MAAM,OAAO,OAAO,MAAM,UAAU,GAAG;CACvC,IAAI,SAAS,KAAA,GAAW,OAAO,KAAA;CAC/B,MAAM,UAAU,OAAO,kBAAkB,IAAI,CAAC,CAAC,KAAK,OAAO,MAAM;CACjE,IAAI,OAAO,OAAO,OAAO,GAAG,OAAO,KAAA;CACnC,MAAM,QAAQ,QAAQ;CACtB,IAAI,MAAM,UAAU,KAAA,GAAW;EAC7B,OAAO,OAAO,WAAW,oCAAoC,EAAE,OAAO,MAAM,MAAM,CAAC;EACnF;CACF;CACA,MAAM,QAAQ,MAAM,QAAQ,YAAY;CACxC,IAAI,UAAU,KAAA,KAAa,UAAU,IAAI,OAAO,KAAA;CAChD,MAAM,QAAQ,OAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,OAAO,MAAM;CACjE,OAAO,OAAO,MAAM,OAAO;EACzB,cAAc,KAAA;EACd,SAAS,OAAmB,EAAE,OAAO,EAAE;CACzC,CAAC;AACH,CAAC;AAMH,MAAa,mBACV,SAEC,QACA,YAEA,OAAO,OACL,OAAO,IAAI,aAAa;CAItB,IAAI,QAAQ,mBAAmB,KAAA,KAAa,QAAQ,eAAe,SAAS,GAC1E,OAAO,OAAO,KACZ,IAAI,QAAQ,YAAY;EACtB,UAAU;EACV,YAAY;EACZ,QACE;CACJ,CAAC,CACH;CAEF,MAAM,SAAS,OAAO,YAAY,OAAO;CACzC,MAAM,SAAS,OAAO,OAAO,cAAc,WAAW,GAAG,CAAC,CAAC,CAAC,KAC1D,OAAO,eACL,OAAO,sBACP,IAAI,aAAa,oBAAoB,IAAI,MAAM,CACjD,CACF;CACA,MAAM,EAAE,UAAU,OAAO,OAAO;CAChC,MAAM,YAAY,iBAAiB,UAAU,SAAS;CAEtD,MAAM,SAAS,OAAO,SAAS,OAAO,aAAa,MAAM,CAAC,CAAC,CAAC,KAC1D,OAAO,QACP,OAAO,QAAQ,iBAAiB,oBAAoB,OAAO,KAAK,GAChE,OAAO,SAAS,SAAS,GACzB,OAAO,UAAU,YAAY,GAC7B,OAAO,OAAO,UAAU,cAAc,CACxC;CAEA,MAAM,WAAW,OAAO,OACtB,OAAO,KAAK,MAAM,GAClB,OAAO,OACL,OAAO,KACL,OAAO,QAAQ,SAAS,KAAK,SAAS,CAAC,GACvC,OAAO,IAAI,aAAa,CAC1B,GACA,OAAO,KAAK,iBAAiB,CAC/B,CACF,CAAC,CAAC,KAAK,OAAO,WAAW,UAAU,OAAO,SAAS,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC;CAG5E,OAAO,OAAO,MAAM,QAAQ,OAAO,MAAM,QAAQ,GAAG,EAAE,cAAc,OAAO,CAAC;AAC9E,CAAC,CACH"}

package/dist/realtimeTts.test.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/realtimeTts.test.mjs

@@ -0,0 +1,70 @@
+import { streamSynthesis } from "./realtimeTts.mjs";
+import { n as globalExpect, r as describe, t as it } from "./dist-Cu2gIMHV.mjs";
+import { Effect, Exit, Fiber, Redacted, Stream } from "effect";
+import { Base64 } from "effect/encoding";
+import * as FakeWebSocket from "@effect-uai/core/testing/FakeWebSocket";
+//#region src/realtimeTts.test.ts
+const request = {
+	model: "inworld-tts-2",
+	voiceId: "Ashley"
+};
+const synthesizing = FakeWebSocket.make({ greeting: [
+	{ result: { contextCreated: {} } },
+	{ result: { audioChunk: { audioContent: Base64.encode(new Uint8Array([
+		1,
+		2,
+		3
+	])) } } },
+	{ error: { message: "transient" } },
+	{ result: { audioChunk: { audioContent: "" } } },
+	{ result: { contextClosed: {} } }
+] });
+/** Run a synthesis against `server`, closing it, if asked, once the frames are in. */
+const synthesize = (server, textIn, close) => Effect.gen(function* () {
+	const run = streamSynthesis({
+		apiKey: Redacted.make("test-key"),
+		webSocket: server.connect
+	});
+	const collector = yield* Effect.forkChild(Effect.exit(Stream.runCollect(run(textIn, request))));
+	if (close !== void 0) {
+		yield* server.greeted;
+		yield* server.awaitSent(close.afterSent ?? 0);
+		yield* server.close(close.code);
+	}
+	return yield* Fiber.join(collector);
+});
+describe("Inworld Realtime TTS socket", () => {
+	it.live("creates the context before any text, and ends on a clean close", () => Effect.gen(function* () {
+		const server = yield* synthesizing;
+		const exit = yield* synthesize(server, Stream.make("Hello", "", " world"), {
+			code: 1e3,
+			afterSent: 4
+		});
+		globalExpect(exit).toEqual(Exit.succeed([{ bytes: new Uint8Array([
+			1,
+			2,
+			3
+		]) }]));
+		const sent = yield* server.sent;
+		globalExpect(sent.map((f) => Object.keys(f)[0])).toEqual([
+			"create",
+			"send_text",
+			"send_text",
+			"close_context"
+		]);
+	}).pipe(Effect.scoped));
+	it.live("fails rather than ending when the connection drops", () => Effect.gen(function* () {
+		const server = yield* synthesizing;
+		const exit = yield* synthesize(server, Stream.never, { code: 1011 });
+		globalExpect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain("Unavailable");
+	}).pipe(Effect.scoped));
+	it.live("fails with the text input's own error", () => Effect.gen(function* () {
+		const server = yield* synthesizing;
+		const exit = yield* synthesize(server, Stream.fail("upstream llm failed"));
+		globalExpect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain("upstream llm failed");
+	}).pipe(Effect.scoped));
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=realtimeTts.test.mjs.map

package/dist/realtimeTts.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtimeTts.test.mjs","names":[],"sources":["../src/realtimeTts.test.ts"],"sourcesContent":["import { describe, it } from \"@effect/vitest\"\nimport { Effect, Exit, Fiber, Redacted, Stream } from \"effect\"\nimport { Base64 } from \"effect/encoding\"\nimport { expect } from \"vitest\"\nimport * as FakeWebSocket from \"@effect-uai/core/testing/FakeWebSocket\"\nimport { streamSynthesis } from \"./realtimeTts.js\"\n\nconst request = { model: \"inworld-tts-2\", voiceId: \"Ashley\" } as const\n\nconst synthesizing = FakeWebSocket.make({\n  greeting: [\n    { result: { contextCreated: {} } },\n    { result: { audioChunk: { audioContent: Base64.encode(new Uint8Array([1, 2, 3])) } } },\n    { error: { message: \"transient\" } },\n    { result: { audioChunk: { audioContent: \"\" } } },\n    { result: { contextClosed: {} } },\n  ],\n})\n\n/** Run a synthesis against `server`, closing it, if asked, once the frames are in. */\nconst synthesize = <E>(\n  server: FakeWebSocket.FakeWebSocketServer,\n  textIn: Stream.Stream<string, E>,\n  close?: { readonly code: number; readonly afterSent?: number },\n) =>\n  Effect.gen(function* () {\n    const run = streamSynthesis({ apiKey: Redacted.make(\"test-key\"), webSocket: server.connect })\n    const collector = yield* Effect.forkChild(Effect.exit(Stream.runCollect(run(textIn, request))))\n    if (close !== undefined) {\n      yield* server.greeted\n      yield* server.awaitSent(close.afterSent ?? 0)\n      yield* server.close(close.code)\n    }\n    return yield* Fiber.join(collector)\n  })\n\ndescribe(\"Inworld Realtime TTS socket\", () => {\n  it.live(\"creates the context before any text, and ends on a clean close\", () =>\n    Effect.gen(function* () {\n      const server = yield* synthesizing\n      const exit = yield* synthesize(server, Stream.make(\"Hello\", \"\", \" world\"), {\n        code: 1000,\n        afterSent: 4,\n      })\n\n      expect(exit).toEqual(Exit.succeed([{ bytes: new Uint8Array([1, 2, 3]) }]))\n      const sent = (yield* server.sent) as ReadonlyArray<Record<string, unknown>>\n      expect(sent.map((f) => Object.keys(f)[0])).toEqual([\n        \"create\",\n        \"send_text\",\n        \"send_text\",\n        \"close_context\",\n      ])\n    }).pipe(Effect.scoped),\n  )\n\n  it.live(\"fails rather than ending when the connection drops\", () =>\n    Effect.gen(function* () {\n      const server = yield* synthesizing\n      const exit = yield* synthesize(server, Stream.never, { code: 1011 })\n\n      expect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain(\"Unavailable\")\n    }).pipe(Effect.scoped),\n  )\n\n  it.live(\"fails with the text input's own error\", () =>\n    Effect.gen(function* () {\n      const server = yield* synthesizing\n      const exit = yield* synthesize(server, Stream.fail(\"upstream llm failed\"))\n\n      expect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain(\"upstream llm failed\")\n    }).pipe(Effect.scoped),\n  )\n})\n"],"mappings":";;;;;;AAOA,MAAM,UAAU;CAAE,OAAO;CAAiB,SAAS;AAAS;AAE5D,MAAM,eAAe,cAAc,KAAK,EACtC,UAAU;CACR,EAAE,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE;CACjC,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,OAAO,OAAO,IAAI,WAAW;EAAC;EAAG;EAAG;CAAC,CAAC,CAAC,EAAE,EAAE,EAAE;CACrF,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE;CAClC,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,GAAG,EAAE,EAAE;CAC/C,EAAE,QAAQ,EAAE,eAAe,CAAC,EAAE,EAAE;AAClC,EACF,CAAC;;AAGD,MAAM,cACJ,QACA,QACA,UAEA,OAAO,IAAI,aAAa;CACtB,MAAM,MAAM,gBAAgB;EAAE,QAAQ,SAAS,KAAK,UAAU;EAAG,WAAW,OAAO;CAAQ,CAAC;CAC5F,MAAM,YAAY,OAAO,OAAO,UAAU,OAAO,KAAK,OAAO,WAAW,IAAI,QAAQ,OAAO,CAAC,CAAC,CAAC;CAC9F,IAAI,UAAU,KAAA,GAAW;EACvB,OAAO,OAAO;EACd,OAAO,OAAO,UAAU,MAAM,aAAa,CAAC;EAC5C,OAAO,OAAO,MAAM,MAAM,IAAI;CAChC;CACA,OAAO,OAAO,MAAM,KAAK,SAAS;AACpC,CAAC;AAEH,SAAS,qCAAqC;CAC5C,GAAG,KAAK,wEACN,OAAO,IAAI,aAAa;EACtB,MAAM,SAAS,OAAO;EACtB,MAAM,OAAO,OAAO,WAAW,QAAQ,OAAO,KAAK,SAAS,IAAI,QAAQ,GAAG;GACzE,MAAM;GACN,WAAW;EACb,CAAC;EAED,aAAO,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,OAAO,IAAI,WAAW;GAAC;GAAG;GAAG;EAAC,CAAC,EAAE,CAAC,CAAC,CAAC;EACzE,MAAM,OAAQ,OAAO,OAAO;EAC5B,aAAO,KAAK,KAAK,MAAM,OAAO,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ;GACjD;GACA;GACA;GACA;EACF,CAAC;CACH,CAAC,CAAC,CAAC,KAAK,OAAO,MAAM,CACvB;CAEA,GAAG,KAAK,4DACN,OAAO,IAAI,aAAa;EACtB,MAAM,SAAS,OAAO;EACtB,MAAM,OAAO,OAAO,WAAW,QAAQ,OAAO,OAAO,EAAE,MAAM,KAAK,CAAC;EAEnE,aAAO,KAAK,UAAU,IAAI,KAAK,KAAK,UAAU,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,aAAa;CACpF,CAAC,CAAC,CAAC,KAAK,OAAO,MAAM,CACvB;CAEA,GAAG,KAAK,+CACN,OAAO,IAAI,aAAa;EACtB,MAAM,SAAS,OAAO;EACtB,MAAM,OAAO,OAAO,WAAW,QAAQ,OAAO,KAAK,qBAAqB,CAAC;EAEzE,aAAO,KAAK,UAAU,IAAI,KAAK,KAAK,UAAU,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,qBAAqB;CAC5F,CAAC,CAAC,CAAC,KAAK,OAAO,MAAM,CACvB;AACF,CAAC"}

package/dist/{rolldown-runtime-D7D4PA-g.mjs → rolldown-runtime-EAsCxrDo.mjs}

@@ -1,5 +1,6 @@
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -10,4 +11,4 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-export { __exportAll as t };
+export { __exportAll as n, __commonJSMin as t };

package/dist/wsAuth.d.mts

@@ -1,5 +1,5 @@
 import { Redacted } from "effect";
-import * as Socket from "effect/unstable/socket/Socket";
+import * as Socket from "effect/socket/Socket";
 //#region src/wsAuth.d.ts
 declare const authedWsConstructor: (apiKey: Redacted.Redacted) => Socket.WebSocketConstructor["Service"];
 //#endregion

package/dist/wsAuth.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"wsAuth.mjs","names":["WSWebSocket"],"sources":["../src/wsAuth.ts"],"sourcesContent":["/**\n * Inworld WS auth helper. The Inworld realtime endpoints (`/tts/...` and\n * `/stt/...`) require `Authorization: Basic <API_KEY>` on the WS upgrade\n * — the docs document a `?Authorization=…` query-param variant, but in\n * practice the server returns `authentication is required` for that\n * path. Header auth is what Inworld's own samples use.\n *\n * Headers on a WS upgrade aren't settable via `globalThis.WebSocket`, so\n * we use the `ws` peer dep (Node/Bun only).\n */\nimport { Redacted } from \"effect\"\nimport type * as Socket from \"effect/unstable/socket/Socket\"\nimport { WebSocket as WSWebSocket } from \"ws\"\nimport { authHeader } from \"./codec.js\"\n\nexport const authedWsConstructor =\n  (apiKey: Redacted.Redacted): Socket.WebSocketConstructor[\"Service\"] =>\n  (url) =>\n    new WSWebSocket(url, undefined, {\n      headers: { Authorization: authHeader(apiKey) },\n    }) as unknown as globalThis.WebSocket\n"],"mappings":";;;AAeA,MAAa,uBACV,YACA,QACC,IAAIA,UAAY,KAAK,KAAA,GAAW,EAC9B,SAAS,EAAE,eAAe,WAAW,MAAM,EAAE,EAC/C,CAAC"}
+{"version":3,"file":"wsAuth.mjs","names":["WSWebSocket"],"sources":["../src/wsAuth.ts"],"sourcesContent":["/**\n * Inworld WS auth helper. The Inworld realtime endpoints (`/tts/...` and\n * `/stt/...`) require `Authorization: Basic <API_KEY>` on the WS upgrade\n * — the docs document a `?Authorization=…` query-param variant, but in\n * practice the server returns `authentication is required` for that\n * path. Header auth is what Inworld's own samples use.\n *\n * Headers on a WS upgrade aren't settable via `globalThis.WebSocket`, so\n * we use the `ws` peer dep (Node/Bun only).\n */\nimport { Redacted } from \"effect\"\nimport type * as Socket from \"effect/socket/Socket\"\nimport { WebSocket as WSWebSocket } from \"ws\"\nimport { authHeader } from \"./codec.js\"\n\nexport const authedWsConstructor =\n  (apiKey: Redacted.Redacted): Socket.WebSocketConstructor[\"Service\"] =>\n  (url) =>\n    new WSWebSocket(url, undefined, {\n      headers: { Authorization: authHeader(apiKey) },\n    }) as unknown as globalThis.WebSocket\n"],"mappings":";;;AAeA,MAAa,uBACV,YACA,QACC,IAAIA,UAAY,KAAK,KAAA,GAAW,EAC9B,SAAS,EAAE,eAAe,WAAW,MAAM,EAAE,EAC/C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/inworld",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Inworld speech-to-text and text-to-speech provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -58,14 +58,14 @@
   },
   "devDependencies": {
     "@types/ws": "^8.5.13",
-    "effect": "4.0.0-rc.111",
+    "effect": "4.0.1",
     "typescript": "^7.0.2",
     "ws": "^8.18.0",
-    "@effect-uai/core": "0.16.0"
+    "@effect-uai/core": "0.18.0"
   },
   "peerDependencies": {
     "@effect-uai/core": ">=0.2.0 <1",
-    "effect": ">=4.0.0-rc.111 <5.0.0",
+    "effect": ">=4.0.1 <5.0.0",
     "ws": "^8.0.0"
   },
   "peerDependenciesMeta": {

package/src/InworldRealtimeSynthesizer.ts

@@ -9,7 +9,7 @@
  * the WS path.
  */
 import { Effect, Layer, Stream } from "effect"
-import { HttpClient } from "effect/unstable/http"
+import { HttpClient } from "effect/http"
 import {
   type CommonStreamSynthesizeRequest,
   type CommonSynthesizeRequest,

package/src/InworldRealtimeTranscriber.ts

@@ -8,7 +8,7 @@
  * the only added surface is the WS path.
  */
 import { Effect, Layer } from "effect"
-import { HttpClient } from "effect/unstable/http"
+import { HttpClient } from "effect/http"
 import {
   type CommonTranscribeRequest,
   SttStreaming,

package/src/InworldSynthesizer.ts

@@ -11,7 +11,7 @@
  * `TtsIncrementalText` capability marker.
  */
 import { Array as Arr, Context, Effect, Layer, Redacted, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as AiError from "@effect-uai/core/AiError"
 import type { AudioBlob, AudioChunk } from "@effect-uai/core/Audio"
 import * as JSONL from "@effect-uai/core/JSONL"

package/src/InworldTranscriber.ts

@@ -8,8 +8,9 @@
  * Streaming transcription lives at the `InworldRealtimeTranscriber`
  * subpath, which adds the WS path and the `SttStreaming` capability marker.
  */
-import { Context, Effect, Encoding, Layer, Match, Redacted, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { Context, Effect, Layer, Match, Redacted, Schema, Stream } from "effect"
+import { Base64 } from "effect/encoding"
+import { HttpClient, HttpClientRequest } from "effect/http"
 import * as AiError from "@effect-uai/core/AiError"
 import type { AudioSource } from "@effect-uai/core/Audio"
 import * as Capabilities from "@effect-uai/core/Capabilities"
@@ -65,7 +66,7 @@ const urlNotSupported: AiError.AiError = new AiError.InvalidRequest({
 
 const audioToBase64: (audio: AudioSource) => Effect.Effect<string, AiError.AiError> =
   Match.type<AudioSource>().pipe(
-    Match.tag("bytes", (a) => Effect.succeed(Encoding.encodeBase64(a.bytes))),
+    Match.tag("bytes", (a) => Effect.succeed(Base64.encode(a.bytes))),
     Match.tag("base64", (a) => Effect.succeed(a.base64)),
     Match.tag("url", () => Effect.fail(urlNotSupported)),
     Match.exhaustive,

package/src/codec.ts

@@ -1,4 +1,5 @@
-import { Effect, Encoding, Match, Redacted, Result } from "effect"
+import { Effect, Match, Redacted, Result } from "effect"
+import { Base64 } from "effect/encoding"
 import * as AiError from "@effect-uai/core/AiError"
 import type { AudioFormat } from "@effect-uai/core/Audio"
 import type { InworldAudioEncoding } from "./models.js"
@@ -82,7 +83,7 @@ export const defaultFormat: AudioFormat = {
 // ---------------------------------------------------------------------------
 
 export const decodeAudioContent = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>
-  Result.match(Encoding.decodeBase64(b64), {
+  Result.match(Base64.decode(b64), {
     onSuccess: Effect.succeed,
     onFailure: (cause) =>
       Effect.fail(

package/src/realtimeStt.test.ts

@@ -0,0 +1,82 @@
+import { describe, it } from "@effect/vitest"
+import { Effect, Exit, Fiber, Redacted, Stream } from "effect"
+import { expect } from "vitest"
+import * as FakeWebSocket from "@effect-uai/core/testing/FakeWebSocket"
+import { streamTranscription } from "./realtimeStt.js"
+
+const pcm = { container: "raw", encoding: "pcm_s16le", sampleRate: 16000, channels: 1 } as const
+
+const request = { model: "inworld/inworld-stt-1", inputFormat: pcm }
+
+const transcribing = FakeWebSocket.make({
+  greeting: [
+    { result: { speechStarted: { startTimeMs: 1500 } } },
+    { result: { transcription: { transcript: "hel", isFinal: false } } },
+    { result: { transcription: { transcript: "hello", isFinal: true } } },
+  ],
+})
+
+/** Run a transcription against `server`, closing it, if asked, once the frames are in. */
+const transcribe = <E>(
+  server: FakeWebSocket.FakeWebSocketServer,
+  audioIn: Stream.Stream<Uint8Array, E>,
+  close?: { readonly code: number; readonly afterSent?: number },
+) =>
+  Effect.gen(function* () {
+    const run = streamTranscription({
+      apiKey: Redacted.make("test-key"),
+      webSocket: server.connect,
+    })
+    const collector = yield* Effect.forkChild(Effect.exit(Stream.runCollect(run(audioIn, request))))
+    if (close !== undefined) {
+      yield* server.greeted
+      yield* server.awaitSent(close.afterSent ?? 0)
+      yield* server.close(close.code)
+    }
+    return yield* Fiber.join(collector)
+  })
+
+describe("Inworld Realtime STT socket", () => {
+  it.live("sends the config before any audio, and ends on a clean close", () =>
+    Effect.gen(function* () {
+      const server = yield* transcribing
+      const exit = yield* transcribe(server, Stream.make(new Uint8Array([1, 2])), {
+        code: 1000,
+        afterSent: 4,
+      })
+
+      expect(exit).toEqual(
+        Exit.succeed([
+          { _tag: "speech-started", atSeconds: 1.5 },
+          { _tag: "partial", text: "hel" },
+          { _tag: "final", text: "hello" },
+        ]),
+      )
+      const sent = (yield* server.sent) as ReadonlyArray<Record<string, unknown>>
+      expect(sent.map((f) => Object.keys(f)[0])).toEqual([
+        "transcribeConfig",
+        "audioChunk",
+        "endTurn",
+        "closeStream",
+      ])
+    }).pipe(Effect.scoped),
+  )
+
+  it.live("fails rather than ending when the connection drops", () =>
+    Effect.gen(function* () {
+      const server = yield* transcribing
+      const exit = yield* transcribe(server, Stream.never, { code: 1011 })
+
+      expect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain("Unavailable")
+    }).pipe(Effect.scoped),
+  )
+
+  it.live("fails with the audio input's own error", () =>
+    Effect.gen(function* () {
+      const server = yield* transcribing
+      const exit = yield* transcribe(server, Stream.fail("microphone unplugged"))
+
+      expect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain("microphone unplugged")
+    }).pipe(Effect.scoped),
+  )
+})

package/src/realtimeStt.ts

@@ -18,17 +18,27 @@
  * Inworld's STT WS sends audio as base64 inside JSON (NOT binary frames),
  * matching the rest of the Inworld API style.
  */
-import { Cause, Effect, Encoding, Match, Queue, Redacted, Schema, Stream } from "effect"
-import * as Socket from "effect/unstable/socket/Socket"
+import { Effect, Match, Option, Predicate, Redacted, Schema, Stream } from "effect"
+import { Base64 } from "effect/encoding"
+import * as Socket from "effect/socket/Socket"
 import * as AiError from "@effect-uai/core/AiError"
 import type { AudioFormat } from "@effect-uai/core/Audio"
 import * as Capabilities from "@effect-uai/core/Capabilities"
 import * as JSONL from "@effect-uai/core/JSONL"
 import type { TranscriptEvent, WordTimestamp } from "@effect-uai/core/Transcript"
 import type { CommonStreamTranscribeRequest } from "@effect-uai/core/Transcriber"
+import * as WebSocketSession from "@effect-uai/core/WebSocketSession"
 import { authedWsConstructor } from "./wsAuth.js"
 
-export type Config = { readonly apiKey: Redacted.Redacted; readonly baseUrl?: string }
+export type Config = {
+  readonly apiKey: Redacted.Redacted
+  readonly baseUrl?: string
+  /**
+   * Build the socket yourself, for a proxy or an in-memory transport. The
+   * default attaches the Basic auth header through the `ws` package.
+   */
+  readonly webSocket?: Socket.WebSocketConstructor["Service"]
+}
 
 // ---------------------------------------------------------------------------
 // AudioFormat → `audioEncoding` slug for Inworld STT
@@ -85,7 +95,7 @@ const configFrame = (encoding: WireEncoding, request: CommonStreamTranscribeRequ
   })
 
 const audioChunkFrame = (bytes: Uint8Array) =>
-  JSON.stringify({ audioChunk: { content: Encoding.encodeBase64(bytes) } })
+  JSON.stringify({ audioChunk: { content: Base64.encode(bytes) } })
 
 const endTurnFrame = JSON.stringify({ endTurn: {} })
 const closeStreamFrame = JSON.stringify({ closeStream: {} })
@@ -177,14 +187,13 @@ export const wireToEvent = (frame: typeof ServerFrame.Type): TranscriptEvent | u
   return undefined
 }
 
-const handleServerMessage = (queue: Queue.Queue<TranscriptEvent, Cause.Done>) => (raw: string) =>
+/** One raw text frame to at most one event; unknown or malformed frames yield `undefined`. */
+const frameToEvent = (raw: string): Effect.Effect<TranscriptEvent | undefined> =>
   Effect.gen(function* () {
     const json = yield* JSONL.parseSafe(raw)
-    if (json === undefined) return
+    if (json === undefined) return undefined
     const decoded = yield* decodeServerFrame(json).pipe(Effect.option)
-    if (decoded._tag === "None") return
-    const event = wireToEvent(decoded.value)
-    if (event !== undefined) yield* Queue.offer(queue, event)
+    return Option.match(decoded, { onNone: () => undefined, onSome: wireToEvent })
   })
 
 // ---------------------------------------------------------------------------
@@ -206,32 +215,33 @@ export const streamTranscription =
           reason: "Inworld STT has no free-form prompt field; bias via `biasingTerms`.",
         })
         const encoding = yield* inputFormatToWire(request.inputFormat)
-        const socket = yield* Socket.makeWebSocket(buildWsUrl(cfg), {
-          // Effect's Socket treats all close codes as errors by default —
-          // whitelist standard clean-close codes (1000 / 1001 / 1005).
-          closeCodeIsError: (code) => code !== 1000 && code !== 1001 && code !== 1005,
-        }).pipe(Effect.provideService(Socket.WebSocketConstructor, authedWsConstructor(cfg.apiKey)))
-        const queue = yield* Queue.bounded<TranscriptEvent, Cause.Done>(64)
-        const write = yield* socket.writer
-
-        // Writer: config → drain audio → endTurn → closeStream. Inworld
-        // emits `result.transcription` partials in real-time via VAD;
-        // `endTurn` is sent on input-stream end to flush any tail audio
-        // into a final transcript, then `closeStream` for graceful close.
-        yield* Effect.gen(function* () {
-          yield* write(configFrame(encoding, request))
-          yield* Stream.runForEach(audioIn, (bytes) => write(audioChunkFrame(bytes)))
-          yield* write(endTurnFrame)
-          yield* write(closeStreamFrame)
-        }).pipe(Effect.ignore, Effect.forkScoped)
-
-        // `Queue.end` flushes pending events then fails the next take with
-        // `Done` — clean stream end. `Queue.shutdown` would CLEAR queued
-        // items and interrupt pending takes (wrong for graceful teardown).
-        yield* socket
-          .runString(handleServerMessage(queue))
-          .pipe(Effect.ensuring(Queue.end(queue)), Effect.forkScoped)
-
-        return Stream.fromQueue(queue)
+        const socket = yield* Socket.makeWebSocket(buildWsUrl(cfg)).pipe(
+          Effect.provideService(
+            Socket.WebSocketConstructor,
+            cfg.webSocket ?? authedWsConstructor(cfg.apiKey),
+          ),
+        )
+        const { write } = yield* socket.writer
+        const asAiError = WebSocketSession.toAiError("inworld")
+
+        const events = Stream.fromPull(Socket.readerString(socket)).pipe(
+          Stream.scoped,
+          Stream.catchIf(WebSocketSession.isCleanClose, () => Stream.empty),
+          Stream.mapError(asAiError),
+          Stream.mapEffect(frameToEvent),
+          Stream.filter(Predicate.isNotUndefined),
+        )
+
+        // `endTurn` flushes tail audio into a final transcript before `closeStream`.
+        const outgoing = Stream.concat(
+          Stream.make(configFrame(encoding, request)),
+          Stream.concat(
+            Stream.map(audioIn, audioChunkFrame),
+            Stream.make(endTurnFrame, closeStreamFrame),
+          ),
+        ).pipe(Stream.mapEffect((frame) => Effect.mapError(write(frame), asAiError)))
+
+        // The server's close ends the transcript; the audio running out does not.
+        return Stream.merge(events, Stream.drain(outgoing), { haltStrategy: "left" })
       }),
     )

package/src/realtimeTts.test.ts

@@ -0,0 +1,74 @@
+import { describe, it } from "@effect/vitest"
+import { Effect, Exit, Fiber, Redacted, Stream } from "effect"
+import { Base64 } from "effect/encoding"
+import { expect } from "vitest"
+import * as FakeWebSocket from "@effect-uai/core/testing/FakeWebSocket"
+import { streamSynthesis } from "./realtimeTts.js"
+
+const request = { model: "inworld-tts-2", voiceId: "Ashley" } as const
+
+const synthesizing = FakeWebSocket.make({
+  greeting: [
+    { result: { contextCreated: {} } },
+    { result: { audioChunk: { audioContent: Base64.encode(new Uint8Array([1, 2, 3])) } } },
+    { error: { message: "transient" } },
+    { result: { audioChunk: { audioContent: "" } } },
+    { result: { contextClosed: {} } },
+  ],
+})
+
+/** Run a synthesis against `server`, closing it, if asked, once the frames are in. */
+const synthesize = <E>(
+  server: FakeWebSocket.FakeWebSocketServer,
+  textIn: Stream.Stream<string, E>,
+  close?: { readonly code: number; readonly afterSent?: number },
+) =>
+  Effect.gen(function* () {
+    const run = streamSynthesis({ apiKey: Redacted.make("test-key"), webSocket: server.connect })
+    const collector = yield* Effect.forkChild(Effect.exit(Stream.runCollect(run(textIn, request))))
+    if (close !== undefined) {
+      yield* server.greeted
+      yield* server.awaitSent(close.afterSent ?? 0)
+      yield* server.close(close.code)
+    }
+    return yield* Fiber.join(collector)
+  })
+
+describe("Inworld Realtime TTS socket", () => {
+  it.live("creates the context before any text, and ends on a clean close", () =>
+    Effect.gen(function* () {
+      const server = yield* synthesizing
+      const exit = yield* synthesize(server, Stream.make("Hello", "", " world"), {
+        code: 1000,
+        afterSent: 4,
+      })
+
+      expect(exit).toEqual(Exit.succeed([{ bytes: new Uint8Array([1, 2, 3]) }]))
+      const sent = (yield* server.sent) as ReadonlyArray<Record<string, unknown>>
+      expect(sent.map((f) => Object.keys(f)[0])).toEqual([
+        "create",
+        "send_text",
+        "send_text",
+        "close_context",
+      ])
+    }).pipe(Effect.scoped),
+  )
+
+  it.live("fails rather than ending when the connection drops", () =>
+    Effect.gen(function* () {
+      const server = yield* synthesizing
+      const exit = yield* synthesize(server, Stream.never, { code: 1011 })
+
+      expect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain("Unavailable")
+    }).pipe(Effect.scoped),
+  )
+
+  it.live("fails with the text input's own error", () =>
+    Effect.gen(function* () {
+      const server = yield* synthesizing
+      const exit = yield* synthesize(server, Stream.fail("upstream llm failed"))
+
+      expect(Exit.isFailure(exit) && JSON.stringify(exit.cause)).toContain("upstream llm failed")
+    }).pipe(Effect.scoped),
+  )
+})