byourside 0.1.0__tar.gz

byourside-0.1.0/LICENSE

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

byourside-0.1.0/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: byourside
+Version: 0.1.0
+Summary: By Your Side SDK: give an AI a phone (outbound objective-driven calls).
+Author: By Your Side
+License: MIT
+Project-URL: Homepage, https://byourside.ai/docs/agent-api
+Project-URL: Repository, https://github.com/allexp1/voip-agent
+Keywords: voice,ai,phone,outbound,agent,sdk,voip,calls
+Classifier: Development Status :: 3 - Alpha
+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
+Classifier: Topic :: Communications :: Telephony
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# By Your Side Python SDK
+
+Zero-dependency Python client for the By Your Side Agent Outbound-Call API.
+Place objective-driven AI calls, poll for results, and verify webhooks using only the Python standard library.
+
+Requires Python 3.8+. No third-party packages needed.
+
+---
+
+## Quick start
+
+### Place a call and wait for the result
+
+```python
+from byourside import Client
+
+client = Client(api_key="bys_ak_YOUR_KEY")
+
+# Place an outbound call with an objective
+call = client.place_call(
+    to="+14155550123",
+    objective="Confirm the appointment for tomorrow at 2pm and ask if they need to reschedule.",
+    fields=[
+        {"name": "confirmed", "type": "boolean"},
+        {"name": "new_time", "type": "string"},
+    ],
+)
+print("Placed:", call["callId"], "status:", call["status"])
+
+# Poll until the call reaches a terminal status (default timeout: 180s)
+result = client.wait_for_call(call["callId"], timeout=180, interval=5)
+print("Final status:", result["status"])
+print("Extracted fields:", result.get("extracted"))
+```
+
+### List recent calls
+
+```python
+calls = client.list_calls(limit=10)
+for c in calls:
+    print(c["callId"], c["status"])
+```
+
+### Get a specific call
+
+```python
+call = client.get_call("call_abc123")
+print(call)
+```
+
+---
+
+## Call statuses
+
+| Status | Meaning |
+|---|---|
+| `queued` | Call accepted, waiting to be placed |
+| `in_progress` | Call is active |
+| `completed` | Call finished normally (terminal) |
+| `no_answer` | Recipient did not pick up (terminal) |
+| `voicemail` | Reached voicemail (terminal) |
+| `declined` | Recipient declined the call (terminal) |
+| `failed` | Call could not complete (terminal) |
+
+`wait_for_call` returns once the status is one of the five terminal states.
+
+---
+
+## Webhook verification
+
+By Your Side sends a `X-BYS-Signature` header with each webhook delivery.
+Verify it before processing the payload.
+
+### Flask example
+
+```python
+from flask import Flask, request, abort
+from byourside import verify_webhook
+
+app = Flask(__name__)
+WEBHOOK_SECRET = "whsec_YOUR_SECRET"
+
+@app.route("/webhook/bys", methods=["POST"])
+def bys_webhook():
+    sig = request.headers.get("X-BYS-Signature", "")
+    raw_body = request.get_data(as_text=True)
+    if not verify_webhook(sig, raw_body, WEBHOOK_SECRET):
+        abort(400, "Invalid signature")
+    payload = request.get_json()
+    print("Call update:", payload["callId"], payload["status"])
+    return "", 200
+```
+
+The signature format is `t=<unix_seconds>,v1=<hex>` where
+`hex = HMAC-SHA256(secret, f"{t}.{raw_body}")`.
+
+`verify_webhook` never raises. It returns `False` for invalid or expired signatures
+(default tolerance: 300 seconds).
+
+---
+
+## Error handling
+
+All API errors raise `ByoursideError`:
+
+```python
+from byourside import Client, ByoursideError
+
+client = Client(api_key="bys_ak_YOUR_KEY")
+try:
+    client.place_call(to="+19001234567", objective="Sell something")
+except ByoursideError as e:
+    print(e.code)    # e.g. "destination_blocked"
+    print(e.status)  # HTTP status, or 0 for network/timeout errors
+    print(str(e))    # Human-readable message
+```
+
+Common error codes:
+
+| Code | Meaning |
+|---|---|
+| `destination_blocked` | Destination not allowed (premium, IRSF, or unsupported country) |
+| `invalid_number` | Number must be E.164, e.g. +14155550123 |
+| `to_required` | Missing destination number |
+| `objective_required` | Missing call objective |
+| `caller_id_not_owned` | Caller ID not on your account |
+| `rate_limited` | Rate limit reached, retry shortly |
+| `over_minute_cap` | Outbound usage limit reached |
+| `unauthorized` | Invalid or missing API key |
+| `not_found` | Call ID not found |
+| `placement_failed` | Carrier or trunk issue, retry shortly |
+| `store_error` | Temporary service error, retry shortly |
+| `network_error` | Could not reach the API |
+| `timeout` | `wait_for_call` deadline exceeded |
+
+---
+
+## Development
+
+Clone the repo. No install step needed for local use: run tests from the `sdks/python/` directory so that `byourside/` is on the path automatically.
+
+```bash
+cd sdks/python
+python3 -m unittest discover -s tests
+```
+
+Expected output: all tests pass (11 tests across errors, client, wait, and webhooks).
+
+If your environment does not add CWD to the path automatically, use:
+
+```bash
+cd sdks/python
+PYTHONPATH=. python3 -m unittest discover -s tests
+```
+
+Syntax check all source files:
+
+```bash
+python3 -m py_compile byourside/errors.py byourside/client.py byourside/webhooks.py byourside/__init__.py
+```
+
+Publishing to PyPI is deferred. Do not publish without explicit owner approval.

byourside-0.1.0/README.md

@@ -0,0 +1,162 @@
+# By Your Side Python SDK
+
+Zero-dependency Python client for the By Your Side Agent Outbound-Call API.
+Place objective-driven AI calls, poll for results, and verify webhooks using only the Python standard library.
+
+Requires Python 3.8+. No third-party packages needed.
+
+---
+
+## Quick start
+
+### Place a call and wait for the result
+
+```python
+from byourside import Client
+
+client = Client(api_key="bys_ak_YOUR_KEY")
+
+# Place an outbound call with an objective
+call = client.place_call(
+    to="+14155550123",
+    objective="Confirm the appointment for tomorrow at 2pm and ask if they need to reschedule.",
+    fields=[
+        {"name": "confirmed", "type": "boolean"},
+        {"name": "new_time", "type": "string"},
+    ],
+)
+print("Placed:", call["callId"], "status:", call["status"])
+
+# Poll until the call reaches a terminal status (default timeout: 180s)
+result = client.wait_for_call(call["callId"], timeout=180, interval=5)
+print("Final status:", result["status"])
+print("Extracted fields:", result.get("extracted"))
+```
+
+### List recent calls
+
+```python
+calls = client.list_calls(limit=10)
+for c in calls:
+    print(c["callId"], c["status"])
+```
+
+### Get a specific call
+
+```python
+call = client.get_call("call_abc123")
+print(call)
+```
+
+---
+
+## Call statuses
+
+| Status | Meaning |
+|---|---|
+| `queued` | Call accepted, waiting to be placed |
+| `in_progress` | Call is active |
+| `completed` | Call finished normally (terminal) |
+| `no_answer` | Recipient did not pick up (terminal) |
+| `voicemail` | Reached voicemail (terminal) |
+| `declined` | Recipient declined the call (terminal) |
+| `failed` | Call could not complete (terminal) |
+
+`wait_for_call` returns once the status is one of the five terminal states.
+
+---
+
+## Webhook verification
+
+By Your Side sends a `X-BYS-Signature` header with each webhook delivery.
+Verify it before processing the payload.
+
+### Flask example
+
+```python
+from flask import Flask, request, abort
+from byourside import verify_webhook
+
+app = Flask(__name__)
+WEBHOOK_SECRET = "whsec_YOUR_SECRET"
+
+@app.route("/webhook/bys", methods=["POST"])
+def bys_webhook():
+    sig = request.headers.get("X-BYS-Signature", "")
+    raw_body = request.get_data(as_text=True)
+    if not verify_webhook(sig, raw_body, WEBHOOK_SECRET):
+        abort(400, "Invalid signature")
+    payload = request.get_json()
+    print("Call update:", payload["callId"], payload["status"])
+    return "", 200
+```
+
+The signature format is `t=<unix_seconds>,v1=<hex>` where
+`hex = HMAC-SHA256(secret, f"{t}.{raw_body}")`.
+
+`verify_webhook` never raises. It returns `False` for invalid or expired signatures
+(default tolerance: 300 seconds).
+
+---
+
+## Error handling
+
+All API errors raise `ByoursideError`:
+
+```python
+from byourside import Client, ByoursideError
+
+client = Client(api_key="bys_ak_YOUR_KEY")
+try:
+    client.place_call(to="+19001234567", objective="Sell something")
+except ByoursideError as e:
+    print(e.code)    # e.g. "destination_blocked"
+    print(e.status)  # HTTP status, or 0 for network/timeout errors
+    print(str(e))    # Human-readable message
+```
+
+Common error codes:
+
+| Code | Meaning |
+|---|---|
+| `destination_blocked` | Destination not allowed (premium, IRSF, or unsupported country) |
+| `invalid_number` | Number must be E.164, e.g. +14155550123 |
+| `to_required` | Missing destination number |
+| `objective_required` | Missing call objective |
+| `caller_id_not_owned` | Caller ID not on your account |
+| `rate_limited` | Rate limit reached, retry shortly |
+| `over_minute_cap` | Outbound usage limit reached |
+| `unauthorized` | Invalid or missing API key |
+| `not_found` | Call ID not found |
+| `placement_failed` | Carrier or trunk issue, retry shortly |
+| `store_error` | Temporary service error, retry shortly |
+| `network_error` | Could not reach the API |
+| `timeout` | `wait_for_call` deadline exceeded |
+
+---
+
+## Development
+
+Clone the repo. No install step needed for local use: run tests from the `sdks/python/` directory so that `byourside/` is on the path automatically.
+
+```bash
+cd sdks/python
+python3 -m unittest discover -s tests
+```
+
+Expected output: all tests pass (11 tests across errors, client, wait, and webhooks).
+
+If your environment does not add CWD to the path automatically, use:
+
+```bash
+cd sdks/python
+PYTHONPATH=. python3 -m unittest discover -s tests
+```
+
+Syntax check all source files:
+
+```bash
+python3 -m py_compile byourside/errors.py byourside/client.py byourside/webhooks.py byourside/__init__.py
+```
+
+Publishing to PyPI is deferred. Do not publish without explicit owner approval.

byourside-0.1.0/byourside/__init__.py

@@ -0,0 +1,5 @@
+from .client import Client
+from .errors import ByoursideError
+from .webhooks import verify_webhook
+
+__all__ = ["Client", "ByoursideError", "verify_webhook"]

byourside-0.1.0/byourside/client.py

@@ -0,0 +1,79 @@
+"""By Your Side SDK client. Zero third-party deps (urllib). Raises ByoursideError on any
+non-2xx or network failure. The HTTP transport is injectable for tests."""
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from .errors import map_error, ByoursideError
+
+TERMINAL = {"completed", "no_answer", "voicemail", "declined", "failed"}
+
+
+def _default_transport(method, url, headers, body):
+    data = body.encode() if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req) as resp:
+            return (resp.status, json.loads(resp.read().decode() or "null"))
+    except urllib.error.HTTPError as e:
+        try:
+            obj = json.loads(e.read().decode() or "null")
+        except Exception:
+            obj = None
+        return (e.code, obj)
+    except urllib.error.URLError as e:
+        raise ByoursideError(map_error(0, None), 0, "network_error")
+
+
+class Client:
+    def __init__(self, api_key, base_url="https://api.byourside.ai", transport=None, sleep=None):
+        if not api_key:
+            raise ByoursideError("api_key is required", 0, "no_api_key")
+        self._api_key = api_key
+        self._base = base_url.rstrip("/")
+        self._transport = transport or _default_transport
+        self._sleep = sleep or time.sleep
+
+    def _request(self, method, path, body=None):
+        headers = {"Authorization": "Bearer %s" % self._api_key}
+        body_str = None
+        if body is not None and method != "GET":
+            headers["content-type"] = "application/json"
+            body_str = json.dumps(body)
+        status, data = self._transport(method, self._base + path, headers, body_str)
+        if not (200 <= status < 300):
+            code = data.get("error") if isinstance(data, dict) else "error"
+            raise ByoursideError(map_error(status, data), status, code or "error")
+        return data
+
+    def place_call(self, to, objective, context=None, fields=None, webhook_url=None, caller_id=None):
+        body = {"to": to, "objective": objective}
+        if context is not None:
+            body["context"] = context
+        if fields is not None:
+            body["fields"] = fields
+        if webhook_url is not None:
+            body["webhookUrl"] = webhook_url
+        if caller_id is not None:
+            body["callerId"] = caller_id
+        return self._request("POST", "/v1/agent/calls", body)
+
+    def get_call(self, call_id):
+        return self._request("GET", "/v1/agent/calls/" + urllib.parse.quote(str(call_id), safe=""))
+
+    def list_calls(self, limit=20):
+        n = min(max(1, int(limit) if str(limit).isdigit() else 20), 100)
+        data = self._request("GET", "/v1/agent/calls?limit=%d" % n)
+        return data.get("calls", []) if isinstance(data, dict) else []
+
+    def wait_for_call(self, call_id, timeout=180, interval=3):
+        deadline = time.monotonic() + timeout
+        while True:
+            call = self.get_call(call_id)
+            if isinstance(call, dict) and call.get("status") in TERMINAL:
+                return call
+            if time.monotonic() + interval > deadline:
+                raise ByoursideError("Call %s did not finish within %ss" % (call_id, timeout), 0, "timeout")
+            self._sleep(interval)

byourside-0.1.0/byourside/errors.py

@@ -0,0 +1,34 @@
+"""Typed error + token->message mapping for the By Your Side SDK. Never includes the API key."""
+
+_TOKEN_MESSAGES = {
+    "destination_blocked": "That destination is not allowed (premium, IRSF, or unsupported country).",
+    "invalid_number": "The destination number is invalid (use full E.164, e.g. +14155550123).",
+    "to_required": "A destination number (to) is required.",
+    "objective_required": "An objective for the call is required.",
+    "caller_id_not_owned": "That caller ID is not a number on your account.",
+    "rate_limited": "Rate limit reached. Try again shortly.",
+    "over_minute_cap": "Outbound usage limit reached for now.",
+    "unauthorized": "Invalid or missing API key.",
+    "not_found": "No call found with that id (or it does not belong to your account).",
+    "placement_failed": "The call could not be placed (carrier/trunk issue). Try again shortly.",
+    "store_error": "Temporary service error. Please retry shortly.",
+}
+
+
+def map_error(status, body):
+    token = body.get("error", "") if isinstance(body, dict) else ""
+    if token and token in _TOKEN_MESSAGES:
+        return _TOKEN_MESSAGES[token]
+    if not status or status >= 500:
+        return "Temporary service error. Please retry shortly."
+    if token:
+        return "Request failed (%s)." % token
+    return "Request failed with status %s." % status
+
+
+class ByoursideError(Exception):
+    def __init__(self, message, status=0, code=None):
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code

byourside-0.1.0/byourside/webhooks.py

@@ -0,0 +1,26 @@
+"""Verify a By Your Side webhook signature header. Never raises; returns bool.
+Header: "t=<unix_seconds>,v1=<hex>"; sig = HMAC-SHA256(secret, f"{t}.{raw_body}")."""
+import hmac
+import hashlib
+import time
+
+
+def verify_webhook(signature_header, raw_body, secret, tolerance=300):
+    try:
+        if not signature_header or not secret:
+            return False
+        parts = {}
+        for kv in str(signature_header).split(","):
+            if "=" in kv:
+                k, v = kv.split("=", 1)
+                parts[k.strip()] = v.strip()
+        t = parts.get("t"); v1 = parts.get("v1")
+        if t is None or v1 is None:
+            return False
+        t = int(t)
+        if abs(int(time.time()) - t) > tolerance:
+            return False
+        expected = hmac.new(secret.encode(), ("%d.%s" % (t, raw_body)).encode(), hashlib.sha256).hexdigest()
+        return hmac.compare_digest(expected, str(v1))
+    except Exception:
+        return False

byourside-0.1.0/byourside.egg-info/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: byourside
+Version: 0.1.0
+Summary: By Your Side SDK: give an AI a phone (outbound objective-driven calls).
+Author: By Your Side
+License: MIT
+Project-URL: Homepage, https://byourside.ai/docs/agent-api
+Project-URL: Repository, https://github.com/allexp1/voip-agent
+Keywords: voice,ai,phone,outbound,agent,sdk,voip,calls
+Classifier: Development Status :: 3 - Alpha
+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
+Classifier: Topic :: Communications :: Telephony
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# By Your Side Python SDK
+
+Zero-dependency Python client for the By Your Side Agent Outbound-Call API.
+Place objective-driven AI calls, poll for results, and verify webhooks using only the Python standard library.
+
+Requires Python 3.8+. No third-party packages needed.
+
+---
+
+## Quick start
+
+### Place a call and wait for the result
+
+```python
+from byourside import Client
+
+client = Client(api_key="bys_ak_YOUR_KEY")
+
+# Place an outbound call with an objective
+call = client.place_call(
+    to="+14155550123",
+    objective="Confirm the appointment for tomorrow at 2pm and ask if they need to reschedule.",
+    fields=[
+        {"name": "confirmed", "type": "boolean"},
+        {"name": "new_time", "type": "string"},
+    ],
+)
+print("Placed:", call["callId"], "status:", call["status"])
+
+# Poll until the call reaches a terminal status (default timeout: 180s)
+result = client.wait_for_call(call["callId"], timeout=180, interval=5)
+print("Final status:", result["status"])
+print("Extracted fields:", result.get("extracted"))
+```
+
+### List recent calls
+
+```python
+calls = client.list_calls(limit=10)
+for c in calls:
+    print(c["callId"], c["status"])
+```
+
+### Get a specific call
+
+```python
+call = client.get_call("call_abc123")
+print(call)
+```
+
+---
+
+## Call statuses
+
+| Status | Meaning |
+|---|---|
+| `queued` | Call accepted, waiting to be placed |
+| `in_progress` | Call is active |
+| `completed` | Call finished normally (terminal) |
+| `no_answer` | Recipient did not pick up (terminal) |
+| `voicemail` | Reached voicemail (terminal) |
+| `declined` | Recipient declined the call (terminal) |
+| `failed` | Call could not complete (terminal) |
+
+`wait_for_call` returns once the status is one of the five terminal states.
+
+---
+
+## Webhook verification
+
+By Your Side sends a `X-BYS-Signature` header with each webhook delivery.
+Verify it before processing the payload.
+
+### Flask example
+
+```python
+from flask import Flask, request, abort
+from byourside import verify_webhook
+
+app = Flask(__name__)
+WEBHOOK_SECRET = "whsec_YOUR_SECRET"
+
+@app.route("/webhook/bys", methods=["POST"])
+def bys_webhook():
+    sig = request.headers.get("X-BYS-Signature", "")
+    raw_body = request.get_data(as_text=True)
+    if not verify_webhook(sig, raw_body, WEBHOOK_SECRET):
+        abort(400, "Invalid signature")
+    payload = request.get_json()
+    print("Call update:", payload["callId"], payload["status"])
+    return "", 200
+```
+
+The signature format is `t=<unix_seconds>,v1=<hex>` where
+`hex = HMAC-SHA256(secret, f"{t}.{raw_body}")`.
+
+`verify_webhook` never raises. It returns `False` for invalid or expired signatures
+(default tolerance: 300 seconds).
+
+---
+
+## Error handling
+
+All API errors raise `ByoursideError`:
+
+```python
+from byourside import Client, ByoursideError
+
+client = Client(api_key="bys_ak_YOUR_KEY")
+try:
+    client.place_call(to="+19001234567", objective="Sell something")
+except ByoursideError as e:
+    print(e.code)    # e.g. "destination_blocked"
+    print(e.status)  # HTTP status, or 0 for network/timeout errors
+    print(str(e))    # Human-readable message
+```
+
+Common error codes:
+
+| Code | Meaning |
+|---|---|
+| `destination_blocked` | Destination not allowed (premium, IRSF, or unsupported country) |
+| `invalid_number` | Number must be E.164, e.g. +14155550123 |
+| `to_required` | Missing destination number |
+| `objective_required` | Missing call objective |
+| `caller_id_not_owned` | Caller ID not on your account |
+| `rate_limited` | Rate limit reached, retry shortly |
+| `over_minute_cap` | Outbound usage limit reached |
+| `unauthorized` | Invalid or missing API key |
+| `not_found` | Call ID not found |
+| `placement_failed` | Carrier or trunk issue, retry shortly |
+| `store_error` | Temporary service error, retry shortly |
+| `network_error` | Could not reach the API |
+| `timeout` | `wait_for_call` deadline exceeded |
+
+---
+
+## Development
+
+Clone the repo. No install step needed for local use: run tests from the `sdks/python/` directory so that `byourside/` is on the path automatically.
+
+```bash
+cd sdks/python
+python3 -m unittest discover -s tests
+```
+
+Expected output: all tests pass (11 tests across errors, client, wait, and webhooks).
+
+If your environment does not add CWD to the path automatically, use:
+
+```bash
+cd sdks/python
+PYTHONPATH=. python3 -m unittest discover -s tests
+```
+
+Syntax check all source files:
+
+```bash
+python3 -m py_compile byourside/errors.py byourside/client.py byourside/webhooks.py byourside/__init__.py
+```
+
+Publishing to PyPI is deferred. Do not publish without explicit owner approval.

byourside-0.1.0/byourside.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+byourside/__init__.py
+byourside/client.py
+byourside/errors.py
+byourside/webhooks.py
+byourside.egg-info/PKG-INFO
+byourside.egg-info/SOURCES.txt
+byourside.egg-info/dependency_links.txt
+byourside.egg-info/top_level.txt
+tests/test_client.py
+tests/test_errors.py
+tests/test_wait.py
+tests/test_webhooks.py

byourside-0.1.0/byourside.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

byourside-0.1.0/byourside.egg-info/top_level.txt

@@ -0,0 +1 @@
+byourside

byourside-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "byourside"
+version = "0.1.0"
+description = "By Your Side SDK: give an AI a phone (outbound objective-driven calls)."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = []
+license = { text = "MIT" }
+authors = [{ name = "By Your Side" }]
+keywords = ["voice", "ai", "phone", "outbound", "agent", "sdk", "voip", "calls"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Communications :: Telephony",
+  "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+[project.urls]
+Homepage = "https://byourside.ai/docs/agent-api"
+Repository = "https://github.com/allexp1/voip-agent"
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["byourside*"]

byourside-0.1.0/setup.cfg

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

byourside-0.1.0/tests/test_client.py

@@ -0,0 +1,48 @@
+import json, unittest
+from byourside.client import Client
+from byourside.errors import ByoursideError
+
+def make_client(captured, resp=None, raise_status=None):
+    def transport(method, url, headers, body):
+        captured["method"] = method; captured["url"] = url
+        captured["headers"] = headers; captured["body"] = body
+        if raise_status is not None:
+            return raise_status  # (status, obj)
+        return resp
+    return Client(api_key="bys_ak_x", base_url="https://b", transport=transport)
+
+class TestClient(unittest.TestCase):
+    def test_place_call(self):
+        cap = {}
+        c = make_client(cap, resp=(200, {"callId": "c1", "status": "queued"}))
+        r = c.place_call(to="+14155550123", objective="Book a table", fields=[{"name": "booked"}])
+        self.assertEqual(cap["method"], "POST")
+        self.assertEqual(cap["url"], "https://b/v1/agent/calls")
+        self.assertEqual(cap["headers"]["Authorization"], "Bearer bys_ak_x")
+        self.assertEqual(json.loads(cap["body"])["to"], "+14155550123")
+        self.assertEqual(r["callId"], "c1")
+
+    def test_get_call_encoded(self):
+        cap = {}
+        c = make_client(cap, resp=(200, {"id": "c1", "status": "completed"}))
+        c.get_call("c 1")
+        self.assertEqual(cap["method"], "GET")
+        self.assertEqual(cap["url"], "https://b/v1/agent/calls/c%201")
+        self.assertIsNone(cap["body"])
+
+    def test_list_calls_unwrap_clamp(self):
+        cap = {}
+        c = make_client(cap, resp=(200, {"calls": [{"id": "c1"}]}))
+        r = c.list_calls(limit=9999)
+        self.assertTrue(cap["url"].endswith("/v1/agent/calls?limit=100"))
+        self.assertEqual(r, [{"id": "c1"}])
+
+    def test_error_raises(self):
+        c = make_client({}, raise_status=(400, {"error": "destination_blocked"}))
+        with self.assertRaises(ByoursideError) as ctx:
+            c.place_call(to="+1900", objective="x")
+        self.assertEqual(ctx.exception.status, 400)
+        self.assertEqual(ctx.exception.code, "destination_blocked")
+
+if __name__ == "__main__":
+    unittest.main()

byourside-0.1.0/tests/test_errors.py

@@ -0,0 +1,17 @@
+import unittest
+from byourside.errors import map_error, ByoursideError
+
+class TestErrors(unittest.TestCase):
+    def test_known_tokens(self):
+        self.assertIn("not allowed", map_error(400, {"error": "destination_blocked"}).lower())
+        self.assertIn("api key", map_error(401, {"error": "unauthorized"}).lower())
+    def test_fallbacks(self):
+        self.assertIn("temporary", map_error(503, {"error": "store_error"}).lower())
+        self.assertIn("temporary", map_error(0, None).lower())
+        self.assertIn("weird", map_error(400, {"error": "weird"}))
+    def test_error_fields(self):
+        e = ByoursideError("msg", 400, "destination_blocked")
+        self.assertEqual(e.status, 400); self.assertEqual(e.code, "destination_blocked"); self.assertEqual(e.message, "msg")
+
+if __name__ == "__main__":
+    unittest.main()

byourside-0.1.0/tests/test_wait.py

@@ -0,0 +1,26 @@
+import unittest
+from byourside.client import Client
+from byourside.errors import ByoursideError
+
+def seq_client(statuses):
+    state = {"i": 0, "sleeps": 0}
+    def transport(method, url, headers, body):
+        s = statuses[min(state["i"], len(statuses) - 1)]; state["i"] += 1
+        return (200, {"id": "c1", "status": s})
+    c = Client(api_key="k", base_url="https://b", transport=transport, sleep=lambda *_: state.__setitem__("sleeps", state["sleeps"] + 1))
+    return c, state
+
+class TestWait(unittest.TestCase):
+    def test_returns_when_terminal(self):
+        c, st = seq_client(["queued", "in_progress", "completed"])
+        r = c.wait_for_call("c1", timeout=100, interval=0)
+        self.assertEqual(r["status"], "completed")
+        self.assertEqual(st["sleeps"], 2)
+    def test_timeout(self):
+        c, _ = seq_client(["queued"])
+        with self.assertRaises(ByoursideError) as ctx:
+            c.wait_for_call("c1", timeout=0, interval=0)
+        self.assertEqual(ctx.exception.code, "timeout")
+
+if __name__ == "__main__":
+    unittest.main()

byourside-0.1.0/tests/test_webhooks.py

@@ -0,0 +1,22 @@
+import hmac, hashlib, time, unittest
+from byourside.webhooks import verify_webhook
+
+SECRET = "whsec"
+def sign(ts, body):
+    v1 = hmac.new(SECRET.encode(), ("%d.%s" % (ts, body)).encode(), hashlib.sha256).hexdigest()
+    return "t=%d,v1=%s" % (ts, v1)
+
+class TestWebhooks(unittest.TestCase):
+    def test_accepts_valid(self):
+        body = '{"callId":"c1"}'; ts = int(time.time())
+        self.assertTrue(verify_webhook(sign(ts, body), body, SECRET))
+    def test_rejects(self):
+        body = '{"callId":"c1"}'; ts = int(time.time())
+        self.assertFalse(verify_webhook(sign(ts, body), '{"callId":"c2"}', SECRET))
+        self.assertFalse(verify_webhook(sign(ts, body), body, "other"))
+        self.assertFalse(verify_webhook(sign(ts - 9999, body), body, SECRET, tolerance=300))
+        self.assertFalse(verify_webhook("garbage", body, SECRET))
+        self.assertFalse(verify_webhook("", body, SECRET))
+
+if __name__ == "__main__":
+    unittest.main()