moss-voice-server 0.1.0__tar.gz

moss_voice_server-0.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 InferEdge Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

moss_voice_server-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: moss-voice-server
+Version: 0.1.0
+Summary: Backend token generation for Moss voice agents. Mint LiveKit JWTs server-side so clients never see API secrets.
+Author-email: Moss Team <support@moss.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/InferEdge-Inc/moss
+Project-URL: Repository, https://github.com/InferEdge-Inc/moss
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Requires-Dist: livekit-api<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Dynamic: license-file
+
+# moss-voice-server
+
+Backend token generation for Moss voice agents. Mints short-lived LiveKit
+participant JWTs server-side so your API secrets never reach the browser.
+
+A Node.js equivalent is available as [`@moss-tools/voice-server`](https://www.npmjs.com/package/@moss-tools/voice-server) on npm.
+
+## Why
+
+Browser clients shouldn't hold LiveKit API secrets. The recommended flow:
+
+1. Your frontend asks **your backend** for a join token.
+2. Your backend calls `MossVoiceServer.create_participant_token(...)` and
+   returns the signed JWT + server URL.
+3. The frontend connects to LiveKit with that token.
+
+This package handles steps 1–2 from Python (FastAPI, Flask, Django, etc.).
+
+## Install
+
+```bash
+pip install moss-voice-server
+```
+
+Python 3.10+.
+
+## Usage — async (FastAPI, asyncio)
+
+```python
+import os
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from moss_voice_server import MossVoiceServer, ParticipantInfo
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    app.state.voice_server = await MossVoiceServer.create(
+        project_id=os.environ["MOSS_PROJECT_ID"],
+        project_key=os.environ["MOSS_PROJECT_KEY"],
+        voice_agent_id=os.environ["MOSS_VOICE_AGENT_ID"],
+    )
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.post("/voice/token")
+async def issue_token(user_id: str, room: str) -> dict[str, str]:
+    server: MossVoiceServer = app.state.voice_server
+    token = server.create_participant_token(
+        ParticipantInfo(identity=user_id),
+        room_name=room,
+    )
+    return {"token": token, "url": server.get_server_url()}
+```
+
+## Usage — sync (Flask, Django)
+
+```python
+import os
+from moss_voice_server import MossVoiceServerSync, ParticipantInfo
+
+voice_server = MossVoiceServerSync.create(
+    project_id=os.environ["MOSS_PROJECT_ID"],
+    project_key=os.environ["MOSS_PROJECT_KEY"],
+    voice_agent_id=os.environ["MOSS_VOICE_AGENT_ID"],
+)
+
+token = voice_server.create_participant_token(
+    ParticipantInfo(identity="user_123", name="Jane"),
+    room_name="support_456",
+)
+```
+
+## API
+
+### `MossVoiceServer.create(project_id, project_key, voice_agent_id, api_url=...)`
+
+Async factory. Fetches credentials from the Moss API and returns an initialized
+instance. Raises ``RuntimeError`` on network failure or invalid credentials.
+
+### `MossVoiceServerSync.create(...)`
+
+Same arguments, sync. Use in Flask/Django.
+
+### `server.create_participant_token(participant, room_name, agent_name=None) -> str`
+
+Mint a signed JWT for ``participant`` to join ``room_name``. Token TTL is
+15 minutes. Pass ``agent_name`` only when you need to override LiveKit's
+default dispatch rules.
+
+### `server.get_server_url() -> str`
+
+LiveKit WebSocket URL the client should connect to.
+
+### `server.get_agent_name() -> str`
+
+Configured voice agent name.
+
+### `ParticipantInfo(identity, name=None, metadata=None, attributes=None)`
+
+Identity payload for the token. ``identity`` is required and must be unique
+per user.
+
+## Environment variables
+
+The library accepts credentials as arguments. By convention, applications
+typically read them from these env vars:
+
+```bash
+MOSS_PROJECT_ID=<your project id>
+MOSS_PROJECT_KEY=<your project key>
+MOSS_VOICE_AGENT_ID=<your voice agent id>
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

moss_voice_server-0.1.0/README.md

@@ -0,0 +1,127 @@
+# moss-voice-server
+
+Backend token generation for Moss voice agents. Mints short-lived LiveKit
+participant JWTs server-side so your API secrets never reach the browser.
+
+A Node.js equivalent is available as [`@moss-tools/voice-server`](https://www.npmjs.com/package/@moss-tools/voice-server) on npm.
+
+## Why
+
+Browser clients shouldn't hold LiveKit API secrets. The recommended flow:
+
+1. Your frontend asks **your backend** for a join token.
+2. Your backend calls `MossVoiceServer.create_participant_token(...)` and
+   returns the signed JWT + server URL.
+3. The frontend connects to LiveKit with that token.
+
+This package handles steps 1–2 from Python (FastAPI, Flask, Django, etc.).
+
+## Install
+
+```bash
+pip install moss-voice-server
+```
+
+Python 3.10+.
+
+## Usage — async (FastAPI, asyncio)
+
+```python
+import os
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from moss_voice_server import MossVoiceServer, ParticipantInfo
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    app.state.voice_server = await MossVoiceServer.create(
+        project_id=os.environ["MOSS_PROJECT_ID"],
+        project_key=os.environ["MOSS_PROJECT_KEY"],
+        voice_agent_id=os.environ["MOSS_VOICE_AGENT_ID"],
+    )
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.post("/voice/token")
+async def issue_token(user_id: str, room: str) -> dict[str, str]:
+    server: MossVoiceServer = app.state.voice_server
+    token = server.create_participant_token(
+        ParticipantInfo(identity=user_id),
+        room_name=room,
+    )
+    return {"token": token, "url": server.get_server_url()}
+```
+
+## Usage — sync (Flask, Django)
+
+```python
+import os
+from moss_voice_server import MossVoiceServerSync, ParticipantInfo
+
+voice_server = MossVoiceServerSync.create(
+    project_id=os.environ["MOSS_PROJECT_ID"],
+    project_key=os.environ["MOSS_PROJECT_KEY"],
+    voice_agent_id=os.environ["MOSS_VOICE_AGENT_ID"],
+)
+
+token = voice_server.create_participant_token(
+    ParticipantInfo(identity="user_123", name="Jane"),
+    room_name="support_456",
+)
+```
+
+## API
+
+### `MossVoiceServer.create(project_id, project_key, voice_agent_id, api_url=...)`
+
+Async factory. Fetches credentials from the Moss API and returns an initialized
+instance. Raises ``RuntimeError`` on network failure or invalid credentials.
+
+### `MossVoiceServerSync.create(...)`
+
+Same arguments, sync. Use in Flask/Django.
+
+### `server.create_participant_token(participant, room_name, agent_name=None) -> str`
+
+Mint a signed JWT for ``participant`` to join ``room_name``. Token TTL is
+15 minutes. Pass ``agent_name`` only when you need to override LiveKit's
+default dispatch rules.
+
+### `server.get_server_url() -> str`
+
+LiveKit WebSocket URL the client should connect to.
+
+### `server.get_agent_name() -> str`
+
+Configured voice agent name.
+
+### `ParticipantInfo(identity, name=None, metadata=None, attributes=None)`
+
+Identity payload for the token. ``identity`` is required and must be unique
+per user.
+
+## Environment variables
+
+The library accepts credentials as arguments. By convention, applications
+typically read them from these env vars:
+
+```bash
+MOSS_PROJECT_ID=<your project id>
+MOSS_PROJECT_KEY=<your project key>
+MOSS_VOICE_AGENT_ID=<your voice agent id>
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

moss_voice_server-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "moss-voice-server"
+version = "0.1.0"
+description = "Backend token generation for Moss voice agents. Mint LiveKit JWTs server-side so clients never see API secrets."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE.txt"]
+authors = [
+    {name = "Moss Team", email = "support@moss.dev"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "httpx>=0.27.0,<1.0.0",
+    "livekit-api>=1.0.0,<2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.23",
+    "black>=22.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/InferEdge-Inc/moss"
+Repository = "https://github.com/InferEdge-Inc/moss"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.package-data]
+moss_voice_server = ["py.typed"]

moss_voice_server-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moss_voice_server-0.1.0/src/moss_voice_server/__init__.py

@@ -0,0 +1,10 @@
+"""Moss Voice Server — backend token generation for Moss voice agents.
+
+Mint LiveKit participant JWTs server-side so the API secret never reaches the
+browser. Mirrors the Node ``@moss-tools/voice-server`` package.
+"""
+
+from ._client import MossVoiceServer, ParticipantInfo
+from ._sync import MossVoiceServerSync
+
+__all__ = ["MossVoiceServer", "MossVoiceServerSync", "ParticipantInfo"]

moss_voice_server-0.1.0/src/moss_voice_server/_client.py

@@ -0,0 +1,205 @@
+"""Async ``MossVoiceServer`` — mints LiveKit JWTs from Moss-issued credentials."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import timedelta
+from typing import Optional
+from urllib.parse import quote
+
+import httpx
+from livekit.api import AccessToken, RoomAgentDispatch, RoomConfiguration, VideoGrants
+
+DEFAULT_API_URL = "https://service.usemoss.dev"
+_CREDENTIALS_PATH = "/api/voice-agent/get-voice-agent"
+_TOKEN_TTL = timedelta(minutes=15)
+_FETCH_TIMEOUT_SECONDS = 10.0
+_CREDENTIAL_FIELDS = (
+    "voice_agent_url",
+    "voice_agent_api_key",
+    "voice_agent_api_secret",
+    "voice_agent_name",
+)
+
+
+@dataclass(frozen=True)
+class ParticipantInfo:
+    """Identity and optional metadata for the participant the token is minted for."""
+
+    identity: str
+    name: Optional[str] = None
+    metadata: Optional[str] = None
+    attributes: Optional[dict[str, str]] = field(default=None)
+
+
+@dataclass(frozen=True)
+class _Credentials:
+    voice_agent_url: str
+    voice_agent_api_key: str
+    voice_agent_api_secret: str
+    voice_agent_name: str
+
+
+class _MossVoiceServerBase:
+    """Shared sync surface for both async and sync flavors of the server.
+
+    Subclasses are responsible for populating ``self._credentials`` via either
+    an async or sync fetch implementation. Everything else — validation,
+    request URL building, token minting — is sync and lives here.
+    """
+
+    def __init__(
+        self,
+        project_id: str,
+        project_key: str,
+        voice_agent_id: str,
+        api_url: str = DEFAULT_API_URL,
+    ) -> None:
+        if not project_id or not project_key or not voice_agent_id:
+            raise ValueError("project_id, project_key, and voice_agent_id are required")
+        self._project_id = project_id
+        self._project_key = project_key
+        self._voice_agent_id = voice_agent_id
+        self._api_url = api_url.rstrip("/")
+        self._credentials: Optional[_Credentials] = None
+
+    def get_server_url(self) -> str:
+        """LiveKit WebSocket URL the client should connect to."""
+        return self._require_credentials().voice_agent_url
+
+    def get_agent_name(self) -> str:
+        """Configured voice agent name."""
+        return self._require_credentials().voice_agent_name
+
+    def create_participant_token(
+        self,
+        participant: ParticipantInfo,
+        room_name: str,
+        agent_name: Optional[str] = None,
+    ) -> str:
+        """Mint a signed LiveKit JWT for a participant joining ``room_name``.
+
+        The token is valid for 15 minutes. Pass ``agent_name`` only to override
+        the default agent; otherwise LiveKit dispatch rules handle agent joining.
+        """
+        creds = self._require_credentials()
+
+        token = (
+            AccessToken(creds.voice_agent_api_key, creds.voice_agent_api_secret)
+            .with_identity(participant.identity)
+            .with_ttl(_TOKEN_TTL)
+            .with_grants(
+                VideoGrants(
+                    room=room_name,
+                    room_join=True,
+                    can_publish=True,
+                    can_publish_data=True,
+                    can_subscribe=True,
+                )
+            )
+        )
+        if participant.name is not None:
+            token = token.with_name(participant.name)
+        if participant.metadata is not None:
+            token = token.with_metadata(participant.metadata)
+        if participant.attributes is not None:
+            token = token.with_attributes(participant.attributes)
+
+        if agent_name:
+            token = token.with_room_config(
+                RoomConfiguration(agents=[RoomAgentDispatch(agent_name=agent_name)])
+            )
+
+        return token.to_jwt()
+
+    def _credentials_endpoint(self) -> str:
+        return f"{self._api_url}{_CREDENTIALS_PATH}?voice_agent_id={quote(self._voice_agent_id)}"
+
+    def _auth_headers(self) -> dict[str, str]:
+        return {
+            "X-Project-Id": self._project_id,
+            "X-Project-Key": self._project_key,
+        }
+
+    def _require_credentials(self) -> _Credentials:
+        if self._credentials is None:
+            raise RuntimeError(
+                f"{type(self).__name__} not initialized — call {type(self).__name__}.create()"
+            )
+        return self._credentials
+
+
+class MossVoiceServer(_MossVoiceServerBase):
+    """Backend client that mints LiveKit participant tokens for voice agents.
+
+    Fetch credentials once at app startup via :meth:`create`, then mint per-user
+    tokens on demand. Credentials never leave the server.
+
+    Example::
+
+        server = await MossVoiceServer.create(
+            project_id=os.environ["MOSS_PROJECT_ID"],
+            project_key=os.environ["MOSS_PROJECT_KEY"],
+            voice_agent_id=os.environ["MOSS_VOICE_AGENT_ID"],
+        )
+
+        url = server.get_server_url()
+        token = server.create_participant_token(
+            ParticipantInfo(identity="user_123", name="John"),
+            room_name="support_room_456",
+        )
+    """
+
+    @classmethod
+    async def create(
+        cls,
+        project_id: str,
+        project_key: str,
+        voice_agent_id: str,
+        api_url: str = DEFAULT_API_URL,
+    ) -> "MossVoiceServer":
+        """Create and initialize a server instance by fetching credentials."""
+        instance = cls(project_id, project_key, voice_agent_id, api_url)
+        await instance._initialize()
+        return instance
+
+    async def _initialize(self) -> None:
+        try:
+            async with httpx.AsyncClient(timeout=_FETCH_TIMEOUT_SECONDS) as client:
+                response = await client.get(
+                    self._credentials_endpoint(),
+                    headers=self._auth_headers(),
+                )
+                self._credentials = _parse_credentials_response(response)
+        except httpx.TimeoutException as exc:
+            raise RuntimeError(
+                "Failed to initialize MossVoiceServer: request timed out after 10 seconds"
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise RuntimeError(f"Failed to initialize MossVoiceServer: {exc}") from exc
+
+
+def _parse_credentials_response(response: httpx.Response) -> _Credentials:
+    if response.status_code >= 400:
+        raise RuntimeError(
+            f"Failed to fetch credentials: {response.status_code} {response.text}"
+        )
+    try:
+        data = response.json()
+    except ValueError as exc:
+        raise RuntimeError(
+            f"Moss API returned non-JSON response: {response.text!r}"
+        ) from exc
+    if not isinstance(data, dict):
+        raise RuntimeError(f"Moss API returned unexpected response shape: {data!r}")
+    missing = [field for field in _CREDENTIAL_FIELDS if field not in data]
+    if missing:
+        raise RuntimeError(
+            f"Moss API response missing field(s): {', '.join(missing)}"
+        )
+    return _Credentials(
+        voice_agent_url=data["voice_agent_url"],
+        voice_agent_api_key=data["voice_agent_api_key"],
+        voice_agent_api_secret=data["voice_agent_api_secret"],
+        voice_agent_name=data["voice_agent_name"],
+    )

moss_voice_server-0.1.0/src/moss_voice_server/_sync.py

@@ -0,0 +1,64 @@
+"""Sync wrapper for ``MossVoiceServer`` — for Flask, Django, and other sync frameworks."""
+
+from __future__ import annotations
+
+import httpx
+
+from ._client import (
+    DEFAULT_API_URL,
+    ParticipantInfo,
+    _FETCH_TIMEOUT_SECONDS,
+    _MossVoiceServerBase,
+    _parse_credentials_response,
+)
+
+
+class MossVoiceServerSync(_MossVoiceServerBase):
+    """Sync flavor of :class:`MossVoiceServer`.
+
+    Initialization performs a single blocking HTTP request. After that, token
+    minting is purely CPU work (JWT signing).
+
+    Example::
+
+        server = MossVoiceServerSync.create(
+            project_id=os.environ["MOSS_PROJECT_ID"],
+            project_key=os.environ["MOSS_PROJECT_KEY"],
+            voice_agent_id=os.environ["MOSS_VOICE_AGENT_ID"],
+        )
+
+        token = server.create_participant_token(
+            ParticipantInfo(identity="user_123"),
+            room_name="support_room_456",
+        )
+    """
+
+    @classmethod
+    def create(
+        cls,
+        project_id: str,
+        project_key: str,
+        voice_agent_id: str,
+        api_url: str = DEFAULT_API_URL,
+    ) -> "MossVoiceServerSync":
+        instance = cls(project_id, project_key, voice_agent_id, api_url)
+        instance._initialize_sync()
+        return instance
+
+    def _initialize_sync(self) -> None:
+        try:
+            with httpx.Client(timeout=_FETCH_TIMEOUT_SECONDS) as client:
+                response = client.get(
+                    self._credentials_endpoint(),
+                    headers=self._auth_headers(),
+                )
+                self._credentials = _parse_credentials_response(response)
+        except httpx.TimeoutException as exc:
+            raise RuntimeError(
+                "Failed to initialize MossVoiceServerSync: request timed out after 10 seconds"
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise RuntimeError(f"Failed to initialize MossVoiceServerSync: {exc}") from exc
+
+
+__all__ = ["MossVoiceServerSync", "ParticipantInfo"]

moss_voice_server-0.1.0/src/moss_voice_server.egg-info/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: moss-voice-server
+Version: 0.1.0
+Summary: Backend token generation for Moss voice agents. Mint LiveKit JWTs server-side so clients never see API secrets.
+Author-email: Moss Team <support@moss.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/InferEdge-Inc/moss
+Project-URL: Repository, https://github.com/InferEdge-Inc/moss
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Requires-Dist: livekit-api<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Dynamic: license-file
+
+# moss-voice-server
+
+Backend token generation for Moss voice agents. Mints short-lived LiveKit
+participant JWTs server-side so your API secrets never reach the browser.
+
+A Node.js equivalent is available as [`@moss-tools/voice-server`](https://www.npmjs.com/package/@moss-tools/voice-server) on npm.
+
+## Why
+
+Browser clients shouldn't hold LiveKit API secrets. The recommended flow:
+
+1. Your frontend asks **your backend** for a join token.
+2. Your backend calls `MossVoiceServer.create_participant_token(...)` and
+   returns the signed JWT + server URL.
+3. The frontend connects to LiveKit with that token.
+
+This package handles steps 1–2 from Python (FastAPI, Flask, Django, etc.).
+
+## Install
+
+```bash
+pip install moss-voice-server
+```
+
+Python 3.10+.
+
+## Usage — async (FastAPI, asyncio)
+
+```python
+import os
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from moss_voice_server import MossVoiceServer, ParticipantInfo
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    app.state.voice_server = await MossVoiceServer.create(
+        project_id=os.environ["MOSS_PROJECT_ID"],
+        project_key=os.environ["MOSS_PROJECT_KEY"],
+        voice_agent_id=os.environ["MOSS_VOICE_AGENT_ID"],
+    )
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.post("/voice/token")
+async def issue_token(user_id: str, room: str) -> dict[str, str]:
+    server: MossVoiceServer = app.state.voice_server
+    token = server.create_participant_token(
+        ParticipantInfo(identity=user_id),
+        room_name=room,
+    )
+    return {"token": token, "url": server.get_server_url()}
+```
+
+## Usage — sync (Flask, Django)
+
+```python
+import os
+from moss_voice_server import MossVoiceServerSync, ParticipantInfo
+
+voice_server = MossVoiceServerSync.create(
+    project_id=os.environ["MOSS_PROJECT_ID"],
+    project_key=os.environ["MOSS_PROJECT_KEY"],
+    voice_agent_id=os.environ["MOSS_VOICE_AGENT_ID"],
+)
+
+token = voice_server.create_participant_token(
+    ParticipantInfo(identity="user_123", name="Jane"),
+    room_name="support_456",
+)
+```
+
+## API
+
+### `MossVoiceServer.create(project_id, project_key, voice_agent_id, api_url=...)`
+
+Async factory. Fetches credentials from the Moss API and returns an initialized
+instance. Raises ``RuntimeError`` on network failure or invalid credentials.
+
+### `MossVoiceServerSync.create(...)`
+
+Same arguments, sync. Use in Flask/Django.
+
+### `server.create_participant_token(participant, room_name, agent_name=None) -> str`
+
+Mint a signed JWT for ``participant`` to join ``room_name``. Token TTL is
+15 minutes. Pass ``agent_name`` only when you need to override LiveKit's
+default dispatch rules.
+
+### `server.get_server_url() -> str`
+
+LiveKit WebSocket URL the client should connect to.
+
+### `server.get_agent_name() -> str`
+
+Configured voice agent name.
+
+### `ParticipantInfo(identity, name=None, metadata=None, attributes=None)`
+
+Identity payload for the token. ``identity`` is required and must be unique
+per user.
+
+## Environment variables
+
+The library accepts credentials as arguments. By convention, applications
+typically read them from these env vars:
+
+```bash
+MOSS_PROJECT_ID=<your project id>
+MOSS_PROJECT_KEY=<your project key>
+MOSS_VOICE_AGENT_ID=<your voice agent id>
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

moss_voice_server-0.1.0/src/moss_voice_server.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/moss_voice_server/__init__.py
+src/moss_voice_server/_client.py
+src/moss_voice_server/_sync.py
+src/moss_voice_server/py.typed
+src/moss_voice_server.egg-info/PKG-INFO
+src/moss_voice_server.egg-info/SOURCES.txt
+src/moss_voice_server.egg-info/dependency_links.txt
+src/moss_voice_server.egg-info/requires.txt
+src/moss_voice_server.egg-info/top_level.txt
+tests/test_public_api.py

moss_voice_server-0.1.0/src/moss_voice_server.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moss_voice_server-0.1.0/src/moss_voice_server.egg-info/requires.txt

@@ -0,0 +1,7 @@
+httpx<1.0.0,>=0.27.0
+livekit-api<2.0.0,>=1.0.0
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.23
+black>=22.0

moss_voice_server-0.1.0/src/moss_voice_server.egg-info/top_level.txt

@@ -0,0 +1 @@
+moss_voice_server

moss_voice_server-0.1.0/tests/test_public_api.py

@@ -0,0 +1,111 @@
+"""Smoke tests for the public API surface.
+
+Integration tests against the live Moss API require real credentials and are
+not run here. The token-minting logic is covered by a fake-response unit test.
+"""
+
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+
+import moss_voice_server
+from moss_voice_server import MossVoiceServer, MossVoiceServerSync, ParticipantInfo
+
+
+def test_public_api_exports() -> None:
+    assert sorted(moss_voice_server.__all__) == [
+        "MossVoiceServer",
+        "MossVoiceServerSync",
+        "ParticipantInfo",
+    ]
+
+
+def test_required_args_validation() -> None:
+    with pytest.raises(ValueError):
+        MossVoiceServer(project_id="", project_key="k", voice_agent_id="v")
+    with pytest.raises(ValueError):
+        MossVoiceServerSync(project_id="p", project_key="", voice_agent_id="v")
+
+
+def test_missing_credential_field_raises_descriptive_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    # Response missing voice_agent_api_secret
+    bad_response = {
+        "voice_agent_url": "wss://example.livekit.cloud",
+        "voice_agent_api_key": "APItest",
+        "voice_agent_name": "moss-agent",
+    }
+
+    transport = httpx.MockTransport(lambda _: httpx.Response(200, json=bad_response))
+    original_client = httpx.Client
+
+    def patched_client(*args: object, **kwargs: object) -> httpx.Client:
+        kwargs["transport"] = transport
+        return original_client(*args, **kwargs)  # type: ignore[arg-type]
+
+    monkeypatch.setattr(httpx, "Client", patched_client)
+
+    with pytest.raises(RuntimeError, match="voice_agent_api_secret"):
+        MossVoiceServerSync.create(project_id="p", project_key="k", voice_agent_id="v")
+
+
+def test_sync_class_does_not_expose_async_create() -> None:
+    # MossVoiceServerSync.create must be a plain sync classmethod — not async.
+    import inspect
+
+    assert not inspect.iscoroutinefunction(MossVoiceServerSync.create)
+
+
+def test_create_participant_token_signs_jwt(monkeypatch: pytest.MonkeyPatch) -> None:
+    fake_creds = {
+        "voice_agent_url": "wss://example.livekit.cloud",
+        "voice_agent_api_key": "APItest",
+        "voice_agent_api_secret": "secret_value_long_enough_for_hmac",
+        "voice_agent_name": "moss-agent",
+    }
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.headers["X-Project-Id"] == "p"
+        assert request.headers["X-Project-Key"] == "k"
+        assert "voice_agent_id=v" in str(request.url)
+        return httpx.Response(200, json=fake_creds)
+
+    transport = httpx.MockTransport(handler)
+
+    # Patch httpx.Client to use the mock transport (sync path)
+    original_client = httpx.Client
+
+    def patched_client(*args: object, **kwargs: object) -> httpx.Client:
+        kwargs["transport"] = transport
+        return original_client(*args, **kwargs)  # type: ignore[arg-type]
+
+    monkeypatch.setattr(httpx, "Client", patched_client)
+
+    server = MossVoiceServerSync.create(project_id="p", project_key="k", voice_agent_id="v")
+
+    assert server.get_server_url() == "wss://example.livekit.cloud"
+    assert server.get_agent_name() == "moss-agent"
+
+    token = server.create_participant_token(
+        ParticipantInfo(identity="user_123", name="Jane"),
+        room_name="room_abc",
+    )
+
+    assert isinstance(token, str)
+    # JWT is three base64url segments separated by dots
+    assert token.count(".") == 2
+
+    # Decode payload (middle segment) — base64url, no padding
+    import base64
+
+    payload_segment = token.split(".")[1]
+    payload_segment += "=" * (-len(payload_segment) % 4)
+    payload = json.loads(base64.urlsafe_b64decode(payload_segment))
+    assert payload["sub"] == "user_123"
+    assert payload["name"] == "Jane"
+    assert payload["video"]["room"] == "room_abc"
+    assert payload["video"]["roomJoin"] is True