wss://{host}/ete/v1/{appid}
    ?model=<audio-og-realtime-2.1|audio-og-realtime-2.1mini|audio-s-realtime-3.0>
    &secretId=<TC3 SecretId>
    &signature=<TC3-HMAC-SHA256 hex>
    &timeStamp=<unix seconds>
    &expired=<unix seconds>
    &nonce=<random integer>
    &timeoutSec=<session idle timeout in seconds>

wss://mps.tencentcloud.com/ete/v1/1301234567
    ?model=audio-s-realtime-3.0
    &secretId=AKIDzxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
    &signature=8f2c...4b3a
    &timeStamp=1735012345
    &expired=1735015945
    &nonce=8391023472
    &timeoutSec=60
    &resId=order_20260826_0001

Step 1: Sort and URL-encode the parameters to construct a canonicalized query string.
  keys = sort(param keys involved in signing)         // All query parameters except signature
  canonicalQueryString = keys.map(k => k + '=' + urlEncode(params[k])).join('&')

Step 2: Construct a canonicalized request.
  canonicalRequest =
      "post"                                             + "\\n"
    + "/ete/v1/{appid}"                                  + "\\n"
    + canonicalQueryString                               + "\\n"
    + "content-type:application/json; charset=utf-8"     + "\\n"
    + "host:" + host                                     + "\\n"
    + ""                                                 + "\\n"
    + "content-type;host"                                + "\\n"

Step 3: Construct the string to be signed.
  date              = YYYY-MM-DD of UTC(timeStamp)
  credentialScope   = date + "/mps/tc3_request"
  hashedRequest     = hex( SHA-256( canonicalRequest ) )
  stringToSign      = "TC3-HMAC-SHA256"     + "\\n"
                    + timeStamp             + "\\n"
                    + credentialScope       + "\\n"
                    + hashedRequest

Step 4: Calculate the derived signing key.
  kDate    = HMAC-SHA256( date,          "TC3" + secretKey )
  kService = HMAC-SHA256( "mps",         kDate )
  kSigning = HMAC-SHA256( "tc3_request", kService )

Step 5: Calculate the final signature.
  signature = hex( HMAC-SHA256( stringToSign, kSigning ) )      // Lowercase hex

async function sign(cfg) {
  const now = Math.floor(Date.now() / 1000);
  const expired = now + 3600;
  const params = {
    // All query parameters except signature must be included in the signature.
    model:      cfg.model,           // Optional. If not passed, it is not added to params.
    timeStamp:  String(now),
    expired:    String(expired),
    nonce:      String(Math.floor(Math.random() * 1e10)),
    secretId:   cfg.secretId,
    timeoutSec: String(cfg.timeoutSec || 30),
    // If resId is used, include it and add it to the signature as well:
    // resId: cfg.resId,
  };

  const path = `/ete/v1/${cfg.appid}`;
  const keys = Object.keys(params).sort();
  const canonicalQueryString = keys
    .map((k) => `${k}=${encodeURIComponent(params[k])}`).join('&');

  const canonicalRequest = [
    'post', path, canonicalQueryString,
    'content-type:application/json; charset=utf-8',
    `host:${cfg.host}`, '', 'content-type;host', '',
  ].join('\\n');

  const hashed = await sha256Hex(canonicalRequest);
  const date   = new Date(now * 1000).toISOString().split('T')[0];
  const scope  = `${date}/mps/tc3_request`;
  const stringToSign = ['TC3-HMAC-SHA256', String(now), scope, hashed].join('\\n');

  const kDate    = await hmacSha256(date, 'TC3' + cfg.secretKey);
  const kService = await hmacSha256('mps', kDate);
  const kSigning = await hmacSha256('tc3_request', kService);
  const signature = bufToHex(await hmacSha256(stringToSign, kSigning));

  const q = new URLSearchParams(); keys.forEach((k) => q.append(k, params[k]));
  q.append('signature', signature);
  return `wss://${cfg.host}${path}?${q.toString()}`;
}

func sign(host, appID, secretID, secretKey, model string, timeoutSec int) string {
    now := time.Now().Unix()
    expired := now + 3600
    params := map[string]string{
        "timeStamp":  strconv.FormatInt(now, 10),
        "expired":    strconv.FormatInt(expired, 10),
        "nonce":      strconv.Itoa(rand.Intn(1e9)),
        "secretId":   secretID,
        "timeoutSec": strconv.Itoa(timeoutSec),
    }
    if model != "" {
        params["model"] = model
    }
    keys := make([]string, 0, len(params))
    for k := range params { keys = append(keys, k) }
    sort.Strings(keys)
    parts := make([]string, 0, len(keys))
    for _, k := range keys {
        parts = append(parts, k+"="+url.QueryEscape(params[k]))
    }
    cqs := strings.Join(parts, "&")

    path := "/ete/v1/" + appID
    canonical := strings.Join([]string{
        "post", path, cqs,
        "content-type:application/json; charset=utf-8",
        "host:" + host, "", "content-type;host", "",
    }, "\\n")

    hashed := sha256Hex([]byte(canonical))
    date   := time.Unix(now, 0).UTC().Format("2006-01-02")
    scope  := date + "/mps/tc3_request"
    stringToSign := strings.Join([]string{
        "TC3-HMAC-SHA256", strconv.FormatInt(now, 10), scope, hashed,
    }, "\\n")

    kDate    := hmac256([]byte(date), []byte("TC3"+secretKey))
    kService := hmac256([]byte("mps"), kDate)
    kSigning := hmac256([]byte("tc3_request"), kService)
    signature := hex.EncodeToString(hmac256([]byte(stringToSign), kSigning))

    q := url.Values{}
    for k, v := range params { q.Set(k, v) }
    q.Set("signature", signature)
    return "wss://" + host + path + "?" + q.Encode()
}

func sha256Hex(b []byte) string       { h := sha256.Sum256(b); return hex.EncodeToString(h[:]) }
func hmac256(msg, key []byte) []byte  { m := hmac.New(sha256.New, key); m.Write(msg); return m.Sum(nil) }

{
  "type": "session.update",
  "session": {
    "instructions": "You are a professional AI assistant. Speak concisely and in a friendly manner.",
    "audio": {
      "input":  {
        "format": { "type": "audio/pcm", "rate": 16000 },
        "transcription": { "language": "zh" }
      },
      "output": {
        "format":   { "type": "audio/pcm", "rate": 24000 },
        "voice":    "xxxxxx",
        "speed":    100,
        "loudness": 100
      }
    },
    "tools": [
      {
        "type": "function",
        "name": "get_current_time",
        "description": "Obtain the current system time",
        "parameters": { "type": "object", "properties": {}, "required": [] }
      }
    ]
  }
}

{
  "type": "input_audio_buffer.append",
  "audio": "<base64-encoded audio chunk>"
}

{ "type": "input_audio_buffer.commit" }
{ "type": "input_audio_buffer.clear" }

{
  "type": "response.create",
  "response": {
    "instructions": "Hello, I am your AI assistant."   // Optional
  }
}
{ "type": "response.cancel" }

{
  "type": "conversation.item.create",
  "item": {
    "type": "message",
    "role": "user",
    "content": [{ "type": "input_text", "text": "Check today's weather in Shenzhen for me" }]
  }
}

{
  "type": "conversation.item.create",
  "item": {
    "type": "function_call_output",
    "call_id": "call_abc123",
    "output": "2026-08-26 09:30:00"
  }
}

{ "type": "conversation.item.retrieve", "item_id": "item_xxx" }
{ "type": "conversation.item.delete",   "item_id": "item_xxx" }
{ "type": "conversation.item.truncate", "item_id": "item_xxx",
  "content_index": 0, "audio_end_ms": 1500 }

{ "type": "output_audio_buffer.clear" }

{
  "type": "session.updated",
  "event_id": "evt_xxxxxxxx",
  "session": {
    "id": "sess_xxxxxxxx",
    "type": "realtime",
    "model": "audio-s-realtime-3.0",
    "audio":  { "input": {...}, "output": {...} },
    "voice":  "xxxxxx",
    "instructions": "..."
  }
}

{
  "type": "conversation.item.input_audio_transcription.delta",
  "event_id": "evt_xxx", "item_id": "item_xxx",
  "content_index": 0, "delta": "Shenzhen"
}
{
  "type": "conversation.item.input_audio_transcription.completed",
  "event_id": "evt_xxx", "item_id": "item_xxx",
  "content_index": 0, "transcript": "How is the weather in Shenzhen today",
  "usage": { "type": "duration", "seconds": 2 }
}

{
  "type": "response.output_audio.delta",
  "event_id": "evt_xxx",
  "response_id": "resp_xxx",
  "item_id": "item_xxx",
  "output_index": 0, "content_index": 0,
  "delta": "<base64 pcm16 / opus chunk>"
}
{
  "type": "response.output_audio_transcript.delta",
  "event_id": "evt_xxx",
  "response_id": "resp_xxx",
  "item_id": "item_xxx",
  "delta": "Shenzhen"
}