techartdev
157 lines
5.4 KiB
Python
157 lines
5.4 KiB
Python
"""DataUpdateCoordinator for the OpenClaw integration."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from datetime import datetime, timedelta, timezone
|
|
import logging
|
|
from typing import Any
|
|
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
|
|
|
|
from .api import (
|
|
OpenClawApiClient,
|
|
OpenClawApiError,
|
|
OpenClawAuthError,
|
|
OpenClawConnectionError,
|
|
)
|
|
from .const import (
|
|
DATA_CONNECTED,
|
|
DATA_CONTEXT_WINDOW,
|
|
DATA_GATEWAY_VERSION,
|
|
DATA_LAST_ACTIVITY,
|
|
DATA_MODEL,
|
|
DATA_PROVIDER,
|
|
DATA_SESSION_COUNT,
|
|
DATA_SESSIONS,
|
|
DATA_STATUS,
|
|
DATA_UPTIME,
|
|
DEFAULT_SCAN_INTERVAL,
|
|
DOMAIN,
|
|
)
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
class OpenClawCoordinator(DataUpdateCoordinator[dict[str, Any]]):
|
|
"""Coordinator that polls the OpenClaw gateway for status updates.
|
|
|
|
Fetches status, session info, and model info on a regular interval
|
|
and makes the data available to sensor/binary_sensor entities.
|
|
|
|
Handles:
|
|
- Transient connection failures (returns offline data, no UpdateFailed)
|
|
- Auth failures (triggers filesystem token re-read)
|
|
- Model info cached separately with a longer poll interval
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
hass: HomeAssistant,
|
|
client: OpenClawApiClient,
|
|
) -> None:
|
|
"""Initialize the coordinator."""
|
|
super().__init__(
|
|
hass,
|
|
_LOGGER,
|
|
name=DOMAIN,
|
|
update_interval=timedelta(seconds=DEFAULT_SCAN_INTERVAL),
|
|
)
|
|
self.client = client
|
|
self._last_activity: datetime | None = None
|
|
self._model_cache: dict[str, Any] = {}
|
|
self._consecutive_failures = 0
|
|
|
|
def _offline_data(self) -> dict[str, Any]:
|
|
"""Return a data dict representing the offline state."""
|
|
return {
|
|
DATA_STATUS: "offline",
|
|
DATA_CONNECTED: False,
|
|
DATA_SESSION_COUNT: 0,
|
|
DATA_SESSIONS: [],
|
|
DATA_MODEL: self._model_cache.get(DATA_MODEL),
|
|
DATA_LAST_ACTIVITY: self._last_activity,
|
|
DATA_GATEWAY_VERSION: None,
|
|
DATA_UPTIME: None,
|
|
DATA_PROVIDER: self._model_cache.get(DATA_PROVIDER),
|
|
DATA_CONTEXT_WINDOW: self._model_cache.get(DATA_CONTEXT_WINDOW),
|
|
}
|
|
|
|
async def _async_update_data(self) -> dict[str, Any]:
|
|
"""Fetch data from the OpenClaw gateway.
|
|
|
|
The OpenClaw gateway does not implement /v1/models — only
|
|
/v1/chat/completions is guaranteed. We use a lightweight base-URL
|
|
ping (``async_check_alive``) to confirm the gateway process is
|
|
running and then attempt ``async_get_models`` as a best-effort call.
|
|
|
|
Returns:
|
|
Aggregated data dict for all entities.
|
|
"""
|
|
data = self._offline_data()
|
|
|
|
# ── Connectivity check (base URL ping) ─────────────────────
|
|
try:
|
|
alive = await self.client.async_check_alive()
|
|
if not alive:
|
|
return data
|
|
|
|
data[DATA_STATUS] = "online"
|
|
data[DATA_CONNECTED] = True
|
|
data[DATA_GATEWAY_VERSION] = None
|
|
data[DATA_UPTIME] = None
|
|
data[DATA_SESSION_COUNT] = 0
|
|
data[DATA_SESSIONS] = []
|
|
data[DATA_LAST_ACTIVITY] = self._last_activity
|
|
self._consecutive_failures = 0
|
|
|
|
except OpenClawConnectionError:
|
|
self._consecutive_failures += 1
|
|
if self._consecutive_failures <= 3:
|
|
_LOGGER.debug("Gateway unreachable (attempt %d)", self._consecutive_failures)
|
|
elif self._consecutive_failures == 4:
|
|
_LOGGER.warning(
|
|
"Gateway has been unreachable for %d consecutive polls",
|
|
self._consecutive_failures,
|
|
)
|
|
return data
|
|
|
|
# ── Best-effort model info (/v1/models may not exist) ──────
|
|
try:
|
|
models_resp = await self.client.async_get_models()
|
|
models = models_resp.get("data", [])
|
|
if models:
|
|
current = models[0]
|
|
self._model_cache = {
|
|
DATA_MODEL: current.get("id", "unknown"),
|
|
DATA_PROVIDER: current.get("owned_by"),
|
|
DATA_CONTEXT_WINDOW: current.get("context_window"),
|
|
}
|
|
except OpenClawAuthError as err:
|
|
_LOGGER.warning("Gateway auth failed during poll: %s", err)
|
|
await self._try_refresh_token()
|
|
except OpenClawApiError:
|
|
# /v1/models not implemented — expected, not an error
|
|
pass
|
|
|
|
data.update(self._model_cache)
|
|
return data
|
|
|
|
async def _try_refresh_token(self) -> None:
|
|
"""Attempt to re-read the gateway token via the refresh callback."""
|
|
entry_data = self.hass.data.get(DOMAIN, {})
|
|
for eid, ed in entry_data.items():
|
|
if isinstance(ed, dict) and "refresh_token" in ed:
|
|
refresh_fn = ed["refresh_token"]
|
|
if await refresh_fn():
|
|
_LOGGER.info("Token refreshed successfully — next poll should succeed")
|
|
return
|
|
_LOGGER.debug("No token refresh callback available")
|
|
|
|
def update_last_activity(self) -> None:
|
|
"""Update the last activity timestamp to now.
|
|
|
|
Called when a message is sent/received through the integration.
|
|
"""
|
|
self._last_activity = datetime.now(timezone.utc)
|