machinaos 0.0.21 → 0.0.23

package/server/services/handlers/utility.py

@@ -820,3 +820,94 @@ def _format_console_output(data: Any, format_type: str) -> str:
                 return json.dumps(data, indent=2, default=str, ensure_ascii=False)
         case _:
             return str(data)
+
+
+# =============================================================================
+# TEAM MONITOR HANDLER
+# =============================================================================
+
+async def handle_team_monitor(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle team monitor node - returns team status snapshot.
+
+    Args:
+        node_id: The node ID
+        node_type: The node type (teamMonitor)
+        parameters: Resolved parameters
+        context: Execution context with team_id from connected team node
+
+    Returns:
+        Execution result dict with team status
+    """
+    from services.agent_team import get_agent_team_service
+    start_time = time.time()
+
+    try:
+        # Get team_id from context (set by connected team lead node)
+        team_id = context.get('team_id')
+
+        # Try to get from connected node outputs
+        if not team_id:
+            outputs = context.get('outputs', {})
+            for output in outputs.values():
+                if isinstance(output, dict) and output.get('team_id'):
+                    team_id = output.get('team_id')
+                    break
+
+        if not team_id:
+            return {
+                "success": True,
+                "node_id": node_id,
+                "node_type": "teamMonitor",
+                "result": {
+                    "message": "No team connected",
+                    "team_id": None,
+                    "members": [],
+                    "tasks": {"total": 0, "completed": 0, "active": 0, "pending": 0, "failed": 0},
+                    "active_tasks": [],
+                    "recent_events": []
+                },
+                "execution_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+
+        team_service = get_agent_team_service()
+        status = await team_service.get_team_status(team_id)
+
+        max_history = parameters.get('maxHistoryItems', 50)
+
+        return {
+            "success": True,
+            "node_id": node_id,
+            "node_type": "teamMonitor",
+            "result": {
+                "team_id": team_id,
+                "members": status.get('members', []),
+                "tasks": {
+                    "total": status.get('task_count', 0),
+                    "completed": status.get('completed_count', 0),
+                    "active": status.get('active_count', 0),
+                    "pending": status.get('pending_count', 0),
+                    "failed": status.get('failed_count', 0)
+                },
+                "active_tasks": status.get('active_tasks', []),
+                "recent_events": status.get('recent_events', [])[-max_history:]
+            },
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+    except Exception as e:
+        logger.error("[TeamMonitor] Failed", node_id=node_id, error=str(e))
+        return {
+            "success": False,
+            "node_id": node_id,
+            "node_type": "teamMonitor",
+            "error": str(e),
+            "execution_time": time.time() - start_time,
+            "timestamp": datetime.now().isoformat()
+        }

package/server/services/node_executor.py

@@ -30,12 +30,13 @@ from services.handlers import (
     handle_create_map, handle_add_locations, handle_nearby_places,
     handle_text_generator, handle_file_handler,
     handle_chat_send, handle_chat_history,
-    handle_start, handle_cron_scheduler, handle_timer, handle_console,
+    handle_start, handle_cron_scheduler, handle_timer, handle_console, handle_team_monitor,
     handle_whatsapp_send, handle_whatsapp_db,
     handle_social_receive, handle_social_send,
     handle_http_scraper, handle_file_downloader, handle_document_parser,
     handle_text_chunker, handle_embedding_generator, handle_vector_store,
     handle_task_manager,
+    handle_twitter_send, handle_twitter_search, handle_twitter_user,
 )
 
 if TYPE_CHECKING:
@@ -122,6 +123,7 @@ class NodeExecutor:
             'consumer_agent': partial(handle_chat_agent, ai_service=self.ai_service, database=self.database),
             'autonomous_agent': partial(handle_chat_agent, ai_service=self.ai_service, database=self.database),
             'orchestrator_agent': partial(handle_chat_agent, ai_service=self.ai_service, database=self.database),
+            'ai_employee': partial(handle_chat_agent, ai_service=self.ai_service, database=self.database),
             'simpleMemory': handle_simple_memory,
             # Maps
             'gmaps_create': partial(handle_create_map, maps_service=self.maps_service),
@@ -133,6 +135,10 @@ class NodeExecutor:
             # WhatsApp
             'whatsappSend': handle_whatsapp_send,
             'whatsappDb': handle_whatsapp_db,
+            # Twitter/X
+            'twitterSend': handle_twitter_send,
+            'twitterSearch': handle_twitter_search,
+            'twitterUser': handle_twitter_user,
             # Social (unified messaging)
             # Note: socialReceive handled in _dispatch with connected_outputs
             'socialSend': handle_social_send,
@@ -150,6 +156,8 @@ class NodeExecutor:
             'vectorStore': handle_vector_store,
             # Task management
             'taskManager': handle_task_manager,
+            # Team monitoring
+            'teamMonitor': handle_team_monitor,
             # Note: 'console' handled in _dispatch with connected_outputs
         }
 
@@ -227,6 +235,12 @@ class NodeExecutor:
                     await self._output_store(session_id, node_id, "output_contact", output_data.get('contact', {}))
                     await self._output_store(session_id, node_id, "output_metadata", output_data.get('metadata', {}))
 
+                # Store with multiple keys for different handle IDs used by frontend components:
+                # - output_main: SquareNode, GenericNode, TriggerNode, StartNode
+                # - output_top: AIAgentNode (agents use top output handle)
+                # - output_0: backward compatibility
+                await self._output_store(session_id, node_id, "output_main", output_data)
+                await self._output_store(session_id, node_id, "output_top", output_data)
                 await self._output_store(session_id, node_id, "output_0", output_data)
 
             return result

package/server/services/pricing.py

@@ -0,0 +1,270 @@
+"""LLM pricing service for token cost calculation.
+
+Provides cost calculation for all supported LLM providers based on official pricing.
+Pricing is in USD per million tokens (MTok).
+"""
+
+from dataclasses import dataclass
+from typing import Dict, Optional
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class ModelPricing:
+    """Pricing for a specific model."""
+    input_per_mtok: float   # USD per 1M input tokens
+    output_per_mtok: float  # USD per 1M output tokens
+    cache_read_per_mtok: Optional[float] = None  # USD per 1M cache read tokens (Anthropic)
+    reasoning_per_mtok: Optional[float] = None   # USD per 1M reasoning tokens (OpenAI o-series)
+
+
+# Official pricing as of February 2026
+# Sources: openai.com/api/pricing, anthropic.com/pricing, ai.google.dev/pricing,
+#          groq.com/pricing, cerebras.ai/pricing
+PRICING_REGISTRY: Dict[str, Dict[str, ModelPricing]] = {
+    'openai': {
+        # GPT-5 series
+        'gpt-5.2': ModelPricing(1.75, 14.00),
+        'gpt-5.1': ModelPricing(1.25, 10.00),
+        'gpt-5': ModelPricing(1.25, 10.00),
+        'gpt-5-mini': ModelPricing(0.25, 2.00),
+        'gpt-5-nano': ModelPricing(0.05, 0.40),
+        'gpt-5-pro': ModelPricing(15.00, 120.00),
+        # O-series (reasoning models)
+        'o3': ModelPricing(2.00, 8.00, reasoning_per_mtok=8.00),
+        'o3-mini': ModelPricing(1.10, 4.40, reasoning_per_mtok=4.40),
+        'o3-pro': ModelPricing(20.00, 80.00, reasoning_per_mtok=80.00),
+        'o4-mini': ModelPricing(1.10, 4.40, reasoning_per_mtok=4.40),
+        'o1': ModelPricing(15.00, 60.00, reasoning_per_mtok=60.00),
+        'o1-mini': ModelPricing(1.10, 4.40, reasoning_per_mtok=4.40),
+        # GPT-4 series
+        'gpt-4o': ModelPricing(2.50, 10.00),
+        'gpt-4o-mini': ModelPricing(0.15, 0.60),
+        'gpt-4.1': ModelPricing(2.00, 8.00),
+        'gpt-4.1-mini': ModelPricing(0.40, 1.60),
+        'gpt-4.1-nano': ModelPricing(0.10, 0.40),
+        'gpt-4-turbo': ModelPricing(10.00, 30.00),
+        'gpt-4': ModelPricing(30.00, 60.00),
+        # GPT-3.5
+        'gpt-3.5-turbo': ModelPricing(0.50, 1.50),
+        # Default fallback
+        '_default': ModelPricing(2.50, 10.00),
+    },
+    'anthropic': {
+        # Claude 4.x series
+        'claude-opus-4.6': ModelPricing(5.00, 25.00, cache_read_per_mtok=0.50),
+        'claude-opus-4.5': ModelPricing(5.00, 25.00, cache_read_per_mtok=0.50),
+        'claude-opus-4.1': ModelPricing(15.00, 75.00, cache_read_per_mtok=1.50),
+        'claude-opus-4': ModelPricing(15.00, 75.00, cache_read_per_mtok=1.50),
+        'claude-sonnet-4.6': ModelPricing(3.00, 15.00, cache_read_per_mtok=0.30),
+        'claude-sonnet-4.5': ModelPricing(3.00, 15.00, cache_read_per_mtok=0.30),
+        'claude-sonnet-4': ModelPricing(3.00, 15.00, cache_read_per_mtok=0.30),
+        'claude-haiku-4.5': ModelPricing(1.00, 5.00, cache_read_per_mtok=0.10),
+        # Claude 3.x series (legacy)
+        'claude-3-opus': ModelPricing(15.00, 75.00, cache_read_per_mtok=1.50),
+        'claude-3-5-sonnet': ModelPricing(3.00, 15.00, cache_read_per_mtok=0.30),
+        'claude-3-sonnet': ModelPricing(3.00, 15.00, cache_read_per_mtok=0.30),
+        'claude-3-haiku': ModelPricing(0.25, 1.25, cache_read_per_mtok=0.03),
+        'claude-3.5-haiku': ModelPricing(0.80, 4.00, cache_read_per_mtok=0.08),
+        # Partial matches (for model names like claude-3-5-sonnet-20241022)
+        'claude-opus': ModelPricing(5.00, 25.00, cache_read_per_mtok=0.50),
+        'claude-sonnet': ModelPricing(3.00, 15.00, cache_read_per_mtok=0.30),
+        'claude-haiku': ModelPricing(1.00, 5.00, cache_read_per_mtok=0.10),
+        # Default fallback
+        '_default': ModelPricing(3.00, 15.00, cache_read_per_mtok=0.30),
+    },
+    'gemini': {
+        # Gemini 3.x series
+        'gemini-3-pro': ModelPricing(2.00, 12.00),
+        'gemini-3-flash': ModelPricing(0.50, 3.00),
+        # Gemini 2.5 series
+        'gemini-2.5-pro': ModelPricing(1.25, 10.00),
+        'gemini-2.5-flash': ModelPricing(0.30, 2.50),
+        'gemini-2.5-flash-lite': ModelPricing(0.10, 0.40),
+        # Gemini 2.0 series
+        'gemini-2.0-flash': ModelPricing(0.10, 0.40),
+        'gemini-2.0-flash-lite': ModelPricing(0.08, 0.30),
+        # Gemini 1.x series (legacy)
+        'gemini-1.5-pro': ModelPricing(1.25, 5.00),
+        'gemini-1.5-flash': ModelPricing(0.075, 0.30),
+        'gemini-pro': ModelPricing(0.50, 1.50),
+        # Default fallback
+        '_default': ModelPricing(0.50, 2.50),
+    },
+    'groq': {
+        # Llama 4 series
+        'llama-4-scout': ModelPricing(0.11, 0.34),
+        'llama-4-maverick': ModelPricing(0.20, 0.60),
+        # Llama 3.x series
+        'llama-3.3-70b': ModelPricing(0.59, 0.79),
+        'llama-3.1-70b': ModelPricing(0.59, 0.79),
+        'llama-3.1-8b': ModelPricing(0.05, 0.08),
+        'llama3-70b': ModelPricing(0.59, 0.79),
+        'llama3-8b': ModelPricing(0.05, 0.08),
+        # Qwen series
+        'qwen3-32b': ModelPricing(0.29, 0.59),
+        'qwen-qwq-32b': ModelPricing(0.29, 0.59),
+        # Mixtral
+        'mixtral-8x7b': ModelPricing(0.24, 0.24),
+        # GPT OSS
+        'gpt-oss-20b': ModelPricing(0.075, 0.30),
+        'gpt-oss-120b': ModelPricing(0.15, 0.60),
+        # Default fallback
+        '_default': ModelPricing(0.29, 0.59),
+    },
+    'cerebras': {
+        # Llama series
+        'llama-3.1-8b': ModelPricing(0.10, 0.10),
+        'llama-3.1-70b': ModelPricing(0.60, 0.60),
+        'llama-3.1-405b': ModelPricing(6.00, 12.00),
+        'llama3.1-8b': ModelPricing(0.10, 0.10),
+        'llama3.1-70b': ModelPricing(0.60, 0.60),
+        # Qwen
+        'qwen-3-32b': ModelPricing(0.20, 0.20),
+        # Default fallback
+        '_default': ModelPricing(0.60, 0.60),
+    },
+    'openrouter': {
+        # OpenRouter passes through provider pricing
+        # These are approximate defaults; actual cost depends on underlying provider
+        '_default': ModelPricing(1.00, 5.00),
+    },
+}
+
+
+class PricingService:
+    """Service for calculating LLM token costs."""
+
+    def __init__(self):
+        self._registry = PRICING_REGISTRY
+
+    def get_pricing(self, provider: str, model: str) -> ModelPricing:
+        """Get pricing for a specific model.
+
+        Uses partial matching: 'claude-3-5-sonnet-20241022' matches 'claude-3-5-sonnet'.
+        Falls back to '_default' if no match found.
+
+        Args:
+            provider: Provider name (openai, anthropic, gemini, groq, cerebras, openrouter)
+            model: Model name or ID
+
+        Returns:
+            ModelPricing with rates per million tokens
+        """
+        provider_lower = provider.lower()
+        model_lower = model.lower() if model else ''
+
+        provider_pricing = self._registry.get(provider_lower, {})
+
+        # Try exact match first
+        if model_lower in provider_pricing:
+            return provider_pricing[model_lower]
+
+        # Try partial match (model name starts with a known key)
+        for model_key, pricing in provider_pricing.items():
+            if model_key != '_default' and model_lower.startswith(model_key):
+                return pricing
+
+        # Try if any key is contained in the model name
+        for model_key, pricing in provider_pricing.items():
+            if model_key != '_default' and model_key in model_lower:
+                return pricing
+
+        # Fall back to provider default
+        default_pricing = provider_pricing.get('_default')
+        if default_pricing:
+            return default_pricing
+
+        # Ultimate fallback
+        logger.warning(f"[Pricing] No pricing found for {provider}/{model}, using global default")
+        return ModelPricing(1.00, 5.00)
+
+    def calculate_cost(
+        self,
+        provider: str,
+        model: str,
+        input_tokens: int,
+        output_tokens: int,
+        cache_read_tokens: int = 0,
+        cache_creation_tokens: int = 0,
+        reasoning_tokens: int = 0
+    ) -> Dict[str, float]:
+        """Calculate cost for token usage.
+
+        Args:
+            provider: LLM provider name
+            model: Model name/ID
+            input_tokens: Number of input tokens
+            output_tokens: Number of output tokens
+            cache_read_tokens: Number of cache read tokens (Anthropic)
+            cache_creation_tokens: Number of cache creation tokens (Anthropic)
+            reasoning_tokens: Number of reasoning tokens (OpenAI o-series)
+
+        Returns:
+            Dict with cost breakdown:
+            - input_cost: USD for input tokens
+            - output_cost: USD for output tokens
+            - cache_cost: USD for cache tokens
+            - reasoning_cost: USD for reasoning tokens
+            - total_cost: Total USD cost
+        """
+        pricing = self.get_pricing(provider, model)
+
+        # Calculate costs (prices are per 1M tokens)
+        input_cost = (input_tokens / 1_000_000) * pricing.input_per_mtok
+        output_cost = (output_tokens / 1_000_000) * pricing.output_per_mtok
+
+        # Cache costs (Anthropic pattern)
+        cache_cost = 0.0
+        if pricing.cache_read_per_mtok:
+            # Cache reads are discounted (typically 10% of input price)
+            cache_cost += (cache_read_tokens / 1_000_000) * pricing.cache_read_per_mtok
+            # Cache creation is charged at 1.25x output rate
+            cache_cost += (cache_creation_tokens / 1_000_000) * pricing.output_per_mtok * 1.25
+
+        # Reasoning costs (OpenAI o-series)
+        reasoning_cost = 0.0
+        if pricing.reasoning_per_mtok and reasoning_tokens > 0:
+            reasoning_cost = (reasoning_tokens / 1_000_000) * pricing.reasoning_per_mtok
+
+        total_cost = input_cost + output_cost + cache_cost + reasoning_cost
+
+        return {
+            'input_cost': round(input_cost, 6),
+            'output_cost': round(output_cost, 6),
+            'cache_cost': round(cache_cost, 6),
+            'reasoning_cost': round(reasoning_cost, 6),
+            'total_cost': round(total_cost, 6),
+        }
+
+    def get_all_pricing(self) -> Dict[str, Dict[str, Dict[str, float]]]:
+        """Get all pricing data for frontend display.
+
+        Returns:
+            Nested dict: {provider: {model: {input, output, cache_read, reasoning}}}
+        """
+        result = {}
+        for provider, models in self._registry.items():
+            result[provider] = {}
+            for model, pricing in models.items():
+                result[provider][model] = {
+                    'input': pricing.input_per_mtok,
+                    'output': pricing.output_per_mtok,
+                    'cache_read': pricing.cache_read_per_mtok,
+                    'reasoning': pricing.reasoning_per_mtok,
+                }
+        return result
+
+
+# Singleton instance
+_service: Optional[PricingService] = None
+
+
+def get_pricing_service() -> PricingService:
+    """Get the singleton PricingService instance."""
+    global _service
+    if _service is None:
+        _service = PricingService()
+    return _service

package/server/services/status_broadcaster.py

@@ -41,6 +41,13 @@ class StatusBroadcaster:
                 "device_id": None,
                 "qr": None
             },
+            "twitter": {
+                "connected": False,
+                "username": None,
+                "user_id": None,
+                "name": None,
+                "profile_image_url": None
+            },
             "api_keys": {},  # provider -> validation status
             "nodes": {},  # node_id -> node status
             "variables": {},  # variable_name -> value
@@ -73,6 +80,9 @@ class StatusBroadcaster:
         # This ensures client sees actual connection state (especially after auto-connect)
         await self._refresh_whatsapp_status()
 
+        # Fetch Twitter status from stored OAuth tokens
+        await self._refresh_twitter_status()
+
         # Auto-reconnect Android relay if there's a stored session
         await self._auto_reconnect_android_relay()
 
@@ -228,6 +238,56 @@ class StatusBroadcaster:
             # Don't fail client connection if WhatsApp service is down
             logger.debug(f"[StatusBroadcaster] Could not refresh WhatsApp status: {e}")
 
+    async def _refresh_twitter_status(self):
+        """Fetch Twitter status from stored OAuth tokens in database.
+
+        Called on client connect to check if user is authenticated with Twitter.
+        """
+        try:
+            from core.container import container
+            auth_service = container.auth_service()
+
+            # Check for stored access token
+            access_token = await auth_service.get_api_key("twitter_access_token")
+            if not access_token:
+                self._status["twitter"] = {
+                    "connected": False,
+                    "username": None,
+                    "user_id": None,
+                    "name": None,
+                    "profile_image_url": None
+                }
+                return
+
+            # Get stored user info
+            user_info_str = await auth_service.get_api_key("twitter_user_info")
+            if user_info_str:
+                # Format: "user_id:username:name"
+                parts = user_info_str.split(":", 2)
+                user_id = parts[0] if len(parts) > 0 else None
+                username = parts[1] if len(parts) > 1 else None
+                name = parts[2] if len(parts) > 2 else None
+
+                self._status["twitter"] = {
+                    "connected": True,
+                    "username": username,
+                    "user_id": user_id,
+                    "name": name,
+                    "profile_image_url": None  # Could fetch fresh if needed
+                }
+                logger.debug(f"[StatusBroadcaster] Twitter status: connected as @{username}")
+            else:
+                # Has token but no user info - still connected
+                self._status["twitter"] = {
+                    "connected": True,
+                    "username": None,
+                    "user_id": None,
+                    "name": None,
+                    "profile_image_url": None
+                }
+        except Exception as e:
+            logger.debug(f"[StatusBroadcaster] Could not refresh Twitter status: {e}")
+
     async def _auto_reconnect_android_relay(self):
         """Auto-reconnect to Android relay if there's a stored pairing session.
 
@@ -755,6 +815,25 @@ class StatusBroadcaster:
             "type": "terminal_logs_cleared"
         })
 
+    # =========================================================================
+    # Agent Team Updates
+    # =========================================================================
+
+    async def broadcast_team_event(self, team_id: str, event_type: str, data: Dict[str, Any]):
+        """Broadcast a team-related event to all connected clients.
+
+        Args:
+            team_id: The team ID
+            event_type: Event type (team_created, task_added, task_claimed, etc.)
+            data: Event data
+        """
+        await self.broadcast({
+            "type": "team_event",
+            "team_id": team_id,
+            "event_type": event_type,
+            "data": data
+        })
+
     # =========================================================================
     # Generic Updates
     # =========================================================================