hyperagents 1.2.3rc5.post3__py3-none-any.whl

hyperclaw/updates/upgrade.py

@@ -0,0 +1,253 @@
+"""``hyperclaw upgrade`` / ``--rollback``: signed-only install with a kept
+previous version and automatic rollback (docs/UPDATES.md, "Flows").
+
+Every wheel that is installed, including a rollback target, is checked
+against a Hyper-signed manifest immediately before the install.
+"""
+from __future__ import annotations
+
+import datetime as _dt
+import json
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Optional, Tuple
+
+from hyperclaw import distribution as _dist
+from hyperclaw.updates import index, install as _inst, versioning
+from hyperclaw.updates import manifest as _m
+from hyperclaw.updates.paths import current_version, read_json, releases_dir, updates_dir, write_json
+
+
+@dataclass
+class Result:
+    status: str          # up-to-date | checked | declined | upgraded | restored | rolled-back | refused | failed
+    message: str
+    before: str = ""
+    after: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return self.status in ("up-to-date", "checked", "declined", "upgraded", "restored")
+
+
+# ───────────────────────── state + retained releases ─────────────────────────
+
+def state_path() -> Path:
+    return updates_dir() / "state.json"
+
+
+def load_state() -> dict:
+    s = read_json(state_path(), {})
+    return s if isinstance(s, dict) else {}
+
+
+def _record(action: str, frm: str, to: str, result: str, source: str, **upd) -> None:
+    s = load_state()
+    s.update(upd)
+    hist = s.setdefault("history", [])
+    hist.append({"at": _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="seconds"),
+                 "action": action, "from": frm, "to": to, "result": result, "source": source})
+    del hist[:-50]
+    write_json(state_path(), s)
+
+
+def release_dir(version: str) -> Path:
+    return releases_dir() / versioning.normalize(version)
+
+
+def load_retained(version: str) -> Tuple[dict, Path]:
+    """Re-verify a retained release (signature + wheel sha256). Raises ManifestError."""
+    d = release_dir(version)
+    m = _m.load_and_verify(d / "manifest.json", expect_version=version)
+    wheel = d / m["wheel"]
+    _m.verify_wheel_file(wheel, m)
+    return m, wheel
+
+
+def fetch_and_retain(version: str, *, timeout: float = 60) -> Tuple[dict, Path]:
+    """Retained copy of ``version`` (reused if it still verifies, else fetched
+    from the index and checked against its signed manifest)."""
+    try:
+        return load_retained(version)
+    except _m.ManifestError:
+        pass
+    rel = index.release_info(version, timeout=timeout)
+    m, env = index.fetch_signed(version, rel, timeout=timeout)
+    d = release_dir(version)
+    wheel = index.download_wheel(index.wheel_url(rel, m["wheel"]), d, m, timeout=timeout)
+    write_json(d / "manifest.json", env)
+    return m, wheel
+
+
+# ───────────────────────── upgrade ─────────────────────────
+
+Out = Callable[[str], None]
+
+
+def _notes(m: dict) -> str:
+    return f"HyperClaw {m['version']} release notes:\n\n{m['release_notes'].strip()}\n"
+
+
+def latest_or_current(current: str, *, timeout: float = 10) -> str:
+    """Newest ``hyperagents`` release on the index, or ``current`` when the
+    index cannot be reached (offline) or lists nothing usable."""
+    try:
+        info = index.project_info(timeout=timeout)
+        return index.latest_version(info, include_pre=index.include_prereleases(current)) \
+            or current
+    except Exception:  # offline, bad JSON: fall back to the running version
+        return current
+
+
+def legacy_result(current: str, *, timeout: float = 10) -> Result:
+    """An install of the old ``hyperclaw`` distribution: one plain line saying
+    how to move to ``hyperagents``. Nothing is uninstalled automatically."""
+    return Result("refused", _dist.migration_line(latest_or_current(current, timeout=timeout)),
+                  current, current)
+
+
+def upgrade(*, target: Optional[str] = None, yes: bool = False, check_only: bool = False,
+            allow_no_rollback: bool = False, confirm: Optional[Callable[[str], bool]] = None,
+            out: Out = print, method: Optional[_inst.InstallMethod] = None,
+            runner=subprocess.run, source: str = "user",
+            current: Optional[str] = None, legacy: Optional[bool] = None) -> Result:
+    current = current or current_version()
+    if _dist.is_legacy_install() if legacy is None else legacy:
+        return legacy_result(current)
+    try:
+        if target is None:
+            info = index.project_info()
+            target = index.latest_version(info, include_pre=index.include_prereleases(current))
+            if not target or not versioning.is_newer(target, current):
+                return Result("up-to-date", f"HyperClaw {current} is up to date.", current, current)
+        elif not versioning.is_newer(target, current):
+            return Result("refused", f"Refused: {target} is not newer than the installed "
+                          f"{current}. To go back, use 'hyperclaw upgrade --rollback'.",
+                          current, current)
+        rel = index.release_info(target)
+        m, _env = index.fetch_signed(target, rel)
+    except _m.ManifestError as e:
+        return Result("refused", f"Refused: {e}. Only Hyper-signed releases are installed.",
+                      current, current)
+    except index.IndexError_ as e:
+        return Result("failed", f"Could not check for updates ({e}).", current, current)
+
+    target = m["version"]
+    mn = versioning.parse(m["min_upgrade_from"])
+    if mn and versioning.parse(current) < mn:
+        return Result("refused", f"Refused: {target} needs {m['min_upgrade_from']} or later "
+                      f"installed first (you have {current}). Run 'hyperclaw upgrade "
+                      f"--version {m['min_upgrade_from']}' first.", current, current)
+    out(_notes(m))
+    if check_only:
+        return Result("checked", f"{target} is available (signed, verified).", current, current)
+
+    try:
+        method = method or _inst.detect()
+    except _inst.UnsupportedInstall as e:
+        return Result("refused", str(e), current, current)
+
+    if not yes:
+        ask = confirm or (lambda q: input(q).strip().lower() in ("y", "yes"))
+        if not ask(f"Install HyperClaw {target} (replacing {current})? [y/N] "):
+            return Result("declined", "Nothing installed.", current, current)
+
+    try:
+        m, wheel = fetch_and_retain(target)
+    except (_m.ManifestError, index.IndexError_) as e:
+        return Result("refused", f"Refused: {e}. Nothing installed.", current, current)
+    prev_wheel = None
+    try:
+        _pm, prev_wheel = fetch_and_retain(current)
+    except (_m.ManifestError, index.IndexError_) as e:
+        if not allow_no_rollback:
+            return Result("refused", f"Refused: the installed version {current} cannot be kept "
+                          f"for rollback ({e}). Re-run with --allow-no-rollback to upgrade "
+                          f"without a way back.", current, current)
+        out(f"Warning: {current} cannot be kept for rollback ({e}).")
+
+    out(f"Installing HyperClaw {target} ({method.kind})...")
+    ok, log = _inst.install(method, wheel, runner=runner)
+    if ok and _inst.verify(method, target, runner=runner):
+        upd = {"installed": target, "method": method.kind}
+        if prev_wheel is not None:
+            upd["previous"] = versioning.normalize(current)
+        _record("upgrade", current, target, "ok", source, **upd)
+        return Result("upgraded", f"HyperClaw {target} installed and verified "
+                      f"(previous {current} kept; 'hyperclaw upgrade --rollback' restores it). "
+                      f"Restart any running HyperClaw services to use it.", current, target)
+
+    why = "install failed" if not ok else "post-install check failed"
+    return _auto_rollback(method, current, target, why, log, runner, source)
+
+
+def _auto_rollback(method, current, target, why, log, runner, source) -> Result:
+    tail = (log or "").strip().splitlines()[-3:]
+    detail = (" | " + " / ".join(tail)) if tail and why == "install failed" else ""
+    try:
+        _pm, prev_wheel = load_retained(current)
+    except _m.ManifestError as e:
+        _record("upgrade", current, target, f"{why}; no rollback ({e})", source)
+        return Result("failed", f"Upgrade to {target} failed ({why}{detail}) and {current} "
+                      f"could not be restored automatically ({e}). Reinstall with "
+                      f"'pipx install --force {_dist.DIST_NAME}=={current}'.", current, "")
+    ok, _ = _inst.install(method, prev_wheel, force=True, runner=runner)
+    back = ok and _inst.verify(method, current, runner=runner)
+    _record("upgrade", current, target, f"{why}; auto-rollback {'ok' if back else 'FAILED'}",
+            source)
+    if back:
+        return Result("rolled-back", f"Upgrade to {target} failed ({why}{detail}); "
+                      f"rolled back to {current} automatically.", current, current)
+    return Result("failed", f"Upgrade to {target} failed ({why}{detail}) and the automatic "
+                  f"rollback to {current} also failed. Reinstall with "
+                  f"'pipx install --force {_dist.DIST_NAME}=={current}'.", current, "")
+
+
+# ───────────────────────── rollback ─────────────────────────
+
+def rollback(*, yes: bool = False, confirm: Optional[Callable[[str], bool]] = None,
+             out: Out = print, method: Optional[_inst.InstallMethod] = None,
+             runner=subprocess.run, current: Optional[str] = None) -> Result:
+    current = current or current_version()
+    prev = load_state().get("previous")
+    if not prev:
+        return Result("refused", "No previous version is kept; nothing to roll back to.",
+                      current, current)
+    try:
+        _pm, wheel = load_retained(prev)
+    except _m.ManifestError as e:
+        return Result("refused", f"Refused: the kept version {prev} failed verification ({e}). "
+                      f"Nothing installed.", current, current)
+    try:
+        method = method or _inst.detect()
+    except _inst.UnsupportedInstall as e:
+        return Result("refused", str(e), current, current)
+    if not yes:
+        ask = confirm or (lambda q: input(q).strip().lower() in ("y", "yes"))
+        if not ask(f"Roll back HyperClaw {current} to {prev}? [y/N] "):
+            return Result("declined", "Nothing installed.", current, current)
+    out(f"Restoring HyperClaw {prev} ({method.kind})...")
+    ok, _ = _inst.install(method, wheel, force=True, runner=runner)
+    if ok and _inst.verify(method, prev, runner=runner):
+        _record("rollback", current, prev, "ok", "user", installed=prev,
+                previous=versioning.normalize(current))
+        return Result("restored", f"Rolled back to HyperClaw {prev} (verified). "
+                      f"{current} is kept; run --rollback again to return to it.", current, prev)
+    # The rollback itself failed: try to put the current version back.
+    try:
+        _cm, cur_wheel = load_retained(current)
+        ok2, _ = _inst.install(method, cur_wheel, force=True, runner=runner)
+        restored = ok2 and _inst.verify(method, current, runner=runner)
+    except _m.ManifestError:
+        restored = False
+    _record("rollback", current, prev, f"failed; restore {'ok' if restored else 'FAILED'}", "user")
+    return Result("rolled-back" if restored else "failed",
+                  f"Rollback to {prev} failed; " + (f"{current} restored." if restored else
+                                                    f"reinstall with 'pipx install --force "
+                                                    f"{_dist.DIST_NAME}=={current}'."),
+                  current, current if restored else "")
+
+
+def history_json() -> str:
+    return json.dumps(load_state(), indent=2, sort_keys=True)

hyperclaw/updates/versioning.py

@@ -0,0 +1,104 @@
+"""PEP 440 version parsing/ordering for the subset HyperClaw publishes
+(``X.Y.Z``, ``aN``/``bN``/``rcN``, ``.postN``, ``.devN``, ``+local``).
+
+Kept dependency-free so the updater works even if ``packaging`` is absent.
+"""
+from __future__ import annotations
+
+import re
+from typing import Optional, Tuple
+
+_RE = re.compile(
+    r"^\s*v?(?P<rel>\d+(?:\.\d+)*)"
+    r"(?:[-_.]?(?P<pre>a|alpha|b|beta|c|rc|pre|preview)[-_.]?(?P<pren>\d*))?"
+    r"(?:[-_.]?post[-_.]?(?P<post>\d*))?"
+    r"(?:[-_.]?dev[-_.]?(?P<dev>\d*))?"
+    r"(?:\+(?P<local>[a-z0-9]+(?:[-_.][a-z0-9]+)*))?\s*$",
+    re.IGNORECASE,
+)
+_PHASE = {"a": 0, "alpha": 0, "b": 1, "beta": 1, "c": 2, "rc": 2, "pre": 2, "preview": 2}
+_PHASE_NAME = {0: "a", 1: "b", 2: "rc"}
+
+
+class Version:
+    __slots__ = ("release", "pre", "post", "dev", "local")
+
+    def __init__(self, release: Tuple[int, ...], pre=None, post=None, dev=None, local=None):
+        self.release, self.pre, self.post, self.dev, self.local = release, pre, post, dev, local
+
+    @property
+    def is_prerelease(self) -> bool:
+        return self.pre is not None or self.dev is not None
+
+    def _key(self):
+        rel = list(self.release)
+        while len(rel) > 1 and rel[-1] == 0:
+            rel.pop()
+        if self.pre is not None:
+            pre = self.pre
+        elif self.dev is not None and self.post is None:
+            pre = (-1, 0)          # X.devN sorts before X.aN
+        else:
+            pre = (3, 0)           # final release
+        post = self.post if self.post is not None else -1
+        dev = self.dev if self.dev is not None else float("inf")
+        return (tuple(rel), pre, post, dev)
+
+    def __eq__(self, o):
+        return isinstance(o, Version) and self._key() == o._key()
+
+    def __lt__(self, o):
+        return self._key() < o._key()
+
+    def __le__(self, o):
+        return self._key() <= o._key()
+
+    def __gt__(self, o):
+        return self._key() > o._key()
+
+    def __ge__(self, o):
+        return self._key() >= o._key()
+
+    def __hash__(self):
+        return hash(self._key())
+
+    def __str__(self):
+        s = ".".join(map(str, self.release))
+        if self.pre is not None:
+            s += f"{_PHASE_NAME[self.pre[0]]}{self.pre[1]}"
+        if self.post is not None:
+            s += f".post{self.post}"
+        if self.dev is not None:
+            s += f".dev{self.dev}"
+        if self.local:
+            s += f"+{self.local}"
+        return s
+
+    __repr__ = __str__
+
+
+def parse(v) -> Optional[Version]:
+    """Parse a version string; None when it is not a valid PEP 440 version."""
+    if isinstance(v, Version):
+        return v
+    m = _RE.match(str(v or ""))
+    if not m:
+        return None
+    rel = tuple(int(x) for x in m.group("rel").split("."))
+    pre = None
+    if m.group("pre"):
+        pre = (_PHASE[m.group("pre").lower()], int(m.group("pren") or 0))
+    post = int(m.group("post") or 0) if m.group("post") is not None else None
+    dev = int(m.group("dev") or 0) if m.group("dev") is not None else None
+    local = m.group("local").lower() if m.group("local") else None
+    return Version(rel, pre, post, dev, local)
+
+
+def normalize(v) -> str:
+    p = parse(v)
+    return str(p) if p else str(v)
+
+
+def is_newer(candidate, current) -> bool:
+    a, b = parse(candidate), parse(current)
+    return bool(a and b and a > b)

hyperclaw/userconfig.py

@@ -0,0 +1,119 @@
+"""The customer's own config: ``config.json`` and ``.env`` under HYPERCLAW_ROOT.
+
+One place that knows where these live, so onboarding, the TUI, the Telegram
+bot, doctor and the CLI all read and write the same files. Writes merge;
+they never drop keys they were not asked to change.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+
+def root() -> Path:
+    return Path(os.environ.get("HYPERCLAW_ROOT", str(Path.home() / ".hyperclaw")))
+
+
+def config_path() -> Path:
+    return root() / "config.json"
+
+
+def env_path() -> Path:
+    return root() / ".env"
+
+
+def load_config() -> dict:
+    p = config_path()
+    try:
+        if p.exists():
+            data = json.loads(p.read_text(encoding="utf-8"))
+            if isinstance(data, dict):
+                return data
+    except Exception:
+        pass
+    return {}
+
+
+def update_config(**updates) -> dict:
+    """Merge ``updates`` into config.json (a value of None removes the key)."""
+    data = load_config()
+    for k, v in updates.items():
+        if v is None:
+            data.pop(k, None)
+        else:
+            data[k] = v
+    p = config_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    os.replace(tmp, p)
+    return data
+
+
+# ── .env ────────────────────────────────────────────────────────────────
+
+def _parse_env(text: str) -> list:
+    """Lines as (key|None, raw_line)."""
+    out = []
+    for line in text.splitlines():
+        s = line.strip()
+        if s and not s.startswith("#") and "=" in s:
+            out.append((s.split("=", 1)[0].strip(), line))
+        else:
+            out.append((None, line))
+    return out
+
+
+def env_read() -> dict:
+    p = env_path()
+    if not p.exists():
+        return {}
+    out = {}
+    for key, line in _parse_env(p.read_text(encoding="utf-8")):
+        if key:
+            out[key] = line.split("=", 1)[1].strip().strip('"')
+    return out
+
+
+def env_update(values: dict, apply_to_process: bool = True) -> None:
+    """Set (value str) or remove (value None) keys in .env, keeping every
+    other line. The file is created owner-read/write only (0600)."""
+    p = env_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    lines = _parse_env(p.read_text(encoding="utf-8")) if p.exists() else []
+    pending = dict(values)
+    out = []
+    for key, line in lines:
+        if key is not None and key in pending:
+            v = pending.pop(key)
+            if v is not None:
+                out.append(f"{key}={v}")
+            continue
+        out.append(line)
+    for key, v in pending.items():
+        if v is not None:
+            out.append(f"{key}={v}")
+    text = "\n".join(out).rstrip("\n") + "\n"
+    fd = os.open(str(p), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(text)
+    try:
+        os.chmod(p, 0o600)
+    except OSError:
+        pass
+    if apply_to_process:
+        for key, v in values.items():
+            if v is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = v
+
+
+def load_env_into_process() -> None:
+    """setdefault every .env key into os.environ (never overrides), then the
+    secrets a team install keeps in the OS secret store (hyperclaw.teamsetup.secrets)."""
+    for k, v in env_read().items():
+        os.environ.setdefault(k, v)
+    from hyperclaw.teamsetup.secrets import export_env
+    export_env()

hyperclaw/xai.py

@@ -0,0 +1,83 @@
+"""xAI as a named provider (Grok), on the existing OpenAI-compatible client.
+
+- Base URL https://api.x.ai/v1, Bearer auth with XAI_API_KEY, the chat
+  completions endpoint (``POST /v1/chat/completions``).
+- Model ids from xAI's model documentation (read 2026-10-11). Default grok-4.7.
+- The reasoning models reject ``presence_penalty``, ``frequency_penalty`` and
+  ``stop``: ``clean_request`` removes them for those models, and every chat
+  request to this provider goes through it.
+- Tools only with a Hyper-signed qualification record (hyperclaw.qualification).
+  None ships, so Grok is chat-only.
+"""
+from __future__ import annotations
+
+from urllib.parse import urlsplit
+
+PROVIDER_NAME = "xai"
+LABEL = "xAI"
+BASE_URL = "https://api.x.ai/v1"
+HOST = "api.x.ai"
+API_KEY_ENV = "XAI_API_KEY"
+BASE_URL_ENV = "XAI_BASE_URL"
+MODEL_ENV = "XAI_MODEL"
+KEY_PREFIX = "xai-"
+
+DEFAULT_MODEL = "grok-4.7"
+MODELS = (
+    "grok-4.7",
+    "grok-4.6",
+    "grok-4.5",
+    "grok-4.3",
+    "grok-4.20-0309-reasoning",
+    "grok-4.20-0309-non-reasoning",
+    "grok-4.20-multi-agent-0309",
+    "grok-build-0.1",
+)
+# These reject presence_penalty, frequency_penalty and stop.
+REASONING_MODELS = frozenset({"grok-4.7", "grok-4.6", "grok-4.5",
+                              "grok-4.20-multi-agent-0309"})
+REJECTED_PARAMS = ("presence_penalty", "frequency_penalty", "stop")
+
+NAMES = {
+    "grok-4.7": "Grok 4.7",
+    "grok-4.6": "Grok 4.6",
+    "grok-4.5": "Grok 4.5",
+    "grok-4.3": "Grok 4.3",
+    "grok-4.20-0309-reasoning": "Grok 4.20 (reasoning)",
+    "grok-4.20-0309-non-reasoning": "Grok 4.20 (non-reasoning)",
+    "grok-4.20-multi-agent-0309": "Grok 4.20 multi-agent",
+    "grok-build-0.1": "Grok Build 0.1",
+}
+
+
+def is_xai(provider_name: str = "", base_url: str = "") -> bool:
+    if provider_name == PROVIDER_NAME:
+        return True
+    try:
+        return (urlsplit(base_url or "").hostname or "") == HOST
+    except ValueError:
+        return False
+
+
+def rejects_penalties(model: str) -> bool:
+    return (model or "").strip() in REASONING_MODELS
+
+
+def clean_request(provider_name: str, base_url: str, model: str, kwargs: dict) -> dict:
+    """Request kwargs safe for this provider + model. For xAI: never the
+    parameters its reasoning models reject, and never the vLLM-only
+    ``chat_template_kwargs`` switch. Other providers: unchanged."""
+    if not is_xai(provider_name, base_url):
+        return kwargs
+    out = dict(kwargs)
+    if rejects_penalties(model):
+        for k in REJECTED_PARAMS:
+            out.pop(k, None)
+    extra = out.get("extra_body")
+    if isinstance(extra, dict) and "chat_template_kwargs" in extra:
+        extra = {k: v for k, v in extra.items() if k != "chat_template_kwargs"}
+        if extra:
+            out["extra_body"] = extra
+        else:
+            out.pop("extra_body")
+    return out

integrations/__init__.py

@@ -0,0 +1,31 @@
+"""
+HyperClaw Integrations Layer — unified connector system for all platforms.
+"""
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorRegistry,
+    ConnectorInfo,
+    InboundMessage,
+    OutboundMessage,
+    ConnectorAuthError,
+    ConnectorRateLimitError,
+    ConnectorUnavailableError,
+    CapabilityNotSupportedError,
+)
+from integrations.gateway import HyperClawGateway
+
+__all__ = [
+    "BaseConnector",
+    "ConnectorCapability",
+    "ConnectorRegistry",
+    "ConnectorInfo",
+    "InboundMessage",
+    "OutboundMessage",
+    "ConnectorAuthError",
+    "ConnectorRateLimitError",
+    "ConnectorUnavailableError",
+    "CapabilityNotSupportedError",
+    "HyperClawGateway",
+]

integrations/automation/__init__.py

@@ -0,0 +1 @@
+# Automation integrations

integrations/automation/make.py

@@ -0,0 +1,87 @@
+"""MakeConnector — Make (formerly Integromat) webhook integration."""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.make")
+
+
+class MakeConnector(BaseConnector):
+    """
+    Make (Integromat) webhook connector for triggering scenarios.
+
+    Required config:
+        - webhook_url: Make webhook URL
+    """
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.webhook_url = config.get("webhook_url", "")
+
+        if config.get("enabled", False) and not self.webhook_url:
+            raise ValueError("MakeConnector requires webhook_url")
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="make",
+            platform="make",
+            category="automation",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.ACTION,
+                    ConnectorCapability.WEBHOOKS,
+                ]
+            ),
+            auth_type="webhook_token",
+            rate_limit_per_minute=60,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=30.0,
+                headers={"Content-Type": "application/json"},
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Make webhooks don't have a health endpoint."""
+        return True
+
+    async def trigger_scenario(self, data: dict) -> dict:
+        """Trigger a Make scenario with the given data."""
+        client = await self._get_client()
+
+        response = await client.post(
+            self.webhook_url,
+            json=data,
+        )
+
+        # Make webhooks return various status codes
+        if response.status_code not in (200, 201, 202):
+            raise Exception(f"Make trigger_scenario failed: {response.text}")
+
+        try:
+            return response.json()
+        except Exception:
+            return {"status": "triggered", "response": response.text}
+
+    async def _action_impl(self, action_name: str, params: dict) -> dict:
+        """Execute Make-specific actions."""
+        if action_name == "trigger" or action_name == "trigger_scenario":
+            return await self.trigger_scenario(params)
+
+        # Default: pass all params to trigger
+        return await self.trigger_scenario(params)