rymi 1.1.0__py3-none-any.whl

rymi/__init__.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from .client import RymiClient, RymiError
+from .resources.agents import AgentsResource
+from .resources.calls import CallsResource
+from .resources.numbers import NumbersResource
+from .resources.telephony import TelephonyResource
+from .resources.keys import KeysResource
+from .resources.billing import BillingResource
+from .resources.templates import TemplatesResource
+from .resources.webhooks import WebhooksUtility
+
+class Rymi:
+    """The official Python SDK for the Rymi Voice API."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
+        self._client = RymiClient(api_key=api_key, base_url=base_url)
+
+        self.agents = AgentsResource(self._client)
+        self.calls = CallsResource(self._client)
+        self.numbers = NumbersResource(self._client)
+        self.telephony = TelephonyResource(self._client)
+        self.keys = KeysResource(self._client)
+        self.billing = BillingResource(self._client)
+        self.templates = TemplatesResource(self._client)
+        self.webhooks = WebhooksUtility()
+
+__all__ = ["Rymi", "RymiError"]

rymi/client.py

@@ -0,0 +1,76 @@
+import os
+import requests
+from typing import Any, Dict, Optional
+from urllib.parse import urlparse
+
+class RymiError(Exception):
+    """Custom exception raised for Rymi API Errors."""
+    def __init__(self, message: str, status: Optional[int] = None, code: Optional[str] = None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+
+class RymiClient:
+    """Core HTTP Client for the Rymi API."""
+    
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None):
+        self.api_key = api_key or os.environ.get("RYMI_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "The Rymi API Key must be set either by passing `api_key` to the client "
+                "or setting the `RYMI_API_KEY` environment variable."
+            )
+            
+        self.base_url = (base_url or "https://api.rymi.live/v1").rstrip("/")
+        
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+            "User-Agent": "rymi-python/1.0.0"
+        })
+
+    def request(self, method: str, path: str, json: Optional[Dict[str, Any]] = None, params: Optional[Dict[str, Any]] = None) -> Any:
+        url = f"{self.base_url}{path if path.startswith('/') else '/' + path}"
+        
+        try:
+            response = self.session.request(method, url, json=json, params=params)
+            
+            # Attempt to parse JSON regardless of status code to check for error details
+            data = None
+            if "application/json" in response.headers.get("Content-Type", ""):
+                try:
+                    data = response.json()
+                except ValueError:
+                    data = response.text
+            else:
+                data = response.text
+
+            if not response.ok:
+                message = response.reason
+                code = None
+                
+                if isinstance(data, dict):
+                    message = data.get("error", message)
+                    code = data.get("code")
+                elif isinstance(data, str) and data:
+                    message = data
+                    
+                raise RymiError(message, status=response.status_code, code=code)
+                
+            return data
+            
+        except requests.exceptions.RequestException as e:
+            raise RymiError(f"Network Error: {str(e)}")
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("GET", path, params=params)
+
+    def post(self, path: str, json: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("POST", path, json=json)
+
+    def put(self, path: str, json: Optional[Dict[str, Any]] = None) -> Any:
+        return self.request("PUT", path, json=json)
+        
+    def delete(self, path: str) -> Any:
+        return self.request("DELETE", path)

rymi/resources/agents.py

@@ -0,0 +1,159 @@
+from typing import Any, Dict, List, Optional
+from rymi.client import RymiClient
+
+class AgentsResource:
+    """Manage AI Agents."""
+    
+    def __init__(self, client: RymiClient):
+        self.client = client
+        
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """Retrieve a list of all your AI Agents."""
+        return self.client.get("/agents", params=params or None)
+        
+    def retrieve(self, agent_id: str) -> Dict[str, Any]:
+        """Retrieve a single AI Agent by its unique ID."""
+        return self.client.get(f"/agents/{agent_id}")
+        
+    def create(self, name: str, system_prompt: Optional[str] = None, voice: Optional[str] = None, language: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """Create a new AI Agent."""
+        prompt = kwargs.pop("prompt", None)
+        payload = {"name": name}
+        if system_prompt or prompt:
+            payload["system_prompt"] = system_prompt or prompt
+        if voice:
+            payload["voice"] = voice
+        if language:
+            payload["language"] = language
+        payload.update(kwargs)
+            
+        return self.client.post("/agents", json=payload)
+        
+    def update(self, agent_id: str, name: Optional[str] = None, system_prompt: Optional[str] = None, voice: Optional[str] = None, language: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """Update an existing AI Agent."""
+        prompt = kwargs.pop("prompt", None)
+        payload = {}
+        if name: payload["name"] = name
+        if system_prompt or prompt: payload["system_prompt"] = system_prompt or prompt
+        if voice: payload["voice"] = voice
+        if language: payload["language"] = language
+        payload.update(kwargs)
+            
+        return self.client.put(f"/agents/{agent_id}", json=payload)
+        
+    def delete(self, agent_id: str) -> Dict[str, Any]:
+        """Delete an AI Agent permanently."""
+        return self.client.delete(f"/agents/{agent_id}")
+
+    def llm_options(self) -> Dict[str, Any]:
+        """Retrieve model and voice catalog options."""
+        return self.client.get("/agents/llm-options")
+
+    def generate(self, prompt: str, options: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Generate a structured agent draft from a plain-English brief."""
+        payload: Dict[str, Any] = {"prompt": prompt}
+        if options:
+            payload["options"] = options
+        return self.client.post("/agents/generate", json=payload)
+
+    def list_calls(self, agent_id: str, limit: int = 50, offset: int = 0, status: Optional[str] = None) -> Dict[str, Any]:
+        """List calls made with a specific agent."""
+        params: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if status:
+            params["status"] = status
+        return self.client.get(f"/agents/{agent_id}/calls", params=params)
+
+    def clone(self, agent_id: str) -> Dict[str, Any]:
+        """Duplicate an existing agent. The copy gets ' (Copy)' appended to its name."""
+        return self.client.post(f"/agents/{agent_id}/clone", json={})
+
+    def validate_publish(self, agent_id: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """Check whether an agent is ready to go live without persisting changes."""
+        payload: Dict[str, Any] = {}
+        if agent_id:
+            payload["agent_id"] = agent_id
+        payload.update(kwargs)
+        return self.client.post("/agents/validate-publish", json=payload)
+
+    def apply_changes(self, current_config: Dict[str, Any], changes: list, mode: str = "edit", lenient: bool = False) -> Dict[str, Any]:
+        """Validate and resolve a flat key/value change-set. Does NOT persist — follow up with update()."""
+        return self.client.post("/agents/apply-changes", json={
+            "currentConfig": current_config,
+            "changes": changes,
+            "mode": mode,
+            "lenient": lenient,
+        })
+
+    def enrich_company(self, company_name: str, website_url: str) -> Dict[str, Any]:
+        """Auto-generate a company description from a website URL using AI + Google Search."""
+        return self.client.post("/agents/enrich-company", json={
+            "companyName": company_name,
+            "websiteUrl": website_url,
+        })
+
+    def preview_stack(
+        self,
+        supported_languages: List[str],
+        agent_role: Optional[str] = None,
+        language: Optional[str] = None,
+        current_provider_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Resolve the per-language model stack (STT/LLM/TTS), blockers, warnings, and
+        required role upgrades without saving. The concierge (realtime) role is not
+        supported by this endpoint."""
+        payload: Dict[str, Any] = {"supported_languages": supported_languages}
+        if agent_role:
+            payload["agent_role"] = agent_role
+        if language is not None:
+            payload["language"] = language
+        if current_provider_config is not None:
+            payload["current_provider_config"] = current_provider_config
+        return self.client.post("/agents/stack-preview", json=payload)
+
+    def list_knowledge_sources(self, agent_id: str) -> Dict[str, Any]:
+        """List the knowledge sources (RAG context) attached to an agent."""
+        return self.client.get(f"/agents/{agent_id}/knowledge-sources")
+
+    def add_knowledge_source(
+        self,
+        agent_id: str,
+        kind: str,
+        title: str,
+        text: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Add a knowledge source from raw text (kind='text') or a URL (kind='url')."""
+        payload: Dict[str, Any] = {"kind": kind, "title": title}
+        if text is not None:
+            payload["text"] = text
+        if url is not None:
+            payload["url"] = url
+        return self.client.post(f"/agents/{agent_id}/knowledge-sources", json=payload)
+
+    def delete_knowledge_source(self, agent_id: str, source_id: str) -> Dict[str, Any]:
+        """Delete a knowledge source from an agent."""
+        return self.client.delete(f"/agents/{agent_id}/knowledge-sources/{source_id}")
+
+    def list_changes(self, agent_id: str, since: Optional[str] = None) -> Dict[str, Any]:
+        """List recorded configuration changes for an agent (optionally since an ISO timestamp)."""
+        params = {"since": since} if since else None
+        return self.client.get(f"/agents/{agent_id}/changes", params=params)
+
+    def undo_change(self, agent_id: str, change_id: str) -> Dict[str, Any]:
+        """Undo a single recorded configuration change, reverting that field to its previous value."""
+        return self.client.post(f"/agents/{agent_id}/changes/{change_id}/undo", json={})
+
+    def run_evals(self, agent_id: str, mode: Optional[str] = None) -> Dict[str, Any]:
+        """Run the evaluation suite for an agent. mode='synthetic' (default) or 'live'."""
+        path = f"/agents/{agent_id}/evals/run"
+        if mode:
+            path += f"?mode={mode}"
+        return self.client.post(path, json={})
+
+    def list_eval_runs(self, agent_id: str) -> Dict[str, Any]:
+        """List previous evaluation runs for an agent."""
+        return self.client.get(f"/agents/{agent_id}/evals/runs")
+
+    def get_eval_run(self, agent_id: str, run_id: str) -> Dict[str, Any]:
+        """Retrieve a single evaluation run, including per-scenario scores."""
+        return self.client.get(f"/agents/{agent_id}/evals/runs/{run_id}")

rymi/resources/billing.py

@@ -0,0 +1,13 @@
+from typing import Any, Dict
+from rymi.client import RymiClient
+
+class BillingResource:
+    """Account usage. Voice balance is reported in MINUTES, not dollars."""
+
+    def __init__(self, client: RymiClient):
+        self.client = client
+
+    def usage_summary(self) -> Dict[str, Any]:
+        """Lane-aware usage summary: remaining voice-runtime minutes, Studio AI unit
+        usage, and post-call intelligence usage."""
+        return self.client.get("/billing/usage-summary")

rymi/resources/calls.py

@@ -0,0 +1,74 @@
+from typing import Any, Dict, List, Optional
+from rymi.client import RymiClient
+
+class CallsResource:
+    """Manage Outbound Calls."""
+    
+    def __init__(self, client: RymiClient):
+        self.client = client
+        
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """Retrieve a list of all call records."""
+        return self.client.get("/calls", params=params or None)
+
+    def active(self, **params: Any) -> Dict[str, Any]:
+        """Retrieve active in-progress calls."""
+        return self.client.get("/calls/active", params=params or None)
+        
+    def retrieve(self, call_id: str) -> Dict[str, Any]:
+        """Retrieve a single call record and transcript."""
+        return self.client.get(f"/calls/{call_id}")
+        
+    def create(
+        self,
+        agent_id: str,
+        participants: Optional[List[Dict[str, Any]]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        post_call: Optional[Dict[str, Any]] = None,
+        to: Optional[str] = None,
+        from_number: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Create a WebRTC/PSTN call using the participant-first API."""
+        if participants is None and to:
+            participants = [{
+                "transport": "pstn",
+                "identity": to,
+                "from_number": from_number
+            }]
+
+        payload = {
+            "agent_id": agent_id,
+            "participants": participants or []
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if variables:
+            payload["variables"] = variables
+        if post_call:
+            payload["post_call"] = post_call
+            
+        return self.client.post("/calls", json=payload)
+
+    def batch(self, agent_id: str, to: List[str], from_number: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """Queue a batch of outbound PSTN recipients."""
+        payload = {"agent_id": agent_id, "to": to}
+        if from_number:
+            payload["from_number"] = from_number
+        payload.update(kwargs)
+        return self.client.post("/calls/batch", json=payload)
+
+    def summary(self, call_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/calls/{call_id}/summary")
+
+    def transcript(self, call_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/calls/{call_id}/transcript")
+
+    def recording(self, call_id: str) -> Dict[str, Any]:
+        return self.client.get(f"/calls/{call_id}/recording")
+
+    def reprocess(self, call_id: str) -> Dict[str, Any]:
+        return self.client.post(f"/calls/{call_id}/reprocess")
+
+    def queue_stats(self) -> Dict[str, Any]:
+        return self.client.get("/calls/queue/stats")

rymi/resources/keys.py

@@ -0,0 +1,16 @@
+from typing import Any, Dict
+from rymi.client import RymiClient
+
+class KeysResource:
+    """Read-only access to publishable (browser-safe) keys.
+
+    Creating or revoking keys mints/destroys credentials and changes standing
+    config, so those remain dashboard actions and are not exposed here.
+    """
+
+    def __init__(self, client: RymiClient):
+        self.client = client
+
+    def list_publishable(self) -> Dict[str, Any]:
+        """List publishable keys and their agent/channel scoping. Returns key prefixes only, never full secrets."""
+        return self.client.get("/keys/publishable")

rymi/resources/numbers.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict, Optional
+from rymi.client import RymiClient
+
+class NumbersResource:
+    """Manage already-owned BYOC phone numbers registered with Rymi."""
+    
+    def __init__(self, client: RymiClient):
+        self.client = client
+        
+    def list(self, **params: Any) -> Dict[str, Any]:
+        """Retrieve a list of all assigned phone numbers."""
+        return self.client.get("/numbers", params=params or None)
+
+    def register(self, number: str, agent_id: Optional[str] = None) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {"number": number}
+        if agent_id is not None:
+            payload["agent_id"] = agent_id
+        return self.client.post("/numbers", json=payload)
+
+    def attach(self, number: str, agent_id: str) -> Dict[str, Any]:
+        return self.client.post(f"/numbers/{number}/attach", json={"agent_id": agent_id})
+
+    def remove(self, number: str) -> Dict[str, Any]:
+        return self.client.delete(f"/numbers/{number}")

rymi/resources/telephony.py

@@ -0,0 +1,20 @@
+from typing import Any, Dict
+from rymi.client import RymiClient
+
+class TelephonyResource:
+    """Inspect the connected telephony carrier.
+
+    Connecting/disconnecting a carrier requires carrier credentials and changes a
+    standing integration, so it is a dashboard action and not exposed here.
+    """
+
+    def __init__(self, client: RymiClient):
+        self.client = client
+
+    def status(self) -> Dict[str, Any]:
+        """Report whether a carrier is connected, and which provider/account."""
+        return self.client.get("/telephony/status")
+
+    def numbers(self) -> Dict[str, Any]:
+        """List numbers available on the connected telephony carrier account."""
+        return self.client.get("/telephony/numbers")

rymi/resources/templates.py

@@ -0,0 +1,12 @@
+from typing import Any, Dict
+from rymi.client import RymiClient
+
+class TemplatesResource:
+    """Published agent templates."""
+
+    def __init__(self, client: RymiClient):
+        self.client = client
+
+    def list(self) -> Dict[str, Any]:
+        """List published agent templates. Use a template's `defaults` as the starting config for agents.create()."""
+        return self.client.get("/agent-templates")

rymi/resources/webhooks.py

@@ -0,0 +1,46 @@
+import hmac
+import hashlib
+import time
+
+class WebhooksUtility:
+    """Secure Utility for Webhook Signature Verification."""
+
+    @staticmethod
+    def verify_signature(
+        payload: str,
+        signature_header: str,
+        timestamp_header: str,
+        webhook_secret: str,
+        tolerance_millis: int = 300000 # 5 minutes
+    ) -> bool:
+        """
+        Verifies that a webhook received by your backend was genuinely dispatched by Rymi.
+        
+        Rymi endpoints secure webhooks by computing an HMAC-SHA256 signature
+        of the raw JSON body concatenated with the timestamp using your Webhook Secret.
+        """
+        # 1. Check for Replay Attacks
+        try:
+            timestamp = int(timestamp_header)
+        except ValueError:
+            raise ValueError("Invalid Rymi-Timestamp header format.")
+            
+        current_time = int(time.time() * 1000)
+        if (current_time - timestamp) > tolerance_millis:
+            raise ValueError("Webhook timestamp is too old. Possible replay attack.")
+            
+        # 2. Prepare the verification string
+        signature_payload = f"{timestamp}.{payload}"
+        
+        # 3. Compute expected HMAC
+        expected_signature = hmac.new(
+            webhook_secret.encode('utf-8'),
+            signature_payload.encode('utf-8'),
+            hashlib.sha256
+        ).hexdigest()
+        
+        # 4. Secure string comparison
+        if not hmac.compare_digest(signature_header, expected_signature):
+            raise ValueError("Invalid Webhook Signature. The secret might be incorrect.")
+            
+        return True

rymi-1.1.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: rymi
+Version: 1.1.0
+Summary: The official Python REST API wrapper for Rymi.
+Author-email: Rymi AI <engineering@rymi.live>
+Project-URL: Homepage, https://rymi.live
+Project-URL: Documentation, https://rymi.live/docs
+Project-URL: Source, https://github.com/rymi-ai/rymi
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"
+Dynamic: license-file
+
+# Rymi Python SDK
+
+The official Python wrapper for the Rymi Voice AI REST API. Manage agents (incl. multi-language and model-stack config), phone numbers, calls, knowledge sources, evaluations, usage, and templates, plus webhook verification.
+
+Resources: `agents` · `calls` · `numbers` · `telephony` · `keys` · `billing` · `templates` · `webhooks`.
+
+## Installation
+
+```bash
+pip install rymi
+```
+
+## Quick Start
+
+```python
+import os
+from rymi import Rymi
+
+# Automatically picks up RYMI_API_KEY from environment
+client = Rymi()
+
+# Or pass explicitly
+# client = Rymi(api_key="rymi_live_...")
+
+agents = client.agents.list()
+for agent in agents["agents"]:
+    print(agent['name'])
+```

rymi-1.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+rymi/__init__.py,sha256=NQqdhCywP9BN0VMeZV-31R77wrv5-jo-Rhl7218mImk,1115
+rymi/client.py,sha256=r-E6-R5DPkq9sNCMgu0Ikqq1cvKHZP3MWkbpoE-d_wc,2983
+rymi/resources/agents.py,sha256=2IZ_lBvTRbP9RI88yQUgn676xWv6swFAPxF_rz_mixM,7501
+rymi/resources/billing.py,sha256=mgb_BbZATx-jtCb9geHdwF3mMnDJG5g9R51u6Ntoy10,480
+rymi/resources/calls.py,sha256=Rs1ft8f7-a3rOV-Xs55zt1kIXFIm7Hks83tmn-pTrOY,2743
+rymi/resources/keys.py,sha256=quG-iUiewAHR1I5SRe0n0DrrVMO9c9jACBkEQtgG9qs,597
+rymi/resources/numbers.py,sha256=QC18bTiSUFz9gQUB8NVKXUpPz47htSgcBnPHeKKeZkA,981
+rymi/resources/telephony.py,sha256=z3MxdSDIlnljalTMEjuiqsCgQ5MIfJGuApOY-Earwec,729
+rymi/resources/templates.py,sha256=u3-tVMkmzjBrjjwCV0XXIkHDry4tHS8zlQMFS8dlJKE,409
+rymi/resources/webhooks.py,sha256=t5sCtEIOBU6vE30SnEQxSHU5Nlc19Dr7H0PLNAZKk40,1613
+rymi-1.1.0.dist-info/licenses/LICENSE,sha256=Z1Q9UlBjwLe7vpwpO5tJ9C0ERnX69PjT2Y39hgH_Xrk,1064
+rymi-1.1.0.dist-info/METADATA,sha256=jObAEwYa5sHtDB6PkBoL5Osi8JPdF4BMD-cxkhyHNvw,1689
+rymi-1.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+rymi-1.1.0.dist-info/top_level.txt,sha256=f0F0RByoASQayVpbn60M1eibY2_gusWuZDzaGklpLT0,5
+rymi-1.1.0.dist-info/RECORD,,

rymi-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rymi-1.1.0.dist-info/licenses/LICENSE

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

rymi-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rymi