Connect with WebSocket

curl -sS -A "relay-docs/1.0" https://api.staging.relayapp.im/v1/webhook-subscriptions \
  -H "Authorization: Bearer $RELAY_AGENT_TOKEN"

const { subscriptions } = await relay.webhookSubscriptions.list();

if (subscriptions.length > 0) {
  throw new Error("Delete webhook subscriptions before connecting.");
}

# Inspect the upgrade response; use a WebSocket client for ongoing frames.
curl -sS --http1.1 -i --no-buffer \
  'https://api.staging.relayapp.im/v1/websocket' \
  -H "Authorization: Bearer $RELAY_AGENT_TOKEN" \
  -H 'Connection: Upgrade' -H 'Upgrade: websocket' \
  -H 'Sec-WebSocket-Version: 13' \
  -H "Sec-WebSocket-Key: $(openssl rand -base64 16)"

import Relay from "@relaymessenger/sdk";

const relay = new Relay({
  apiKey: process.env.RELAY_AGENT_TOKEN!,
  baseURL: "https://api.staging.relayapp.im",
});

const stop = new AbortController();
process.once("SIGINT", () => stop.abort());
process.once("SIGTERM", () => stop.abort());

await relay.websocket.run({
  signal: stop.signal,
  onReady(frame) {
    console.log(`Connected. Acknowledged through ${frame.acked_through}.`);
  },
  // The SDK acknowledges each event after this callback resolves.
  async onEvent(event) {
    if (event.event_type !== "message.received") return;
    const text = event.data.parts
      .flatMap((part) => (part.type === "text" ? [part.value] : []))
      .join(" ");
    console.log(`@${event.data.from_handle.handle}: ${text}`);
    await relay.chats.messages.send(event.data.chat_id, {
      message: {
        parts: [{ type: "text", value: `You said: ${text}` }],
        // The same key on a redelivery, so a retried event never replies twice.
        idempotency_key: `reply-${event.event_id}`,
      },
    });
  },
  // This agent keeps no local state, so a FULL sync has nothing to rebuild.
  async onFullSync() {},
  onError(error) {
    console.error(error);
  },
});

from __future__ import annotations

import asyncio
import os
from typing import Any, Dict

from relaymessenger import Relay, WebSocketEventContext, WebSocketFullSyncContext


async def main() -> None:
    relay = Relay(os.environ["RELAY_AGENT_TOKEN"], base_url="https://api.staging.relayapp.im")

    async def on_event(event: Dict[str, Any], context: WebSocketEventContext) -> None:
        if event["event_type"] != "message.received":
            return
        message = event["data"]
        text = "\n".join(part["value"] for part in message["parts"] if part.get("type") == "text")
        if not text:
            return
        await relay.chats.messages.send(
            message["chat_id"],
            {
                "message": {
                    "parts": [{"type": "text", "value": text}],
                    "reply_to": {"message_id": message["id"]},
                    # The same event can arrive twice after a reconnect; the
                    # same key makes Relay send the reply only once.
                    "idempotency_key": f"echo-{event['event_id']}",
                }
            },
        )
        print(f"echoed {text!r} in chat {message['chat']['id']}", flush=True)

    def on_full_sync(context: WebSocketFullSyncContext) -> None:
        # This agent keeps no local state, so it has nothing to rebuild.
        return None

    await relay.websocket.run(
        on_event=on_event,
        on_full_sync=on_full_sync,
        on_connection_state=lambda state: print(f"websocket {state}", flush=True),
        on_error=lambda error: print(f"websocket error: {error}", flush=True),
    )


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        pass

GET /v1/websocket HTTP/1.1
Host: api.staging.relayapp.im
Authorization: Bearer $RELAY_AGENT_TOKEN
Connection: Upgrade
Upgrade: websocket
Sec-WebSocket-Version: 13
Sec-WebSocket-Key: <generated by your WebSocket client>