@effect-uai/inworld 0.4.0

package/dist/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/codec-C-2ssVAz.d.mts

@@ -0,0 +1,35 @@
+import { t as InworldAudioEncoding } from "./models-CPLZDcgt.mjs";
+import { Effect, Redacted } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+import { AudioFormat } from "@effect-uai/core/Audio";
+
+//#region src/codec.d.ts
+declare namespace codec_d_exports {
+  export { AudioConfig, audioConfigFor, audioEncodingFor, authHeader, decodeAudioContent, defaultFormat, httpStatusError, transportFailure };
+}
+declare const authHeader: (apiKey: Redacted.Redacted) => string;
+type AudioConfig = {
+  readonly audioEncoding: InworldAudioEncoding;
+  readonly sampleRateHertz?: number;
+  readonly bitRate?: number;
+  readonly speakingRate?: number;
+};
+/**
+ * Map our cross-provider `AudioFormat` to Inworld's `audioConfig.audioEncoding`.
+ *
+ * Inworld quirk: sync `LINEAR16` / `WAV` responses include a WAV header in
+ * the returned `audioContent`; streaming (NDJSON + WS) responses for the
+ * same encoding do NOT include the header. Callers consuming raw PCM via
+ * streaming should request `raw + pcm_s16le` (→ `PCM`) for predictable
+ * concatenation, and reserve `wav` for sync.
+ */
+declare const audioEncodingFor: (format: AudioFormat) => Effect.Effect<InworldAudioEncoding, AiError.AiError>;
+declare const audioConfigFor: (format: AudioFormat, speakingRate?: number) => Effect.Effect<AudioConfig, AiError.AiError>;
+/** Default Inworld output: 24 kHz mono mp3. Matches Inworld's docs default. */
+declare const defaultFormat: AudioFormat;
+declare const decodeAudioContent: (b64: string) => Effect.Effect<Uint8Array, AiError.AiError>;
+declare const httpStatusError: (status: number, body: string) => AiError.AiError;
+declare const transportFailure: (cause: unknown) => AiError.AiError;
+//#endregion
+export { codec_d_exports as a, httpStatusError as c, authHeader as i, transportFailure as l, audioConfigFor as n, decodeAudioContent as o, audioEncodingFor as r, defaultFormat as s, AudioConfig as t };
+//# sourceMappingURL=codec-C-2ssVAz.d.mts.map

package/dist/codec-C-2ssVAz.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-C-2ssVAz.d.mts","names":[],"sources":["../src/codec.ts"],"mappings":";;;;;;;;;cAUa,UAAA,GAAc,MAAA,EAAQ,QAAA,CAAS,QAAA;AAAA,KAMhC,WAAA;EAAA,SACD,aAAA,EAAe,oBAAA;EAAA,SACf,eAAA;EAAA,SACA,OAAA;EAAA,SACA,YAAA;AAAA;;;;;;;AAVX;;;cA6Ba,gBAAA,GACX,MAAA,EAAQ,WAAA,KACL,MAAA,CAAO,MAAA,CAAO,oBAAA,EAAsB,OAAA,CAAQ,OAAA;AAAA,cAoBpC,cAAA,GACX,MAAA,EAAQ,WAAA,EACR,YAAA,cACC,MAAA,CAAO,MAAA,CAAO,WAAA,EAAa,OAAA,CAAQ,OAAA;;cASzB,aAAA,EAAe,WAAA;AAAA,cAUf,kBAAA,GAAsB,GAAA,aAAc,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,OAAA,CAAQ,OAAA;AAAA,cAgBtE,eAAA,GAAkB,MAAA,UAAgB,IAAA,aAAiB,OAAA,CAAQ,OAAA;AAAA,cAwC3D,gBAAA,GAAoB,KAAA,cAAiB,OAAA,CAAQ,OAAA"}

package/dist/codec.d.mts

@@ -0,0 +1,2 @@
+import { c as httpStatusError, i as authHeader, l as transportFailure, n as audioConfigFor, o as decodeAudioContent, r as audioEncodingFor, s as defaultFormat, t as AudioConfig } from "./codec-C-2ssVAz.mjs";
+export { AudioConfig, audioConfigFor, audioEncodingFor, authHeader, decodeAudioContent, defaultFormat, httpStatusError, transportFailure };

package/dist/codec.mjs

@@ -0,0 +1,100 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { Effect, Encoding, Match, Redacted, Result } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+//#region src/codec.ts
+var codec_exports = /* @__PURE__ */ __exportAll({
+	audioConfigFor: () => audioConfigFor,
+	audioEncodingFor: () => audioEncodingFor,
+	authHeader: () => authHeader,
+	decodeAudioContent: () => decodeAudioContent,
+	defaultFormat: () => defaultFormat,
+	httpStatusError: () => httpStatusError,
+	transportFailure: () => transportFailure
+});
+const authHeader = (apiKey) => `Basic ${Redacted.value(apiKey)}`;
+const unsupportedFormat = (format) => new AiError.Unsupported({
+	provider: "inworld",
+	capability: "outputFormat",
+	reason: `Cannot encode ${JSON.stringify(format)} as Inworld audioConfig. Supported: mp3, wav (LINEAR16), ogg+opus, flac, raw pcm_s16le/mulaw/alaw.`
+});
+/**
+* Map our cross-provider `AudioFormat` to Inworld's `audioConfig.audioEncoding`.
+*
+* Inworld quirk: sync `LINEAR16` / `WAV` responses include a WAV header in
+* the returned `audioContent`; streaming (NDJSON + WS) responses for the
+* same encoding do NOT include the header. Callers consuming raw PCM via
+* streaming should request `raw + pcm_s16le` (→ `PCM`) for predictable
+* concatenation, and reserve `wav` for sync.
+*/
+const audioEncodingFor = (format) => Match.value(format).pipe(Match.when({ container: "mp3" }, () => Effect.succeed("MP3")), Match.when({ container: "wav" }, () => Effect.succeed("LINEAR16")), Match.when({
+	container: "ogg",
+	encoding: "opus"
+}, () => Effect.succeed("OGG_OPUS")), Match.when({ container: "flac" }, () => Effect.succeed("FLAC")), Match.when({
+	container: "raw",
+	encoding: "pcm_s16le"
+}, () => Effect.succeed("PCM")), Match.when({
+	container: "raw",
+	encoding: "pcm_mulaw"
+}, () => Effect.succeed("MULAW")), Match.when({
+	container: "raw",
+	encoding: "pcm_alaw"
+}, () => Effect.succeed("ALAW")), Match.orElse((f) => Effect.fail(unsupportedFormat(f))));
+const audioConfigFor = (format, speakingRate) => Effect.map(audioEncodingFor(format), (audioEncoding) => ({
+	audioEncoding,
+	sampleRateHertz: format.sampleRate,
+	...format.bitRate !== void 0 && { bitRate: format.bitRate },
+	...speakingRate !== void 0 && { speakingRate }
+}));
+/** Default Inworld output: 24 kHz mono mp3. Matches Inworld's docs default. */
+const defaultFormat = {
+	container: "mp3",
+	encoding: "mp3",
+	sampleRate: 24e3
+};
+const decodeAudioContent = (b64) => Result.match(Encoding.decodeBase64(b64), {
+	onSuccess: Effect.succeed,
+	onFailure: (cause) => Effect.fail(new AiError.GenerationFailed({
+		provider: "inworld",
+		raw: {
+			message: "audioContent base64 decode failed",
+			cause
+		}
+	}))
+});
+const httpStatusError = (status, body) => Match.value(status).pipe(Match.when(429, () => new AiError.RateLimited({
+	provider: "inworld",
+	raw: body
+})), Match.whenOr(408, 504, () => new AiError.Timeout({
+	provider: "inworld",
+	raw: body
+})), Match.when(401, () => new AiError.AuthFailed({
+	provider: "inworld",
+	subtype: "auth",
+	raw: body
+})), Match.when(403, () => new AiError.AuthFailed({
+	provider: "inworld",
+	subtype: "permission",
+	raw: body
+})), Match.when(402, () => new AiError.AuthFailed({
+	provider: "inworld",
+	subtype: "billing",
+	raw: body
+})), Match.when(413, () => new AiError.ContextLengthExceeded({
+	provider: "inworld",
+	raw: body
+})), Match.when((n) => n >= 500, (n) => new AiError.Unavailable({
+	provider: "inworld",
+	status: n,
+	raw: body
+})), Match.orElse(() => new AiError.InvalidRequest({
+	provider: "inworld",
+	raw: body
+})));
+const transportFailure = (cause) => new AiError.Unavailable({
+	provider: "inworld",
+	raw: cause
+});
+//#endregion
+export { audioConfigFor, audioEncodingFor, authHeader, decodeAudioContent, defaultFormat, httpStatusError, codec_exports as t, transportFailure };
+
+//# sourceMappingURL=codec.mjs.map

package/dist/codec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.mjs","names":[],"sources":["../src/codec.ts"],"sourcesContent":["import { Effect, Encoding, Match, Redacted, Result } from \"effect\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport type { AudioFormat } from \"@effect-uai/core/Audio\"\nimport type { InworldAudioEncoding } from \"./models.js\"\n\n// ---------------------------------------------------------------------------\n// Auth — `Authorization: Basic $INWORLD_API_KEY`. The portal key is already\n// base64-encoded, so we inject it verbatim. Do NOT re-encode `key:secret`.\n// ---------------------------------------------------------------------------\n\nexport const authHeader = (apiKey: Redacted.Redacted): string => `Basic ${Redacted.value(apiKey)}`\n\n// ---------------------------------------------------------------------------\n// AudioFormat → Inworld `audioConfig`\n// ---------------------------------------------------------------------------\n\nexport type AudioConfig = {\n  readonly audioEncoding: InworldAudioEncoding\n  readonly sampleRateHertz?: number\n  readonly bitRate?: number\n  readonly speakingRate?: number\n}\n\nconst unsupportedFormat = (format: AudioFormat): AiError.AiError =>\n  new AiError.Unsupported({\n    provider: \"inworld\",\n    capability: \"outputFormat\",\n    reason: `Cannot encode ${JSON.stringify(format)} as Inworld audioConfig. Supported: mp3, wav (LINEAR16), ogg+opus, flac, raw pcm_s16le/mulaw/alaw.`,\n  })\n\n/**\n * Map our cross-provider `AudioFormat` to Inworld's `audioConfig.audioEncoding`.\n *\n * Inworld quirk: sync `LINEAR16` / `WAV` responses include a WAV header in\n * the returned `audioContent`; streaming (NDJSON + WS) responses for the\n * same encoding do NOT include the header. Callers consuming raw PCM via\n * streaming should request `raw + pcm_s16le` (→ `PCM`) for predictable\n * concatenation, and reserve `wav` for sync.\n */\nexport const audioEncodingFor: (\n  format: AudioFormat,\n) => Effect.Effect<InworldAudioEncoding, AiError.AiError> = (format) =>\n  Match.value(format).pipe(\n    Match.when({ container: \"mp3\" }, () => Effect.succeed<InworldAudioEncoding>(\"MP3\")),\n    Match.when({ container: \"wav\" }, () => Effect.succeed<InworldAudioEncoding>(\"LINEAR16\")),\n    Match.when({ container: \"ogg\", encoding: \"opus\" }, () =>\n      Effect.succeed<InworldAudioEncoding>(\"OGG_OPUS\"),\n    ),\n    Match.when({ container: \"flac\" }, () => Effect.succeed<InworldAudioEncoding>(\"FLAC\")),\n    Match.when({ container: \"raw\", encoding: \"pcm_s16le\" }, () =>\n      Effect.succeed<InworldAudioEncoding>(\"PCM\"),\n    ),\n    Match.when({ container: \"raw\", encoding: \"pcm_mulaw\" }, () =>\n      Effect.succeed<InworldAudioEncoding>(\"MULAW\"),\n    ),\n    Match.when({ container: \"raw\", encoding: \"pcm_alaw\" }, () =>\n      Effect.succeed<InworldAudioEncoding>(\"ALAW\"),\n    ),\n    Match.orElse((f) => Effect.fail(unsupportedFormat(f))),\n  )\n\nexport const audioConfigFor = (\n  format: AudioFormat,\n  speakingRate?: number,\n): Effect.Effect<AudioConfig, AiError.AiError> =>\n  Effect.map(audioEncodingFor(format), (audioEncoding) => ({\n    audioEncoding,\n    sampleRateHertz: format.sampleRate,\n    ...(format.bitRate !== undefined && { bitRate: format.bitRate }),\n    ...(speakingRate !== undefined && { speakingRate }),\n  }))\n\n/** Default Inworld output: 24 kHz mono mp3. Matches Inworld's docs default. */\nexport const defaultFormat: AudioFormat = {\n  container: \"mp3\",\n  encoding: \"mp3\",\n  sampleRate: 24000,\n}\n\n// ---------------------------------------------------------------------------\n// base64 → bytes — decoding `audioContent` from sync, NDJSON, and WS responses\n// ---------------------------------------------------------------------------\n\nexport const decodeAudioContent = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>\n  Result.match(Encoding.decodeBase64(b64), {\n    onSuccess: Effect.succeed,\n    onFailure: (cause) =>\n      Effect.fail(\n        new AiError.GenerationFailed({\n          provider: \"inworld\",\n          raw: { message: \"audioContent base64 decode failed\", cause },\n        }),\n      ),\n  })\n\n// ---------------------------------------------------------------------------\n// HTTP status → AiError\n// ---------------------------------------------------------------------------\n\nexport const httpStatusError: (status: number, body: string) => AiError.AiError = (status, body) =>\n  Match.value(status).pipe(\n    Match.when(\n      429,\n      (): AiError.AiError => new AiError.RateLimited({ provider: \"inworld\", raw: body }),\n    ),\n    Match.whenOr(\n      408,\n      504,\n      (): AiError.AiError => new AiError.Timeout({ provider: \"inworld\", raw: body }),\n    ),\n    Match.when(\n      401,\n      (): AiError.AiError =>\n        new AiError.AuthFailed({ provider: \"inworld\", subtype: \"auth\", raw: body }),\n    ),\n    Match.when(\n      403,\n      (): AiError.AiError =>\n        new AiError.AuthFailed({ provider: \"inworld\", subtype: \"permission\", raw: body }),\n    ),\n    Match.when(\n      402,\n      (): AiError.AiError =>\n        new AiError.AuthFailed({ provider: \"inworld\", subtype: \"billing\", raw: body }),\n    ),\n    Match.when(\n      413,\n      (): AiError.AiError => new AiError.ContextLengthExceeded({ provider: \"inworld\", raw: body }),\n    ),\n    Match.when(\n      (n) => n >= 500,\n      (n): AiError.AiError =>\n        new AiError.Unavailable({ provider: \"inworld\", status: n, raw: body }),\n    ),\n    Match.orElse(\n      (): AiError.AiError => new AiError.InvalidRequest({ provider: \"inworld\", raw: body }),\n    ),\n  )\n\nexport const transportFailure = (cause: unknown): AiError.AiError =>\n  new AiError.Unavailable({ provider: \"inworld\", raw: cause })\n"],"mappings":";;;;;;;;;;;;;AAUA,MAAa,cAAc,WAAsC,SAAS,SAAS,MAAM,OAAO;AAahG,MAAM,qBAAqB,WACzB,IAAI,QAAQ,YAAY;CACtB,UAAU;CACV,YAAY;CACZ,QAAQ,iBAAiB,KAAK,UAAU,OAAO,CAAC;CACjD,CAAC;;;;;;;;;;AAWJ,MAAa,oBAEgD,WAC3D,MAAM,MAAM,OAAO,CAAC,KAClB,MAAM,KAAK,EAAE,WAAW,OAAO,QAAQ,OAAO,QAA8B,MAAM,CAAC,EACnF,MAAM,KAAK,EAAE,WAAW,OAAO,QAAQ,OAAO,QAA8B,WAAW,CAAC,EACxF,MAAM,KAAK;CAAE,WAAW;CAAO,UAAU;CAAQ,QAC/C,OAAO,QAA8B,WAAW,CACjD,EACD,MAAM,KAAK,EAAE,WAAW,QAAQ,QAAQ,OAAO,QAA8B,OAAO,CAAC,EACrF,MAAM,KAAK;CAAE,WAAW;CAAO,UAAU;CAAa,QACpD,OAAO,QAA8B,MAAM,CAC5C,EACD,MAAM,KAAK;CAAE,WAAW;CAAO,UAAU;CAAa,QACpD,OAAO,QAA8B,QAAQ,CAC9C,EACD,MAAM,KAAK;CAAE,WAAW;CAAO,UAAU;CAAY,QACnD,OAAO,QAA8B,OAAO,CAC7C,EACD,MAAM,QAAQ,MAAM,OAAO,KAAK,kBAAkB,EAAE,CAAC,CAAC,CACvD;AAEH,MAAa,kBACX,QACA,iBAEA,OAAO,IAAI,iBAAiB,OAAO,GAAG,mBAAmB;CACvD;CACA,iBAAiB,OAAO;CACxB,GAAI,OAAO,YAAY,KAAA,KAAa,EAAE,SAAS,OAAO,SAAS;CAC/D,GAAI,iBAAiB,KAAA,KAAa,EAAE,cAAc;CACnD,EAAE;;AAGL,MAAa,gBAA6B;CACxC,WAAW;CACX,UAAU;CACV,YAAY;CACb;AAMD,MAAa,sBAAsB,QACjC,OAAO,MAAM,SAAS,aAAa,IAAI,EAAE;CACvC,WAAW,OAAO;CAClB,YAAY,UACV,OAAO,KACL,IAAI,QAAQ,iBAAiB;EAC3B,UAAU;EACV,KAAK;GAAE,SAAS;GAAqC;GAAO;EAC7D,CAAC,CACH;CACJ,CAAC;AAMJ,MAAa,mBAAsE,QAAQ,SACzF,MAAM,MAAM,OAAO,CAAC,KAClB,MAAM,KACJ,WACuB,IAAI,QAAQ,YAAY;CAAE,UAAU;CAAW,KAAK;CAAM,CAAC,CACnF,EACD,MAAM,OACJ,KACA,WACuB,IAAI,QAAQ,QAAQ;CAAE,UAAU;CAAW,KAAK;CAAM,CAAC,CAC/E,EACD,MAAM,KACJ,WAEE,IAAI,QAAQ,WAAW;CAAE,UAAU;CAAW,SAAS;CAAQ,KAAK;CAAM,CAAC,CAC9E,EACD,MAAM,KACJ,WAEE,IAAI,QAAQ,WAAW;CAAE,UAAU;CAAW,SAAS;CAAc,KAAK;CAAM,CAAC,CACpF,EACD,MAAM,KACJ,WAEE,IAAI,QAAQ,WAAW;CAAE,UAAU;CAAW,SAAS;CAAW,KAAK;CAAM,CAAC,CACjF,EACD,MAAM,KACJ,WACuB,IAAI,QAAQ,sBAAsB;CAAE,UAAU;CAAW,KAAK;CAAM,CAAC,CAC7F,EACD,MAAM,MACH,MAAM,KAAK,MACX,MACC,IAAI,QAAQ,YAAY;CAAE,UAAU;CAAW,QAAQ;CAAG,KAAK;CAAM,CAAC,CACzE,EACD,MAAM,aACmB,IAAI,QAAQ,eAAe;CAAE,UAAU;CAAW,KAAK;CAAM,CAAC,CACtF,CACF;AAEH,MAAa,oBAAoB,UAC/B,IAAI,QAAQ,YAAY;CAAE,UAAU;CAAW,KAAK;CAAO,CAAC"}

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { a as InworldVoiceId, i as InworldTtsModel, n as InworldDeliveryMode, r as InworldSttModel, t as InworldAudioEncoding } from "./models-CPLZDcgt.mjs";
+import { a as codec_d_exports } from "./codec-C-2ssVAz.mjs";
+import { t as InworldSynthesizer_d_exports } from "./InworldSynthesizer.mjs";
+import { t as InworldRealtimeSynthesizer_d_exports } from "./InworldRealtimeSynthesizer.mjs";
+import { t as InworldTranscriber_d_exports } from "./InworldTranscriber.mjs";
+import { t as InworldRealtimeTranscriber_d_exports } from "./InworldRealtimeTranscriber.mjs";
+export { InworldAudioEncoding, InworldDeliveryMode, InworldRealtimeSynthesizer_d_exports as InworldRealtimeSynthesizer, InworldRealtimeTranscriber_d_exports as InworldRealtimeTranscriber, InworldSttModel, InworldSynthesizer_d_exports as InworldSynthesizer, InworldTranscriber_d_exports as InworldTranscriber, InworldTtsModel, InworldVoiceId, codec_d_exports as codec };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { t as codec_exports } from "./codec.mjs";
+import { t as InworldSynthesizer_exports } from "./InworldSynthesizer.mjs";
+import { t as InworldRealtimeSynthesizer_exports } from "./InworldRealtimeSynthesizer.mjs";
+import { t as InworldTranscriber_exports } from "./InworldTranscriber.mjs";
+import { t as InworldRealtimeTranscriber_exports } from "./InworldRealtimeTranscriber.mjs";
+import "./models.mjs";
+export { InworldRealtimeSynthesizer_exports as InworldRealtimeSynthesizer, InworldRealtimeTranscriber_exports as InworldRealtimeTranscriber, InworldSynthesizer_exports as InworldSynthesizer, InworldTranscriber_exports as InworldTranscriber, codec_exports as codec };

package/dist/models-CPLZDcgt.d.mts

@@ -0,0 +1,47 @@
+//#region src/models.d.ts
+/**
+ * Inworld TTS models (current per [docs.inworld.ai/tts/tts](https://docs.inworld.ai/tts/tts)).
+ *
+ * - `inworld-tts-2` — flagship, 100+ languages, supports `deliveryMode` style
+ *   steering (`STABLE` / `BALANCED` / `CREATIVE`). ~200ms P50.
+ * - `inworld-tts-1.5-max` — 15 languages, ~200ms P50.
+ * - `inworld-tts-1.5-mini` — 15 languages, ~120ms P50, lowest latency.
+ *
+ * `inworld-tts-1` / `inworld-tts-1-max` are not in current docs — treat as
+ * superseded. The `(string & {})` tail keeps autocomplete on literals while
+ * accepting any string so newly-released models work without an SDK update.
+ */
+type InworldTtsModel = "inworld-tts-2" | "inworld-tts-1.5-max" | "inworld-tts-1.5-mini" | (string & {});
+/**
+ * Inworld voice ID. Inworld voices are human-readable names ("Sarah",
+ * "Edward", …) but there's no public list-voices REST endpoint — voices
+ * are browsed via the Inworld Portal. Typing this as `string` rather than
+ * a hard-coded union avoids the union rotting between SDK releases.
+ */
+type InworldVoiceId = string;
+/**
+ * Inworld STT models. `inworld/inworld-stt-1` is the first-party model
+ * (marked Experimental in docs at time of writing). The rest are
+ * router-style passthroughs — Inworld proxies to the named provider
+ * behind their auth & billing.
+ *
+ * Streaming WS support varies: `inworld/inworld-stt-1` and AssemblyAI /
+ * Soniox variants support both sync + WS; Groq Whisper is sync-only.
+ */
+type InworldSttModel = "inworld/inworld-stt-1" | "groq/whisper-large-v3" | "assemblyai/universal-streaming-english" | "assemblyai/universal-streaming-multilingual" | "assemblyai/u3-rt-pro" | "assemblyai/whisper-rt" | "soniox/stt-rt-v4" | (string & {});
+/**
+ * `deliveryMode` style steering — only honored by `inworld-tts-2`. Older
+ * models ignore the field silently.
+ */
+type InworldDeliveryMode = "STABLE" | "BALANCED" | "CREATIVE";
+/**
+ * Inworld's `audioEncoding` enum (TTS audioConfig).
+ *
+ * Note: sync `LINEAR16` / `WAV` responses include a WAV header in the
+ * `audioContent` bytes. Streaming (NDJSON + WS) chunks do **not**. The
+ * codec layer surfaces this difference in `AudioFormat.container`.
+ */
+type InworldAudioEncoding = "LINEAR16" | "MP3" | "OGG_OPUS" | "ALAW" | "MULAW" | "FLAC" | "PCM" | "WAV";
+//#endregion
+export { InworldVoiceId as a, InworldTtsModel as i, InworldDeliveryMode as n, InworldSttModel as r, InworldAudioEncoding as t };
+//# sourceMappingURL=models-CPLZDcgt.d.mts.map

package/dist/models-CPLZDcgt.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models-CPLZDcgt.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;AAYA;;;;;AAaA;;;;;AAWA;KAxBY,eAAA;;;;AAuCZ;;;KA1BY,cAAA;;AAmCZ;;;;;;;;KAxBY,eAAA;;;;;KAeA,mBAAA;;;;;;;;KASA,oBAAA"}

package/dist/models.d.mts

@@ -0,0 +1,2 @@
+import { a as InworldVoiceId, i as InworldTtsModel, n as InworldDeliveryMode, r as InworldSttModel, t as InworldAudioEncoding } from "./models-CPLZDcgt.mjs";
+export { InworldAudioEncoding, InworldDeliveryMode, InworldSttModel, InworldTtsModel, InworldVoiceId };

package/dist/models.mjs

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

package/dist/realtimeStt.d.mts

@@ -0,0 +1,38 @@
+import { Redacted, Schema, Stream } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+import { CommonStreamTranscribeRequest } from "@effect-uai/core/Transcriber";
+import { TranscriptEvent } from "@effect-uai/core/Transcript";
+
+//#region src/realtimeStt.d.ts
+type Config = {
+  readonly apiKey: Redacted.Redacted;
+  readonly baseUrl?: string;
+};
+declare const ServerFrame: Schema.Struct<{
+  readonly result: Schema.optional<Schema.Struct<{
+    readonly transcription: Schema.optional<Schema.Struct<{
+      readonly transcript: Schema.String;
+      readonly isFinal: Schema.optional<Schema.Boolean>;
+      readonly wordTimestamps: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly word: Schema.String;
+        readonly startTimeMs: Schema.optional<Schema.Number>;
+        readonly endTimeMs: Schema.optional<Schema.Number>;
+        readonly confidence: Schema.optional<Schema.Number>;
+      }>>>>;
+    }>>;
+    readonly speechStarted: Schema.optional<Schema.Struct<{
+      readonly startTimeMs: Schema.optional<Schema.Number>;
+      readonly confidence: Schema.optional<Schema.Number>;
+    }>>;
+    readonly speechStopped: Schema.optional<Schema.Struct<{
+      readonly silenceDurationMs: Schema.optional<Schema.Number>;
+    }>>;
+    readonly status: Schema.optional<Schema.Unknown>;
+  }>>;
+  readonly error: Schema.optional<Schema.Unknown>;
+}>;
+declare const wireToEvent: (frame: typeof ServerFrame.Type) => TranscriptEvent | undefined;
+declare const streamTranscription: (cfg: Config) => <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R>;
+//#endregion
+export { Config, streamTranscription, wireToEvent };
+//# sourceMappingURL=realtimeStt.d.mts.map

package/dist/realtimeStt.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtimeStt.d.mts","names":[],"sources":["../src/realtimeStt.ts"],"mappings":";;;;;;KA6BY,MAAA;EAAA,SAAoB,MAAA,EAAQ,QAAA,CAAS,QAAA;EAAA,SAAmB,OAAA;AAAA;AAAA,cAqG9D,WAAA,EAAW,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;cAgBJ,WAAA,GAAe,KAAA,SAAc,WAAA,CAAY,IAAA,KAAO,eAAA;AAAA,cAoDhD,mBAAA,GACV,GAAA,EAAK,MAAA,YAEJ,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,GACtC,OAAA,EAAS,6BAAA,KACR,MAAA,CAAO,MAAA,CAAO,eAAA,EAAiB,OAAA,CAAQ,OAAA,GAAU,CAAA,EAAG,CAAA"}

package/dist/realtimeStt.mjs

@@ -0,0 +1,145 @@
+import { authedWsConstructor } from "./wsAuth.mjs";
+import { Effect, Encoding, Match, Queue, 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";
+//#region src/realtimeStt.ts
+/**
+* Inworld Realtime STT — `wss://api.inworld.ai/stt/v1/transcribe:streamBidirectional`.
+*
+* Auth: `Authorization: Basic <API_KEY>` on the WS upgrade header (matches
+* Inworld's own JS sample). Setting headers needs the `ws` peer dep
+* (Node/Bun); see `./wsAuth.ts`.
+*
+* Wire shape (per [inworld-ai/inworld-api-examples](https://github.com/inworld-ai/inworld-api-examples)):
+*   client → server:
+*     `{ "transcribeConfig": { modelId, audioEncoding, sampleRateHertz, language, ... } }`  (first frame)
+*     `{ "audioChunk": { "content": "<base64 audio>" } }`                                  (×N)
+*     `{ "closeStream": {} }`                                                              (end-of-input)
+*   server → client:
+*     `{ "result": { "transcription": { "transcript": "...", "isFinal": true|false } } }`
+*     `{ "result": { "speechStarted": { "startTimeMs": ... } } }`
+*     `{ "result": { "speechStopped": { "silenceDurationMs": ... } } }`
+*
+* Inworld's STT WS sends audio as base64 inside JSON (NOT binary frames),
+* matching the rest of the Inworld API style.
+*/
+const unsupportedFormat = (format) => new AiError.Unsupported({
+	provider: "inworld",
+	capability: "inputFormat",
+	reason: `Inworld realtime STT accepts pcm_s16le (LINEAR16), mp3, ogg/opus, or flac. Got ${JSON.stringify(format)}.`
+});
+const inputFormatToWire = Match.type().pipe(Match.when({
+	container: "raw",
+	encoding: "pcm_s16le"
+}, () => Effect.succeed("LINEAR16")), Match.when({
+	container: "wav",
+	encoding: "pcm_s16le"
+}, () => Effect.succeed("LINEAR16")), Match.when({ container: "mp3" }, () => Effect.succeed("MP3")), Match.when({
+	container: "ogg",
+	encoding: "opus"
+}, () => Effect.succeed("OGG_OPUS")), Match.when({ container: "flac" }, () => Effect.succeed("FLAC")), Match.orElse((f) => Effect.fail(unsupportedFormat(f))));
+const buildWsUrl = (cfg) => {
+	return `${(cfg.baseUrl ?? "https://api.inworld.ai").replace(/^http/, "ws")}/stt/v1/transcribe:streamBidirectional`;
+};
+const promptToTerms = (prompt) => prompt === void 0 ? void 0 : typeof prompt === "string" ? [prompt] : prompt.terms;
+const configFrame = (encoding, request) => {
+	const prompts = promptToTerms(request.prompt);
+	return JSON.stringify({ transcribeConfig: {
+		modelId: request.model,
+		audioEncoding: encoding,
+		sampleRateHertz: request.inputFormat.sampleRate,
+		numberOfChannels: request.inputFormat.channels ?? 1,
+		language: request.language ?? "en-US",
+		...prompts !== void 0 && { prompts },
+		...request.wordTimestamps === true && { includeWordTimestamps: true }
+	} });
+};
+const audioChunkFrame = (bytes) => JSON.stringify({ audioChunk: { content: Encoding.encodeBase64(bytes) } });
+const endTurnFrame = JSON.stringify({ endTurn: {} });
+const closeStreamFrame = JSON.stringify({ closeStream: {} });
+const WireWord = Schema.Struct({
+	word: Schema.String,
+	startTimeMs: Schema.optional(Schema.Number),
+	endTimeMs: Schema.optional(Schema.Number),
+	confidence: Schema.optional(Schema.Number)
+});
+const ResultBody = Schema.Struct({
+	transcription: Schema.optional(Schema.Struct({
+		transcript: Schema.String,
+		isFinal: Schema.optional(Schema.Boolean),
+		wordTimestamps: Schema.optional(Schema.NullOr(Schema.Array(WireWord)))
+	})),
+	speechStarted: Schema.optional(Schema.Struct({
+		startTimeMs: Schema.optional(Schema.Number),
+		confidence: Schema.optional(Schema.Number)
+	})),
+	speechStopped: Schema.optional(Schema.Struct({ silenceDurationMs: Schema.optional(Schema.Number) })),
+	status: Schema.optional(Schema.Unknown)
+});
+const ServerFrame = Schema.Struct({
+	result: Schema.optional(ResultBody),
+	error: Schema.optional(Schema.Unknown)
+});
+const decodeServerFrame = Schema.decodeUnknownEffect(ServerFrame);
+const wireWordToCommon = (w) => w.startTimeMs === void 0 || w.endTimeMs === void 0 ? void 0 : {
+	text: w.word,
+	startSeconds: w.startTimeMs / 1e3,
+	endSeconds: w.endTimeMs / 1e3,
+	...w.confidence !== void 0 && { confidence: w.confidence }
+};
+const wireToEvent = (frame) => {
+	if (frame.error !== void 0) return {
+		_tag: "error",
+		message: typeof frame.error === "string" ? frame.error : JSON.stringify(frame.error)
+	};
+	const result = frame.result;
+	if (result === void 0) return void 0;
+	if (result.transcription !== void 0) {
+		const t = result.transcription;
+		const words = t.wordTimestamps?.map(wireWordToCommon).filter((w) => w !== void 0);
+		return t.isFinal === true ? {
+			_tag: "final",
+			text: t.transcript,
+			...words !== void 0 && words.length > 0 && { words }
+		} : {
+			_tag: "partial",
+			text: t.transcript,
+			...words !== void 0 && words.length > 0 && { words }
+		};
+	}
+	if (result.speechStarted !== void 0) return {
+		_tag: "speech-started",
+		atSeconds: (result.speechStarted.startTimeMs ?? 0) / 1e3
+	};
+	if (result.speechStopped !== void 0) return {
+		_tag: "utterance-ended",
+		atSeconds: 0
+	};
+};
+const handleServerMessage = (queue) => (raw) => Effect.gen(function* () {
+	const json = yield* JSONL.parseSafe(raw);
+	if (json === void 0) return;
+	const decoded = yield* decodeServerFrame(json).pipe(Effect.option);
+	if (decoded._tag === "None") return;
+	const event = wireToEvent(decoded.value);
+	if (event !== void 0) yield* Queue.offer(queue, event);
+});
+const streamTranscription = (cfg) => (audioIn, request) => Stream.unwrap(Effect.gen(function* () {
+	const encoding = yield* inputFormatToWire(request.inputFormat);
+	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(configFrame(encoding, request));
+		yield* Stream.runForEach(audioIn, (bytes) => write(audioChunkFrame(bytes)));
+		yield* write(endTurnFrame);
+		yield* write(closeStreamFrame);
+	}).pipe(Effect.ignore, Effect.forkScoped);
+	yield* socket.runString(handleServerMessage(queue)).pipe(Effect.ensuring(Queue.end(queue)), Effect.forkScoped);
+	return Stream.fromQueue(queue);
+}));
+//#endregion
+export { streamTranscription, wireToEvent };
+
+//# sourceMappingURL=realtimeStt.mjs.map

package/dist/realtimeStt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtimeStt.mjs","names":[],"sources":["../src/realtimeStt.ts"],"sourcesContent":["/**\n * Inworld Realtime STT — `wss://api.inworld.ai/stt/v1/transcribe:streamBidirectional`.\n *\n * Auth: `Authorization: Basic <API_KEY>` on the WS upgrade header (matches\n * Inworld's own JS sample). Setting headers needs the `ws` peer dep\n * (Node/Bun); see `./wsAuth.ts`.\n *\n * Wire shape (per [inworld-ai/inworld-api-examples](https://github.com/inworld-ai/inworld-api-examples)):\n *   client → server:\n *     `{ \"transcribeConfig\": { modelId, audioEncoding, sampleRateHertz, language, ... } }`  (first frame)\n *     `{ \"audioChunk\": { \"content\": \"<base64 audio>\" } }`                                  (×N)\n *     `{ \"closeStream\": {} }`                                                              (end-of-input)\n *   server → client:\n *     `{ \"result\": { \"transcription\": { \"transcript\": \"...\", \"isFinal\": true|false } } }`\n *     `{ \"result\": { \"speechStarted\": { \"startTimeMs\": ... } } }`\n *     `{ \"result\": { \"speechStopped\": { \"silenceDurationMs\": ... } } }`\n *\n * Inworld's STT WS sends audio as base64 inside JSON (NOT binary frames),\n * matching the rest of the Inworld API style.\n */\nimport { Cause, Effect, Encoding, Match, Queue, Redacted, Schema, Stream } from \"effect\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport type { AudioFormat } from \"@effect-uai/core/Audio\"\nimport * as JSONL from \"@effect-uai/core/JSONL\"\nimport type { TranscriptEvent, WordTimestamp } from \"@effect-uai/core/Transcript\"\nimport type { CommonStreamTranscribeRequest } from \"@effect-uai/core/Transcriber\"\nimport { authedWsConstructor } from \"./wsAuth.js\"\n\nexport type Config = { readonly apiKey: Redacted.Redacted; readonly baseUrl?: string }\n\n// ---------------------------------------------------------------------------\n// AudioFormat → `audioEncoding` slug for Inworld STT\n// ---------------------------------------------------------------------------\n\ntype WireEncoding = \"LINEAR16\" | \"MP3\" | \"OGG_OPUS\" | \"FLAC\"\n\nconst unsupportedFormat = (format: AudioFormat) =>\n  new AiError.Unsupported({\n    provider: \"inworld\",\n    capability: \"inputFormat\",\n    reason: `Inworld realtime STT accepts pcm_s16le (LINEAR16), mp3, ogg/opus, or flac. Got ${JSON.stringify(format)}.`,\n  })\n\nconst inputFormatToWire: (format: AudioFormat) => Effect.Effect<WireEncoding, AiError.AiError> =\n  Match.type<AudioFormat>().pipe(\n    Match.when({ container: \"raw\", encoding: \"pcm_s16le\" }, () =>\n      Effect.succeed<WireEncoding>(\"LINEAR16\"),\n    ),\n    Match.when({ container: \"wav\", encoding: \"pcm_s16le\" }, () =>\n      Effect.succeed<WireEncoding>(\"LINEAR16\"),\n    ),\n    Match.when({ container: \"mp3\" }, () => Effect.succeed<WireEncoding>(\"MP3\")),\n    Match.when({ container: \"ogg\", encoding: \"opus\" }, () =>\n      Effect.succeed<WireEncoding>(\"OGG_OPUS\"),\n    ),\n    Match.when({ container: \"flac\" }, () => Effect.succeed<WireEncoding>(\"FLAC\")),\n    Match.orElse((f) => Effect.fail(unsupportedFormat(f))),\n  )\n\n// ---------------------------------------------------------------------------\n// URL + frame builders\n// ---------------------------------------------------------------------------\n\nconst buildWsUrl = (cfg: Config) => {\n  const wsBase = (cfg.baseUrl ?? \"https://api.inworld.ai\").replace(/^http/, \"ws\")\n  return `${wsBase}/stt/v1/transcribe:streamBidirectional`\n}\n\nconst promptToTerms = (\n  prompt: string | { readonly terms: ReadonlyArray<string> } | undefined,\n): ReadonlyArray<string> | undefined =>\n  prompt === undefined ? undefined : typeof prompt === \"string\" ? [prompt] : prompt.terms\n\nconst configFrame = (encoding: WireEncoding, request: CommonStreamTranscribeRequest) => {\n  const prompts = promptToTerms(request.prompt)\n  return JSON.stringify({\n    transcribeConfig: {\n      modelId: request.model,\n      audioEncoding: encoding,\n      sampleRateHertz: request.inputFormat.sampleRate,\n      numberOfChannels: request.inputFormat.channels ?? 1,\n      // Inworld's sample includes `language` even though docs mark it optional.\n      // Default to en-US to match the sample's behavior; caller can override.\n      language: request.language ?? \"en-US\",\n      ...(prompts !== undefined && { prompts }),\n      ...(request.wordTimestamps === true && { includeWordTimestamps: true }),\n    },\n  })\n}\n\nconst audioChunkFrame = (bytes: Uint8Array) =>\n  JSON.stringify({ audioChunk: { content: Encoding.encodeBase64(bytes) } })\n\nconst endTurnFrame = JSON.stringify({ endTurn: {} })\nconst closeStreamFrame = JSON.stringify({ closeStream: {} })\n\n// ---------------------------------------------------------------------------\n// Wire schemas (server → client)\n// ---------------------------------------------------------------------------\n\nconst WireWord = Schema.Struct({\n  word: Schema.String,\n  startTimeMs: Schema.optional(Schema.Number),\n  endTimeMs: Schema.optional(Schema.Number),\n  confidence: Schema.optional(Schema.Number),\n})\n\nconst ResultBody = Schema.Struct({\n  transcription: Schema.optional(\n    Schema.Struct({\n      transcript: Schema.String,\n      isFinal: Schema.optional(Schema.Boolean),\n      wordTimestamps: Schema.optional(Schema.NullOr(Schema.Array(WireWord))),\n    }),\n  ),\n  speechStarted: Schema.optional(\n    Schema.Struct({\n      startTimeMs: Schema.optional(Schema.Number),\n      confidence: Schema.optional(Schema.Number),\n    }),\n  ),\n  speechStopped: Schema.optional(\n    Schema.Struct({\n      silenceDurationMs: Schema.optional(Schema.Number),\n    }),\n  ),\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 wireWordToCommon = (w: typeof WireWord.Type): WordTimestamp | undefined =>\n  w.startTimeMs === undefined || w.endTimeMs === undefined\n    ? undefined\n    : {\n        text: w.word,\n        startSeconds: w.startTimeMs / 1000,\n        endSeconds: w.endTimeMs / 1000,\n        ...(w.confidence !== undefined && { confidence: w.confidence }),\n      }\n\nexport const wireToEvent = (frame: typeof ServerFrame.Type): TranscriptEvent | undefined => {\n  if (frame.error !== undefined) {\n    return {\n      _tag: \"error\",\n      message: typeof frame.error === \"string\" ? frame.error : JSON.stringify(frame.error),\n    }\n  }\n  const result = frame.result\n  if (result === undefined) return undefined\n  if (result.transcription !== undefined) {\n    const t = result.transcription\n    const words = t.wordTimestamps\n      ?.map(wireWordToCommon)\n      .filter((w): w is WordTimestamp => w !== undefined)\n    return t.isFinal === true\n      ? {\n          _tag: \"final\",\n          text: t.transcript,\n          ...(words !== undefined && words.length > 0 && { words }),\n        }\n      : {\n          _tag: \"partial\",\n          text: t.transcript,\n          ...(words !== undefined && words.length > 0 && { words }),\n        }\n  }\n  if (result.speechStarted !== undefined) {\n    return {\n      _tag: \"speech-started\",\n      atSeconds: (result.speechStarted.startTimeMs ?? 0) / 1000,\n    }\n  }\n  if (result.speechStopped !== undefined) {\n    return { _tag: \"utterance-ended\", atSeconds: 0 }\n  }\n  return undefined\n}\n\nconst handleServerMessage = (queue: Queue.Queue<TranscriptEvent, 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 event = wireToEvent(decoded.value)\n    if (event !== undefined) yield* Queue.offer(queue, event)\n  })\n\n// ---------------------------------------------------------------------------\n// Stream<Uint8Array> → Stream<TranscriptEvent>\n// ---------------------------------------------------------------------------\n\nexport const streamTranscription =\n  (cfg: Config) =>\n  <E, R>(\n    audioIn: Stream.Stream<Uint8Array, E, R>,\n    request: CommonStreamTranscribeRequest,\n  ): Stream.Stream<TranscriptEvent, AiError.AiError | E, R> =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const encoding = yield* inputFormatToWire(request.inputFormat)\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<TranscriptEvent, Cause.Done>(64)\n        const write = yield* socket.writer\n\n        // Writer: config → drain audio → endTurn → closeStream. Inworld\n        // emits `result.transcription` partials in real-time via VAD;\n        // `endTurn` is sent on input-stream end to flush any tail audio\n        // into a final transcript, then `closeStream` for graceful close.\n        yield* Effect.gen(function* () {\n          yield* write(configFrame(encoding, request))\n          yield* Stream.runForEach(audioIn, (bytes) => write(audioChunkFrame(bytes)))\n          yield* write(endTurnFrame)\n          yield* write(closeStreamFrame)\n        }).pipe(Effect.ignore, Effect.forkScoped)\n\n        // `Queue.end` flushes pending events then fails the next take with\n        // `Done` — clean stream end. `Queue.shutdown` would CLEAR queued\n        // items and interrupt pending takes (wrong for graceful teardown).\n        yield* socket\n          .runString(handleServerMessage(queue))\n          .pipe(Effect.ensuring(Queue.end(queue)), Effect.forkScoped)\n\n        return Stream.fromQueue(queue)\n      }),\n    )\n"],"mappings":"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"}

package/dist/realtimeTts.d.mts

@@ -0,0 +1,29 @@
+import { a as InworldVoiceId, i as InworldTtsModel, n as InworldDeliveryMode } from "./models-CPLZDcgt.mjs";
+import { Redacted, Stream } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+import { AudioChunk, AudioFormat } from "@effect-uai/core/Audio";
+
+//#region src/realtimeTts.d.ts
+type Config = {
+  readonly apiKey: Redacted.Redacted;
+  readonly baseUrl?: string;
+};
+/**
+ * Incremental-text-in request. Mirrors the sync request minus `text` (which
+ * comes from the input stream).
+ */
+type StreamSynthesizeRequest = {
+  readonly model: InworldTtsModel;
+  readonly voiceId: InworldVoiceId;
+  readonly outputFormat?: AudioFormat;
+  readonly languageCode?: string;
+  readonly temperature?: number;
+  readonly deliveryMode?: InworldDeliveryMode;
+  readonly applyTextNormalization?: "ON" | "OFF";
+  readonly speed?: number;
+};
+declare const buildWsUrl: (cfg: Config) => string;
+declare const streamSynthesis: (cfg: Config) => <E, R>(textIn: Stream.Stream<string, E, R>, request: StreamSynthesizeRequest) => Stream.Stream<AudioChunk, AiError.AiError | E, R>;
+//#endregion
+export { Config, StreamSynthesizeRequest, buildWsUrl, streamSynthesis };
+//# sourceMappingURL=realtimeTts.d.mts.map

package/dist/realtimeTts.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtimeTts.d.mts","names":[],"sources":["../src/realtimeTts.ts"],"mappings":";;;;;;KA8BY,MAAA;EAAA,SAAoB,MAAA,EAAQ,QAAA,CAAS,QAAA;EAAA,SAAmB,OAAA;AAAA;;;;;KAMxD,uBAAA;EAAA,SACD,KAAA,EAAO,eAAA;EAAA,SACP,OAAA,EAAS,cAAA;EAAA,SACT,YAAA,GAAe,WAAA;EAAA,SACf,YAAA;EAAA,SACA,WAAA;EAAA,SACA,YAAA,GAAe,mBAAA;EAAA,SACf,sBAAA;EAAA,SACA,KAAA;AAAA;AAAA,cAOE,UAAA,GAAc,GAAA,EAAK,MAAA;AAAA,cA8EnB,eAAA,GACV,GAAA,EAAK,MAAA,YAEJ,MAAA,EAAQ,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,GACjC,OAAA,EAAS,uBAAA,KACR,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,OAAA,CAAQ,OAAA,GAAU,CAAA,EAAG,CAAA"}

package/dist/realtimeTts.mjs

@@ -0,0 +1,94 @@
+import { audioConfigFor, decodeAudioContent, defaultFormat } from "./codec.mjs";
+import { authedWsConstructor } from "./wsAuth.mjs";
+import { Effect, Queue, Schema, Stream } from "effect";
+import * as JSONL from "@effect-uai/core/JSONL";
+import * as Socket from "effect/unstable/socket/Socket";
+//#region src/realtimeTts.ts
+/**
+* Inworld Realtime TTS — `wss://api.inworld.ai/tts/v1/voice:streamBidirectional`.
+*
+* Auth: `Authorization: Basic <API_KEY>` on the WS upgrade header (matches
+* Inworld's own JS sample). The docs mention a `?Authorization=…` query
+* variant but the server rejects it in practice. Setting headers needs the
+* `ws` peer dep (Node/Bun); see `./wsAuth.ts`.
+*
+* Wire shape (single-context per call):
+*   client → server:
+*     `{ "create": { voiceId, modelId, audioConfig, ... } }`
+*     `{ "send_text": { "text": "..." } }`             (repeated)
+*     `{ "close_context": {} }`                        (text stream end)
+*   server → client:
+*     `{ "result": { "contextCreated": {...} } }`      (handshake ack)
+*     `{ "result": { "audioChunk": { "audioContent": "<b64>" } } }` (×N)
+*     `{ "result": { "contextClosed": {...} } }`       (final)
+*
+* Multi-context (`contextId`) is not surfaced here — one logical
+* utterance per call.
+*/
+const buildWsUrl = (cfg) => {
+	return `${(cfg.baseUrl ?? "https://api.inworld.ai").replace(/^http/, "ws")}/tts/v1/voice:streamBidirectional`;
+};
+const audioConfigSnake = (request) => Effect.map(audioConfigFor(request.outputFormat ?? defaultFormat, request.speed), (cfg) => ({
+	audio_encoding: cfg.audioEncoding,
+	...cfg.sampleRateHertz !== void 0 && { sample_rate_hertz: cfg.sampleRateHertz },
+	...cfg.bitRate !== void 0 && { bit_rate: cfg.bitRate },
+	...cfg.speakingRate !== void 0 && { speaking_rate: cfg.speakingRate }
+}));
+const createFrame = (request) => Effect.map(audioConfigSnake(request), (audio_config) => JSON.stringify({ create: {
+	voice_id: request.voiceId,
+	model_id: request.model,
+	audio_config,
+	...request.languageCode !== void 0 && { language: request.languageCode },
+	...request.deliveryMode !== void 0 && { delivery_mode: request.deliveryMode },
+	...request.temperature !== void 0 && { temperature: request.temperature },
+	...request.applyTextNormalization !== void 0 && { apply_text_normalization: request.applyTextNormalization }
+} }));
+const sendTextFrame = (text) => JSON.stringify({ send_text: {
+	text,
+	flush_context: {}
+} });
+const closeContextFrame = JSON.stringify({ close_context: {} });
+const ResultBody = Schema.Struct({
+	audioChunk: Schema.optional(Schema.Struct({ audioContent: Schema.String })),
+	contextCreated: Schema.optional(Schema.Unknown),
+	flushCompleted: Schema.optional(Schema.Unknown),
+	contextClosed: Schema.optional(Schema.Unknown),
+	status: Schema.optional(Schema.Unknown)
+});
+const ServerFrame = Schema.Struct({
+	result: Schema.optional(ResultBody),
+	error: Schema.optional(Schema.Unknown)
+});
+const decodeServerFrame = Schema.decodeUnknownEffect(ServerFrame);
+const handleServerFrame = (queue) => (raw) => Effect.gen(function* () {
+	const json = yield* JSONL.parseSafe(raw);
+	if (json === void 0) return;
+	const decoded = yield* decodeServerFrame(json).pipe(Effect.option);
+	if (decoded._tag === "None") return;
+	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;
+	const bytes = yield* decodeAudioContent(audio).pipe(Effect.option);
+	if (bytes._tag === "Some") yield* Queue.offer(queue, { bytes: bytes.value });
+});
+const streamSynthesis = (cfg) => (textIn, request) => Stream.unwrap(Effect.gen(function* () {
+	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);
+}));
+//#endregion
+export { buildWsUrl, streamSynthesis };
+
+//# sourceMappingURL=realtimeTts.mjs.map

package/dist/realtimeTts.mjs.map

@@ -0,0 +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 { 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}\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        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":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,MAAa,cAAc,QAAgB;AAEzC,QAAO,IADS,IAAI,WAAW,0BAA0B,QAAQ,SAAS,KAC1D,CAAC;;AAOnB,MAAM,oBAAoB,YACxB,OAAO,IAAI,eAAe,QAAQ,gBAAgB,eAAe,QAAQ,MAAM,GAAG,SAAS;CACzF,gBAAgB,IAAI;CACpB,GAAI,IAAI,oBAAoB,KAAA,KAAa,EAAE,mBAAmB,IAAI,iBAAiB;CACnF,GAAI,IAAI,YAAY,KAAA,KAAa,EAAE,UAAU,IAAI,SAAS;CAC1D,GAAI,IAAI,iBAAiB,KAAA,KAAa,EAAE,eAAe,IAAI,cAAc;CAC1E,EAAE;AAEL,MAAM,eAAe,YACnB,OAAO,IAAI,iBAAiB,QAAQ,GAAG,iBACrC,KAAK,UAAU,EACb,QAAQ;CACN,UAAU,QAAQ;CAClB,UAAU,QAAQ;CAClB;CACA,GAAI,QAAQ,iBAAiB,KAAA,KAAa,EAAE,UAAU,QAAQ,cAAc;CAC5E,GAAI,QAAQ,iBAAiB,KAAA,KAAa,EAAE,eAAe,QAAQ,cAAc;CACjF,GAAI,QAAQ,gBAAgB,KAAA,KAAa,EAAE,aAAa,QAAQ,aAAa;CAC7E,GAAI,QAAQ,2BAA2B,KAAA,KAAa,EAClD,0BAA0B,QAAQ,wBACnC;CACF,EACF,CAAC,CACH;AAIH,MAAM,iBAAiB,SAAiB,KAAK,UAAU,EAAE,WAAW;CAAE;CAAM,eAAe,EAAE;CAAE,EAAE,CAAC;AAClG,MAAM,oBAAoB,KAAK,UAAU,EAAE,eAAe,EAAE,EAAE,CAAC;AAM/D,MAAM,aAAa,OAAO,OAAO;CAC/B,YAAY,OAAO,SAAS,OAAO,OAAO,EAAE,cAAc,OAAO,QAAQ,CAAC,CAAC;CAC3E,gBAAgB,OAAO,SAAS,OAAO,QAAQ;CAC/C,gBAAgB,OAAO,SAAS,OAAO,QAAQ;CAC/C,eAAe,OAAO,SAAS,OAAO,QAAQ;CAC9C,QAAQ,OAAO,SAAS,OAAO,QAAQ;CACxC,CAAC;AAEF,MAAM,cAAc,OAAO,OAAO;CAChC,QAAQ,OAAO,SAAS,WAAW;CACnC,OAAO,OAAO,SAAS,OAAO,QAAQ;CACvC,CAAC;AACF,MAAM,oBAAoB,OAAO,oBAAoB,YAAY;AAEjE,MAAM,qBAAqB,WAAgD,QACzE,OAAO,IAAI,aAAa;CACtB,MAAM,OAAO,OAAO,MAAM,UAAU,IAAI;AACxC,KAAI,SAAS,KAAA,EAAW;CACxB,MAAM,UAAU,OAAO,kBAAkB,KAAK,CAAC,KAAK,OAAO,OAAO;AAClE,KAAI,QAAQ,SAAS,OAAQ;CAC7B,MAAM,QAAQ,QAAQ;AACtB,KAAI,MAAM,UAAU,KAAA,GAAW;AAC7B,SAAO,OAAO,WAAW,oCAAoC,EAAE,OAAO,MAAM,OAAO,CAAC;AACpF;;CAEF,MAAM,QAAQ,MAAM,QAAQ,YAAY;AACxC,KAAI,UAAU,KAAA,KAAa,UAAU,GAAI;CACzC,MAAM,QAAQ,OAAO,mBAAmB,MAAM,CAAC,KAAK,OAAO,OAAO;AAClE,KAAI,MAAM,SAAS,OAAQ,QAAO,MAAM,MAAM,OAAO,EAAE,OAAO,MAAM,OAAO,CAAC;EAC5E;AAMJ,MAAa,mBACV,SAEC,QACA,YAEA,OAAO,OACL,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,YAAY,QAAQ;CAC1C,MAAM,SAAS,OAAO,OAAO,cAAc,WAAW,IAAI,EAAE,EAG1D,mBAAmB,SAAS,SAAS,OAAQ,SAAS,QAAQ,SAAS,MACxE,CAAC,CAAC,KAAK,OAAO,eAAe,OAAO,sBAAsB,oBAAoB,IAAI,OAAO,CAAC,CAAC;CAC5F,MAAM,QAAQ,OAAO,MAAM,QAAgC,GAAG;CAC9D,MAAM,QAAQ,OAAO,OAAO;AAK5B,QAAO,OAAO,IAAI,aAAa;AAC7B,SAAO,MAAM,OAAO;AACpB,SAAO,OAAO,WAAW,SAAS,SAChC,KAAK,WAAW,IAAI,OAAO,OAAO,MAAM,cAAc,KAAK,CAAC,CAC7D;AACD,SAAO,MAAM,kBAAkB;GAC/B,CAAC,KAAK,OAAO,QAAQ,OAAO,WAAW;AAKzC,QAAO,OACJ,UAAU,kBAAkB,MAAM,CAAC,CACnC,KAAK,OAAO,SAAS,MAAM,IAAI,MAAM,CAAC,EAAE,OAAO,WAAW;AAE7D,QAAO,OAAO,UAAU,MAAM;EAC9B,CACH"}