monkeybrain-runtime 1.0.0__py3-none-any.whl

src/cerebellum/capabilities/workflow/workflows.py

@@ -0,0 +1,49 @@
+"""Workflow Capabilities — workflow engine integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class N8nCapability(Capability):
+    def __init__(self, webhook_url: str = ""):
+        super().__init__(name='n8n')
+        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=state)
+            return response.json()
+
+
+class TemporalCapability(Capability):
+    def __init__(self, server_url: str = ""):
+        super().__init__(name='temporal')
+        self._server_url = server_url
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "workflow": "temporal"}
+
+
+class AirflowCapability(Capability):
+    def __init__(self, api_url: str = "", username: str = "", password: str = ""):
+        super().__init__(name='airflow')
+        self._api_url = api_url
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "workflow": "airflow"}
+
+
+class PrefectCapability(Capability):
+    def __init__(self, api_url: str = ""):
+        super().__init__(name='prefect')
+        self._api_url = api_url
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "workflow": "prefect"}
+
+
+class ArgoCapability(Capability):
+    def __init__(self, server_url: str = ""):
+        super().__init__(name='argo')
+        self._server_url = server_url
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "workflow": "argo"}

src/cerebellum/capability.py

@@ -0,0 +1,108 @@
+"""Capability — a unit of work that transforms execution state.
+
+Capabilities are the execution primitives.
+The Runtime executes capabilities.
+The Policy selects capabilities.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from src.cerebellum.peripheral import Peripheral
+
+
+@dataclass
+class CapabilityManifest:
+    """Capability metadata for registry."""
+    
+    capability_id: str = ""
+    name: str = ""
+    version: str = "1.0.0"
+    description: str = ""
+    author: str = ""
+    peripheral_type: str | None = None
+    inputs: list[dict[str, Any]] = field(default_factory=list)
+    outputs: list[dict[str, Any]] = field(default_factory=list)
+    dependencies: list[str] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+    checksum: str = ""
+    published_at: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class Capability:
+    """A unit of work that transforms execution state.
+    
+    Responsibilities:
+    - Execute a specific operation
+    - Read from/write to peripherals
+    - Return structured results
+    
+    The Capability never:
+    - Makes execution decisions
+    - Selects other capabilities
+    - Manages threads
+    - Owns execution policy
+    """
+    
+    def __init__(
+        self,
+        name: str,
+        peripheral: Peripheral | None = None,
+        config: dict[str, Any] | None = None,
+    ):
+        self.name = name
+        self.peripheral = peripheral
+        self.config = config or {}
+        self._id = f"cap-{uuid4().hex[:8]}"
+    
+    @property
+    def id(self) -> str:
+        return self._id
+    
+    async def execute(
+        self,
+        state: dict[str, Any],
+        context: Any = None,
+    ) -> dict[str, Any]:
+        """Execute the capability.
+        
+        Args:
+            state: Current execution state (read-only)
+            context: Runtime context (memory, stream)
+            
+        Returns:
+            Result dict with capability output
+        """
+        raise NotImplementedError(f"Capability '{self.name}' must implement execute()")
+    
+    def can_execute(self, state: dict[str, Any]) -> bool:
+        """Check if capability can execute."""
+        return True
+    
+    def estimate_cost(self, state: dict[str, Any]) -> float:
+        """Estimate execution cost."""
+        return 1.0
+    
+    def estimate_reward(self, state: dict[str, Any]) -> float:
+        """Estimate expected reward."""
+        return 0.5
+    
+    def manifest(self) -> CapabilityManifest:
+        """Generate manifest for registry."""
+        return CapabilityManifest(
+            capability_id=self._id,
+            name=self.name,
+            description=f"Capability: {self.name}",
+            peripheral_type=self.peripheral.type.value if self.peripheral else None,
+        )
+    
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self._id,
+            "name": self.name,
+            "peripheral": self.peripheral.name if self.peripheral else None,
+        }

src/cerebellum/config.py

@@ -0,0 +1,157 @@
+"""Capability Configuration — API keys and settings for all capabilities.
+
+Centralizes configuration for all capabilities.
+Supports environment variables, config files, and runtime configuration.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CapabilityConfig:
+    """Configuration for a single capability."""
+    
+    name: str
+    enabled: bool = True
+    api_key: str = ""
+    api_url: str = ""
+    timeout_ms: int = 5000
+    max_retries: int = 3
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class ConfigManager:
+    """Manages configuration for all capabilities.
+    
+    Supports:
+    - Environment variables
+    - Config file
+    - Runtime configuration
+    """
+    
+    def __init__(self):
+        self._configs: dict[str, CapabilityConfig] = {}
+        self._env_prefix = "AGENTOS_"
+    
+    def load_from_env(self) -> None:
+        """Load configuration from environment variables."""
+        # API Keys
+        self._configs["openai"] = CapabilityConfig(
+            name="openai",
+            api_key=os.getenv("OPENAI_API_KEY", ""),
+            api_url=os.getenv("OPENAI_API_URL", "https://api.openai.com/v1"),
+        )
+        
+        self._configs["anthropic"] = CapabilityConfig(
+            name="anthropic",
+            api_key=os.getenv("ANTHROPIC_API_KEY", ""),
+            api_url=os.getenv("ANTHROPIC_API_URL", "https://api.anthropic.com/v1"),
+        )
+        
+        self._configs["openrouter"] = CapabilityConfig(
+            name="openrouter",
+            api_key=os.getenv("OPENROUTER_API_KEY", ""),
+            api_url=os.getenv("OPENROUTER_API_URL", "https://openrouter.ai/api/v1"),
+        )
+        
+        self._configs["ollama"] = CapabilityConfig(
+            name="ollama",
+            api_url=os.getenv("OLLAMA_API_URL", "http://localhost:11434"),
+        )
+        
+        self._configs["gemini"] = CapabilityConfig(
+            name="gemini",
+            api_key=os.getenv("GOOGLE_API_KEY", ""),
+        )
+        
+        self._configs["azure_openai"] = CapabilityConfig(
+            name="azure_openai",
+            api_key=os.getenv("AZURE_OPENAI_API_KEY", ""),
+            api_url=os.getenv("AZURE_OPENAI_ENDPOINT", ""),
+        )
+        
+        self._configs["aws_bedrock"] = CapabilityConfig(
+            name="aws_bedrock",
+            api_key=os.getenv("AWS_ACCESS_KEY_ID", ""),
+        )
+        
+        # Databases
+        self._configs["mongodb"] = CapabilityConfig(
+            name="mongodb",
+            api_url=os.getenv("MONGODB_URL", "mongodb://localhost:27017"),
+            metadata={"database": os.getenv("DB_NAME", "agentos")},
+        )
+        
+        self._configs["redis"] = CapabilityConfig(
+            name="redis",
+            api_url=os.getenv("REDIS_URL", "redis://localhost:6379"),
+        )
+        
+        self._configs["neo4j"] = CapabilityConfig(
+            name="neo4j",
+            api_url=os.getenv("NEO4J_URI", "bolt://localhost:7687"),
+            api_key=os.getenv("NEO4J_PASSWORD", ""),
+        )
+        
+        self._configs["influxdb"] = CapabilityConfig(
+            name="influxdb",
+            api_key=os.getenv("INFLUXDB_TOKEN", ""),
+            api_url=os.getenv("INFLUXDB_URL", "http://localhost:8086"),
+            metadata={"org": os.getenv("INFLUXDB_ORG", "agentos")},
+        )
+        
+        self._configs["elasticsearch"] = CapabilityConfig(
+            name="elasticsearch",
+            api_url=os.getenv("ELASTICSEARCH_URL", "http://localhost:9200"),
+        )
+        
+        # Communication
+        self._configs["slack"] = CapabilityConfig(
+            name="slack",
+            api_key=os.getenv("SLACK_WEBHOOK_URL", ""),
+        )
+        
+        self._configs["email"] = CapabilityConfig(
+            name="email",
+            api_key=os.getenv("SMTP_PASSWORD", ""),
+            api_url=os.getenv("SMTP_HOST", "smtp.gmail.com"),
+        )
+        
+        # Cloud
+        self._configs["aws"] = CapabilityConfig(
+            name="aws",
+            api_key=os.getenv("AWS_ACCESS_KEY_ID", ""),
+            metadata={"region": os.getenv("AWS_REGION", "us-east-1")},
+        )
+        
+        self._configs["azure"] = CapabilityConfig(
+            name="azure",
+            api_key=os.getenv("AZURE_SUBSCRIPTION_ID", ""),
+        )
+        
+        self._configs["google_cloud"] = CapabilityConfig(
+            name="google_cloud",
+            api_key=os.getenv("GOOGLE_CLOUD_PROJECT", ""),
+        )
+    
+    def get(self, capability_name: str) -> CapabilityConfig | None:
+        """Get configuration for a capability."""
+        return self._configs.get(capability_name)
+    
+    def set(self, capability_name: str, config: CapabilityConfig) -> None:
+        """Set configuration for a capability."""
+        self._configs[capability_name] = config
+    
+    def get_all(self) -> dict[str, CapabilityConfig]:
+        return dict(self._configs)
+    
+    def summary(self) -> dict:
+        return {
+            "total_configs": len(self._configs),
+            "configured": [name for name, config in self._configs.items() if config.api_key or config.api_url],
+            "not_configured": [name for name, config in self._configs.items() if not config.api_key and not config.api_url],
+        }

src/cerebellum/fallback.py

@@ -0,0 +1,147 @@
+"""Fallback Capabilities — document search and web search for retry.
+
+When an answer fails:
+1. Use document search to find relevant information
+2. Use web search to find external information
+3. Replan execution based on gathered information
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from src.cerebellum.capability import Capability
+
+
+class DocumentSearchCapability(Capability):
+    """Search internal documents for relevant information."""
+    
+    def __init__(self):
+        super().__init__(name='document_search')
+        self._documents = {
+            'batch': [
+                {'id': 'DOC-001', 'title': 'Batch Record Procedure', 'content': 'Batch records track production from raw materials to finished goods.'},
+                {'id': 'DOC-002', 'title': 'Batch Release SOP', 'content': 'Batch release requires quality approval and documentation review.'},
+            ],
+            'plant': [
+                {'id': 'DOC-010', 'title': 'Plant Operations Manual', 'content': 'Plants contain production lines, stages, and workstations.'},
+            ],
+            'worker': [
+                {'id': 'DOC-020', 'title': 'Worker Assignment Guide', 'content': 'Workers are assigned to shifts and workstations.'},
+            ],
+            'maintenance': [
+                {'id': 'DOC-030', 'title': 'Maintenance Procedures', 'content': 'Maintenance includes preventive and corrective activities.'},
+                {'id': 'DOC-031', 'title': 'Calibration Schedule', 'content': 'Calibration is required quarterly for all measurement equipment.'},
+            ],
+            'sop': [
+                {'id': 'DOC-040', 'title': 'SOP Management', 'content': 'SOPs define standard operating procedures for all processes.'},
+            ],
+            'approval': [
+                {'id': 'DOC-050', 'title': 'Approval Workflow', 'content': 'Approvals follow a hierarchical review process.'},
+            ],
+            'line': [
+                {'id': 'DOC-060', 'title': 'Production Line Guide', 'content': 'Production lines contain stages and workstations.'},
+            ],
+            'stage': [
+                {'id': 'DOC-070', 'title': 'Process Stages', 'content': 'Stages include dispensing, granulation, compression, coating.'},
+            ],
+            'workstation': [
+                {'id': 'DOC-080', 'title': 'Workstation Configuration', 'content': 'Workstations contain machines and equipment.'},
+            ],
+        }
+    
+    async def execute(self, state, **kwargs):
+        entities = state.get('entities', {})
+        query = state.get('question', '').lower()
+        
+        found_docs = []
+        for etype in entities:
+            docs = self._documents.get(etype, [])
+            for doc in docs:
+                if any(word in doc['content'].lower() for word in query.split()):
+                    found_docs.append(doc)
+        
+        # If no entity-based docs, search all
+        if not found_docs:
+            for etype, docs in self._documents.items():
+                for doc in docs:
+                    if any(word in doc['content'].lower() for word in query.split()):
+                        found_docs.append(doc)
+        
+        return {
+            'documents': found_docs[:5],
+            'count': len(found_docs),
+            'phase': 'document_search',
+        }
+
+
+class WebSearchCapability(Capability):
+    """Search the web for external information."""
+    
+    def __init__(self):
+        super().__init__(name='web_search')
+        self._web_results = {
+            'batch': [
+                {'title': 'GMP Batch Record Requirements', 'url': 'https://example.com/gmp-batch', 'snippet': 'FDA 21 CFR Part 211 requires complete batch records for pharmaceutical manufacturing.'},
+            ],
+            'maintenance': [
+                {'title': 'Preventive Maintenance Best Practices', 'url': 'https://example.com/pm-best', 'snippet': 'Preventive maintenance reduces downtime by 25-30%.'},
+            ],
+            'quality': [
+                {'title': 'Quality Management Systems', 'url': 'https://example.com/qms', 'snippet': 'ISO 9001 quality management standards.'},
+            ],
+        }
+    
+    async def execute(self, state, **kwargs):
+        query = state.get('question', '').lower()
+        entities = state.get('entities', {})
+        
+        results = []
+        for etype in entities:
+            web = self._web_results.get(etype, [])
+            results.extend(web)
+        
+        # Fallback: search all
+        if not results:
+            for web in self._web_results.values():
+                results.extend(web)
+        
+        return {
+            'web_results': results[:5],
+            'count': len(results),
+            'phase': 'web_search',
+        }
+
+
+class ReplannerCapability(Capability):
+    """Replan execution based on gathered information."""
+    
+    def __init__(self):
+        super().__init__(name='replan')
+    
+    async def execute(self, state, **kwargs):
+        docs = state.get('documents', [])
+        web_results = state.get('web_results', [])
+        original_answer = state.get('current_answer', '')
+        question = state.get('question', '')
+        
+        # Aggregate information
+        aggregated_info = []
+        for doc in docs:
+            aggregated_info.append(f"Document: {doc.get('title', '')} - {doc.get('content', '')}")
+        for web in web_results:
+            aggregated_info.append(f"Web: {web.get('title', '')} - {web.get('snippet', '')}")
+        
+        # Build enhanced answer
+        if aggregated_info:
+            enhanced_answer = f"Based on available information:\n" + '\n'.join(f"• {info}" for info in aggregated_info[:5])
+        else:
+            enhanced_answer = f"I found some relevant information about your question regarding: {question}"
+        
+        return {
+            'enhanced_answer': enhanced_answer,
+            'aggregated_info': aggregated_info,
+            'phase': 'replan',
+        }

src/cerebellum/fallback_engine.py

@@ -0,0 +1,121 @@
+"""Fallback Engine — handles failed answers with document/web search and replanning.
+
+When an answer fails:
+1. Use document search to find relevant information
+2. Use web search to find external information
+3. Replan execution based on gathered information
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from src.cerebellum.fallback import DocumentSearchCapability, WebSearchCapability, ReplannerCapability
+from src.monkey_brain.kernel.pipeline import Pipeline, PipelineStep
+from src.monkey_brain.kernel.execution_state import ExecutionState
+from src.monkey_brain.runtime.runtime import Runtime
+
+
+@dataclass
+class FallbackResult:
+    """Result of a fallback execution."""
+    
+    fallback_id: str = field(default_factory=lambda: f"fb-{uuid4().hex[:8]}")
+    original_answer: str = ""
+    enhanced_answer: str = ""
+    documents_found: int = 0
+    web_results_found: int = 0
+    replanned: bool = False
+    success: bool = False
+    latency_ms: float = 0.0
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class FallbackEngine:
+    """Handles failed answers with document/web search and replanning.
+    
+    When an answer fails:
+    1. Use document search to find relevant information
+    2. Use web search to find external information
+    3. Replan execution based on gathered information
+    """
+    
+    def __init__(self, runtime: Runtime):
+        self._runtime = runtime
+        self._doc_search = DocumentSearchCapability()
+        self._web_search = WebSearchCapability()
+        self._replanner = ReplannerCapability()
+        self._fallback_count = 0
+    
+    async def execute_fallback(
+        self,
+        question: str,
+        original_answer: str,
+        state: dict[str, Any] | None = None,
+    ) -> FallbackResult:
+        """Execute fallback when original answer fails."""
+        import time
+        start = time.monotonic()
+        
+        result = FallbackResult(
+            original_answer=original_answer,
+        )
+        
+        current_state = dict(state or {})
+        current_state['question'] = question
+        current_state['current_answer'] = original_answer
+        
+        # Step 1: Document Search
+        doc_pipeline = Pipeline(
+            steps=[PipelineStep(capability_name='document_search')]
+        )
+        
+        # Register fallback capabilities temporarily
+        self._runtime.register(self._doc_search)
+        self._runtime.register(self._web_search)
+        self._runtime.register(self._replanner)
+        
+        doc_result = await self._runtime.execute(doc_pipeline, ExecutionState(question=question))
+        if doc_result.success:
+            docs = doc_result.final_state.get('documents', [])
+            result.documents_found = len(docs)
+            current_state['documents'] = docs
+        
+        # Step 2: Web Search
+        web_pipeline = Pipeline(
+            steps=[PipelineStep(capability_name='web_search')]
+        )
+        
+        web_result = await self._runtime.execute(web_pipeline, ExecutionState(question=question))
+        if web_result.success:
+            web_results = web_result.final_state.get('web_results', [])
+            result.web_results_found = len(web_results)
+            current_state['web_results'] = web_results
+        
+        # Step 3: Replan
+        if result.documents_found > 0 or result.web_results_found > 0:
+            replan_pipeline = Pipeline(
+                steps=[PipelineStep(capability_name='replan')]
+            )
+            
+            replan_result = await self._runtime.execute(replan_pipeline, ExecutionState(question=question))
+            if replan_result.success:
+                result.enhanced_answer = replan_result.final_state.get('enhanced_answer', original_answer)
+                result.replaned = True
+                result.success = True
+            else:
+                result.enhanced_answer = original_answer
+        else:
+            result.enhanced_answer = original_answer
+        
+        result.latency_ms = (time.monotonic() - start) * 1000
+        self._fallback_count += 1
+        
+        return result
+    
+    def summary(self) -> dict:
+        return {
+            "fallback_count": self._fallback_count,
+        }