rime-api 0.0.1__py3-none-any.whl

rime_api/SOURCE.json

@@ -0,0 +1,9 @@
+{
+  "version": "0.0.1",
+  "schema": "rime/text_to_speech.proto",
+  "sha256": "b33b23caed621c19f848693d26301e43639a3a2fd63c8133a37f2f3673f7a412",
+  "asyncapi": {
+    "schema": "text_to_speech.asyncapi.yaml",
+    "sha256": "0ba7a67cf88127bcf21bfbffab4f7c752e823c3a80fc7e354d1cdc7a0fbcb4ee"
+  }
+}

rime_api/__init__.py

@@ -0,0 +1 @@
+"""Generated Rime protocol definitions."""

rime_api/schema/rime/text_to_speech.proto

@@ -0,0 +1,303 @@
+syntax = "proto3";
+
+package rime;
+
+service TextToSpeech {
+  rpc Synthesize(SynthesisRequest) returns (stream SynthesisResponseStream) {}
+  // Streaming text input: the client feeds text incrementally into a single
+  // continuous synthesis. The FIRST client message MUST set `header` (all
+  // synthesis params; its `text` field may carry the first chunk or be empty);
+  // subsequent messages set `text_chunk`. End-of-input is signalled by the
+  // client half-closing the request stream. Audio frames stream back as they
+  // are produced.
+  rpc SynthesizeStreaming(stream StreamingSynthesisRequest) returns (stream SynthesisResponseStream) {}
+  rpc NormalizeText(NormalizeTextRequest) returns (NormalizeTextResponse) {}
+  rpc GetSupportedLanguages(GetSupportedLanguagesRequest) returns (GetSupportedLanguagesResponse) {}
+  rpc GetSupportedSpeakers(GetSupportedSpeakersRequest) returns (GetSupportedSpeakersResponse) {}
+}
+
+message StreamingSynthesisRequest {
+  reserved 3;
+  reserved "flush";
+
+  oneof payload {
+    // FIRST message only: all synthesis parameters. Its `text` field may carry
+    // the first complete sentence or be left empty.
+    SynthesisRequest header = 1;
+
+    // Subsequent messages: one complete sentence to append to the live
+    // synthesis.
+    string text_chunk = 2;
+  }
+}
+
+message SynthesisRequest {
+  reserved 1;
+
+  // BCP-47 language tag, e.g. "en".
+  // Used to route the frontend pipeline and set backend language.
+  optional string language = 2;
+
+  // Speaker name, e.g. "luna".
+  optional string speaker = 3;
+
+  // Text to synthesize.
+  string text = 4;
+
+  optional AudioParameters audio_parameters = 5;
+
+  // Controls how input text is split before synthesis.
+  // Defaults to SPLIT_STRATEGY_SENTENCE when unset.
+  optional SplitStrategy split_strategy = 6;
+
+  optional ArcanaParameters arcana_parameters = 7;
+  optional CodaParameters coda_parameters = 8;
+  optional MistParameters mist_parameters = 9;
+}
+
+message SynthesisResponseStream {
+  bytes audio = 1;
+}
+
+message AudioParameters {
+  // Equivalent to the HTTP `Accept` header.
+  // Examples: "audio/wav", "audio/mpeg", "audio/ogg;codecs=opus", "audio/l16".
+  optional string audio_format = 1;
+
+  optional int32 sampling_rate = 2;
+  optional float time_scale_factor = 3;
+}
+
+message ArcanaParameters {
+  optional float repetition_penalty = 1;
+  optional float top_p = 2;
+  optional float temperature = 3;
+  optional int32 max_tokens = 4;
+  optional float presence_penalty = 5;
+  optional float frequency_penalty = 6;
+  optional int32 top_k = 7;
+  optional float min_p = 8;
+  optional int64 seed = 9;
+  optional int32 min_tokens = 13;
+  optional bool detokenize = 14;
+  optional bool skip_special_tokens = 15;
+  optional bool spaces_between_special_tokens = 16;
+}
+
+message CodaParameters {
+  reserved 1, 2, 3, 4, 5, 6, 7;
+  reserved "temperature", "top_k", "top_p", "repetition_penalty", "max_tokens", "min_tokens", "seed";
+
+  // Streaming text input (`SynthesizeStreaming` / WebSocket `text`) only:
+  // number of leading text tokens prefilled as a lookahead block so the first
+  // audio frames have content context. Higher values improve content
+  // robustness at the start of the utterance but delay the first audio until
+  // that many text tokens have arrived. Clamped to the tokens available when
+  // generation starts. Defaults to 0, which reproduces upstream Qwen3-TTS's
+  // exact streaming layout. Ignored for one-shot synthesis (which always sees
+  // the complete text up front).
+  optional int32 text_lookahead_tokens = 8;
+}
+
+message MistParameters {
+  optional bool pause_between_brackets = 1;
+  optional bool phonemize_between_brackets = 2;
+  repeated float inline_time_scale_factors = 3;
+  optional bool save_oovs = 4;
+}
+
+enum SplitStrategy {
+  SPLIT_STRATEGY_UNSPECIFIED = 0;
+  SPLIT_STRATEGY_SENTENCE = 1;
+  SPLIT_STRATEGY_NONE = 2;
+}
+
+message NormalizeTextRequest {
+  // Text to normalize.
+  string text = 1;
+
+  // BCP-47 language tag, e.g. "en".
+  optional string language = 2;
+}
+
+message NormalizeTextResponse {
+  // Deprecated: use normalized_sentences. Sentences are concatenated with no
+  // whitespace separator, so multi-sentence inputs come back glued together.
+  string normalized_text = 1;
+
+  // The normalized text, one entry per sentence emitted by the frontend
+  // pipeline. Each entry is already trimmed; join with a single space to
+  // reconstruct display text.
+  repeated string normalized_sentences = 2;
+}
+
+message GetSupportedLanguagesRequest {
+  // Empty for now, but used instead of google.protobuf.Empty for extensibility.
+}
+
+message GetSupportedLanguagesResponse {
+  // List of supported BCP-47 language tags.
+  repeated string languages = 1;
+}
+
+message GetSupportedSpeakersRequest {
+  optional string language = 1;
+}
+
+message GetSupportedSpeakersResponse {
+  // List of supported speaker names for the given language.
+  repeated string speakers = 1;
+}
+
+// ======================= WebSocket envelope =======================
+//
+// The engine serves a WebSocket synthesis interface at `GET /ws` on the HTTP
+// port. Every WebSocket message carries exactly one envelope message:
+//   - text frames:   canonical proto3 JSON encoding of the envelope
+//   - binary frames: protobuf binary encoding of the envelope
+// Client frames are decoded according to their frame type. The response
+// encoding is fixed at upgrade time by the WebSocket subprotocol: the first
+// recognized entry in the client's offer list wins — `rime.v1.binary`
+// selects binary frames, `rime.v1.json` selects JSON text frames — and the
+// server echoes the selected subprotocol. Offering no subprotocol selects
+// JSON. Offering only unrecognized values also selects JSON but echoes no
+// subprotocol, which spec-compliant clients (RFC 6455 section 4.1; all
+// browsers) treat as a failed handshake — offer one of the values above, or
+// none.
+//
+// A *context* is one continuous synthesis. It is either one-shot (opened by a
+// `start` whose `text` is the whole input) or streaming (opened by a `start`
+// with empty `text`, then fed by `text` chunks and closed by `end`); either
+// way the audio is a single continuous stream. Per context the server emits
+// `started`, then zero or more `audio` payloads, then exactly one terminal
+// event: `done`, `cancelled`, or `error`. Multiple contexts may be open
+// concurrently on one connection; events are correlated by `context_id`.
+//
+// Authentication: preferred is an `Authorization` header on the upgrade
+// request (rejected with HTTP 401 before the socket opens). Browsers cannot
+// set WebSocket headers; they send `config.authorization` (or
+// `config.license`) as the first message instead. Debug builds skip auth.
+
+// Client -> server. Exactly one message per WebSocket frame.
+message WebSocketRequest {
+  reserved 7;
+  reserved "flush";
+
+  // Client-chosen context identifier, at most 128 bytes. Empty selects the
+  // context named "default". An identifier may be reused after its context
+  // reaches a terminal event.
+  string context_id = 1;
+
+  oneof payload {
+    // Connection-level configuration. At most one, and only before the first
+    // `start`. Not required in debug mode or when the upgrade request
+    // carried an `Authorization` header.
+    WebSocketConfig config = 2;
+
+    // Opens the context with the full synthesis parameters. A non-empty
+    // `text` is the complete input for one-shot synthesis: audio streams
+    // and ends with `done`, no `end` required. An empty `text` opens a
+    // streaming context that stays open for `text` messages and finalizes
+    // on `end`.
+    SynthesisRequest start = 3;
+
+    // Appends a chunk of input text to an open streaming context (one opened
+    // with an empty `start.text`). The engine meters, segments, and
+    // synthesizes it into the same continuous audio as it arrives. Rejected
+    // with kind "invalid_input" if the context is not open for input (no
+    // `start`, or already `end`ed / one-shot).
+    string text = 4;
+
+    // Declares end of input for a streaming context. Remaining audio is
+    // delivered, followed by `done`. A no-op for a one-shot context. The
+    // connection stays open for further contexts.
+    WebSocketEnd end = 5;
+
+    // Aborts the context immediately, discarding in-flight synthesis.
+    // Acknowledged with `cancelled`; idempotent (cancelling an unknown or
+    // finished context is not an error).
+    WebSocketCancel cancel = 6;
+  }
+}
+
+message WebSocketConfig {
+  // Mirrors the HTTP `Authorization` header, e.g. "Api-Key <key>".
+  // Rejected if the upgrade request already carried an Authorization header.
+  optional string authorization = 1;
+
+  // License JSON for on-prem deployments; mirrors the `x-rime-license`
+  // gRPC metadata / the `license` field of the HTTP API.
+  optional string license = 2;
+
+  // Defaults merged (field-wise, shallow) under every subsequent `start`.
+  // Its `text` field is ignored.
+  optional SynthesisRequest defaults = 3;
+}
+
+message WebSocketEnd {}
+
+message WebSocketCancel {}
+
+// Server -> client. Exactly one message per WebSocket frame.
+message WebSocketResponse {
+  // Context the payload applies to. Empty for connection-scoped payloads
+  // (`ready` and connection-level `error`s).
+  string context_id = 1;
+
+  oneof payload {
+    // Sent once per connection when the engine is ready to synthesize
+    // (pipelines loaded and serving). Gate `start` on this event.
+    WebSocketReady ready = 2;
+
+    // The context was accepted; precedes any of its audio.
+    WebSocketStarted started = 3;
+
+    // A chunk of encoded audio, in the format requested at `start`.
+    bytes audio = 4;
+
+    // Terminal: all audio for the context has been delivered.
+    WebSocketDone done = 5;
+
+    // Terminal: the context was aborted by `cancel`.
+    WebSocketCancelled cancelled = 6;
+
+    // Terminal for the context it names. Errors with an empty `context_id`
+    // are connection-scoped and leave open contexts running; the server
+    // closes the connection only when the failure is unrecoverable
+    // (undecodable frames, failed authentication).
+    WebSocketError error = 7;
+  }
+}
+
+message WebSocketReady {
+  // Protocol version. Currently 1.
+  uint32 protocol = 1;
+
+  // Supported BCP-47 language tags (mirrors GetSupportedLanguages).
+  repeated string languages = 2;
+
+  optional string default_language = 3;
+}
+
+message WebSocketStarted {
+  // Engine request id for this context; correlates with engine logs and
+  // matches the `x-request-id` gRPC/HTTP metadata.
+  string request_id = 1;
+}
+
+message WebSocketDone {}
+
+message WebSocketCancelled {}
+
+message WebSocketError {
+  // Stable machine-readable kind; same values as the HTTP error body
+  // (e.g. "invalid_input", "unauthenticated", "unavailable", "internal",
+  // "unimplemented").
+  string kind = 1;
+
+  // Human-readable description.
+  string message = 2;
+
+  // Engine request id, when the error occurred inside a synthesis request.
+  optional string request_id = 3;
+}