machinaos 0.0.64 → 0.0.73

package/server/services/handlers/search.py

@@ -1,385 +0,0 @@
-"""Search API node handlers - Brave Search, Serper, Perplexity Sonar.
-
-Each handler fetches the API key from the encrypted credentials system
-via auth_service, then calls the provider's API.
-"""
-
-import time
-from typing import Dict, Any
-
-import httpx
-
-from core.logging import get_logger
-from services.pricing import get_pricing_service
-
-logger = get_logger(__name__)
-
-
-async def _track_search_usage(
-    node_id: str,
-    service: str,
-    action: str,
-    resource_count: int = 1,
-    workflow_id: str = None,
-    session_id: str = "default"
-) -> Dict[str, float]:
-    """Track search API usage for cost calculation."""
-    from core.container import container
-
-    pricing = get_pricing_service()
-    cost_data = pricing.calculate_api_cost(service, action, resource_count)
-
-    db = container.database()
-    await db.save_api_usage_metric({
-        'session_id': session_id,
-        'node_id': node_id,
-        'workflow_id': workflow_id,
-        'service': service,
-        'operation': cost_data.get('operation', action),
-        'endpoint': action,
-        'resource_count': resource_count,
-        'cost': cost_data.get('total_cost', 0.0)
-    })
-
-    logger.debug(f"[Search] Tracked {service} usage: {action} x{resource_count} = ${cost_data.get('total_cost', 0):.6f}")
-    return cost_data
-
-
-async def _get_api_key(provider: str) -> str:
-    """Get API key from encrypted credentials."""
-    from core.container import container
-    auth_service = container.auth_service()
-    api_key = await auth_service.get_api_key(provider)
-    if not api_key:
-        raise ValueError(
-            f"{provider} API key not configured. "
-            f"Please add it in Credentials > Search."
-        )
-    return api_key
-
-
-# =============================================================================
-# BRAVE SEARCH HANDLER
-# =============================================================================
-
-async def handle_brave_search(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Handle Brave Search API requests.
-
-    API: GET https://api.search.brave.com/res/v1/web/search
-    Auth: X-Subscription-Token header
-    """
-    start_time = time.time()
-
-    query = parameters.get('query', '').strip()
-    if not query:
-        return {"success": False, "error": "Search query is required"}
-
-    max_results = parameters.get('maxResults', 10)
-    country = parameters.get('country', '')
-    search_lang = parameters.get('searchLang', '')
-    safe_search = parameters.get('safeSearch', 'moderate')
-
-    try:
-        api_key = await _get_api_key('brave_search')
-
-        params = {
-            'q': query,
-            'count': min(max_results, 100),
-        }
-        if country:
-            params['country'] = country
-        if search_lang:
-            params['search_lang'] = search_lang
-        if safe_search:
-            params['safesearch'] = safe_search
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.get(
-                'https://api.search.brave.com/res/v1/web/search',
-                headers={
-                    'X-Subscription-Token': api_key,
-                    'Accept': 'application/json',
-                },
-                params=params,
-            )
-            response.raise_for_status()
-            data = response.json()
-
-        # Extract web results
-        web_results = data.get('web', {}).get('results', [])
-        results = []
-        for item in web_results[:max_results]:
-            results.append({
-                'title': item.get('title', ''),
-                'snippet': item.get('description', ''),
-                'url': item.get('url', ''),
-            })
-
-        execution_time = time.time() - start_time
-
-        # Track usage
-        workflow_id = context.get('workflow_id')
-        session_id = context.get('session_id', 'default')
-        await _track_search_usage(node_id, 'brave_search', 'web_search', 1, workflow_id, session_id)
-
-        return {
-            "success": True,
-            "result": {
-                "query": query,
-                "results": results,
-                "result_count": len(results),
-                "provider": "brave_search",
-            },
-            "execution_time": round(execution_time, 3),
-        }
-
-    except httpx.HTTPStatusError as e:
-        logger.error(f"[BraveSearch] API error: {e.response.status_code} - {e.response.text}")
-        return {"success": False, "error": f"Brave Search API error: {e.response.status_code}"}
-    except ValueError as e:
-        return {"success": False, "error": str(e)}
-    except Exception as e:
-        logger.error(f"[BraveSearch] Error: {e}")
-        return {"success": False, "error": f"Brave Search failed: {str(e)}"}
-
-
-# =============================================================================
-# SERPER SEARCH HANDLER
-# =============================================================================
-
-async def handle_serper_search(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Handle Serper (Google) Search API requests.
-
-    API: POST https://google.serper.dev/search
-    Auth: X-API-KEY header
-    """
-    start_time = time.time()
-
-    query = parameters.get('query', '').strip()
-    if not query:
-        return {"success": False, "error": "Search query is required"}
-
-    max_results = parameters.get('maxResults', 10)
-    search_type = parameters.get('searchType', 'search')
-    country = parameters.get('country', '')
-    language = parameters.get('language', '')
-
-    try:
-        api_key = await _get_api_key('serper')
-
-        body: Dict[str, Any] = {
-            'q': query,
-            'num': min(max_results, 100),
-        }
-        if country:
-            body['gl'] = country
-        if language:
-            body['hl'] = language
-
-        # Map search type to endpoint
-        endpoint_map = {
-            'search': 'https://google.serper.dev/search',
-            'news': 'https://google.serper.dev/news',
-            'images': 'https://google.serper.dev/images',
-            'places': 'https://google.serper.dev/places',
-        }
-        endpoint = endpoint_map.get(search_type, 'https://google.serper.dev/search')
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(
-                endpoint,
-                headers={
-                    'X-API-KEY': api_key,
-                    'Content-Type': 'application/json',
-                },
-                json=body,
-            )
-            response.raise_for_status()
-            data = response.json()
-
-        # Extract results based on search type
-        results = []
-        if search_type == 'search':
-            for item in data.get('organic', [])[:max_results]:
-                results.append({
-                    'title': item.get('title', ''),
-                    'snippet': item.get('snippet', ''),
-                    'url': item.get('link', ''),
-                    'position': item.get('position'),
-                })
-        elif search_type == 'news':
-            for item in data.get('news', [])[:max_results]:
-                results.append({
-                    'title': item.get('title', ''),
-                    'snippet': item.get('snippet', ''),
-                    'url': item.get('link', ''),
-                    'date': item.get('date', ''),
-                    'source': item.get('source', ''),
-                })
-        elif search_type == 'images':
-            for item in data.get('images', [])[:max_results]:
-                results.append({
-                    'title': item.get('title', ''),
-                    'imageUrl': item.get('imageUrl', ''),
-                    'url': item.get('link', ''),
-                })
-        elif search_type == 'places':
-            for item in data.get('places', [])[:max_results]:
-                results.append({
-                    'title': item.get('title', ''),
-                    'address': item.get('address', ''),
-                    'rating': item.get('rating'),
-                    'url': item.get('website', ''),
-                })
-
-        # Include knowledge graph if available
-        knowledge_graph = data.get('knowledgeGraph')
-
-        execution_time = time.time() - start_time
-
-        # Track usage
-        workflow_id = context.get('workflow_id')
-        session_id = context.get('session_id', 'default')
-        await _track_search_usage(node_id, 'serper', 'web_search', 1, workflow_id, session_id)
-
-        result = {
-            "query": query,
-            "results": results,
-            "result_count": len(results),
-            "search_type": search_type,
-            "provider": "serper",
-        }
-        if knowledge_graph:
-            result["knowledge_graph"] = knowledge_graph
-
-        return {
-            "success": True,
-            "result": result,
-            "execution_time": round(execution_time, 3),
-        }
-
-    except httpx.HTTPStatusError as e:
-        logger.error(f"[Serper] API error: {e.response.status_code} - {e.response.text}")
-        return {"success": False, "error": f"Serper API error: {e.response.status_code}"}
-    except ValueError as e:
-        return {"success": False, "error": str(e)}
-    except Exception as e:
-        logger.error(f"[Serper] Error: {e}")
-        return {"success": False, "error": f"Serper search failed: {str(e)}"}
-
-
-# =============================================================================
-# PERPLEXITY SEARCH HANDLER
-# =============================================================================
-
-async def handle_perplexity_search(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Handle Perplexity Sonar AI search requests.
-
-    API: POST https://api.perplexity.ai/chat/completions
-    Auth: Authorization: Bearer header
-    """
-    start_time = time.time()
-
-    query = parameters.get('query', '').strip()
-    if not query:
-        return {"success": False, "error": "Search query is required"}
-
-    model = parameters.get('model', 'sonar')
-    search_recency_filter = parameters.get('searchRecencyFilter', '')
-    return_images = parameters.get('returnImages', False)
-    return_related_questions = parameters.get('returnRelatedQuestions', False)
-
-    try:
-        api_key = await _get_api_key('perplexity')
-
-        body: Dict[str, Any] = {
-            'model': model,
-            'messages': [
-                {'role': 'user', 'content': query}
-            ],
-        }
-
-        if search_recency_filter:
-            body['search_recency_filter'] = search_recency_filter
-        if return_images:
-            body['return_images'] = True
-        if return_related_questions:
-            body['return_related_questions'] = True
-
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            response = await client.post(
-                'https://api.perplexity.ai/chat/completions',
-                headers={
-                    'Authorization': f'Bearer {api_key}',
-                    'Content-Type': 'application/json',
-                },
-                json=body,
-            )
-            response.raise_for_status()
-            data = response.json()
-
-        # Extract answer and citations
-        choices = data.get('choices', [])
-        answer = ''
-        if choices:
-            message = choices[0].get('message', {})
-            answer = message.get('content', '')
-
-        citations = data.get('citations', [])
-        images = data.get('images', [])
-        related_questions = data.get('related_questions', [])
-
-        # Build results from citations
-        results = []
-        for url in citations:
-            results.append({'url': url})
-
-        execution_time = time.time() - start_time
-
-        # Track usage
-        workflow_id = context.get('workflow_id')
-        session_id = context.get('session_id', 'default')
-        await _track_search_usage(node_id, 'perplexity', 'sonar_search', 1, workflow_id, session_id)
-
-        result: Dict[str, Any] = {
-            "query": query,
-            "answer": answer,
-            "citations": citations,
-            "results": results,
-            "model": model,
-            "provider": "perplexity",
-        }
-        if images:
-            result["images"] = images
-        if related_questions:
-            result["related_questions"] = related_questions
-
-        return {
-            "success": True,
-            "result": result,
-            "execution_time": round(execution_time, 3),
-        }
-
-    except httpx.HTTPStatusError as e:
-        logger.error(f"[Perplexity] API error: {e.response.status_code} - {e.response.text}")
-        return {"success": False, "error": f"Perplexity API error: {e.response.status_code}"}
-    except ValueError as e:
-        return {"success": False, "error": str(e)}
-    except Exception as e:
-        logger.error(f"[Perplexity] Error: {e}")
-        return {"success": False, "error": f"Perplexity search failed: {str(e)}"}

package/server/services/handlers/sheets.py

@@ -1,314 +0,0 @@
-"""Google Sheets node handlers using Google API Python client.
-
-API Reference: https://developers.google.com/workspace/sheets/api/reference/rest
-"""
-
-import asyncio
-import time
-from typing import Any, Dict
-
-from googleapiclient.discovery import build
-
-from core.logging import get_logger
-from services.handlers.google_auth import get_google_credentials
-from services.pricing import get_pricing_service
-
-logger = get_logger(__name__)
-
-
-async def _track_sheets_usage(
-    node_id: str,
-    action: str,
-    resource_count: int = 1,
-    workflow_id: str = None,
-    session_id: str = "default"
-) -> Dict[str, float]:
-    """Track Google Sheets API usage for analytics.
-
-    Note: Sheets API is free but rate limited (300 requests/min).
-    We track for analytics purposes with $0 cost.
-    """
-    from core.container import container
-
-    pricing = get_pricing_service()
-    cost_data = pricing.calculate_api_cost('google_sheets', action, resource_count)
-
-    db = container.database()
-    await db.save_api_usage_metric({
-        'session_id': session_id,
-        'node_id': node_id,
-        'workflow_id': workflow_id,
-        'service': 'google_sheets',
-        'operation': cost_data.get('operation', action),
-        'endpoint': action,
-        'resource_count': resource_count,
-        'cost': cost_data.get('total_cost', 0.0)
-    })
-
-    logger.debug(f"[Sheets] Tracked usage: {action} x{resource_count}")
-    return cost_data
-
-
-async def _get_sheets_service(
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-):
-    """Get authenticated Google Sheets service."""
-    creds = await get_google_credentials(parameters, context)
-
-    def build_service():
-        return build("sheets", "v4", credentials=creds)
-
-    loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(None, build_service)
-
-
-async def handle_sheets_read(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Read data from a Google Sheets spreadsheet.
-
-    Parameters:
-        spreadsheet_id: ID of the spreadsheet (required)
-        range: A1 notation range (e.g., "Sheet1!A1:D10") (required)
-        value_render_option: How values should be rendered ('FORMATTED_VALUE', 'UNFORMATTED_VALUE', 'FORMULA')
-        major_dimension: Rows or columns first ('ROWS', 'COLUMNS')
-    """
-    start_time = time.time()
-
-    try:
-        service = await _get_sheets_service(parameters, context)
-
-        spreadsheet_id = parameters.get('spreadsheet_id', '')
-        range_notation = parameters.get('range', '')
-        value_render = parameters.get('value_render_option', 'FORMATTED_VALUE')
-        major_dimension = parameters.get('major_dimension', 'ROWS')
-
-        if not spreadsheet_id:
-            raise ValueError("Spreadsheet ID is required")
-        if not range_notation:
-            raise ValueError("Range is required (e.g., 'Sheet1!A1:D10')")
-
-        workflow_id = context.get('workflow_id')
-        session_id = context.get('session_id', 'default')
-
-        def read_values():
-            return service.spreadsheets().values().get(
-                spreadsheetId=spreadsheet_id,
-                range=range_notation,
-                valueRenderOption=value_render,
-                majorDimension=major_dimension
-            ).execute()
-
-        loop = asyncio.get_event_loop()
-        result = await loop.run_in_executor(None, read_values)
-
-        values = result.get('values', [])
-
-        await _track_sheets_usage(node_id, 'read', len(values), workflow_id, session_id)
-
-        return {
-            "success": True,
-            "result": {
-                "values": values,
-                "range": result.get('range'),
-                "rows": len(values),
-                "columns": len(values[0]) if values else 0,
-                "major_dimension": result.get('majorDimension'),
-            },
-            "execution_time": time.time() - start_time
-        }
-
-    except Exception as e:
-        logger.error(f"Sheets read error: {e}")
-        return {"success": False, "error": str(e), "execution_time": time.time() - start_time}
-
-
-async def handle_sheets_write(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Write data to a Google Sheets spreadsheet.
-
-    Parameters:
-        spreadsheet_id: ID of the spreadsheet (required)
-        range: A1 notation range (e.g., "Sheet1!A1") (required)
-        values: 2D array of values to write (required)
-        value_input_option: How input values should be interpreted ('RAW', 'USER_ENTERED')
-    """
-    start_time = time.time()
-
-    try:
-        service = await _get_sheets_service(parameters, context)
-
-        spreadsheet_id = parameters.get('spreadsheet_id', '')
-        range_notation = parameters.get('range', '')
-        values = parameters.get('values', [])
-        value_input = parameters.get('value_input_option', 'USER_ENTERED')
-
-        if not spreadsheet_id:
-            raise ValueError("Spreadsheet ID is required")
-        if not range_notation:
-            raise ValueError("Range is required (e.g., 'Sheet1!A1')")
-        if not values:
-            raise ValueError("Values are required")
-
-        # Parse values if string (JSON format)
-        if isinstance(values, str):
-            import json
-            values = json.loads(values)
-
-        # Ensure values is a 2D array
-        if values and not isinstance(values[0], list):
-            values = [values]
-
-        workflow_id = context.get('workflow_id')
-        session_id = context.get('session_id', 'default')
-
-        body = {'values': values}
-
-        def write_values():
-            return service.spreadsheets().values().update(
-                spreadsheetId=spreadsheet_id,
-                range=range_notation,
-                valueInputOption=value_input,
-                body=body
-            ).execute()
-
-        loop = asyncio.get_event_loop()
-        result = await loop.run_in_executor(None, write_values)
-
-        await _track_sheets_usage(node_id, 'write', result.get('updatedCells', 0), workflow_id, session_id)
-
-        return {
-            "success": True,
-            "result": {
-                "updated_range": result.get('updatedRange'),
-                "updated_rows": result.get('updatedRows'),
-                "updated_columns": result.get('updatedColumns'),
-                "updated_cells": result.get('updatedCells'),
-            },
-            "execution_time": time.time() - start_time
-        }
-
-    except Exception as e:
-        logger.error(f"Sheets write error: {e}")
-        return {"success": False, "error": str(e), "execution_time": time.time() - start_time}
-
-
-async def handle_sheets_append(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Append rows to a Google Sheets spreadsheet.
-
-    Parameters:
-        spreadsheet_id: ID of the spreadsheet (required)
-        range: A1 notation range (e.g., "Sheet1!A:D") (required)
-        values: 2D array of values to append (required)
-        value_input_option: How input values should be interpreted ('RAW', 'USER_ENTERED')
-        insert_data_option: How the input data should be inserted ('OVERWRITE', 'INSERT_ROWS')
-    """
-    start_time = time.time()
-
-    try:
-        service = await _get_sheets_service(parameters, context)
-
-        spreadsheet_id = parameters.get('spreadsheet_id', '')
-        range_notation = parameters.get('range', '')
-        values = parameters.get('values', [])
-        value_input = parameters.get('value_input_option', 'USER_ENTERED')
-        insert_option = parameters.get('insert_data_option', 'INSERT_ROWS')
-
-        if not spreadsheet_id:
-            raise ValueError("Spreadsheet ID is required")
-        if not range_notation:
-            raise ValueError("Range is required (e.g., 'Sheet1!A:D')")
-        if not values:
-            raise ValueError("Values are required")
-
-        # Parse values if string (JSON format)
-        if isinstance(values, str):
-            import json
-            values = json.loads(values)
-
-        # Ensure values is a 2D array
-        if values and not isinstance(values[0], list):
-            values = [values]
-
-        workflow_id = context.get('workflow_id')
-        session_id = context.get('session_id', 'default')
-
-        body = {'values': values}
-
-        def append_values():
-            return service.spreadsheets().values().append(
-                spreadsheetId=spreadsheet_id,
-                range=range_notation,
-                valueInputOption=value_input,
-                insertDataOption=insert_option,
-                body=body
-            ).execute()
-
-        loop = asyncio.get_event_loop()
-        result = await loop.run_in_executor(None, append_values)
-
-        updates = result.get('updates', {})
-
-        await _track_sheets_usage(node_id, 'append', updates.get('updatedCells', 0), workflow_id, session_id)
-
-        return {
-            "success": True,
-            "result": {
-                "updated_range": updates.get('updatedRange'),
-                "updated_rows": updates.get('updatedRows'),
-                "updated_columns": updates.get('updatedColumns'),
-                "updated_cells": updates.get('updatedCells'),
-                "table_range": result.get('tableRange'),
-            },
-            "execution_time": time.time() - start_time
-        }
-
-    except Exception as e:
-        logger.error(f"Sheets append error: {e}")
-        return {"success": False, "error": str(e), "execution_time": time.time() - start_time}
-
-
-# ============================================================================
-# CONSOLIDATED DISPATCHER
-# ============================================================================
-
-async def handle_google_sheets(
-    node_id: str,
-    node_type: str,
-    parameters: Dict[str, Any],
-    context: Dict[str, Any]
-) -> Dict[str, Any]:
-    """Consolidated Sheets handler with operation dispatcher.
-
-    Routes to appropriate handler based on 'operation' parameter:
-    - read: Read data from spreadsheet
-    - write: Write data to spreadsheet
-    - append: Append rows to spreadsheet
-    """
-    operation = parameters.get('operation', 'read')
-
-    if operation == 'read':
-        return await handle_sheets_read(node_id, node_type, parameters, context)
-    elif operation == 'write':
-        return await handle_sheets_write(node_id, node_type, parameters, context)
-    elif operation == 'append':
-        return await handle_sheets_append(node_id, node_type, parameters, context)
-    else:
-        return {
-            "success": False,
-            "error": f"Unknown Sheets operation: {operation}. Supported: read, write, append",
-            "execution_time": 0
-        }