Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Teachtaireachtaí WebSocket: téacs agus fuaime

Ceacht 10 as 14 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Prótacal teachtaireachta TTS
  2. Teachtaireachtaí ón gcliant go dtí an freastalaí
  3. Teachtaireachtaí ón bhfreastalaí go dtí an cliant
  4. An sruth cumarsáide iomlán
  5. Cur i bhfeidhm iomlán i bPython
  6. Cur i bhfeidhm i JavaScript (Node.js)
  7. Ildeiltí a láimhseáil
  8. Príomhphointí

Nuashonraithe an 3 Samhain, 2026, bunaithe ar leathanach Text to Speech de chuid xAI: deiltí de suas le 60,000 carachtar, cealú (text.clear, audio.clear), agus an tábla fuaimniúcháin (session.update, session.updated). Foinse: Text to Speech.

Prótacal teachtaireachta TTS

Nuair a bheidh an nasc WebSocket oscailte, déantar cumarsáid trí theachtaireachtaí JSON a mhalartú. Seolann tú téacs, agus freagraíonn an freastalaí le fuaime atá ionchódaithe i mbonn64. Tá sé ríthábhachtach an prótacal seo a thuiscint chun sruthú TTS a chur i bhfeidhm i gceart.

Teachtaireachtaí ón gcliant go dtí an freastalaí

Seolann d’fheidhmchlár ceithre chineál teachtaireachta chuig an bhfreastalaí: text.delta agus text.done don téacs, text.clear chun cealú, agus session.update chun cumraíocht a dhéanamh.

text.delta: píosa téacs a sheoladh

Seolann an teachtaireacht text.delta blúire téacs le tiontú. Is féidir leat an téacs a sheoladh i bpíosaí leantacha:

{"type": "text.delta", "delta": "Hello, and welcome to "}
{"type": "text.delta", "delta": "our presentation on speech synthesis."}

Is féidir le gach deilt suas le 60,000 carachtar a bheith ann, agus níl aon teorainn leis an téacs iomlán. Tosaíonn an freastalaí ag giniúint fuaime chomh luath agus a bhíonn comhthéacs dóthainn aige chun fuaimniú nádúrtha a tháirgeadh.

text.done: deireadh an téacs a chur in iúl

Cuirtear in iúl don fhreastalaí leis an teachtaireacht text.done go bhfuil tú tar éis an téacs a sheoladh don seicheamh seo:

{"type": "text.done"}

Nuair a fhaigheann sé an teachtaireacht seo, críochnaíonn an freastalaí an fhuaim a ghiniúint agus seolann sé teachtaireacht audio.done. Ansin, is féidir leat tosú ag seoladh deiltí nua do sheicheamh nua.

text.clear: an seicheamh reatha a chealú

Cealaíonn text.clear an seicheamh reatha: stopann an freastalaí ag giniúint fuaime, caitear an méid a bhí sa chuimhne, agus freagraítear le audio.clear. Tá an nasc réidh láithreach don chéad seicheamh eile, gan aon lámhchruthú WebSocket nua; measann xAI go sábhálann sé seo thart ar 600 ms do chlient i gcéin. Is é seo an mheicníocht idirbhriseadh (“barge-in”) don uair a chuireann an t-úsáideoir isteach air.

{"type": "text.clear"}

session.update: fuaimniú a shocrú

Suiteálann session.update, nó athsholáthraíonn sé, tábla replace an naisc: déantar gach frása a fhaightear sa téacs a mhalartú lena fhoirm labhartha sula ndéantar sintéis, gan an téacs a sheolann tú ná líon na gcarachtar a ghearrtar ort a athrú. Seol é roimh an chéad text.delta ionas go gclúdaíonn sé an nasc ar fad; ní bhaineann nuashonrú a fhaightear i lár seichimh ach leis an seicheamh seo chugainn.

{"type": "session.update", "replace": {"kubectl": "kube cuttle"}}

Teachtaireachtaí ón bhfreastalaí go dtí an cliant

Freagraíonn an freastalaí le cúig chineál teachtaireachta: audio.delta, audio.done, agus error, atá mionsonraithe thíos, chomh maith le audio.clear, a dheimhníonn cealú, agus session.updated, a thugann ar ais an tábla replace atá i bhfeidhm.

audio.delta: píosa fuaime

Tá blúire fuaime ionchódaithe i mbonn64 sa teachtaireacht audio.delta:

{
  "type": "audio.delta",
  "delta": "SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU4Ljc2..."
}

Is píosa bailí fuaime gach deilt is féidir leat a dhíchódú agus a sheinm láithreach. Tagann na deiltí de réir mar a théann an ghiniúint ar aghaidh.

audio.done: críochnaithe ag an nginiúint

Cuireann an teachtaireacht audio.done in iúl go bhfuil an fhuaim uile don seicheamh téacs a sheol tú ginte:

{
  "type": "audio.done",
  "trace_id": "550e8400-e29b-41d4-a716-446655440000"
}

Is aitheantóir uathúil é an trace_id don seicheamh, atá úsáideach le haghaidh dífhabhtaithe agus rianaithe.

error: tharla earráid

Má théann rud éigin mícheart, seolann an freastalaí teachtaireacht earráide:

{
  "type": "error",
  "message": "Invalid text encoding"
}

An sruth cumarsáide iomlán

Seo mar a imíonn seisiún tipiciúil:

Client                          Server
  |                                |
  |-- text.delta ("Hello, ") ----->|
  |-- text.delta ("how are ") ---->|
  |-- text.delta ("you?") -------->|
  |<-- audio.delta (chunk 1) -----|
  |<-- audio.delta (chunk 2) -----|
  |-- text.done ----------------->|
  |<-- audio.delta (chunk 3) -----|
  |<-- audio.done ----------------|

Is féidir leis an bhfreastalaí tosú ag seoladh teachtaireachtaí audio.delta sula mbeidh text.done seolta agat fiú. Sin é bunbhrí an tsruthaithe: tosaíonn an ghiniúint chomh luath agus is féidir.

Cur i bhfeidhm iomlán i bPython

import asyncio
import websockets
import json
import base64

async def stream_tts(api_key, text, voice="eve", language="en"):
    uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}&codec=mp3"
    headers = {"Authorization": f"Bearer {api_key}"}

    audio_chunks = []

    async with websockets.connect(uri, additional_headers=headers) as ws:
        # Send the text in pieces of 2,000 characters
        chunk_size = 2000
        for i in range(0, len(text), chunk_size):
            chunk = text[i:i + chunk_size]
            await ws.send(json.dumps({
                "type": "text.delta",
                "delta": chunk
            }))

        # Signal the end of the text
        await ws.send(json.dumps({"type": "text.done"}))

        # Receive the audio pieces
        async for message in ws:
            data = json.loads(message)

            if data["type"] == "audio.delta":
                audio_bytes = base64.b64decode(data["delta"])
                audio_chunks.append(audio_bytes)

            elif data["type"] == "audio.done":
                print(f"Generation finished (trace: {data['trace_id']})")
                break

            elif data["type"] == "error":
                raise Exception(f"TTS error: {data['message']}")

    # Assemble the complete audio
    return b"".join(audio_chunks)

Cur i bhfeidhm i JavaScript (Node.js)

const WebSocket = require("ws");

function streamTTS(apiKey, text, voice = "eve", language = "en") {
  return new Promise((resolve, reject) => {
    const ws = new WebSocket(
      `wss://api.x.ai/v1/tts?language=${language}&voice=${voice}&codec=mp3`,
      { headers: { Authorization: `Bearer ${apiKey}` } }
    );

    const audioChunks = [];

    ws.on("open", () => {
      // Send the text
      ws.send(JSON.stringify({ type: "text.delta", delta: text }));
      ws.send(JSON.stringify({ type: "text.done" }));
    });

    ws.on("message", (raw) => {
      const data = JSON.parse(raw);

      if (data.type === "audio.delta") {
        audioChunks.push(Buffer.from(data.delta, "base64"));
      } else if (data.type === "audio.done") {
        ws.close();
        resolve(Buffer.concat(audioChunks));
      } else if (data.type === "error") {
        ws.close();
        reject(new Error(data.message));
      }
    });

    ws.on("error", reject);
  });
}

Ildeiltí a láimhseáil

Le haghaidh téacs a ghintear go forásach (aschur LLM, mar shampla), seol gach token díreach chuig WebSocket TTS:

async def llm_to_speech(ws_tts, llm_stream):
    async for token in llm_stream:
        await ws_tts.send(json.dumps({
            "type": "text.delta",
            "delta": token
        }))

    await ws_tts.send(json.dumps({"type": "text.done"}))

Tugann an ailtireacht “LLM sruthaithe isteach i dTTS sruthaithe” seo an moill is ísle is féidir: cloiseann an t-úsáideoir an freagra agus an LLM fós á ghiniúint.

Príomhphointí

  • Ceithre theachtaireacht cliant: text.delta (téacs a sheoladh), text.done (deireadh an téacs), text.clear (cealú), agus session.update (tábla replace)
  • Cúig theachtaireacht freastalaí: audio.delta (píosa fuaime), audio.done (deireadh), audio.clear (cealú deimhnithe), session.updated, agus error
  • Tá an fhuaim ionchódaithe i mbonn64 i dteachtaireachtaí audio.delta
  • Tosaíonn an freastalaí ag giniúint sula bhfaigheann sé text.done
  • Tá gach deilt téacs teoranta do 60,000 carachtar
  • Soláthraíonn slabhrú LLM sruthaithe isteach i dTTS sruthaithe an mhoill is ísle