introvoyz045's picture
Migrated from GitHub
9410704 verified
Raw History Blame Contribute Delete
6.2 kB
"""SpeechEngineServer — standalone WebSocket server for Speech Engine."""
import asyncio
import http
import os
import typing
import warnings
from .session import SpeechEngineSession, _make_log, _wire_handlers
from .types import WebSocketLike
class SpeechEngineServer:
"""Standalone WebSocket server that produces :class:`SpeechEngineSession`
instances for each incoming connection from the ElevenLabs Speech Engine
API.
Every incoming connection is verified against the ElevenLabs API using
the configured API key before being accepted, unless ``disable_auth`` is
set to ``True``.
Example::
server = SpeechEngineServer(
port=3001,
api_key="sk_...",
debug=True,
on_transcript=handle_transcript,
)
await server.serve()
"""
def __init__(
self,
*,
port: int = 3001,
path: typing.Optional[str] = None,
api_key: typing.Optional[str] = None,
debug: bool = False,
disable_auth: bool = False,
**handlers: typing.Any,
) -> None:
"""Initialize a Speech Engine server.
:param disable_auth: If ``True``, skip verification of the
``X-Elevenlabs-Speech-Engine-Authorization`` JWT on incoming
connections. **Insecure** — only enable this if the server is
protected by an IP allowlist scoped to ElevenLabs' egress
ranges. Without one, anyone on the internet can open a session
and consume your compute and downstream LLM quota.
"""
self._port = port
self._path = path
self._api_key = api_key
self._debug = debug
self._disable_auth = disable_auth
self._handlers = handlers
self._stop_event = None # type: typing.Optional[asyncio.Event]
self._server = None # type: typing.Any
self._log = _make_log(debug)
def handle_connection(self, ws: WebSocketLike) -> SpeechEngineSession:
"""Wrap *ws* in a :class:`SpeechEngineSession` with the server's
handlers wired up.
Use this when you manage your own WebSocket server and want to wrap
individual connections. The returned session's :meth:`run` must
still be awaited by the caller.
"""
self._log("creating new session")
session = SpeechEngineSession(ws, debug=self._debug)
_wire_handlers(session, self._handlers)
return session
async def serve(self) -> None:
"""Start the WebSocket server. Blocks until :meth:`stop` is called."""
from .resource import verify_speech_engine_jwt # noqa: E402
# Use the new asyncio API explicitly: `websockets.serve` was still
# the legacy server on websockets 13.x and only became the asyncio
# one in 14.0. The process_request callback below relies on the
# asyncio signature (connection, request) and connection.respond().
from websockets.asyncio.server import serve as _ws_serve # noqa: E402
api_key = self._api_key or os.environ.get("ELEVENLABS_API_KEY")
if not api_key and not self._disable_auth:
raise RuntimeError(
"SpeechEngineServer requires an API key to verify incoming "
"connections. Pass api_key= or set the ELEVENLABS_API_KEY "
"environment variable. To run without authentication, pass "
"disable_auth=True — but only behind an IP allowlist."
)
if self._disable_auth:
warnings.warn(
"SpeechEngineServer: authentication is disabled — incoming "
"connections will NOT be verified. Make sure the server is "
"protected by either IP allowlist restricting traffic to "
"ElevenLabs or custom header values.",
UserWarning,
stacklevel=2,
)
self._stop_event = asyncio.Event()
def _process_request(
connection: typing.Any, request: typing.Any
) -> typing.Any:
if self._path is not None and request.path != self._path:
self._log(
"rejected connection — path mismatch: "
"expected %s, got %s",
self._path,
request.path,
)
return connection.respond(
http.HTTPStatus.NOT_FOUND, "not found\n"
)
if self._disable_auth:
return None
header_value = request.headers.get(
"x-elevenlabs-speech-engine-authorization"
)
if not header_value:
self._log(
"rejected connection — missing "
"X-Elevenlabs-Speech-Engine-Authorization header"
)
return connection.respond(
http.HTTPStatus.UNAUTHORIZED,
"missing authorization header\n",
)
try:
verify_speech_engine_jwt(header_value, typing.cast(str, api_key))
except ValueError as e:
self._log("rejected connection — %s", e)
return connection.respond(
http.HTTPStatus.UNAUTHORIZED,
"authorization failed\n",
)
return None
async def _handler(websocket: typing.Any) -> None:
self._log("verified connection, accepting WebSocket")
session = self.handle_connection(websocket)
await session.run()
self._server = await _ws_serve(
_handler,
"",
self._port,
process_request=_process_request,
)
self._log("speech engine server listening on port %d", self._port)
try:
await self._stop_event.wait()
finally:
self._server.close()
await self._server.wait_closed()
async def stop(self) -> None:
"""Signal the server to shut down gracefully."""
if self._stop_event is not None:
self._stop_event.set()