monkeybrain-runtime 1.0.0__py3-none-any.whl

src/cerebellum/capabilities/agent/agents.py

@@ -0,0 +1,65 @@
+"""Agent Capabilities — agent-to-agent communication."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class OpenClawCapability(Capability):
+    def __init__(self, api_url: str = ""):
+        super().__init__(name='openclaw')
+        self._api_url = api_url
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "agent": "openclaw"}
+
+
+class ExternalAgentCapability(Capability):
+    def __init__(self, agent_url: str = ""):
+        super().__init__(name='external_agent')
+        self._agent_url = agent_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self._agent_url, json=state)
+            return response.json()
+
+
+class AgentToAgentCapability(Capability):
+    def __init__(self):
+        super().__init__(name='agent_to_agent')
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "communication": "agent_to_agent"}
+
+
+class RemoteAgentExecutionCapability(Capability):
+    def __init__(self, remote_url: str = ""):
+        super().__init__(name='remote_agent_execution')
+        self._remote_url = remote_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(f"{self._remote_url}/execute", json=state)
+            return response.json()
+
+
+class AgentDiscoveryCapability(Capability):
+    def __init__(self, registry_url: str = ""):
+        super().__init__(name='agent_discovery')
+        self._registry_url = registry_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.get(f"{self._registry_url}/agents")
+            return response.json()
+
+
+class AgentRegistryCapability(Capability):
+    def __init__(self, registry_url: str = ""):
+        super().__init__(name='agent_registry')
+        self._registry_url = registry_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(f"{self._registry_url}/register", json=state)
+            return response.json()

src/cerebellum/capabilities/ai/providers.py

@@ -0,0 +1,106 @@
+"""AI Provider Capabilities — LLM and AI integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class OpenAICapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='openai')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers={"Authorization": f"Bearer {self._api_key}"},
+                json={"model": state.get("model", "gpt-4"), "messages": [{"role": "user", "content": state.get("prompt", "")}]}
+            )
+            return response.json()
+
+
+class AnthropicCapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='anthropic')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "https://api.anthropic.com/v1/messages",
+                headers={"x-api-key": self._api_key, "anthropic-version": "2023-06-01"},
+                json={"model": state.get("model", "claude-3"), "messages": [{"role": "user", "content": state.get("prompt", "")}]}
+            )
+            return response.json()
+
+
+class GeminiCapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='gemini')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "google_gemini"}
+
+
+class AzureOpenAICapability(Capability):
+    def __init__(self, endpoint: str = "", api_key: str = ""):
+        super().__init__(name='azure_openai')
+        self._endpoint = endpoint
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "azure_openai"}
+
+
+class AWSBedrockCapability(Capability):
+    def __init__(self, region: str = "us-east-1"):
+        super().__init__(name='aws_bedrock')
+        self._region = region
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "aws_bedrock"}
+
+
+class OllamaCapability(Capability):
+    def __init__(self, url: str = "http://localhost:11434"):
+        super().__init__(name='ollama')
+        self._url = url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{self._url}/api/chat",
+                json={"model": state.get("model", "gemma3:latest"), "messages": [{"role": "user", "content": state.get("prompt", "")}]}
+            )
+            return response.json()
+
+
+class HuggingFaceCapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='huggingface')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "huggingface"}
+
+
+class OpenRouterCapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='openrouter')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                headers={"Authorization": f"Bearer {self._api_key}"},
+                json={"model": state.get("model", "openai/gpt-4o-mini"), "messages": [{"role": "user", "content": state.get("prompt", "")}]}
+            )
+            return response.json()
+
+
+class LocalModelCapability(Capability):
+    def __init__(self, model_path: str = ""):
+        super().__init__(name='local_model')
+        self._model_path = model_path
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "local_model"}

src/cerebellum/capabilities/api/graphql.py

@@ -0,0 +1,35 @@
+"""GraphQL API Capability — GraphQL integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class GraphQLCapability(Capability):
+    """GraphQL API integration capability."""
+    
+    def __init__(self, endpoint: str = "", api_key: str = ""):
+        super().__init__(name='graphql')
+        self._endpoint = endpoint
+        self._api_key = api_key
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute GraphQL query."""
+        import httpx
+        
+        endpoint = state.get('endpoint', self._endpoint)
+        query = state.get('query', '')
+        variables = state.get('variables', {})
+        
+        headers = {'Content-Type': 'application/json'}
+        if self._api_key:
+            headers['Authorization'] = f'Bearer {self._api_key}'
+        
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                endpoint,
+                headers=headers,
+                json={'query': query, 'variables': variables}
+            )
+            return response.json()

src/cerebellum/capabilities/api/rest_api.py

@@ -0,0 +1,45 @@
+"""REST API Capability — HTTP REST integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class RestAPICapability(Capability):
+    """REST API integration capability."""
+    
+    def __init__(self, base_url: str = "", api_key: str = ""):
+        super().__init__(name='rest_api')
+        self._base_url = base_url
+        self._api_key = api_key
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute REST API call."""
+        import httpx
+        
+        url = state.get('url', self._base_url)
+        method = state.get('method', 'GET')
+        headers = state.get('headers', {})
+        data = state.get('data')
+        
+        if self._api_key:
+            headers['Authorization'] = f'Bearer {self._api_key}'
+        
+        async with httpx.AsyncClient() as client:
+            if method.upper() == 'GET':
+                response = await client.get(url, headers=headers)
+            elif method.upper() == 'POST':
+                response = await client.post(url, headers=headers, json=data)
+            elif method.upper() == 'PUT':
+                response = await client.put(url, headers=headers, json=data)
+            elif method.upper() == 'DELETE':
+                response = await client.delete(url, headers=headers)
+            else:
+                return {'status': 'error', 'error': f'Unsupported method: {method}'}
+            
+            return {
+                'status_code': response.status_code,
+                'data': response.json() if response.headers.get('content-type', '').startswith('application/json') else response.text,
+                'headers': dict(response.headers),
+            }

src/cerebellum/capabilities/api/webhook.py

@@ -0,0 +1,30 @@
+"""Webhook Capability — webhook integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class WebhookCapability(Capability):
+    """Webhook integration capability."""
+    
+    def __init__(self, url: str = "", secret: str = ""):
+        super().__init__(name='webhook')
+        self._url = url
+        self._secret = secret
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Send webhook."""
+        import httpx
+        
+        url = state.get('url', self._url)
+        payload = state.get('payload', {})
+        headers = state.get('headers', {'Content-Type': 'application/json'})
+        
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload, headers=headers)
+            return {
+                'status_code': response.status_code,
+                'success': 200 <= response.status_code < 300,
+            }

src/cerebellum/capabilities/browser/browsers.py

@@ -0,0 +1,27 @@
+"""Browser Capabilities — web browser integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class PlaywrightCapability(Capability):
+    def __init__(self):
+        super().__init__(name='playwright')
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "browser": "playwright"}
+
+
+class SeleniumCapability(Capability):
+    def __init__(self):
+        super().__init__(name='selenium')
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "browser": "selenium"}
+
+
+class PuppeteerCapability(Capability):
+    def __init__(self):
+        super().__init__(name='puppeteer')
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "browser": "puppeteer"}

src/cerebellum/capabilities/cloud/cloud.py

@@ -0,0 +1,46 @@
+"""Cloud Capabilities — cloud provider integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class AWSCapability(Capability):
+    def __init__(self, region: str = "us-east-1"):
+        super().__init__(name='aws')
+        self._region = region
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "aws", "region": self._region}
+
+
+class AzureCapability(Capability):
+    def __init__(self, subscription_id: str = ""):
+        super().__init__(name='azure')
+        self._subscription_id = subscription_id
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "azure"}
+
+
+class GoogleCloudCapability(Capability):
+    def __init__(self, project_id: str = ""):
+        super().__init__(name='google_cloud')
+        self._project_id = project_id
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "google_cloud"}
+
+
+class CloudflareCapability(Capability):
+    def __init__(self, api_token: str = ""):
+        super().__init__(name='cloudflare')
+        self._api_token = api_token
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "cloudflare"}
+
+
+class DigitalOceanCapability(Capability):
+    def __init__(self, api_token: str = ""):
+        super().__init__(name='digitalocean')
+        self._api_token = api_token
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "digitalocean"}

src/cerebellum/capabilities/communication/communication.py

@@ -0,0 +1,62 @@
+"""Communication Capabilities — messaging integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class EmailCapability(Capability):
+    def __init__(self, smtp_host: str = "", smtp_port: int = 587):
+        super().__init__(name='email')
+        self._smtp_host = smtp_host
+        self._smtp_port = smtp_port
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "communication": "email"}
+
+
+class SlackCapability(Capability):
+    def __init__(self, webhook_url: str = ""):
+        super().__init__(name='slack')
+        self._webhook_url = webhook_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self._webhook_url, json={"text": state.get("message", "")})
+            return {"status": "sent" if response.status_code == 200 else "failed"}
+
+
+class DiscordCapability(Capability):
+    def __init__(self, webhook_url: str = ""):
+        super().__init__(name='discord')
+        self._webhook_url = webhook_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self._webhook_url, json={"content": state.get("message", "")})
+            return {"status": "sent" if response.status_code == 204 else "failed"}
+
+
+class TelegramCapability(Capability):
+    def __init__(self, bot_token: str = ""):
+        super().__init__(name='telegram')
+        self._bot_token = bot_token
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"https://api.telegram.org/bot{self._bot_token}/sendMessage",
+                json={"chat_id": state.get("chat_id", ""), "text": state.get("message", "")}
+            )
+            return response.json()
+
+
+class MicrosoftTeamsCapability(Capability):
+    def __init__(self, webhook_url: str = ""):
+        super().__init__(name='microsoft_teams')
+        self._webhook_url = webhook_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self._webhook_url, json={"text": state.get("message", "")})
+            return {"status": "sent" if response.status_code == 200 else "failed"}

src/cerebellum/capabilities/database/elasticsearch.py

@@ -0,0 +1,40 @@
+"""Elasticsearch Capability — search engine integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class ElasticsearchCapability(Capability):
+    """Elasticsearch integration capability."""
+    
+    def __init__(self, url: str = "http://localhost:9200"):
+        super().__init__(name='elasticsearch')
+        self._url = url
+        self._client = None
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute Elasticsearch operation."""
+        from elasticsearch import AsyncElasticsearch
+        
+        if not self._client:
+            self._client = AsyncElasticsearch([self._url])
+        
+        operation = state.get('operation', 'search')
+        index = state.get('index', '')
+        query = state.get('query', {})
+        
+        if operation == 'search':
+            result = await self._client.search(index=index, body=query)
+            return {
+                'results': [hit['_source'] for hit in result['hits']['hits']],
+                'total': result['hits']['total']['value'],
+            }
+        
+        elif operation == 'index':
+            body = state.get('body', {})
+            result = await self._client.index(index=index, document=body)
+            return {'id': result['_id'], 'status': result['result']}
+        
+        return {'status': 'unknown_operation'}

src/cerebellum/capabilities/database/influxdb.py

@@ -0,0 +1,37 @@
+"""InfluxDB Capability — time series database integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class InfluxDBCapability(Capability):
+    """InfluxDB integration capability."""
+    
+    def __init__(self, url: str = "http://localhost:8086", token: str = "", org: str = "agentos"):
+        super().__init__(name='influxdb')
+        self._url = url
+        self._token = token
+        self._org = org
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute InfluxDB query."""
+        from influxdb_client import InfluxDBClient
+        
+        client = InfluxDBClient(url=self._url, token=self._token, org=self._org)
+        query_api = client.query_api()
+        
+        query = state.get('query', '')
+        result = query_api.query(query)
+        
+        records = []
+        for table in result:
+            for record in table.records:
+                records.append({
+                    'time': record.get_time().isoformat(),
+                    'measurement': record.get_measurement(),
+                    'fields': record.values,
+                })
+        
+        return {'results': records, 'count': len(records)}

src/cerebellum/capabilities/database/mongodb.py

@@ -0,0 +1,50 @@
+"""MongoDB Capability — document database integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class MongoDBCapability(Capability):
+    """MongoDB integration capability."""
+    
+    def __init__(self, url: str = "mongodb://localhost:27017", database: str = "agentos"):
+        super().__init__(name='mongodb')
+        self._url = url
+        self._database = database
+        self._client = None
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute MongoDB operation."""
+        from motor.motor_asyncio import AsyncIOMotorClient
+        
+        if not self._client:
+            self._client = AsyncIOMotorClient(self._url)
+        
+        db = self._client[self._database]
+        operation = state.get('operation', 'find')
+        collection = state.get('collection', '')
+        query = state.get('query', {})
+        data = state.get('data')
+        
+        coll = db[collection]
+        
+        if operation == 'find':
+            cursor = coll.find(query)
+            results = await cursor.to_list(length=state.get('limit', 100))
+            return {'results': results, 'count': len(results)}
+        
+        elif operation == 'insert':
+            result = await coll.insert_one(data)
+            return {'inserted_id': str(result.inserted_id)}
+        
+        elif operation == 'update':
+            result = await coll.update_one(query, {'$set': data}, upsert=True)
+            return {'modified': result.modified_count}
+        
+        elif operation == 'delete':
+            result = await coll.delete_one(query)
+            return {'deleted': result.deleted_count}
+        
+        return {'status': 'unknown_operation'}

src/cerebellum/capabilities/database/neo4j.py

@@ -0,0 +1,32 @@
+"""Neo4j Capability — graph database integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class Neo4jCapability(Capability):
+    """Neo4j integration capability."""
+    
+    def __init__(self, uri: str = "bolt://localhost:7687", user: str = "neo4j", password: str = ""):
+        super().__init__(name='neo4j')
+        self._uri = uri
+        self._user = user
+        self._password = password
+        self._driver = None
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute Neo4j query."""
+        from neo4j import AsyncGraphDatabase
+        
+        if not self._driver:
+            self._driver = AsyncGraphDatabase.driver(self._uri, auth=(self._user, self._password))
+        
+        query = state.get('query', '')
+        parameters = state.get('parameters', {})
+        
+        async with self._driver.session() as session:
+            result = await session.run(query, parameters)
+            records = [dict(record) async for record in result]
+            return {'results': records, 'count': len(records)}

src/cerebellum/capabilities/database/redis.py

@@ -0,0 +1,44 @@
+"""Redis Capability — key-value store integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class RedisCapability(Capability):
+    """Redis integration capability."""
+    
+    def __init__(self, url: str = "redis://localhost:6379"):
+        super().__init__(name='redis')
+        self._url = url
+        self._client = None
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute Redis operation."""
+        import redis.asyncio as aioredis
+        
+        if not self._client:
+            self._client = aioredis.from_url(self._url, decode_responses=True)
+        
+        operation = state.get('operation', 'get')
+        key = state.get('key', '')
+        value = state.get('value')
+        
+        if operation == 'get':
+            result = await self._client.get(key)
+            return {'value': result}
+        
+        elif operation == 'set':
+            await self._client.set(key, value)
+            return {'status': 'ok'}
+        
+        elif operation == 'delete':
+            await self._client.delete(key)
+            return {'status': 'deleted'}
+        
+        elif operation == 'exists':
+            result = await self._client.exists(key)
+            return {'exists': bool(result)}
+        
+        return {'status': 'unknown_operation'}