glytos 0.1.0__tar.gz

glytos-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+dist/
+build/
+*.egg-info/
+__pycache__/
+.venv/

glytos-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Glytos
+
+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.

glytos-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: glytos
+Version: 0.1.0
+Summary: Official Glytos server SDK for Python.
+Project-URL: Homepage, https://glytos.com
+Project-URL: Documentation, https://glytos.com/en/docs
+Project-URL: Repository, https://github.com/Glytos/backend
+Author: Glytos
+License: MIT
+License-File: LICENSE
+Keywords: agent,ai,api,glytos,sdk,voice
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24
+Description-Content-Type: text/markdown
+
+# glytos
+
+The official [Glytos](https://glytos.com) server SDK for Python.
+
+Call the Glytos API from your backend with an API key: build and run voice agents,
+start phone calls, mint browser web-call tokens, manage phone numbers, and verify
+webhooks.
+
+> Never ship an API key to the browser. For in-browser voice, use the `@glytos/web`
+> package with a short-lived token you mint here.
+
+## Install
+
+```bash
+pip install glytos
+```
+
+## Quickstart
+
+```python
+from glytos import Glytos
+
+glytos = Glytos(api_key="gly_...")
+
+# List your agents
+agents = glytos.workflows.list()
+
+# Mint a web-call token for the browser
+token = glytos.calls.web_token(workflow_uuid=agents[0]["uuid"])
+print(token["token"], token["ws_url"])
+```
+
+Use it as a context manager to close the HTTP connection cleanly:
+
+```python
+with Glytos(api_key="gly_...") as glytos:
+    overview = glytos.request("GET", "/analytics/overview")
+```
+
+## Resources
+
+| Namespace | Methods |
+| --- | --- |
+| `glytos.workflows` | `list`, `retrieve`, `create`, `publish`, `delete`, `templates`, `session`, `session_events` |
+| `glytos.calls` | `create`, `list`, `retrieve`, `web_token`, `control` |
+| `glytos.phone_numbers` | `search`, `list`, `provision`, `assign`, `release` |
+| `glytos.sessions` | `list` |
+| `glytos.webhooks` | `list`, `create`, `delete`, `events`, `verify` |
+
+Any endpoint without a dedicated helper is one call away with
+`glytos.request(method, path, json=..., params=...)`.
+
+## Errors
+
+Non-2xx responses raise a `GlytosError` with the API error `code`, HTTP `status`,
+and the `request_id`:
+
+```python
+from glytos import GlytosError
+
+try:
+    glytos.workflows.retrieve("missing")
+except GlytosError as err:
+    print(err.status, err.code, err.message)
+```
+
+## Webhooks
+
+Verify a delivery came from Glytos before trusting it. Pass the **raw** request
+body, the `X-Glytos-Signature` header, and your endpoint secret:
+
+```python
+from glytos import verify_webhook
+
+# e.g. in a Flask/FastAPI handler
+ok = verify_webhook(raw_body, request.headers["X-Glytos-Signature"], webhook_secret)
+if not ok:
+    abort(400)
+```
+
+## License
+
+MIT

glytos-0.1.0/README.md

@@ -0,0 +1,83 @@
+# glytos
+
+The official [Glytos](https://glytos.com) server SDK for Python.
+
+Call the Glytos API from your backend with an API key: build and run voice agents,
+start phone calls, mint browser web-call tokens, manage phone numbers, and verify
+webhooks.
+
+> Never ship an API key to the browser. For in-browser voice, use the `@glytos/web`
+> package with a short-lived token you mint here.
+
+## Install
+
+```bash
+pip install glytos
+```
+
+## Quickstart
+
+```python
+from glytos import Glytos
+
+glytos = Glytos(api_key="gly_...")
+
+# List your agents
+agents = glytos.workflows.list()
+
+# Mint a web-call token for the browser
+token = glytos.calls.web_token(workflow_uuid=agents[0]["uuid"])
+print(token["token"], token["ws_url"])
+```
+
+Use it as a context manager to close the HTTP connection cleanly:
+
+```python
+with Glytos(api_key="gly_...") as glytos:
+    overview = glytos.request("GET", "/analytics/overview")
+```
+
+## Resources
+
+| Namespace | Methods |
+| --- | --- |
+| `glytos.workflows` | `list`, `retrieve`, `create`, `publish`, `delete`, `templates`, `session`, `session_events` |
+| `glytos.calls` | `create`, `list`, `retrieve`, `web_token`, `control` |
+| `glytos.phone_numbers` | `search`, `list`, `provision`, `assign`, `release` |
+| `glytos.sessions` | `list` |
+| `glytos.webhooks` | `list`, `create`, `delete`, `events`, `verify` |
+
+Any endpoint without a dedicated helper is one call away with
+`glytos.request(method, path, json=..., params=...)`.
+
+## Errors
+
+Non-2xx responses raise a `GlytosError` with the API error `code`, HTTP `status`,
+and the `request_id`:
+
+```python
+from glytos import GlytosError
+
+try:
+    glytos.workflows.retrieve("missing")
+except GlytosError as err:
+    print(err.status, err.code, err.message)
+```
+
+## Webhooks
+
+Verify a delivery came from Glytos before trusting it. Pass the **raw** request
+body, the `X-Glytos-Signature` header, and your endpoint secret:
+
+```python
+from glytos import verify_webhook
+
+# e.g. in a Flask/FastAPI handler
+ok = verify_webhook(raw_body, request.headers["X-Glytos-Signature"], webhook_secret)
+if not ok:
+    abort(400)
+```
+
+## License
+
+MIT

glytos-0.1.0/glytos/__init__.py

@@ -0,0 +1,21 @@
+"""Official Glytos server SDK for Python.
+
+Call the Glytos API from your backend with an API key: build and run voice agents,
+start phone calls, mint browser web-call tokens, manage phone numbers, and verify
+webhooks.
+
+    from glytos import Glytos
+
+    glytos = Glytos(api_key="gly_...")
+    agents = glytos.workflows.list()
+    token = glytos.calls.web_token(workflow_uuid=agents[0]["uuid"])
+
+Never ship an API key to the browser. For in-browser voice, use the ``@glytos/web``
+package with a short-lived token you mint here via ``calls.web_token(...)``.
+"""
+
+from ._client import Glytos, GlytosError
+from ._webhooks import verify_webhook
+
+__all__ = ["Glytos", "GlytosError", "verify_webhook"]
+__version__ = "0.1.0"

glytos-0.1.0/glytos/_client.py

@@ -0,0 +1,212 @@
+"""Glytos API client and resource namespaces."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from ._webhooks import verify_webhook
+
+DEFAULT_BASE_URL = "https://api.glytos.com/api/v1"
+
+JSON = Any
+
+
+class GlytosError(Exception):
+    """Raised on any non-2xx API response. Carries the API error ``code``."""
+
+    def __init__(self, status: int, code: str, message: str, request_id: str | None = None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+
+
+class Glytos:
+    """Glytos API client.
+
+    ``api_key`` is your organization API key (starts with ``gly_``). Use it as a
+    context manager, or call ``close()`` when done.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        http_client: httpx.Client | None = None,
+    ):
+        if not api_key:
+            raise ValueError("Glytos: an api_key is required")
+        self._base_url = base_url.rstrip("/")
+        self._http = http_client or httpx.Client(timeout=timeout)
+        self._headers = {"X-API-Key": api_key, "Accept": "application/json"}
+
+        self.workflows = Workflows(self)
+        self.calls = Calls(self)
+        self.phone_numbers = PhoneNumbers(self)
+        self.sessions = Sessions(self)
+        self.webhooks = Webhooks(self)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: JSON | None = None,
+        params: dict[str, Any] | None = None,
+    ) -> JSON:
+        """Low-level request against any endpoint (path relative to the API base)."""
+        clean_params = {k: v for k, v in (params or {}).items() if v is not None}
+        response = self._http.request(
+            method,
+            self._base_url + path,
+            headers=self._headers,
+            json=json,
+            params=clean_params or None,
+        )
+        request_id = response.headers.get("x-request-id")
+        if response.is_success:
+            if not response.content:
+                return None
+            try:
+                return response.json()
+            except ValueError:
+                return response.text
+        code, message = "error", response.reason_phrase or "Request failed"
+        try:
+            error = response.json().get("error") or {}
+            code = error.get("code", code)
+            message = error.get("message", message)
+        except ValueError:
+            pass
+        raise GlytosError(response.status_code, code, message, request_id)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> Glytos:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+
+class _Resource:
+    def __init__(self, client: Glytos):
+        self._client = client
+
+
+class Workflows(_Resource):
+    """Agents: prompt agents and visual workflows."""
+
+    def list(self) -> JSON:
+        return self._client.request("GET", "/workflows")
+
+    def retrieve(self, workflow_uuid: str) -> JSON:
+        return self._client.request("GET", f"/workflows/{workflow_uuid}")
+
+    def create(
+        self, *, name: str, mode: str = "prompt", config: dict[str, Any] | None = None
+    ) -> JSON:
+        body: dict[str, Any] = {"name": name, "mode": mode}
+        if config is not None:
+            body["config"] = config
+        return self._client.request("POST", "/workflows", json=body)
+
+    def publish(self, workflow_uuid: str) -> JSON:
+        return self._client.request("POST", f"/workflows/{workflow_uuid}/publish")
+
+    def delete(self, workflow_uuid: str) -> JSON:
+        return self._client.request("DELETE", f"/workflows/{workflow_uuid}")
+
+    def templates(self) -> JSON:
+        return self._client.request("GET", "/workflows/templates")
+
+    def session(self, workflow_uuid: str, session_uuid: str) -> JSON:
+        return self._client.request(
+            "GET", f"/workflows/{workflow_uuid}/sessions/{session_uuid}"
+        )
+
+    def session_events(self, workflow_uuid: str, session_uuid: str) -> JSON:
+        return self._client.request(
+            "GET", f"/workflows/{workflow_uuid}/sessions/{session_uuid}/events"
+        )
+
+
+class Calls(_Resource):
+    def create(self, **body: Any) -> JSON:
+        return self._client.request("POST", "/calls", json=body)
+
+    def list(self, **params: Any) -> JSON:
+        return self._client.request("GET", "/calls", params=params)
+
+    def retrieve(self, call_uuid: str) -> JSON:
+        return self._client.request("GET", f"/calls/{call_uuid}")
+
+    def web_token(
+        self, *, workflow_uuid: str | None = None, agent: dict[str, Any] | None = None
+    ) -> JSON:
+        """Mint a short-lived, workflow-scoped token for an in-browser web call."""
+        body: dict[str, Any] = {}
+        if workflow_uuid is not None:
+            body["workflow_uuid"] = workflow_uuid
+        if agent is not None:
+            body["agent"] = agent
+        return self._client.request("POST", "/calls/web-token", json=body)
+
+    def control(self, call_uuid: str, **body: Any) -> JSON:
+        return self._client.request("POST", f"/calls/{call_uuid}/control", json=body)
+
+
+class PhoneNumbers(_Resource):
+    def search(self, **params: Any) -> JSON:
+        return self._client.request("GET", "/telephony/numbers/search", params=params)
+
+    def list(self) -> JSON:
+        return self._client.request("GET", "/telephony/numbers")
+
+    def provision(self, *, e164: str, **body: Any) -> JSON:
+        return self._client.request("POST", "/telephony/numbers", json={"e164": e164, **body})
+
+    def assign(self, number_uuid: str, **body: Any) -> JSON:
+        return self._client.request(
+            "POST", f"/telephony/numbers/{number_uuid}/assign", json=body
+        )
+
+    def release(self, number_uuid: str) -> JSON:
+        return self._client.request("DELETE", f"/telephony/numbers/{number_uuid}")
+
+
+class Sessions(_Resource):
+    def list(self, **params: Any) -> JSON:
+        return self._client.request("GET", "/sessions", params=params)
+
+
+class Webhooks(_Resource):
+    def list(self) -> JSON:
+        return self._client.request("GET", "/webhooks/endpoints")
+
+    def create(self, *, url: str, events: list[str], **body: Any) -> JSON:
+        return self._client.request(
+            "POST", "/webhooks/endpoints", json={"url": url, "events": events, **body}
+        )
+
+    def delete(self, endpoint_id: int | str) -> JSON:
+        return self._client.request("DELETE", f"/webhooks/endpoints/{endpoint_id}")
+
+    def events(self) -> JSON:
+        return self._client.request("GET", "/webhooks/events")
+
+    @staticmethod
+    def verify(
+        payload: str | bytes,
+        signature_header: str,
+        secret: str,
+        tolerance_seconds: int = 300,
+    ) -> bool:
+        """Verify a webhook delivery signature (see :func:`glytos.verify_webhook`)."""
+        return verify_webhook(payload, signature_header, secret, tolerance_seconds)

glytos-0.1.0/glytos/_webhooks.py

@@ -0,0 +1,51 @@
+"""Webhook signature verification.
+
+Matches the server scheme: HMAC-SHA256 over ``"{timestamp}.{body}"``, delivered in
+the ``X-Glytos-Signature: t=<ts>,v1=<hex>`` header.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import time
+
+
+def verify_webhook(
+    payload: str | bytes,
+    signature_header: str,
+    secret: str,
+    tolerance_seconds: int = 300,
+) -> bool:
+    """Return True only if ``signature_header`` is a valid signature for ``payload``.
+
+    Pass the RAW request body (``str`` or ``bytes``), the ``X-Glytos-Signature``
+    header value, and your endpoint secret. Constant-time and replay-safe.
+    """
+    body = payload.encode("utf-8") if isinstance(payload, str) else payload
+
+    parts: dict[str, str] = {}
+    for piece in signature_header.split(","):
+        key, sep, value = piece.partition("=")
+        if sep:
+            parts[key.strip()] = value.strip()
+
+    timestamp = parts.get("t")
+    provided = parts.get("v1")
+    if not timestamp or not provided:
+        return False
+
+    expected = hmac.new(
+        secret.encode("utf-8"), f"{timestamp}.".encode() + body, hashlib.sha256
+    ).hexdigest()
+    if not hmac.compare_digest(expected, provided):
+        return False
+
+    if tolerance_seconds > 0:
+        try:
+            ts = int(timestamp)
+        except ValueError:
+            return False
+        if abs(time.time() - ts) > tolerance_seconds:
+            return False
+    return True

glytos-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "glytos"
+version = "0.1.0"
+description = "Official Glytos server SDK for Python."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Glytos" }]
+keywords = ["glytos", "voice", "ai", "agent", "sdk", "api"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+]
+dependencies = ["httpx>=0.24"]
+
+[project.urls]
+Homepage = "https://glytos.com"
+Documentation = "https://glytos.com/en/docs"
+Repository = "https://github.com/Glytos/backend"
+
+[tool.hatch.build.targets.wheel]
+packages = ["glytos"]
+
+[tool.hatch.build.targets.sdist]
+include = ["glytos", "README.md", "LICENSE"]