machinaos 0.0.21 → 0.0.23

package/server/services/compaction.py

@@ -10,6 +10,7 @@ from datetime import datetime, timezone
 from typing import Dict, Any, Optional, TYPE_CHECKING
 
 from core.logging import get_logger
+from services.pricing import get_pricing_service
 
 if TYPE_CHECKING:
     from core.database import Database
@@ -92,20 +93,54 @@ class CompactionService:
         return {"context_management": {"compact_threshold": threshold or self._config.threshold}}
 
     async def track(self, session_id: str, node_id: str, provider: str, model: str, usage: Dict[str, int]) -> Dict[str, Any]:
-        """Track token usage and return compaction status."""
-        await self._db.save_token_metric({"session_id": session_id, "node_id": node_id, "provider": provider, "model": model, **usage})
+        """Track token usage and cost, return compaction status."""
+        # Calculate cost using PricingService
+        pricing_service = get_pricing_service()
+        cost = pricing_service.calculate_cost(
+            provider=provider,
+            model=model,
+            input_tokens=usage.get("input_tokens", 0),
+            output_tokens=usage.get("output_tokens", 0),
+            cache_read_tokens=usage.get("cache_read_tokens", 0),
+            cache_creation_tokens=usage.get("cache_creation_tokens", 0),
+            reasoning_tokens=usage.get("reasoning_tokens", 0)
+        )
+
+        # Save token metric with cost fields
+        await self._db.save_token_metric({
+            "session_id": session_id,
+            "node_id": node_id,
+            "provider": provider,
+            "model": model,
+            **usage,
+            "input_cost": cost["input_cost"],
+            "output_cost": cost["output_cost"],
+            "cache_cost": cost["cache_cost"],
+            "total_cost": cost["total_cost"]
+        })
 
         state = await self._db.get_or_create_session_token_state(session_id)
         new_total = state["cumulative_total"] + usage.get("total_tokens", 0)
+        new_total_cost = state.get("cumulative_total_cost", 0.0) + cost["total_cost"]
 
+        # Update cumulative state with cost
         await self._db.update_session_token_state(session_id, {
             "cumulative_input_tokens": state["cumulative_input_tokens"] + usage.get("input_tokens", 0),
             "cumulative_output_tokens": state["cumulative_output_tokens"] + usage.get("output_tokens", 0),
-            "cumulative_total": new_total
+            "cumulative_total": new_total,
+            "cumulative_input_cost": state.get("cumulative_input_cost", 0.0) + cost["input_cost"],
+            "cumulative_output_cost": state.get("cumulative_output_cost", 0.0) + cost["output_cost"],
+            "cumulative_total_cost": new_total_cost
         })
 
         threshold = state.get("custom_threshold") or self._config.threshold
-        return {"total": new_total, "threshold": threshold, "needs_compaction": self._config.enabled and new_total >= threshold}
+        return {
+            "total": new_total,
+            "total_cost": new_total_cost,
+            "cost": cost,
+            "threshold": threshold,
+            "needs_compaction": self._config.enabled and new_total >= threshold
+        }
 
     async def record(self, session_id: str, node_id: str, provider: str, model: str, tokens_before: int, tokens_after: int, summary: Optional[str] = None) -> None:
         """Record compaction event after native API handles it."""

package/server/services/event_waiter.py

@@ -110,6 +110,11 @@ TRIGGER_REGISTRY: Dict[str, TriggerConfig] = {
         event_type='task_completed',
         display_name='Task Completed'
     ),
+    'twitterReceive': TriggerConfig(
+        node_type='twitterReceive',
+        event_type='twitter_event_received',
+        display_name='Twitter Event'
+    ),
     # Future triggers - just add to registry:
     # 'emailTrigger': TriggerConfig('emailTrigger', 'email_received', 'Email'),
     # 'mqttTrigger': TriggerConfig('mqttTrigger', 'mqtt_message', 'MQTT Message'),
@@ -336,12 +341,48 @@ def build_task_completed_filter(params: Dict) -> Callable[[Dict], bool]:
     return matches
 
 
+def build_twitter_filter(params: Dict) -> Callable[[Dict], bool]:
+    """Build filter function for Twitter events.
+
+    Filters by:
+    - trigger_type: 'mentions', 'search', 'user_timeline'
+    - search_query: Search query for 'search' trigger type
+    - user_id: User ID for 'user_timeline' trigger type
+
+    Args:
+        params: Node parameters
+
+    Returns:
+        Filter function that checks if event matches criteria
+    """
+    trigger_type = params.get('trigger_type', 'mentions')
+    search_query = params.get('search_query', '')
+    user_id = params.get('user_id', '')
+
+    def matches(data: Dict) -> bool:
+        event_type = data.get('trigger_type', '')
+        if trigger_type != 'all' and event_type != trigger_type:
+            return False
+        if trigger_type == 'search' and search_query:
+            # Check if search query matches
+            event_query = data.get('query', '')
+            if search_query.lower() not in event_query.lower():
+                return False
+        if trigger_type == 'user_timeline' and user_id:
+            if data.get('user_id') != user_id:
+                return False
+        return True
+
+    return matches
+
+
 # Registry of filter builders per trigger type
 FILTER_BUILDERS: Dict[str, Callable[[Dict], Callable[[Dict], bool]]] = {
     'whatsappReceive': build_whatsapp_filter,
     'webhookTrigger': build_webhook_filter,
     'chatTrigger': build_chat_filter,
     'taskTrigger': build_task_completed_filter,
+    'twitterReceive': build_twitter_filter,
 }
 
 

package/server/services/handlers/__init__.py

@@ -57,6 +57,7 @@ from .utility import (
     handle_cron_scheduler,
     handle_timer,
     handle_console,
+    handle_team_monitor,
 )
 
 # WhatsApp handlers
@@ -65,6 +66,13 @@ from .whatsapp import (
     handle_whatsapp_db,
 )
 
+# Twitter handlers
+from .twitter import (
+    handle_twitter_send,
+    handle_twitter_search,
+    handle_twitter_user,
+)
+
 # Social handlers (unified messaging)
 from .social import (
     handle_social_receive,
@@ -115,9 +123,14 @@ __all__ = [
     'handle_cron_scheduler',
     'handle_timer',
     'handle_console',
+    'handle_team_monitor',
     # WhatsApp
     'handle_whatsapp_send',
     'handle_whatsapp_db',
+    # Twitter
+    'handle_twitter_send',
+    'handle_twitter_search',
+    'handle_twitter_user',
     # Social
     'handle_social_receive',
     'handle_social_send',

package/server/services/handlers/ai.py

@@ -10,6 +10,9 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
+# Team lead types that can create teams
+TEAM_LEAD_TYPES = {'orchestrator_agent', 'ai_employee'}
+
 
 async def _collect_agent_connections(
     node_id: str,
@@ -302,6 +305,50 @@ async def _collect_agent_connections(
     return memory_data, skill_data, tool_data, input_data, task_data
 
 
+async def _collect_teammate_connections(
+    node_id: str,
+    context: Dict[str, Any],
+    database: "Database"
+) -> List[Dict[str, Any]]:
+    """Collect agents connected via input-teammates handle for team mode.
+
+    Args:
+        node_id: The team lead node ID
+        context: Execution context with nodes, edges
+        database: Database instance
+
+    Returns:
+        List of teammate node info dicts
+    """
+    nodes = context.get('nodes', [])
+    edges = context.get('edges', [])
+    teammates = []
+
+    for edge in edges:
+        if edge.get('target') != node_id or edge.get('targetHandle') != 'input-teammates':
+            continue
+
+        source_id = edge.get('source')
+        source_node = next((n for n in nodes if n.get('id') == source_id), None)
+        if not source_node:
+            continue
+
+        node_type = source_node.get('type', '')
+        if node_type not in AI_AGENT_TYPES:
+            continue
+
+        params = await database.get_node_parameters(source_id) or {}
+        teammates.append({
+            'node_id': source_id,
+            'node_type': node_type,
+            'label': source_node.get('data', {}).get('label', node_type),
+            'parameters': params
+        })
+        logger.debug(f"[Teams] Found teammate: {node_type} ({source_id})")
+
+    return teammates
+
+
 def _format_task_context(task_data: Dict[str, Any]) -> str:
     """Format task completion data as context for the agent.
 
@@ -485,7 +532,24 @@ async def handle_chat_agent(
     from services.status_broadcaster import get_status_broadcaster
     broadcaster = get_status_broadcaster()
 
-    # Execute Chat Agent with memory, skills and tools
+    # Team mode detection for orchestrator_agent and ai_employee nodes
+    # Teammates connected via input-teammates become delegation tools
+    if node_type in TEAM_LEAD_TYPES:
+        teammates = await _collect_teammate_connections(node_id, context, database)
+
+        if teammates:
+            # Add teammates as delegation tools (they become delegate_to_* tools)
+            tool_data = tool_data or []
+            for tm in teammates:
+                tool_data.append({
+                    'node_id': tm['node_id'],
+                    'node_type': tm['node_type'],
+                    'label': tm['label'],
+                    'parameters': tm.get('parameters', {}),
+                })
+            logger.info(f"[Teams] Added {len(teammates)} teammates as delegation tools")
+
+    # Standard execution (no team mode)
     return await ai_service.execute_chat_agent(
         node_id,
         parameters,
@@ -494,7 +558,7 @@ async def handle_chat_agent(
         tool_data=tool_data if tool_data else None,
         broadcaster=broadcaster,
         workflow_id=workflow_id,
-        context=context  # Pass context for nested agent delegation
+        context=context
     )
 
 

package/server/services/handlers/tools.py

@@ -107,6 +107,18 @@ async def execute_tool(tool_name: str, tool_args: Dict[str, Any],
     if node_type == 'whatsappDb':
         return await _execute_whatsapp_db(tool_args, config.get('parameters', {}))
 
+    # Twitter Send (dual-purpose: workflow node + AI tool)
+    if node_type == 'twitterSend':
+        return await _execute_twitter_send(tool_args, config.get('parameters', {}))
+
+    # Twitter Search (dual-purpose: workflow node + AI tool)
+    if node_type == 'twitterSearch':
+        return await _execute_twitter_search(tool_args, config.get('parameters', {}))
+
+    # Twitter User (dual-purpose: workflow node + AI tool)
+    if node_type == 'twitterUser':
+        return await _execute_twitter_user(tool_args, config.get('parameters', {}))
+
     # Android toolkit - routes to connected service nodes
     if node_type == 'androidTool':
         return await _execute_android_toolkit(tool_args, config)
@@ -1118,6 +1130,78 @@ async def _execute_nearby_places(args: Dict[str, Any],
         return {"error": f"Nearby places search failed: {str(e)}"}
 
 
+async def _execute_twitter_send(args: Dict[str, Any],
+                                 node_params: Dict[str, Any]) -> Dict[str, Any]:
+    """Execute Twitter send action via XDK SDK.
+
+    Args:
+        args: LLM-provided arguments (action, text, tweet_id, reply_to_id)
+        node_params: Node parameters
+
+    Returns:
+        Twitter API result
+    """
+    from services.handlers.twitter import handle_twitter_send
+
+    parameters = {**node_params, **args}
+    # Handle reply_to_id alias
+    if args.get('reply_to_id') and not args.get('tweet_id'):
+        parameters['tweet_id'] = args['reply_to_id']
+
+    return await handle_twitter_send(
+        node_id="tool_twitter_send",
+        node_type="twitterSend",
+        parameters=parameters,
+        context={}
+    )
+
+
+async def _execute_twitter_search(args: Dict[str, Any],
+                                   node_params: Dict[str, Any]) -> Dict[str, Any]:
+    """Execute Twitter search via XDK SDK.
+
+    Args:
+        args: LLM-provided arguments (query, max_results)
+        node_params: Node parameters
+
+    Returns:
+        Search results
+    """
+    from services.handlers.twitter import handle_twitter_search
+
+    parameters = {**node_params, **args}
+
+    return await handle_twitter_search(
+        node_id="tool_twitter_search",
+        node_type="twitterSearch",
+        parameters=parameters,
+        context={}
+    )
+
+
+async def _execute_twitter_user(args: Dict[str, Any],
+                                 node_params: Dict[str, Any]) -> Dict[str, Any]:
+    """Execute Twitter user lookup via XDK SDK.
+
+    Args:
+        args: LLM-provided arguments (operation, username, user_id, max_results)
+        node_params: Node parameters
+
+    Returns:
+        User data
+    """
+    from services.handlers.twitter import handle_twitter_user
+
+    parameters = {**node_params, **args}
+
+    return await handle_twitter_user(
+        node_id="tool_twitter_user",
+        node_type="twitterUser",
+        parameters=parameters,
+        context={}
+    )
+
+
 async def _execute_generic(args: Dict[str, Any],
                            config: Dict[str, Any]) -> Dict[str, Any]:
     """Execute a generic tool (fallback handler).

package/server/services/handlers/twitter.py

@@ -0,0 +1,297 @@
+"""Twitter/X node handlers using official XDK SDK."""
+
+import time
+from typing import Dict, Any
+from xdk import Client
+
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+async def _get_twitter_client() -> Client:
+    """Get authenticated Twitter client from stored OAuth 2.0 credentials."""
+    # Import inside function to avoid circular import
+    from core.container import container
+    auth_service = container.auth_service()
+    access_token = await auth_service.get_api_key("twitter_access_token")
+    if not access_token:
+        raise ValueError("Twitter not connected. Please authenticate via Credentials.")
+    # Use access_token for OAuth 2.0 user token (not bearer_token which is app-only)
+    return Client(access_token=access_token)
+
+
+async def _get_my_user_id(client: Client) -> str:
+    """Get the authenticated user's ID."""
+    response = client.users.get_me()
+    # response.data is a dict with 'id', 'username', 'name' keys
+    return response.data["id"]
+
+
+async def handle_twitter_send(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle Twitter send actions: tweet, reply, retweet, like, unlike, delete."""
+    start_time = time.time()
+    action = parameters.get('action', 'tweet')
+
+    try:
+        client = await _get_twitter_client()
+
+        match action:
+            case 'tweet':
+                text = parameters.get('text', '')
+                if not text:
+                    raise ValueError("Tweet text is required")
+                # XDK API: client.posts.create(body={"text": "..."})
+                payload = {"text": text[:280]}
+                result = client.posts.create(body=payload)
+                return _success(_format_response(result), "tweet_sent", start_time)
+
+            case 'reply':
+                text = parameters.get('text', '')
+                reply_to = parameters.get('reply_to_id')
+                if not text or not reply_to:
+                    raise ValueError("Text and reply_to_id are required")
+                # XDK API: reply uses nested reply object
+                payload = {
+                    "text": text[:280],
+                    "reply": {"in_reply_to_tweet_id": reply_to}
+                }
+                result = client.posts.create(body=payload)
+                return _success(_format_response(result), "reply_sent", start_time)
+
+            case 'retweet':
+                tweet_id = parameters.get('tweet_id')
+                if not tweet_id:
+                    raise ValueError("tweet_id is required")
+                user_id = await _get_my_user_id(client)
+                # XDK API: client.users.repost_post(user_id, body={"tweet_id": "..."})
+                payload = {"tweet_id": tweet_id}
+                result = client.users.repost_post(user_id, body=payload)
+                return _success(_format_response(result), "retweeted", start_time)
+
+            case 'like':
+                tweet_id = parameters.get('tweet_id')
+                if not tweet_id:
+                    raise ValueError("tweet_id is required")
+                user_id = await _get_my_user_id(client)
+                # XDK API: client.users.like_post(user_id, body={"tweet_id": "..."})
+                payload = {"tweet_id": tweet_id}
+                result = client.users.like_post(user_id, body=payload)
+                return _success(_format_response(result), "liked", start_time)
+
+            case 'unlike':
+                tweet_id = parameters.get('tweet_id')
+                if not tweet_id:
+                    raise ValueError("tweet_id is required")
+                user_id = await _get_my_user_id(client)
+                # XDK API: client.users.unlike_post(user_id, tweet_id=post_id)
+                result = client.users.unlike_post(user_id, tweet_id=tweet_id)
+                return _success(_format_response(result), "unliked", start_time)
+
+            case 'delete':
+                tweet_id = parameters.get('tweet_id')
+                if not tweet_id:
+                    raise ValueError("tweet_id is required")
+                # XDK API: client.posts.delete(post_id)
+                result = client.posts.delete(tweet_id)
+                return _success(_format_response(result), "deleted", start_time)
+
+            case _:
+                raise ValueError(f"Unknown action: {action}")
+
+    except Exception as e:
+        logger.error(f"Twitter send error: {e}")
+        return {"success": False, "error": str(e), "execution_time": time.time() - start_time}
+
+
+async def handle_twitter_search(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle Twitter search operations."""
+    start_time = time.time()
+
+    try:
+        client = await _get_twitter_client()
+        query = parameters.get('query', '')
+        max_results = min(parameters.get('max_results', 10), 100)
+
+        if not query:
+            raise ValueError("Search query is required")
+
+        tweets = []
+        # XDK API: client.posts.search_recent(query=..., max_results=..., tweet_fields=[...])
+        for page in client.posts.search_recent(
+            query=query,
+            max_results=max_results,
+            tweet_fields=["author_id", "created_at"]
+        ):
+            page_data = getattr(page, 'data', []) or []
+            tweets.extend([_format_tweet(t) for t in page_data])
+            break  # Only first page
+
+        return {
+            "success": True,
+            "result": {"tweets": tweets, "count": len(tweets), "query": query},
+            "execution_time": time.time() - start_time
+        }
+
+    except Exception as e:
+        logger.error(f"Twitter search error: {e}")
+        return {"success": False, "error": str(e), "execution_time": time.time() - start_time}
+
+
+async def handle_twitter_user(
+    node_id: str,
+    node_type: str,
+    parameters: Dict[str, Any],
+    context: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Handle Twitter user lookup operations."""
+    start_time = time.time()
+    operation = parameters.get('operation', 'me')
+
+    try:
+        client = await _get_twitter_client()
+
+        match operation:
+            case 'me':
+                # XDK API: client.users.get_me(user_fields=[...])
+                result = client.users.get_me(user_fields=["created_at", "description"])
+                return _success(_format_user_data(result.data), "user", start_time)
+
+            case 'by_username':
+                username = parameters.get('username')
+                if not username:
+                    raise ValueError("Username is required")
+                # XDK API: client.users.get_by_usernames(usernames=[...], user_fields=[...])
+                result = client.users.get_by_usernames(
+                    usernames=[username],
+                    user_fields=["description", "created_at"]
+                )
+                users = getattr(result, 'data', []) or []
+                if not users:
+                    raise ValueError(f"User @{username} not found")
+                return _success(_format_user_data(users[0]), "user", start_time)
+
+            case 'by_id':
+                user_id = parameters.get('user_id')
+                if not user_id:
+                    raise ValueError("User ID is required")
+                # XDK API: client.users.get_by_ids works similar
+                result = client.users.get_by_ids(
+                    ids=[user_id],
+                    user_fields=["description", "created_at"]
+                )
+                users = getattr(result, 'data', []) or []
+                if not users:
+                    raise ValueError(f"User ID {user_id} not found")
+                return _success(_format_user_data(users[0]), "user", start_time)
+
+            case 'followers':
+                user_id = parameters.get('user_id')
+                if not user_id:
+                    user_id = await _get_my_user_id(client)
+                max_results = min(parameters.get('max_results', 100), 1000)
+                users = []
+                # XDK API: client.users.get_followers(user_id, max_results=..., user_fields=[...])
+                for page in client.users.get_followers(
+                    user_id,
+                    max_results=max_results,
+                    user_fields=["created_at"]
+                ):
+                    page_data = getattr(page, 'data', []) or []
+                    users.extend([_format_user_data(u) for u in page_data])
+                    break  # Only first page
+                return _success({"users": users, "count": len(users)}, "followers", start_time)
+
+            case 'following':
+                user_id = parameters.get('user_id')
+                if not user_id:
+                    user_id = await _get_my_user_id(client)
+                max_results = min(parameters.get('max_results', 100), 1000)
+                users = []
+                # XDK API: client.users.get_following(user_id, max_results=..., user_fields=[...])
+                for page in client.users.get_following(
+                    user_id,
+                    max_results=max_results,
+                    user_fields=["created_at"]
+                ):
+                    page_data = getattr(page, 'data', []) or []
+                    users.extend([_format_user_data(u) for u in page_data])
+                    break  # Only first page
+                return _success({"users": users, "count": len(users)}, "following", start_time)
+
+            case _:
+                raise ValueError(f"Unknown operation: {operation}")
+
+    except Exception as e:
+        logger.error(f"Twitter user error: {e}")
+        return {"success": False, "error": str(e), "execution_time": time.time() - start_time}
+
+
+def _success(data: Any, action: str, start_time: float) -> Dict[str, Any]:
+    """Build success response."""
+    return {
+        "success": True,
+        "result": data if isinstance(data, dict) else {"data": data, "action": action},
+        "execution_time": time.time() - start_time
+    }
+
+
+def _format_response(response) -> Dict[str, Any]:
+    """Format XDK response object to dict."""
+    if hasattr(response, 'data'):
+        data = response.data
+        if isinstance(data, dict):
+            return data
+        # Convert object attributes to dict
+        return {k: v for k, v in data.__dict__.items() if not k.startswith('_')} if hasattr(data, '__dict__') else {"data": str(data)}
+    return {"response": str(response)}
+
+
+def _format_tweet(tweet) -> Dict[str, Any]:
+    """Format tweet object/dict to dict."""
+    if isinstance(tweet, dict):
+        return {
+            "id": tweet.get("id"),
+            "text": tweet.get("text"),
+            "author_id": tweet.get("author_id"),
+            "created_at": str(tweet.get("created_at", "")),
+        }
+    return {
+        "id": getattr(tweet, 'id', None),
+        "text": getattr(tweet, 'text', None),
+        "author_id": getattr(tweet, 'author_id', None),
+        "created_at": str(getattr(tweet, 'created_at', '')),
+    }
+
+
+def _format_user_data(user) -> Dict[str, Any]:
+    """Format user object/dict to dict."""
+    if isinstance(user, dict):
+        return {
+            "id": user.get("id"),
+            "username": user.get("username"),
+            "name": user.get("name"),
+            "profile_image_url": user.get("profile_image_url"),
+            "verified": user.get("verified", False),
+            "description": user.get("description"),
+            "created_at": str(user.get("created_at", "")),
+        }
+    return {
+        "id": getattr(user, 'id', None),
+        "username": getattr(user, 'username', None),
+        "name": getattr(user, 'name', None),
+        "profile_image_url": getattr(user, 'profile_image_url', None),
+        "verified": getattr(user, 'verified', False),
+        "description": getattr(user, 'description', None),
+        "created_at": str(getattr(user, 'created_at', '')),
+    }