voicemaster 0.1.0__tar.gz

voicemaster-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: voicemaster
+Version: 0.1.0
+Summary: Real-time AI phone calls: Gemini Live bridged to Vobiz and Twilio, with call reports, tools and knowledge search.
+Author: Rahul Wale
+Keywords: voice,phone,gemini,gemini-live,vobiz,twilio,ai-calling,telephony
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: Topic :: Communications :: Telephony
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi<1,>=0.141.1
+Requires-Dist: uvicorn[standard]<1,>=0.52.4
+Requires-Dist: aiohttp<4,>=3.14.3
+Requires-Dist: google-genai<2,>=1.75.0
+Requires-Dist: loguru<1,>=0.7.3
+Requires-Dist: tzdata>=2025.2
+Provides-Extra: test
+Requires-Dist: httpx; extra == "test"
+
+# voicemaster
+
+Real-time AI phone calls. A caller (or a person being called) talks to a Gemini Live assistant over a Vobiz or Twilio phone
+line. The library is the whole calling engine: the HTTP routes the telephony provider calls, the live audio stream in both
+directions, the Gemini Live session, the tools the assistant may use (end the call, transfer it, search the customer's
+documents), and the signed reports of how each call went.
+
+```bash
+pip install voicemaster
+python -m voicemaster.server        # Vobiz at /vobiz/..., Twilio at /twilio/..., one port (PORT, default 8760)
+```
+
+## Settings (environment variables)
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `PUBLIC_URL` | – | This server's public address **ending in `/vobiz`** (Vobiz). |
+| `TWILIO_PUBLIC_URL` | – | The same, **ending in `/twilio`** (Twilio). |
+| `API_TOKEN` | empty | If set, `POST /start` and `POST /calls/{id}/config` need the header `x-api-token`. |
+| `EVENTS_URL`, `EVENTS_SECRET` | empty | Where call reports go, and the secret that signs them (HMAC-SHA256). |
+| `KNOWLEDGE_SEARCH_URL` | derived from `EVENTS_URL` | Where the `search_knowledge` tool asks for passages. |
+| `MAX_CONCURRENT_CALLS` | 10 | Calls accepted at once. |
+| `RECORD_CALLS`, `RECORD_FORMAT`, `RECORD_MAX_LENGTH_SECONDS` | false, mp3, 300 | Recording (a call is recorded only if this *and* the call both ask). |
+| `GEMINI_LIVE_MODEL` | `gemini-3.1-flash-live-preview` | The Gemini Live model. |
+| `TIME_CONTEXT_TIMEZONE` | `Asia/Kolkata` | Time zone of the "what time is it" line given to the model. |
+| `LOG_LEVEL`, `LOG_DIR` | INFO, `logs` | Logging; files rotate at 50 MB and are kept 14 days. |
+
+The library never loads a `.env` file; load it yourself (`dotenv.load_dotenv()`) before importing `voicemaster`.
+Calling credentials (Vobiz / Twilio accounts, the Gemini key, the assistant's prompt) arrive **per call**, never from settings.
+
+## Building blocks
+
+```python
+from voicemaster.request import VOBIZ, parse_call_request     # check a POST /start body
+from voicemaster.tools import build_tools                      # end_call / transfer_call / search_knowledge
+from voicemaster.live import live_config                       # the Gemini Live settings for a call
+from voicemaster.call_events import sign                       # the HMAC signature of a report
+```
+
+See `voicemaster/__init__.py` for the full map of modules.

voicemaster-0.1.0/README.md

@@ -0,0 +1,40 @@
+# voicemaster
+
+Real-time AI phone calls. A caller (or a person being called) talks to a Gemini Live assistant over a Vobiz or Twilio phone
+line. The library is the whole calling engine: the HTTP routes the telephony provider calls, the live audio stream in both
+directions, the Gemini Live session, the tools the assistant may use (end the call, transfer it, search the customer's
+documents), and the signed reports of how each call went.
+
+```bash
+pip install voicemaster
+python -m voicemaster.server        # Vobiz at /vobiz/..., Twilio at /twilio/..., one port (PORT, default 8760)
+```
+
+## Settings (environment variables)
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `PUBLIC_URL` | – | This server's public address **ending in `/vobiz`** (Vobiz). |
+| `TWILIO_PUBLIC_URL` | – | The same, **ending in `/twilio`** (Twilio). |
+| `API_TOKEN` | empty | If set, `POST /start` and `POST /calls/{id}/config` need the header `x-api-token`. |
+| `EVENTS_URL`, `EVENTS_SECRET` | empty | Where call reports go, and the secret that signs them (HMAC-SHA256). |
+| `KNOWLEDGE_SEARCH_URL` | derived from `EVENTS_URL` | Where the `search_knowledge` tool asks for passages. |
+| `MAX_CONCURRENT_CALLS` | 10 | Calls accepted at once. |
+| `RECORD_CALLS`, `RECORD_FORMAT`, `RECORD_MAX_LENGTH_SECONDS` | false, mp3, 300 | Recording (a call is recorded only if this *and* the call both ask). |
+| `GEMINI_LIVE_MODEL` | `gemini-3.1-flash-live-preview` | The Gemini Live model. |
+| `TIME_CONTEXT_TIMEZONE` | `Asia/Kolkata` | Time zone of the "what time is it" line given to the model. |
+| `LOG_LEVEL`, `LOG_DIR` | INFO, `logs` | Logging; files rotate at 50 MB and are kept 14 days. |
+
+The library never loads a `.env` file; load it yourself (`dotenv.load_dotenv()`) before importing `voicemaster`.
+Calling credentials (Vobiz / Twilio accounts, the Gemini key, the assistant's prompt) arrive **per call**, never from settings.
+
+## Building blocks
+
+```python
+from voicemaster.request import VOBIZ, parse_call_request     # check a POST /start body
+from voicemaster.tools import build_tools                      # end_call / transfer_call / search_knowledge
+from voicemaster.live import live_config                       # the Gemini Live settings for a call
+from voicemaster.call_events import sign                       # the HMAC signature of a report
+```
+
+See `voicemaster/__init__.py` for the full map of modules.

voicemaster-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "voicemaster"
+version = "0.1.0"
+description = "Real-time AI phone calls: Gemini Live bridged to Vobiz and Twilio, with call reports, tools and knowledge search."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Rahul Wale" }]
+keywords = ["voice", "phone", "gemini", "gemini-live", "vobiz", "twilio", "ai-calling", "telephony"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Framework :: FastAPI",
+  "Topic :: Communications :: Telephony",
+]
+dependencies = [
+  "fastapi>=0.141.1,<1",
+  "uvicorn[standard]>=0.52.4,<1",
+  "aiohttp>=3.14.3,<4",
+  "google-genai>=1.75.0,<2",
+  "loguru>=0.7.3,<1",
+  # The engine tells the model the current time in an Indian timezone (zoneinfo); a slim image has no system tz database.
+  "tzdata>=2025.2",
+]
+
+[project.optional-dependencies]
+test = ["httpx"]
+
+[project.scripts]
+voicemaster-server = "voicemaster.server:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+voicemaster = ["static/*.html"]

voicemaster-0.1.0/setup.cfg

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

voicemaster-0.1.0/src/voicemaster/__init__.py

@@ -0,0 +1,28 @@
+"""voicemaster -- real-time AI phone calls: Gemini Live bridged to Vobiz and Twilio.
+
+The whole calling engine lives in this package. A thin application only has to start it:
+
+    python -m voicemaster.server              # both providers on one port (PORT, default 8760)
+    python -m voicemaster.engines.vobiz       # the Vobiz program on its own
+    python -m voicemaster.engines.twilio      # the Twilio program on its own
+
+The parts, so each can be used and tested on its own:
+
+    voicemaster.engines     the Vobiz and Twilio programs: HTTP routes, audio streams and the Gemini sessions
+    voicemaster.audio       audio format helpers (PCM / mu-law, resampling)
+    voicemaster.server      both programs behind one port
+    voicemaster.request     check a call request (POST /start, POST /calls/{id}/config)        parse_call_request
+    voicemaster.validation  phone numbers, language codes, transfer destinations
+    voicemaster.tools       the tools the model may call: end_call, transfer_call, search_knowledge
+    voicemaster.prompts     the base instructions and the "what time is it" line given to the model
+    voicemaster.live        the Gemini Live connection settings for a call
+    voicemaster.prewarm     connect to Gemini before the caller is on the line
+    voicemaster.pending     clean up calls that were placed but never connected
+    voicemaster.call_events report what happened on a call to the backend (signed)
+    voicemaster.knowledge   the search_knowledge tool and its signed call to the backend
+    voicemaster.providers   the Vobiz and Twilio REST / XML helpers
+
+Settings are environment variables, read once by `voicemaster.settings`.
+"""
+
+__version__ = "0.1.0"

voicemaster-0.1.0/src/voicemaster/audio.py

@@ -0,0 +1,162 @@
+"""
+vobiz_gemini_audio.py -- format conversion between the Vobiz stream and Gemini Live
+
+Ported verbatim from Vobiz's own official reference implementation
+(vobiz-ai/Vobiz-Gemini-Live-Streaming, audio.py) -- this is proven, tested
+audio math, not something to second-guess or rewrite.
+
+Two independent directions, each with its own format:
+
+    Vobiz  -> app     whatever `<Stream contentType>` asked for, echoed back
+                      in the WebSocket `start.mediaFormat` event:
+                      L16/8000, L16/16000 or mulaw/8000
+    app    -> Vobiz   `playAudio.media`: L16 at 8/16/24 kHz, or mulaw/8000
+
+Gemini Live is fixed on both sides: it accepts 16-bit PCM mono at 16 kHz and
+emits 16-bit PCM mono at 24 kHz. So the default configuration --
+`audio/x-l16;rate=16000` in, L16/24000 out -- needs no conversion at all in
+either direction. Everything below exists for the other combinations (e.g. if
+Vobiz negotiates mulaw/8000 instead of what we asked for).
+
+Pure Python on purpose: `audioop` was removed in Python 3.13.
+"""
+
+from __future__ import annotations
+
+import struct
+
+GEMINI_INPUT_RATE = 16000  # what Gemini Live expects on realtime input
+GEMINI_OUTPUT_RATE = 24000  # what Gemini Live emits
+
+
+# ---------------------------------------------------------------------------
+# G.711 mu-law
+# ---------------------------------------------------------------------------
+
+_BIAS = 0x84
+_CLIP = 32635
+
+_EXP_LUT = bytes(
+    [
+        0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+        4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+        7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+    ]
+)
+
+
+def _encode_mulaw_sample(sample: int) -> int:
+    sign = 0x80 if sample < 0 else 0x00
+    if sample < 0:
+        sample = -sample
+    if sample > _CLIP:
+        sample = _CLIP
+    sample += _BIAS
+    exponent = _EXP_LUT[(sample >> 7) & 0xFF]
+    mantissa = (sample >> (exponent + 3)) & 0x0F
+    return ~(sign | (exponent << 4) | mantissa) & 0xFF
+
+
+def _decode_mulaw_sample(byte: int) -> int:
+    byte = ~byte & 0xFF
+    t = ((byte & 0x0F) << 3) + _BIAS
+    t <<= (byte & 0x70) >> 4
+    return (_BIAS - t) if (byte & 0x80) else (t - _BIAS)
+
+
+_ENCODE_TABLE = bytes(_encode_mulaw_sample(s) for s in range(-32768, 32768))
+_DECODE_TABLE = [_decode_mulaw_sample(b) for b in range(256)]
+
+
+def pcm16_to_mulaw(pcm: bytes) -> bytes:
+    """Signed 16-bit little-endian PCM -> G.711 mu-law."""
+    samples = struct.unpack_from(f"<{len(pcm) // 2}h", pcm)
+    return bytes(_ENCODE_TABLE[s + 32768] for s in samples)
+
+
+def mulaw_to_pcm16(mulaw: bytes) -> bytes:
+    """G.711 mu-law -> signed 16-bit little-endian PCM."""
+    return struct.pack(f"<{len(mulaw)}h", *(_DECODE_TABLE[b] for b in mulaw))
+
+
+# ---------------------------------------------------------------------------
+# Resampling
+# ---------------------------------------------------------------------------
+
+def resample_pcm16(pcm: bytes, from_rate: int, to_rate: int) -> bytes:
+    """
+    Linear-interpolation resample of mono 16-bit PCM.
+
+    Good enough for telephony speech and dependency-free. Only exercised for
+    the non-default format combos (see module docstring) -- the default path
+    (L16/16000 in, L16/24000 out) never calls this.
+    """
+    if from_rate == to_rate or not pcm:
+        return pcm
+
+    count = len(pcm) // 2
+    if count == 0:
+        return b""
+    samples = struct.unpack_from(f"<{count}h", pcm)
+
+    out_count = max(1, int(count * to_rate / from_rate))
+    step = (count - 1) / out_count if out_count > 1 and count > 1 else 0.0
+
+    out = []
+    for i in range(out_count):
+        pos = i * step
+        left = int(pos)
+        right = min(left + 1, count - 1)
+        frac = pos - left
+        out.append(int(samples[left] + (samples[right] - samples[left]) * frac))
+    return struct.pack(f"<{out_count}h", *out)
+
+
+# ---------------------------------------------------------------------------
+# Vobiz <-> Gemini
+# ---------------------------------------------------------------------------
+
+def parse_content_type(content_type: str) -> tuple[str, int]:
+    """
+    `audio/x-l16;rate=16000` -> ("l16", 16000). Accepts the `encoding` value
+    from `start.mediaFormat` too, which carries no `;rate=` suffix.
+    """
+    head, _, tail = content_type.partition(";")
+    encoding = "mulaw" if "mulaw" in head.lower() else "l16"
+    rate = 8000
+    for part in tail.split(";"):
+        key, _, value = part.partition("=")
+        if key.strip().lower() == "rate" and value.strip().isdigit():
+            rate = int(value.strip())
+    return encoding, rate
+
+
+def to_gemini(payload: bytes, encoding: str, sample_rate: int) -> bytes:
+    """Caller audio in the stream's own format -> PCM16 mono 16 kHz."""
+    pcm = mulaw_to_pcm16(payload) if encoding == "mulaw" else payload
+    return resample_pcm16(pcm, sample_rate, GEMINI_INPUT_RATE)
+
+
+def from_gemini(pcm24: bytes, encoding: str, sample_rate: int) -> bytes:
+    """Gemini PCM16 mono 24 kHz -> the format declared in `playAudio.media`."""
+    pcm = resample_pcm16(pcm24, GEMINI_OUTPUT_RATE, sample_rate)
+    return pcm16_to_mulaw(pcm) if encoding == "mulaw" else pcm
+
+
+def frame_bytes(encoding: str, sample_rate: int, ms: int) -> int:
+    """Raw bytes in one `playAudio` frame of `ms` milliseconds."""
+    width = 1 if encoding == "mulaw" else 2
+    return int(sample_rate * width * ms / 1000)

voicemaster-0.1.0/src/voicemaster/call_events.py

@@ -0,0 +1,178 @@
+"""
+Tells the backend how each call went: answered, and ended.
+
+The engine stores nothing, so it can not be asked afterwards. Instead, each call reports two facts to the backend as
+they happen (see docs/voice-engine-events.md in the backend repo for the contract):
+
+  call.answered  the callee picked up
+  call.ended     the call is over: completed, no_answer or failed, with how long it lasted
+
+Sending never touches the call itself. An event is handed to a background task and `emit` returns at once; if the
+backend is slow, down or refuses, the call carries on exactly as before and the failure is only logged. Events are kept
+in memory only while they are being retried (nothing is written to disk); a restart of the engine loses the ones still
+waiting, which is the price of storing nothing.
+
+Off unless EVENTS_URL and EVENTS_SECRET are both set.
+"""
+
+import asyncio
+import hashlib
+import hmac
+import json
+import time
+from datetime import datetime, timezone
+
+import aiohttp
+from loguru import logger
+
+# The backend answers 404 for a call it does not know YET (the event can beat its own bookkeeping of a new call by a
+# moment), and 5xx or nothing when it has a problem: all worth trying again. Seconds to wait before each retry.
+RETRY_DELAYS = (1, 3, 10, 30)
+SEND_TIMEOUT_SECONDS = 10
+
+
+def iso(timestamp: float) -> str:
+    """Seconds since 1970 -> "2026-03-01T10:00:05Z" (always with a time zone, as the backend requires)."""
+    return datetime.fromtimestamp(timestamp, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def sign(secret: str, timestamp: str, body: bytes) -> str:
+    """The signature the backend checks: HMAC-SHA256 over "<timestamp>." + the exact body, as sha256=<hex>."""
+    digest = hmac.new(secret.encode(), timestamp.encode() + b"." + body, hashlib.sha256).hexdigest()
+    return f"sha256={digest}"
+
+
+def answered_event(call_uuid: str, answered_at: float) -> dict:
+    return {"event": "call.answered", "call_uuid": call_uuid, "answered_at": iso(answered_at)}
+
+
+def transcript_event(call_uuid: str, entries: list[dict]) -> dict:
+    """entries: [{"speaker": "agent"|"caller", "text": "...", "at": <epoch seconds>}, ...], oldest first.
+    One entry per turn (what the model actually heard/said was already assembled turn by turn), not per audio chunk."""
+    return {
+        "event": "call.transcript",
+        "call_uuid": call_uuid,
+        "entries": [{"speaker": entry["speaker"], "content": entry["text"], "spoken_at": iso(entry["at"])} for entry in entries],
+    }
+
+
+def recording_event(call_uuid: str, recording_url: str, duration_seconds: int | None, format: str) -> dict:
+    event = {"event": "call.recording", "call_uuid": call_uuid, "recording_url": recording_url, "format": format}
+    if duration_seconds is not None:
+        event["duration_seconds"] = duration_seconds
+    return event
+
+
+class GeminiUsageMeter:
+    """Adds up the tokens Gemini Live reports it used, by modality, so the backend can work out what the call cost.
+
+    Gemini sends `usage_metadata` once per turn, and each one covers that turn alone (its prompt already includes the
+    conversation so far, which Google bills again every turn) -- so the call's total is the SUM of all of them, not the
+    last one. Only reads messages; it never touches the audio path.
+    """
+
+    def __init__(self) -> None:
+        self.input: dict[str, int] = {}
+        self.output: dict[str, int] = {}
+
+    def add(self, message) -> None:
+        usage = getattr(message, "usage_metadata", None)
+        if not usage:
+            return
+        try:
+            self._count(self.input, getattr(usage, "prompt_tokens_details", None), getattr(usage, "prompt_token_count", None))
+            self._count(self.output, getattr(usage, "response_tokens_details", None), getattr(usage, "response_token_count", None))
+        except Exception:  # metering must never be able to break a live call
+            pass
+
+    @staticmethod
+    def _count(into: dict[str, int], details, total) -> None:
+        if details:
+            for item in details:
+                modality = getattr(getattr(item, "modality", None), "name", None) or "UNKNOWN"
+                into[modality] = into.get(modality, 0) + int(getattr(item, "token_count", 0) or 0)
+        elif total:
+            # No per-modality split: count it as AUDIO, the dearer rate, rather than undercount.
+            into["AUDIO"] = into.get("AUDIO", 0) + int(total)
+
+    def as_event_field(self) -> dict | None:
+        if not self.input and not self.output:
+            return None
+        return {"gemini": {"input": dict(self.input), "output": dict(self.output)}}
+
+
+def ended_event(call_uuid: str, end_reason: str, ended_at: float, answered_at: float | None, transferred: bool = False, ai_usage: dict | None = None) -> dict:
+    """end_reason: completed | no_answer | busy | failed | cancelled. A call nobody answered has no answered_at and no duration.
+
+    transferred: the call was handed to a person (Vobiz accepted the transfer). The backend charges a transfer fee for it.
+    """
+    event = {"event": "call.ended", "call_uuid": call_uuid, "end_reason": end_reason, "ended_at": iso(ended_at), "transferred": transferred}
+    if answered_at is not None:
+        event["answered_at"] = iso(answered_at)
+        event["duration_seconds"] = max(0, int(ended_at - answered_at))
+    if ai_usage:
+        event["ai_usage"] = ai_usage
+    return event
+
+
+class CallEventSender:
+    def __init__(self, url: str, secret: str, session: aiohttp.ClientSession):
+        self.url = url.strip()
+        self.secret = secret.strip()
+        self.session = session
+        self._tasks: set[asyncio.Task] = set()
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.url and self.secret)
+
+    def emit(self, event: dict) -> None:
+        """Hands the event to a background task and returns at once. Never raises, never waits: safe inside a live call."""
+        if not self.enabled:
+            return
+        try:
+            task = asyncio.get_running_loop().create_task(self._deliver(event))
+        except RuntimeError:
+            return
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
+
+    async def drain(self, timeout: float = 5.0) -> None:
+        """At shutdown: gives events that are still being sent a moment to arrive."""
+        if self._tasks:
+            await asyncio.wait(list(self._tasks), timeout=timeout)
+
+    async def _deliver(self, event: dict) -> None:
+        tag = f"{event['event']} {event['call_uuid'][:8]}"
+        body = json.dumps(event, separators=(",", ":")).encode()  # sent exactly as signed
+        for attempt in range(len(RETRY_DELAYS) + 1):
+            status = await self._post(body)
+            if status == 200:
+                return
+            retryable = status is None or status == 404 or status >= 500
+            if not retryable:
+                # 401: wrong secret or a clock that is off. 400: the event is not valid. Trying again changes nothing.
+                logger.error(f"Call event {tag} refused by the backend (HTTP {status}); not retrying")
+                return
+            if attempt == len(RETRY_DELAYS):
+                logger.warning(f"Call event {tag} not delivered after {attempt + 1} tries (last: {status or 'no answer'}); giving up")
+                return
+            await asyncio.sleep(RETRY_DELAYS[attempt])
+
+    async def _post(self, body: bytes) -> int | None:
+        timestamp = str(int(time.time()))
+        headers = {
+            "Content-Type": "application/json",
+            "X-Engine-Timestamp": timestamp,
+            "X-Engine-Signature": sign(self.secret, timestamp, body),
+        }
+        try:
+            async with self.session.post(
+                self.url, data=body, headers=headers, timeout=aiohttp.ClientTimeout(total=SEND_TIMEOUT_SECONDS)
+            ) as response:
+                await response.read()
+                return response.status
+        except Exception as exc:
+            # Only the kind of failure is logged: never the address parameters, the body or the signature.
+            logger.debug(f"Call event not sent: {type(exc).__name__}")
+            return None