hyperagents 1.2.3rc5.post3__py3-none-any.whl

integrations/messaging/slack.py

@@ -0,0 +1,217 @@
+"""SlackConnector — Slack API integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import AsyncIterator
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+    InboundMessage,
+    OutboundMessage,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.slack")
+
+
+from hyperclaw.tools.egress import slack_payload  # noqa: E402  (unfurls off)
+
+
+class SlackConnector(BaseConnector):
+    """
+    Slack API connector using Bot tokens.
+
+    Required config:
+        - bot_token: Slack Bot User OAuth Token (xoxb-...)
+    """
+
+    BASE_URL = "https://slack.com/api"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.bot_token = config.get("bot_token", "")
+
+        if config.get("enabled", False) and not self.bot_token:
+            raise ValueError("SlackConnector requires bot_token")
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="slack",
+            platform="slack",
+            category="messaging",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.SEND_MESSAGE,
+                    ConnectorCapability.RECEIVE_MESSAGE,
+                    ConnectorCapability.FILE_UPLOAD,
+                    ConnectorCapability.FILE_DOWNLOAD,
+                    ConnectorCapability.WEBHOOKS,
+                    ConnectorCapability.SEARCH,
+                    ConnectorCapability.ACTION,
+                    ConnectorCapability.NOTIFY,
+                ]
+            ),
+            auth_type="bearer",
+            rate_limit_per_minute=60,
+            supports_threads=True,
+            supports_attachments=True,
+            supports_reactions=True,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=30.0,
+                headers={
+                    "Authorization": f"Bearer {self.bot_token}",
+                    "Content-Type": "application/json",
+                },
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if bot token is valid."""
+        try:
+            client = await self._get_client()
+            response = await client.post(f"{self.BASE_URL}/auth.test")
+            data = response.json()
+            return data.get("ok", False)
+        except Exception as e:
+            logger.error(f"Slack health check failed: {e}")
+            return False
+
+    async def _send_impl(self, message: OutboundMessage) -> str:
+        """Send a message via Slack."""
+        client = await self._get_client()
+
+        payload = {
+            "channel": message.recipient_id or message.channel_id,
+            "text": message.content,
+        }
+
+        if message.thread_id:
+            payload["thread_ts"] = message.thread_id
+
+        if message.format == "blocks":
+            # If blocks format, content should be JSON blocks
+            import json
+
+            payload["blocks"] = json.loads(message.content)
+            payload["text"] = "Message"  # Fallback text
+
+        response = await client.post(f"{self.BASE_URL}/chat.postMessage", json=slack_payload(payload))
+        data = response.json()
+
+        if not data.get("ok"):
+            raise Exception(f"Slack send failed: {data.get('error')}")
+
+        return data.get("ts", "")
+
+    async def _receive_impl(self) -> AsyncIterator[InboundMessage]:
+        """
+        Receive messages. In production, use Socket Mode or Events API.
+        This implementation uses conversations.history for polling.
+        """
+        # Note: This is a simplified implementation.
+        # In production, use Slack Socket Mode or Events API with webhooks.
+        return
+        yield  # Make this an async generator
+
+    async def post_blocks(
+        self,
+        channel: str,
+        blocks: list[dict],
+        text: str = "Message",
+    ) -> str:
+        """Post a message with Block Kit blocks."""
+        client = await self._get_client()
+
+        payload = {
+            "channel": channel,
+            "blocks": blocks,
+            "text": text,
+        }
+
+        response = await client.post(f"{self.BASE_URL}/chat.postMessage", json=slack_payload(payload))
+        data = response.json()
+
+        if not data.get("ok"):
+            raise Exception(f"Slack post_blocks failed: {data.get('error')}")
+
+        return data.get("ts", "")
+
+    async def add_reaction(
+        self,
+        channel: str,
+        timestamp: str,
+        emoji: str,
+    ) -> bool:
+        """Add a reaction to a message."""
+        client = await self._get_client()
+
+        payload = {
+            "channel": channel,
+            "timestamp": timestamp,
+            "name": emoji.strip(":"),
+        }
+
+        response = await client.post(f"{self.BASE_URL}/reactions.add", json=payload)
+        data = response.json()
+
+        return data.get("ok", False)
+
+    async def search_messages(self, query: str, count: int = 20) -> list[dict]:
+        """Search messages in Slack."""
+        client = await self._get_client()
+
+        params = {
+            "query": query,
+            "count": count,
+        }
+
+        response = await client.get(f"{self.BASE_URL}/search.messages", params=params)
+        data = response.json()
+
+        if not data.get("ok"):
+            raise Exception(f"Slack search failed: {data.get('error')}")
+
+        return data.get("messages", {}).get("matches", [])
+
+    async def _search_impl(self, query: str, **kwargs) -> list[dict]:
+        """Search implementation."""
+        return await self.search_messages(query, kwargs.get("count", 20))
+
+    async def _action_impl(self, action_name: str, params: dict) -> dict:
+        """Execute Slack-specific actions."""
+        client = await self._get_client()
+
+        if action_name == "list_channels":
+            response = await client.get(f"{self.BASE_URL}/conversations.list")
+            return response.json()
+
+        elif action_name == "get_user":
+            response = await client.get(
+                f"{self.BASE_URL}/users.info",
+                params={"user": params["user_id"]},
+            )
+            return response.json()
+
+        elif action_name == "update_message":
+            response = await client.post(
+                f"{self.BASE_URL}/chat.update",
+                json={
+                    "channel": params["channel"],
+                    "ts": params["ts"],
+                    "text": params["text"],
+                },
+            )
+            return response.json()
+
+        raise ValueError(f"Unknown action: {action_name}")

integrations/messaging/sms.py

@@ -0,0 +1,175 @@
+"""SMSConnector — SMS messaging via Twilio API."""
+
+from __future__ import annotations
+
+import base64
+import logging
+from typing import AsyncIterator
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+    InboundMessage,
+    OutboundMessage,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.sms")
+
+
+class SMSConnector(BaseConnector):
+    """
+    SMS connector via Twilio API.
+
+    Required config:
+        - account_sid: Twilio Account SID
+        - auth_token: Twilio Auth Token
+        - from_number: Twilio phone number to send from
+    """
+
+    BASE_URL = "https://api.twilio.com/2010-04-01"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.account_sid = config.get("account_sid", "")
+        self.auth_token = config.get("auth_token", "")
+        self.from_number = config.get("from_number", "")
+
+        if config.get("enabled", False):
+            if not self.account_sid:
+                raise ValueError("SMSConnector requires account_sid")
+            if not self.auth_token:
+                raise ValueError("SMSConnector requires auth_token")
+            if not self.from_number:
+                raise ValueError("SMSConnector requires from_number")
+
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="sms",
+            platform="sms",
+            category="messaging",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.SEND_MESSAGE,
+                    ConnectorCapability.RECEIVE_MESSAGE,
+                    ConnectorCapability.NOTIFY,
+                ]
+            ),
+            auth_type="api_key",
+            rate_limit_per_minute=100,
+            supports_threads=False,
+            supports_attachments=False,
+            supports_reactions=False,
+        )
+
+    def _get_auth_header(self) -> str:
+        """Generate Basic auth header."""
+        credentials = f"{self.account_sid}:{self.auth_token}"
+        encoded = base64.b64encode(credentials.encode()).decode()
+        return f"Basic {encoded}"
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=30.0,
+                headers={
+                    "Authorization": self._get_auth_header(),
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+            )
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if Twilio credentials are valid."""
+        try:
+            client = await self._get_client()
+            response = await client.get(
+                f"{self.BASE_URL}/Accounts/{self.account_sid}.json",
+            )
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"SMS health check failed: {e}")
+            return False
+
+    async def _send_impl(self, message: OutboundMessage) -> str:
+        """Send an SMS message."""
+        client = await self._get_client()
+
+        data = {
+            "To": message.recipient_id,
+            "From": self.from_number,
+            "Body": message.content,
+        }
+
+        response = await client.post(
+            f"{self.BASE_URL}/Accounts/{self.account_sid}/Messages.json",
+            data=data,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"SMS send failed: {response.text}")
+
+        result = response.json()
+        return result.get("sid", "")
+
+    async def _receive_impl(self) -> AsyncIterator[InboundMessage]:
+        """
+        Receive SMS messages. Twilio uses webhooks for incoming messages.
+        This fetches recent messages via API for polling mode.
+        """
+        client = await self._get_client()
+
+        response = await client.get(
+            f"{self.BASE_URL}/Accounts/{self.account_sid}/Messages.json",
+            params={"To": self.from_number, "PageSize": 20},
+        )
+
+        if response.status_code != 200:
+            return
+
+        data = response.json()
+
+        for msg in data.get("messages", []):
+            if msg.get("direction") != "inbound":
+                continue
+
+            yield InboundMessage(
+                message_id=msg.get("sid", ""),
+                platform="sms",
+                sender_id=msg.get("from", ""),
+                sender_name=msg.get("from", ""),
+                content=msg.get("body", ""),
+                raw=msg,
+            )
+
+    async def send_mms(
+        self,
+        to: str,
+        body: str,
+        media_url: str,
+    ) -> str:
+        """Send an MMS with media attachment."""
+        client = await self._get_client()
+
+        data = {
+            "To": to,
+            "From": self.from_number,
+            "Body": body,
+            "MediaUrl": media_url,
+        }
+
+        response = await client.post(
+            f"{self.BASE_URL}/Accounts/{self.account_sid}/Messages.json",
+            data=data,
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"MMS send failed: {response.text}")
+
+        result = response.json()
+        return result.get("sid", "")

integrations/messaging/teams.py

@@ -0,0 +1,208 @@
+"""TeamsConnector — Microsoft Teams integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import AsyncIterator
+
+import httpx
+
+from integrations.base import (
+    BaseConnector,
+    ConnectorCapability,
+    ConnectorInfo,
+    InboundMessage,
+    OutboundMessage,
+)
+
+logger = logging.getLogger("hyperclaw.integrations.teams")
+
+
+class TeamsConnector(BaseConnector):
+    """
+    Microsoft Teams connector.
+
+    Supports two modes:
+    1. Webhook mode: Simple outbound only via webhook_url
+    2. Bot mode: Full bi-directional via app_id + app_password
+
+    Required config (one of):
+        - webhook_url: Teams Incoming Webhook URL (simple mode)
+        - app_id + app_password: Bot Framework credentials (full mode)
+    """
+
+    BOT_FRAMEWORK_URL = "https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token"
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.webhook_url = config.get("webhook_url", "")
+        self.app_id = config.get("app_id", "")
+        self.app_password = config.get("app_password", "")
+
+        if config.get("enabled", False):
+            if not self.webhook_url and not (self.app_id and self.app_password):
+                raise ValueError(
+                    "TeamsConnector requires webhook_url OR (app_id + app_password)"
+                )
+
+        self._client: httpx.AsyncClient | None = None
+        self._access_token: str | None = None
+
+    @property
+    def info(self) -> ConnectorInfo:
+        return ConnectorInfo(
+            connector_id="teams",
+            platform="teams",
+            category="messaging",
+            capabilities=frozenset(
+                [
+                    ConnectorCapability.SEND_MESSAGE,
+                    ConnectorCapability.RECEIVE_MESSAGE,
+                    ConnectorCapability.FILE_UPLOAD,
+                    ConnectorCapability.WEBHOOKS,
+                    ConnectorCapability.ACTION,
+                ]
+            ),
+            auth_type="oauth2" if self.app_id else "webhook_token",
+            rate_limit_per_minute=60,
+            supports_threads=True,
+            supports_attachments=True,
+            supports_reactions=True,
+        )
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=30.0)
+        return self._client
+
+    async def health(self) -> bool:
+        """Check if connector is configured."""
+        # Webhook mode: just check URL is set
+        if self.webhook_url:
+            return bool(self.webhook_url)
+
+        # Bot mode: try to get access token
+        try:
+            await self._get_bot_token()
+            return True
+        except Exception as e:
+            logger.error(f"Teams health check failed: {e}")
+            return False
+
+    async def _get_bot_token(self) -> str:
+        """Get Bot Framework access token."""
+        if self._access_token:
+            return self._access_token
+
+        client = await self._get_client()
+
+        response = await client.post(
+            self.BOT_FRAMEWORK_URL,
+            data={
+                "grant_type": "client_credentials",
+                "client_id": self.app_id,
+                "client_secret": self.app_password,
+                "scope": "https://api.botframework.com/.default",
+            },
+        )
+
+        if response.status_code != 200:
+            raise Exception(f"Failed to get Teams bot token: {response.text}")
+
+        data = response.json()
+        self._access_token = data.get("access_token", "")
+        return self._access_token
+
+    async def _send_impl(self, message: OutboundMessage) -> str:
+        """Send a message via Teams."""
+        if self.webhook_url:
+            return await self._send_via_webhook(message)
+        else:
+            return await self._send_via_bot(message)
+
+    async def _send_via_webhook(self, message: OutboundMessage) -> str:
+        """Send via incoming webhook."""
+        client = await self._get_client()
+
+        payload = {"text": message.content}
+
+        response = await client.post(self.webhook_url, json=payload)
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Teams webhook send failed: {response.text}")
+
+        return "webhook_sent"
+
+    async def _send_via_bot(self, message: OutboundMessage) -> str:
+        """Send via Bot Framework."""
+        client = await self._get_client()
+        token = await self._get_bot_token()
+
+        # Bot Framework requires conversation reference
+        # This is a simplified implementation
+        service_url = self.config.get("service_url", "https://smba.trafficmanager.net/")
+        conversation_id = message.recipient_id
+
+        payload = {
+            "type": "message",
+            "text": message.content,
+        }
+
+        response = await client.post(
+            f"{service_url}v3/conversations/{conversation_id}/activities",
+            json=payload,
+            headers={"Authorization": f"Bearer {token}"},
+        )
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Teams bot send failed: {response.text}")
+
+        data = response.json()
+        return data.get("id", "")
+
+    async def _receive_impl(self) -> AsyncIterator[InboundMessage]:
+        """
+        Receive messages. Teams uses Bot Framework webhooks.
+        """
+        return
+        yield
+
+    async def send_adaptive_card(
+        self,
+        webhook_url: str | None,
+        card: dict,
+    ) -> str:
+        """Send an Adaptive Card."""
+        client = await self._get_client()
+
+        url = webhook_url or self.webhook_url
+        if not url:
+            raise ValueError("No webhook URL provided")
+
+        payload = {
+            "type": "message",
+            "attachments": [
+                {
+                    "contentType": "application/vnd.microsoft.card.adaptive",
+                    "content": card,
+                }
+            ],
+        }
+
+        response = await client.post(url, json=payload)
+
+        if response.status_code not in (200, 201):
+            raise Exception(f"Teams adaptive card send failed: {response.text}")
+
+        return "card_sent"
+
+    async def _action_impl(self, action_name: str, params: dict) -> dict:
+        """Execute Teams-specific actions."""
+        if action_name == "send_adaptive_card":
+            result = await self.send_adaptive_card(
+                params.get("webhook_url"),
+                params["card"],
+            )
+            return {"status": "sent", "id": result}
+
+        raise ValueError(f"Unknown action: {action_name}")