@effect-uai/inworld 0.4.0

package/dist/wsAuth.d.mts

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

package/dist/wsAuth.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsAuth.d.mts","names":[],"sources":["../src/wsAuth.ts"],"mappings":";;;;cAea,mBAAA,GACV,MAAA,EAAQ,QAAA,CAAS,QAAA,KAAW,MAAA,CAAO,oBAAA"}

package/dist/wsAuth.mjs

@@ -0,0 +1,8 @@
+import { authHeader } from "./codec.mjs";
+import { WebSocket } from "ws";
+//#region src/wsAuth.ts
+const authedWsConstructor = (apiKey) => (url) => new WebSocket(url, void 0, { headers: { Authorization: authHeader(apiKey) } });
+//#endregion
+export { authedWsConstructor };
+
+//# sourceMappingURL=wsAuth.mjs.map

package/dist/wsAuth.mjs.map

@@ -0,0 +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,OAAO,EAAE,EAC/C,CAAC"}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@effect-uai/inworld",
+  "version": "0.4.0",
+  "description": "Inworld speech-to-text and text-to-speech provider for @effect-uai/core.",
+  "keywords": [
+    "ai",
+    "effect",
+    "inworld",
+    "speech",
+    "stt",
+    "transcription",
+    "tts"
+  ],
+  "homepage": "https://github.com/betalyra/effect-uai/tree/main/packages/providers/inworld",
+  "bugs": {
+    "url": "https://github.com/betalyra/effect-uai/issues"
+  },
+  "license": "MIT",
+  "author": "Betalyra",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/betalyra/effect-uai",
+    "directory": "packages/providers/inworld"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./InworldSynthesizer": {
+      "types": "./dist/InworldSynthesizer.d.mts",
+      "import": "./dist/InworldSynthesizer.mjs"
+    },
+    "./InworldRealtimeSynthesizer": {
+      "types": "./dist/InworldRealtimeSynthesizer.d.mts",
+      "import": "./dist/InworldRealtimeSynthesizer.mjs"
+    },
+    "./InworldTranscriber": {
+      "types": "./dist/InworldTranscriber.d.mts",
+      "import": "./dist/InworldTranscriber.mjs"
+    },
+    "./InworldRealtimeTranscriber": {
+      "types": "./dist/InworldRealtimeTranscriber.d.mts",
+      "import": "./dist/InworldRealtimeTranscriber.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13",
+    "effect": "4.0.0-beta.57",
+    "typescript": "^6.0.3",
+    "ws": "^8.18.0",
+    "@effect-uai/core": "0.4.0"
+  },
+  "peerDependencies": {
+    "@effect-uai/core": ">=0.2.0 <1",
+    "effect": "4.0.0-beta.57",
+    "ws": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ws": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/InworldRealtimeSynthesizer.ts

@@ -0,0 +1,76 @@
+/**
+ * Realtime variant of `InworldSynthesizer`. Wires `streamSynthesisFrom` to
+ * `wss://api.inworld.ai/tts/v1/voice:streamBidirectional` and registers
+ * the `TtsIncrementalText` capability marker, so the call compiles
+ * against this Layer alone.
+ *
+ * Sync `synthesize` and chunked `streamSynthesis` reuse the implementations
+ * exported from `./InworldSynthesizer.js` — the only added surface here is
+ * the WS path.
+ */
+import { Effect, Layer, Stream } from "effect"
+import { HttpClient } from "effect/unstable/http"
+import {
+  type CommonStreamSynthesizeRequest,
+  type CommonSynthesizeRequest,
+  SpeechSynthesizer,
+  type SpeechSynthesizerService,
+  TtsIncrementalText,
+} from "@effect-uai/core/SpeechSynthesizer"
+import {
+  type Config,
+  InworldSynthesizer,
+  type InworldSynthesizerService,
+  type InworldSynthesizeRequest,
+  streamSynthesisImpl,
+  synthesizeImpl,
+} from "./InworldSynthesizer.js"
+import { streamSynthesis as realtimeStream } from "./realtimeTts.js"
+
+export type {
+  Config,
+  InworldSynthesizerService,
+  InworldSynthesizeRequest,
+} from "./InworldSynthesizer.js"
+export { InworldSynthesizer } from "./InworldSynthesizer.js"
+
+export const make = (cfg: Config) =>
+  Effect.map(
+    HttpClient.HttpClient.asEffect(),
+    (client) =>
+      ({
+        synthesize: (r) =>
+          synthesizeImpl(cfg)(r).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+        streamSynthesis: (r) =>
+          streamSynthesisImpl(cfg)(r).pipe(Stream.provideService(HttpClient.HttpClient, client)),
+        streamSynthesisFrom: (textIn, request) =>
+          realtimeStream(cfg)(textIn, request as InworldSynthesizeRequest),
+      }) satisfies InworldSynthesizerService,
+  )
+
+/**
+ * Realtime Layer. Registers `InworldSynthesizer`, the generic
+ * `SpeechSynthesizer`, **and** the `TtsIncrementalText` capability
+ * marker. The WS constructor uses the `ws` peer dep internally to set
+ * the `Authorization: Basic` header — no `Socket.WebSocketConstructor`
+ * needed at the call site.
+ */
+export const layer = (cfg: Config) =>
+  Layer.mergeAll(
+    Layer.effect(InworldSynthesizer, make(cfg)),
+    Layer.effect(
+      SpeechSynthesizer,
+      Effect.map(
+        make(cfg),
+        (s): SpeechSynthesizerService => ({
+          synthesize: (req: CommonSynthesizeRequest) =>
+            s.synthesize(req as InworldSynthesizeRequest),
+          streamSynthesis: (req: CommonSynthesizeRequest) =>
+            s.streamSynthesis(req as InworldSynthesizeRequest),
+          streamSynthesisFrom: (textIn, req: CommonStreamSynthesizeRequest) =>
+            s.streamSynthesisFrom(textIn, req),
+        }),
+      ),
+    ),
+    Layer.succeed(TtsIncrementalText, undefined),
+  )

package/src/InworldRealtimeTranscriber.ts

@@ -0,0 +1,64 @@
+/**
+ * Realtime variant of `InworldTranscriber`. Wires `streamTranscriptionFrom`
+ * to `wss://api.inworld.ai/stt/v1/transcribe:streamBidirectional` and
+ * registers the `SttStreaming` capability marker, so calls compile against
+ * this Layer alone.
+ *
+ * Sync `transcribe` reuses `transcribeImpl` from `./InworldTranscriber.js` —
+ * the only added surface is the WS path.
+ */
+import { Effect, Layer } from "effect"
+import { HttpClient } from "effect/unstable/http"
+import {
+  type CommonTranscribeRequest,
+  SttStreaming,
+  Transcriber,
+  type TranscriberService,
+} from "@effect-uai/core/Transcriber"
+import {
+  type Config,
+  InworldTranscriber,
+  type InworldTranscriberService,
+  type InworldTranscribeRequest,
+  transcribeImpl,
+} from "./InworldTranscriber.js"
+import { streamTranscription } from "./realtimeStt.js"
+
+export type {
+  Config,
+  InworldTranscriberService,
+  InworldTranscribeRequest,
+} from "./InworldTranscriber.js"
+export { InworldTranscriber } from "./InworldTranscriber.js"
+
+export const make = (cfg: Config) =>
+  Effect.map(
+    HttpClient.HttpClient.asEffect(),
+    (client) =>
+      ({
+        transcribe: (r) =>
+          transcribeImpl(cfg)(r).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+        streamTranscriptionFrom: (audioIn, request) => streamTranscription(cfg)(audioIn, request),
+      }) satisfies InworldTranscriberService,
+  )
+
+/**
+ * Realtime Layer. Registers `InworldTranscriber`, the generic
+ * `Transcriber`, **and** the `SttStreaming` capability marker.
+ */
+export const layer = (cfg: Config) =>
+  Layer.mergeAll(
+    Layer.effect(InworldTranscriber, make(cfg)),
+    Layer.effect(
+      Transcriber,
+      Effect.map(
+        make(cfg),
+        (s): TranscriberService => ({
+          transcribe: (req: CommonTranscribeRequest) =>
+            s.transcribe(req as InworldTranscribeRequest),
+          streamTranscriptionFrom: s.streamTranscriptionFrom,
+        }),
+      ),
+    ),
+    Layer.succeed(SttStreaming, undefined),
+  )

package/src/InworldSynthesizer.ts

@@ -0,0 +1,235 @@
+/**
+ * Sync + chunked-HTTP TTS via Inworld's REST endpoints.
+ *
+ * - `synthesize` → `POST /tts/v1/voice` (JSON body, single base64 audio in
+ *   response).
+ * - `streamSynthesis` → `POST /tts/v1/voice:stream` (NDJSON response, one
+ *   JSON object per line, each carrying a base64 audio chunk).
+ *
+ * Incremental text-in (`streamSynthesisFrom`) lives at the
+ * `InworldRealtimeSynthesizer` subpath, which adds the WS path and the
+ * `TtsIncrementalText` capability marker.
+ */
+import { Context, Effect, Layer, Redacted, Schema, Stream } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/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"
+import {
+  type CommonStreamSynthesizeRequest,
+  type CommonSynthesizeRequest,
+  SpeechSynthesizer,
+  type SpeechSynthesizerService,
+} from "@effect-uai/core/SpeechSynthesizer"
+import {
+  audioConfigFor,
+  authHeader,
+  decodeAudioContent,
+  defaultFormat,
+  httpStatusError,
+  transportFailure,
+} from "./codec.js"
+import type { InworldDeliveryMode, InworldTtsModel, InworldVoiceId } from "./models.js"
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/**
+ * Inworld-typed synthesize request.
+ *
+ * - `deliveryMode` only honored by `inworld-tts-2` (`STABLE` / `BALANCED` /
+ *   `CREATIVE` — older models ignore it).
+ * - `temperature` valid range is `(0, 2]` per docs.
+ * - `applyTextNormalization` defaults to `ON`; pass `"OFF"` to feed the
+ *   model raw text (faster, but punctuation pacing is on you).
+ */
+export type InworldSynthesizeRequest = Omit<CommonSynthesizeRequest, "model" | "voiceId"> & {
+  readonly model: InworldTtsModel
+  readonly voiceId: InworldVoiceId
+  readonly temperature?: number
+  readonly deliveryMode?: InworldDeliveryMode
+  readonly applyTextNormalization?: "ON" | "OFF"
+}
+
+export type InworldSynthesizerService = {
+  readonly synthesize: (r: InworldSynthesizeRequest) => Effect.Effect<AudioBlob, AiError.AiError>
+  readonly streamSynthesis: (
+    r: InworldSynthesizeRequest,
+  ) => Stream.Stream<AudioChunk, AiError.AiError>
+  readonly streamSynthesisFrom: SpeechSynthesizerService["streamSynthesisFrom"]
+}
+
+export class InworldSynthesizer extends Context.Service<
+  InworldSynthesizer,
+  InworldSynthesizerService
+>()("@betalyra/effect-uai/providers/inworld/InworldSynthesizer") {}
+
+export type Config = { readonly apiKey: Redacted.Redacted; readonly baseUrl?: string }
+
+// ---------------------------------------------------------------------------
+// Request body
+// ---------------------------------------------------------------------------
+
+/** Exported for reuse by the realtime variant's BOS `create` frame. */
+export const buildBody = (r: InworldSynthesizeRequest) =>
+  Effect.gen(function* () {
+    const format = r.outputFormat ?? defaultFormat
+    const audioConfig = yield* audioConfigFor(format, r.speed)
+    const body = {
+      text: r.text,
+      voiceId: r.voiceId,
+      modelId: r.model,
+      audioConfig,
+      ...(r.languageCode !== undefined && { language: r.languageCode }),
+      ...(r.deliveryMode !== undefined && { deliveryMode: r.deliveryMode }),
+      ...(r.temperature !== undefined && { temperature: r.temperature }),
+      ...(r.applyTextNormalization !== undefined && {
+        applyTextNormalization: r.applyTextNormalization,
+      }),
+    }
+    return { body, format }
+  })
+
+// ---------------------------------------------------------------------------
+// Wire schemas
+// ---------------------------------------------------------------------------
+
+const SyncResponse = Schema.Struct({ audioContent: Schema.String })
+const decodeSyncResponse = Schema.decodeUnknownEffect(SyncResponse)
+
+const StreamLine = Schema.Struct({
+  result: Schema.optional(Schema.Struct({ audioContent: Schema.optional(Schema.String) })),
+  error: Schema.optional(Schema.Unknown),
+})
+
+// ---------------------------------------------------------------------------
+// HTTP plumbing
+// ---------------------------------------------------------------------------
+
+const baseUrl = (cfg: Config) => cfg.baseUrl ?? "https://api.inworld.ai"
+
+const buildRequest = (cfg: Config, path: "/tts/v1/voice" | "/tts/v1/voice:stream", body: unknown) =>
+  HttpClientRequest.post(`${baseUrl(cfg)}${path}`).pipe(
+    HttpClientRequest.setHeader("Authorization", authHeader(cfg.apiKey)),
+    HttpClientRequest.bodyJsonUnsafe(body),
+  )
+
+/** Exported for reuse by `InworldRealtimeSynthesizer`. */
+export const synthesizeImpl = (cfg: Config) => (request: InworldSynthesizeRequest) =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+    const { body, format } = yield* buildBody(request)
+    const httpRequest = buildRequest(cfg, "/tts/v1/voice", body)
+    const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
+    if (response.status >= 400) {
+      const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+      return yield* Effect.fail(httpStatusError(response.status, text))
+    }
+    const json = yield* response.json.pipe(Effect.mapError(transportFailure))
+    const wire = yield* decodeSyncResponse(json).pipe(
+      Effect.mapError(
+        (cause) =>
+          new AiError.GenerationFailed({
+            provider: "inworld",
+            raw: { message: "sync TTS response missing `audioContent`", cause, json },
+          }),
+      ),
+    )
+    const bytes = yield* decodeAudioContent(wire.audioContent)
+    return { format, bytes } satisfies AudioBlob
+  })
+
+const lineToStream = (line: typeof StreamLine.Type): Stream.Stream<AudioChunk, AiError.AiError> => {
+  if (line.error !== undefined) {
+    return Stream.fail(new AiError.GenerationFailed({ provider: "inworld", raw: line.error }))
+  }
+  const b64 = line.result?.audioContent
+  if (b64 === undefined) return Stream.empty
+  return Stream.fromEffect(
+    decodeAudioContent(b64).pipe(Effect.map((bytes): AudioChunk => ({ bytes }))),
+  )
+}
+
+/** Exported for reuse by `InworldRealtimeSynthesizer`. */
+export const streamSynthesisImpl = (cfg: Config) => (request: InworldSynthesizeRequest) =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const client = yield* HttpClient.HttpClient
+      const { body } = yield* buildBody(request)
+      const httpRequest = buildRequest(cfg, "/tts/v1/voice:stream", body)
+      const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
+      if (response.status >= 400) {
+        const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+        return Stream.fail(httpStatusError(response.status, text))
+      }
+      return response.stream.pipe(
+        Stream.mapError(transportFailure),
+        JSONL.fromBytes,
+        JSONL.parse(StreamLine),
+        Stream.mapError(
+          (cause): AiError.AiError =>
+            new AiError.GenerationFailed({
+              provider: "inworld",
+              raw: { message: "NDJSON parse failed", cause },
+            }),
+        ),
+        Stream.flatMap(lineToStream),
+      )
+    }),
+  )
+
+const streamUnsupported = <E, R>(
+  _textIn: Stream.Stream<string, E, R>,
+  _request: CommonStreamSynthesizeRequest,
+): Stream.Stream<AudioChunk, AiError.AiError | E, R> => {
+  const fail: Stream.Stream<AudioChunk, AiError.AiError | E, R> = Stream.fail(
+    new AiError.Unsupported({
+      provider: "inworld",
+      capability: "streamSynthesisFrom",
+      reason:
+        "This Layer is sync-only. Import `@effect-uai/inworld/InworldRealtimeSynthesizer` to use the WS streamSynthesisFrom path.",
+    }),
+  )
+  return fail
+}
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+export const make = (
+  cfg: Config,
+): Effect.Effect<InworldSynthesizerService, never, HttpClient.HttpClient> =>
+  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+    synthesize: (r) =>
+      synthesizeImpl(cfg)(r).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+    streamSynthesis: (r) =>
+      streamSynthesisImpl(cfg)(r).pipe(Stream.provideService(HttpClient.HttpClient, client)),
+    streamSynthesisFrom: streamUnsupported,
+  }))
+
+/**
+ * Sync-only Layer. Registers `InworldSynthesizer` + the generic
+ * `SpeechSynthesizer`. Does **not** register `TtsIncrementalText` — for
+ * incremental text-in use `@effect-uai/inworld/InworldRealtimeSynthesizer`.
+ */
+export const layer = (
+  cfg: Config,
+): Layer.Layer<InworldSynthesizer | SpeechSynthesizer, never, HttpClient.HttpClient> =>
+  Layer.merge(
+    Layer.effect(InworldSynthesizer, make(cfg)),
+    Layer.effect(
+      SpeechSynthesizer,
+      Effect.map(
+        make(cfg),
+        (s): SpeechSynthesizerService => ({
+          synthesize: (req: CommonSynthesizeRequest) =>
+            s.synthesize(req as InworldSynthesizeRequest),
+          streamSynthesis: (req: CommonSynthesizeRequest) =>
+            s.streamSynthesis(req as InworldSynthesizeRequest),
+          streamSynthesisFrom: s.streamSynthesisFrom,
+        }),
+      ),
+    ),
+  )