genxai-framework 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

genxai/connectors/github.py

@@ -0,0 +1,117 @@
+"""GitHub connector implementation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+import asyncio
+import logging
+
+import httpx
+
+from genxai.connectors.base import Connector
+
+logger = logging.getLogger(__name__)
+
+
+class GitHubConnector(Connector):
+    """GitHub connector using REST API v3.
+
+    Notes:
+        - Provide a personal access token with required scopes.
+        - Incoming webhook events can be forwarded to `handle_event`.
+    """
+
+    def __init__(
+        self,
+        connector_id: str,
+        token: str,
+        name: Optional[str] = None,
+        base_url: str = "https://api.github.com",
+        timeout: float = 10.0,
+    ) -> None:
+        super().__init__(connector_id=connector_id, name=name)
+        self.token = token
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client: Optional[httpx.AsyncClient] = None
+        self._lock = asyncio.Lock()
+
+    async def _start(self) -> None:
+        if not self._client:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers={
+                    "Authorization": f"Bearer {self.token}",
+                    "Accept": "application/vnd.github+json",
+                    "X-GitHub-Api-Version": "2022-11-28",
+                },
+                timeout=self.timeout,
+            )
+
+    async def _stop(self) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def validate_config(self) -> None:
+        if not self.token:
+            raise ValueError("GitHub token must be provided")
+
+    async def get_repo(self, owner: str, repo: str) -> Dict[str, Any]:
+        """Fetch repository metadata."""
+        return await self._get(f"/repos/{owner}/{repo}")
+
+    async def list_issues(
+        self,
+        owner: str,
+        repo: str,
+        state: str = "open",
+        per_page: int = 30,
+    ) -> Any:
+        """List issues for a repository."""
+        return await self._get(
+            f"/repos/{owner}/{repo}/issues",
+            params={"state": state, "per_page": per_page},
+        )
+
+    async def create_issue(
+        self,
+        owner: str,
+        repo: str,
+        title: str,
+        body: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a new GitHub issue."""
+        payload: Dict[str, Any] = {"title": title}
+        if body:
+            payload["body"] = body
+        return await self._post(f"/repos/{owner}/{repo}/issues", payload)
+
+    async def handle_event(
+        self,
+        payload: Dict[str, Any],
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        """Handle an inbound GitHub webhook event and emit it downstream."""
+        await self.emit(payload=payload, metadata={"headers": headers or {}})
+
+    async def _get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.get(path, params=params or {})
+        response.raise_for_status()
+        return response.json()
+
+    async def _post(self, path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.post(path, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    async def _ensure_client(self) -> None:
+        if self._client is not None:
+            return
+        async with self._lock:
+            if self._client is None:
+                await self._start()

genxai/connectors/google_workspace.py

@@ -0,0 +1,124 @@
+"""Google Workspace connector implementation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+import asyncio
+import logging
+
+import httpx
+
+from genxai.connectors.base import Connector
+
+logger = logging.getLogger(__name__)
+
+
+class GoogleWorkspaceConnector(Connector):
+    """Google Workspace connector using Google REST APIs.
+
+    Notes:
+        - Provide an OAuth access token (Bearer) with required scopes.
+        - Supports basic operations for Sheets, Drive, and Calendar.
+    """
+
+    def __init__(
+        self,
+        connector_id: str,
+        access_token: str,
+        name: Optional[str] = None,
+        base_url: str = "https://www.googleapis.com",
+        timeout: float = 10.0,
+    ) -> None:
+        super().__init__(connector_id=connector_id, name=name)
+        self.access_token = access_token
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client: Optional[httpx.AsyncClient] = None
+        self._lock = asyncio.Lock()
+
+    async def _start(self) -> None:
+        if not self._client:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers={
+                    "Authorization": f"Bearer {self.access_token}",
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                },
+                timeout=self.timeout,
+            )
+
+    async def _stop(self) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def validate_config(self) -> None:
+        if not self.access_token:
+            raise ValueError("Google Workspace access_token must be provided")
+
+    async def get_sheet(self, spreadsheet_id: str) -> Dict[str, Any]:
+        """Fetch spreadsheet metadata."""
+        return await self._get(f"/sheets/v4/spreadsheets/{spreadsheet_id}")
+
+    async def append_sheet_values(
+        self,
+        spreadsheet_id: str,
+        range_: str,
+        values: list[list[Any]],
+        value_input_option: str = "USER_ENTERED",
+    ) -> Dict[str, Any]:
+        """Append values to a Google Sheet."""
+        params = {"valueInputOption": value_input_option}
+        payload = {"values": values}
+        return await self._post(
+            f"/sheets/v4/spreadsheets/{spreadsheet_id}/values/{range_}:append",
+            payload,
+            params=params,
+        )
+
+    async def list_drive_files(self, page_size: int = 10, query: Optional[str] = None) -> Dict[str, Any]:
+        """List Drive files."""
+        params: Dict[str, Any] = {"pageSize": page_size}
+        if query:
+            params["q"] = query
+        return await self._get("/drive/v3/files", params=params)
+
+    async def get_calendar_events(
+        self,
+        calendar_id: str = "primary",
+        max_results: int = 10,
+    ) -> Dict[str, Any]:
+        """List calendar events."""
+        params = {"maxResults": max_results, "singleEvents": True, "orderBy": "startTime"}
+        return await self._get(f"/calendar/v3/calendars/{calendar_id}/events", params=params)
+
+    async def handle_event(self, payload: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> None:
+        """Handle an inbound event payload and emit it downstream."""
+        await self.emit(payload=payload, metadata={"headers": headers or {}})
+
+    async def _get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.get(path, params=params or {})
+        response.raise_for_status()
+        return response.json()
+
+    async def _post(
+        self,
+        path: str,
+        payload: Dict[str, Any],
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.post(path, params=params or {}, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    async def _ensure_client(self) -> None:
+        if self._client is not None:
+            return
+        async with self._lock:
+            if self._client is None:
+                await self._start()

genxai/connectors/jira.py

@@ -0,0 +1,108 @@
+"""Jira connector implementation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+import asyncio
+import base64
+import logging
+
+import httpx
+
+from genxai.connectors.base import Connector
+
+logger = logging.getLogger(__name__)
+
+
+class JiraConnector(Connector):
+    """Jira connector using Jira Cloud REST API v3.
+
+    Notes:
+        - Use email + API token for basic auth.
+        - Incoming webhook events can be forwarded to `handle_event`.
+    """
+
+    def __init__(
+        self,
+        connector_id: str,
+        email: str,
+        api_token: str,
+        base_url: str,
+        name: Optional[str] = None,
+        timeout: float = 10.0,
+    ) -> None:
+        super().__init__(connector_id=connector_id, name=name)
+        self.email = email
+        self.api_token = api_token
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client: Optional[httpx.AsyncClient] = None
+        self._lock = asyncio.Lock()
+
+    async def _start(self) -> None:
+        if not self._client:
+            token = f"{self.email}:{self.api_token}".encode("utf-8")
+            auth_header = base64.b64encode(token).decode("utf-8")
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers={
+                    "Authorization": f"Basic {auth_header}",
+                    "Accept": "application/json",
+                    "Content-Type": "application/json",
+                },
+                timeout=self.timeout,
+            )
+
+    async def _stop(self) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def validate_config(self) -> None:
+        if not self.email:
+            raise ValueError("Jira email must be provided")
+        if not self.api_token:
+            raise ValueError("Jira api_token must be provided")
+        if not self.base_url:
+            raise ValueError("Jira base_url must be provided")
+
+    async def get_project(self, project_key: str) -> Dict[str, Any]:
+        """Fetch Jira project metadata."""
+        return await self._get(f"/rest/api/3/project/{project_key}")
+
+    async def search_issues(self, jql: str, max_results: int = 50) -> Dict[str, Any]:
+        """Search issues with JQL."""
+        payload = {"jql": jql, "maxResults": max_results}
+        return await self._post("/rest/api/3/search", payload)
+
+    async def create_issue(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a Jira issue using the provided payload."""
+        return await self._post("/rest/api/3/issue", payload)
+
+    async def handle_event(
+        self,
+        payload: Dict[str, Any],
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        await self.emit(payload=payload, metadata={"headers": headers or {}})
+
+    async def _get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.get(path, params=params or {})
+        response.raise_for_status()
+        return response.json()
+
+    async def _post(self, path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.post(path, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    async def _ensure_client(self) -> None:
+        if self._client is not None:
+            return
+        async with self._lock:
+            if self._client is None:
+                await self._start()

genxai/connectors/notion.py

@@ -0,0 +1,97 @@
+"""Notion connector implementation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+import asyncio
+import logging
+
+import httpx
+
+from genxai.connectors.base import Connector
+
+logger = logging.getLogger(__name__)
+
+
+class NotionConnector(Connector):
+    """Notion connector using the Notion API.
+
+    Notes:
+        - Provide a Notion integration token.
+        - Incoming webhook-like events can be forwarded to `handle_event`.
+    """
+
+    def __init__(
+        self,
+        connector_id: str,
+        token: str,
+        name: Optional[str] = None,
+        base_url: str = "https://api.notion.com/v1",
+        notion_version: str = "2022-06-28",
+        timeout: float = 10.0,
+    ) -> None:
+        super().__init__(connector_id=connector_id, name=name)
+        self.token = token
+        self.base_url = base_url.rstrip("/")
+        self.notion_version = notion_version
+        self.timeout = timeout
+        self._client: Optional[httpx.AsyncClient] = None
+        self._lock = asyncio.Lock()
+
+    async def _start(self) -> None:
+        if not self._client:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers={
+                    "Authorization": f"Bearer {self.token}",
+                    "Notion-Version": self.notion_version,
+                    "Content-Type": "application/json",
+                },
+                timeout=self.timeout,
+            )
+
+    async def _stop(self) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def validate_config(self) -> None:
+        if not self.token:
+            raise ValueError("Notion token must be provided")
+
+    async def get_page(self, page_id: str) -> Dict[str, Any]:
+        """Fetch a Notion page by ID."""
+        return await self._get(f"/pages/{page_id}")
+
+    async def query_database(self, database_id: str, payload: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Query a Notion database."""
+        return await self._post(f"/databases/{database_id}/query", payload or {})
+
+    async def create_page(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a Notion page using the provided payload."""
+        return await self._post("/pages", payload)
+
+    async def handle_event(self, payload: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> None:
+        """Handle an inbound Notion event payload and emit it downstream."""
+        await self.emit(payload=payload, metadata={"headers": headers or {}})
+
+    async def _get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.get(path, params=params or {})
+        response.raise_for_status()
+        return response.json()
+
+    async def _post(self, path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.post(path, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    async def _ensure_client(self) -> None:
+        if self._client is not None:
+            return
+        async with self._lock:
+            if self._client is None:
+                await self._start()

genxai/connectors/slack.py

@@ -0,0 +1,121 @@
+"""Slack connector implementation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+import asyncio
+import logging
+
+import httpx
+
+from genxai.connectors.base import Connector
+
+logger = logging.getLogger(__name__)
+
+
+class SlackConnector(Connector):
+    """Slack connector using Slack Web API + Events API payloads.
+
+    Notes:
+        - This connector handles outgoing API calls and can emit inbound events
+          when `handle_event` is called by your webhook route.
+        - You must provide a Slack Bot token for Web API calls.
+    """
+
+    def __init__(
+        self,
+        connector_id: str,
+        bot_token: str,
+        name: Optional[str] = None,
+        base_url: str = "https://slack.com/api",
+        timeout: float = 10.0,
+    ) -> None:
+        super().__init__(connector_id=connector_id, name=name)
+        self.bot_token = bot_token
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client: Optional[httpx.AsyncClient] = None
+        self._lock = asyncio.Lock()
+
+    async def _start(self) -> None:
+        if not self._client:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers={
+                    "Authorization": f"Bearer {self.bot_token}",
+                    "Content-Type": "application/json; charset=utf-8",
+                },
+                timeout=self.timeout,
+            )
+
+    async def _stop(self) -> None:
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def validate_config(self) -> None:
+        if not self.bot_token:
+            raise ValueError("Slack bot_token must be provided")
+
+    async def send_message(
+        self,
+        channel: str,
+        text: str,
+        blocks: Optional[List[Dict[str, Any]]] = None,
+        attachments: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        """Send a message to a Slack channel."""
+        payload: Dict[str, Any] = {"channel": channel, "text": text}
+        if blocks:
+            payload["blocks"] = blocks
+        if attachments:
+            payload["attachments"] = attachments
+        return await self._post("/chat.postMessage", payload)
+
+    async def post_ephemeral(
+        self,
+        channel: str,
+        user: str,
+        text: str,
+        blocks: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        """Send an ephemeral message to a user in a channel."""
+        payload: Dict[str, Any] = {"channel": channel, "user": user, "text": text}
+        if blocks:
+            payload["blocks"] = blocks
+        return await self._post("/chat.postEphemeral", payload)
+
+    async def list_channels(self, types: str = "public_channel,private_channel") -> Dict[str, Any]:
+        """List available channels."""
+        return await self._get("/conversations.list", {"types": types})
+
+    async def handle_event(self, payload: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> None:
+        """Handle an inbound Slack event payload and emit it downstream."""
+        await self.emit(payload=payload, metadata={"headers": headers or {}})
+
+    async def _get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.get(path, params=params or {})
+        response.raise_for_status()
+        data = response.json()
+        if not data.get("ok", False):
+            raise ValueError(f"Slack API error: {data}")
+        return data
+
+    async def _post(self, path: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        await self._ensure_client()
+        assert self._client is not None
+        response = await self._client.post(path, json=payload)
+        response.raise_for_status()
+        data = response.json()
+        if not data.get("ok", False):
+            raise ValueError(f"Slack API error: {data}")
+        return data
+
+    async def _ensure_client(self) -> None:
+        if self._client is not None:
+            return
+        async with self._lock:
+            if self._client is None:
+                await self._start()

genxai/core/agent/config_io.py

@@ -26,7 +26,38 @@ def agent_to_dict(agent: Agent) -> Dict[str, Any]:
 
 def agent_from_dict(data: Dict[str, Any]) -> Agent:
     """Load Agent from a dictionary."""
-    return Agent(id=data["id"], config=agent_config_from_dict(data["config"]))
+    if "config" in data and isinstance(data.get("config"), dict):
+        config = agent_config_from_dict(data["config"])
+        return Agent(id=data["id"], config=config)
+
+    # Support flat agent definitions (no config wrapper).
+    llm_model = data.get("llm_model") or data.get("llm") or "gpt-4"
+    config = AgentConfig(
+        role=data.get("role", "Agent"),
+        goal=data.get("goal", "Process tasks"),
+        backstory=data.get("backstory", ""),
+        llm_provider=data.get("llm_provider", "openai"),
+        llm_model=llm_model,
+        llm_temperature=data.get("llm_temperature", 0.7),
+        tools=data.get("tools", []),
+        enable_memory=data.get("memory", {}).get("enabled", True)
+        if isinstance(data.get("memory"), dict)
+        else data.get("enable_memory", True),
+        memory_type=data.get("memory", {}).get("type", "short_term")
+        if isinstance(data.get("memory"), dict)
+        else data.get("memory_type", "short_term"),
+        agent_type=data.get("behavior", {}).get("agent_type", "reactive")
+        if isinstance(data.get("behavior"), dict)
+        else data.get("agent_type", "reactive"),
+        max_iterations=data.get("behavior", {}).get("max_iterations", 10)
+        if isinstance(data.get("behavior"), dict)
+        else data.get("max_iterations", 10),
+        verbose=data.get("behavior", {}).get("verbose", False)
+        if isinstance(data.get("behavior"), dict)
+        else data.get("verbose", False),
+        metadata=data.get("metadata", {}),
+    )
+    return Agent(id=data["id"], config=config)
 
 
 def export_agent_config_yaml(agent: Agent, path: Path) -> None: