sunholo 0.143.1__py3-none-any.whl → 0.143.3__py3-none-any.whl

sunholo/a2a/vac_a2a_agent.py

@@ -0,0 +1,383 @@
+#   Copyright [2024] [Holosun ApS]
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+"""
+A2A Agent wrapper for VAC functionality.
+Implements the Agent-to-Agent protocol for Sunholo VACs.
+"""
+
+import asyncio
+import json
+from typing import Dict, List, Any, Optional, Callable, AsyncGenerator
+from ..custom_logging import log
+from .agent_card import AgentCardGenerator
+from .task_manager import A2ATaskManager, A2ATask
+
+try:
+    # Import A2A Python SDK components when available
+    from a2a import Agent, Task, Message
+    A2A_AVAILABLE = True
+except ImportError:
+    # Create placeholder classes for development
+    Agent = None
+    Task = None 
+    Message = None
+    A2A_AVAILABLE = False
+
+
+class VACA2AAgent:
+    """
+    A2A Agent implementation for Sunholo VACs.
+    
+    This class wraps VAC functionality to be compatible with the 
+    Agent-to-Agent protocol, allowing VACs to participate in A2A ecosystems.
+    """
+    
+    def __init__(self, 
+                 base_url: str,
+                 stream_interpreter: Callable,
+                 vac_interpreter: Optional[Callable] = None,
+                 vac_names: Optional[List[str]] = None,
+                 agent_config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the A2A agent.
+        
+        Args:
+            base_url: Base URL where the agent is hosted
+            stream_interpreter: Function for streaming VAC interactions
+            vac_interpreter: Function for static VAC interactions (optional)
+            vac_names: List of VAC names to expose (discovers all if None)
+            agent_config: Additional agent configuration
+        """
+        if not A2A_AVAILABLE:
+            log.warning("A2A Python SDK not available. Install with: pip install a2a-python")
+        
+        self.base_url = base_url.rstrip('/')
+        self.stream_interpreter = stream_interpreter
+        self.vac_interpreter = vac_interpreter
+        self.agent_config = agent_config or {}
+        
+        # Initialize components
+        self.agent_card_generator = AgentCardGenerator(self.base_url)
+        self.task_manager = A2ATaskManager(stream_interpreter, vac_interpreter)
+        
+        # Discover VACs
+        self.vac_names = vac_names or self.agent_card_generator._discover_vacs()
+        if not self.vac_names:
+            log.warning("No VACs discovered. Agent will have no skills.")
+        
+        # Generate agent card
+        self.agent_card = self.agent_card_generator.generate_agent_card(self.vac_names)
+        
+        log.info(f"Initialized A2A agent with {len(self.vac_names)} VACs: {self.vac_names}")
+    
+    def get_agent_card(self) -> Dict[str, Any]:
+        """
+        Get the agent card for A2A discovery.
+        
+        Returns:
+            Agent card dictionary
+        """
+        return self.agent_card
+    
+    def get_discovery_endpoints(self) -> Dict[str, str]:
+        """
+        Get the A2A discovery endpoint paths.
+        
+        Returns:
+            Dictionary mapping endpoint names to their paths
+        """
+        return self.agent_card_generator.generate_discovery_endpoints()
+    
+    async def handle_task_send(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle A2A task send request.
+        
+        Args:
+            request_data: JSON-RPC request data
+            
+        Returns:
+            JSON-RPC response data
+        """
+        try:
+            # Extract parameters from JSON-RPC request
+            params = request_data.get("params", {})
+            skill_name = params.get("skillName")
+            input_data = params.get("input", {})
+            client_metadata = params.get("clientMetadata", {})
+            
+            if not skill_name:
+                return self._create_error_response(
+                    request_data.get("id"),
+                    -32602,  # Invalid params
+                    "Missing required parameter: skillName"
+                )
+            
+            # Validate skill exists
+            available_skills = [skill["name"] for skill in self.agent_card["skills"]]
+            if skill_name not in available_skills:
+                return self._create_error_response(
+                    request_data.get("id"),
+                    -32601,  # Method not found
+                    f"Unknown skill: {skill_name}. Available skills: {available_skills}"
+                )
+            
+            # Create and start task
+            task = await self.task_manager.create_task(skill_name, input_data, client_metadata)
+            
+            # Return task creation response
+            return {
+                "jsonrpc": "2.0",
+                "result": {
+                    "taskId": task.task_id,
+                    "state": task.state.value,
+                    "createdAt": task.created_at.isoformat(),
+                    "estimatedDuration": self._estimate_task_duration(skill_name, input_data)
+                },
+                "id": request_data.get("id")
+            }
+            
+        except Exception as e:
+            log.error(f"Error handling task send: {e}")
+            return self._create_error_response(
+                request_data.get("id"),
+                -32603,  # Internal error
+                f"Internal error: {str(e)}"
+            )
+    
+    async def handle_task_send_subscribe(self, request_data: Dict[str, Any]) -> AsyncGenerator[str, None]:
+        """
+        Handle A2A task send with subscription (SSE).
+        
+        Args:
+            request_data: JSON-RPC request data
+            
+        Yields:
+            Server-sent event data strings
+        """
+        try:
+            # First, send the task
+            response = await self.handle_task_send(request_data)
+            
+            # Send initial response
+            yield f"data: {json.dumps(response)}\n\n"
+            
+            # If task creation failed, stop here
+            if "error" in response:
+                return
+            
+            # Get task ID and subscribe to updates
+            task_id = response["result"]["taskId"]
+            
+            # Subscribe to task updates
+            async for update in self.task_manager.subscribe_to_task(task_id):
+                if update is None:
+                    break
+                
+                # Format as SSE
+                sse_data = {
+                    "type": "task_update",
+                    "taskId": task_id,
+                    "data": update
+                }
+                
+                yield f"data: {json.dumps(sse_data)}\n\n"
+                
+                # Stop if task is complete
+                if update.get("state") in ["completed", "failed", "canceled"]:
+                    break
+            
+        except Exception as e:
+            log.error(f"Error in task send subscribe: {e}")
+            error_event = {
+                "type": "error",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                }
+            }
+            yield f"data: {json.dumps(error_event)}\n\n"
+    
+    async def handle_task_get(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle A2A task get request.
+        
+        Args:
+            request_data: JSON-RPC request data
+            
+        Returns:
+            JSON-RPC response data
+        """
+        try:
+            params = request_data.get("params", {})
+            task_id = params.get("taskId")
+            
+            if not task_id:
+                return self._create_error_response(
+                    request_data.get("id"),
+                    -32602,  # Invalid params
+                    "Missing required parameter: taskId"
+                )
+            
+            task = await self.task_manager.get_task(task_id)
+            if not task:
+                return self._create_error_response(
+                    request_data.get("id"),
+                    -32602,  # Invalid params
+                    f"Task not found: {task_id}"
+                )
+            
+            return {
+                "jsonrpc": "2.0",
+                "result": task.to_dict(),
+                "id": request_data.get("id")
+            }
+            
+        except Exception as e:
+            log.error(f"Error handling task get: {e}")
+            return self._create_error_response(
+                request_data.get("id"),
+                -32603,  # Internal error
+                f"Internal error: {str(e)}"
+            )
+    
+    async def handle_task_cancel(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle A2A task cancel request.
+        
+        Args:
+            request_data: JSON-RPC request data
+            
+        Returns:
+            JSON-RPC response data
+        """
+        try:
+            params = request_data.get("params", {})
+            task_id = params.get("taskId")
+            
+            if not task_id:
+                return self._create_error_response(
+                    request_data.get("id"),
+                    -32602,  # Invalid params
+                    "Missing required parameter: taskId"
+                )
+            
+            success = await self.task_manager.cancel_task(task_id)
+            
+            if not success:
+                return self._create_error_response(
+                    request_data.get("id"),
+                    -32602,  # Invalid params
+                    f"Cannot cancel task: {task_id} (not found or already completed)"
+                )
+            
+            task = await self.task_manager.get_task(task_id)
+            
+            return {
+                "jsonrpc": "2.0",
+                "result": {
+                    "taskId": task_id,
+                    "state": task.state.value if task else "canceled",
+                    "canceledAt": task.updated_at.isoformat() if task else None
+                },
+                "id": request_data.get("id")
+            }
+            
+        except Exception as e:
+            log.error(f"Error handling task cancel: {e}")
+            return self._create_error_response(
+                request_data.get("id"),
+                -32603,  # Internal error
+                f"Internal error: {str(e)}"
+            )
+    
+    async def handle_push_notification_set(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle A2A push notification settings.
+        
+        Args:
+            request_data: JSON-RPC request data
+            
+        Returns:
+            JSON-RPC response data
+        """
+        # For now, this is a placeholder
+        # In a full implementation, this would configure push notifications
+        
+        return {
+            "jsonrpc": "2.0",
+            "result": {
+                "status": "not_implemented",
+                "message": "Push notifications not yet implemented"
+            },
+            "id": request_data.get("id")
+        }
+    
+    def _create_error_response(self, request_id: Any, error_code: int, error_message: str) -> Dict[str, Any]:
+        """
+        Create a JSON-RPC error response.
+        
+        Args:
+            request_id: The request ID
+            error_code: JSON-RPC error code
+            error_message: Error message
+            
+        Returns:
+            JSON-RPC error response
+        """
+        return {
+            "jsonrpc": "2.0",
+            "error": {
+                "code": error_code,
+                "message": error_message
+            },
+            "id": request_id
+        }
+    
+    def _estimate_task_duration(self, skill_name: str, input_data: Dict[str, Any]) -> float:
+        """
+        Estimate task duration in seconds.
+        
+        Args:
+            skill_name: Name of the skill
+            input_data: Input parameters
+            
+        Returns:
+            Estimated duration in seconds
+        """
+        # Simple heuristic based on skill type
+        if "stream" in skill_name:
+            return 30.0  # Streaming typically takes longer
+        elif "memory_search" in skill_name:
+            return 5.0   # Memory searches are usually quick
+        else:
+            return 15.0  # Default for queries
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """
+        Get agent statistics.
+        
+        Returns:
+            Dictionary with agent statistics
+        """
+        return {
+            "agent_name": self.agent_card["name"],
+            "vac_count": len(self.vac_names),
+            "skill_count": len(self.agent_card["skills"]),
+            "active_tasks": len([t for t in self.task_manager.tasks.values() 
+                               if t.state.value in ["submitted", "working"]]),
+            "total_tasks": len(self.task_manager.tasks),
+            "base_url": self.base_url,
+            "a2a_available": A2A_AVAILABLE
+        }

sunholo/agents/flask/vac_routes.py

@@ -45,6 +45,11 @@ except ImportError:
     InitializationOptions = None
     JSONRPCMessage = None
 
+try:
+    from ...a2a.vac_a2a_agent import VACA2AAgent
+except (ImportError, SyntaxError):
+    VACA2AAgent = None
+
 
 # Cache dictionary to store validated API keys
 api_key_cache = {}
@@ -81,7 +86,9 @@ if __name__ == "__main__":
                  mcp_servers: List[Dict[str, Any]] = None,
                  async_stream:bool=False,
                  add_langfuse_eval:bool=True,
-                 enable_mcp_server:bool=False):
+                 enable_mcp_server:bool=False,
+                 enable_a2a_agent:bool=False,
+                 a2a_vac_names: List[str] = None):
         self.app = app
         self.stream_interpreter = stream_interpreter
         self.vac_interpreter = vac_interpreter or partial(self.vac_interpreter_default)
@@ -102,6 +109,15 @@ if __name__ == "__main__":
                 vac_interpreter=self.vac_interpreter
             )
 
+        # A2A agent initialization  
+        self.enable_a2a_agent = enable_a2a_agent
+        self.vac_a2a_agent = None
+        self.a2a_vac_names = a2a_vac_names
+        if self.enable_a2a_agent and VACA2AAgent:
+            # Extract base URL from request context during route handling
+            # For now, initialize with placeholder - will be updated in route handlers
+            self.vac_a2a_agent = None  # Initialized lazily in route handlers
+
         self.additional_routes = additional_routes if additional_routes is not None else []
         self.async_stream = async_stream
         self.add_langfuse_eval = add_langfuse_eval
@@ -177,6 +193,15 @@ if __name__ == "__main__":
         # MCP server endpoint
         if self.enable_mcp_server and self.vac_mcp_server:
             self.app.route('/mcp', methods=['POST', 'GET'])(self.handle_mcp_server)
+        
+        # A2A agent endpoints
+        if self.enable_a2a_agent:
+            self.app.route('/.well-known/agent.json', methods=['GET'])(self.handle_a2a_agent_card)
+            self.app.route('/a2a/tasks/send', methods=['POST'])(self.handle_a2a_task_send)
+            self.app.route('/a2a/tasks/sendSubscribe', methods=['POST'])(self.handle_a2a_task_send_subscribe)
+            self.app.route('/a2a/tasks/get', methods=['POST'])(self.handle_a2a_task_get)
+            self.app.route('/a2a/tasks/cancel', methods=['POST'])(self.handle_a2a_task_cancel)
+            self.app.route('/a2a/tasks/pushNotification/set', methods=['POST'])(self.handle_a2a_push_notification)
     
         self.register_additional_routes()
 
@@ -1101,4 +1126,224 @@ if __name__ == "__main__":
                 "transport": "http",
                 "endpoint": "/mcp",
                 "tools": ["vac_stream", "vac_query"] if self.vac_interpreter else ["vac_stream"]
-            })
+            })
+    
+    def _get_or_create_a2a_agent(self):
+        """Get or create the A2A agent instance with current request context."""
+        if not self.enable_a2a_agent or not VACA2AAgent:
+            return None
+        
+        if self.vac_a2a_agent is None:
+            # Extract base URL from current request
+            base_url = request.url_root.rstrip('/')
+            
+            self.vac_a2a_agent = VACA2AAgent(
+                base_url=base_url,
+                stream_interpreter=self.stream_interpreter,
+                vac_interpreter=self.vac_interpreter,
+                vac_names=self.a2a_vac_names
+            )
+        
+        return self.vac_a2a_agent
+    
+    def handle_a2a_agent_card(self):
+        """Handle A2A agent card discovery request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        return jsonify(agent.get_agent_card())
+    
+    def handle_a2a_task_send(self):
+        """Handle A2A task send request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_send(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task send error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_task_send_subscribe(self):
+        """Handle A2A task send with subscription (SSE)."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                def error_generator():
+                    yield "data: {\"error\": \"Parse error: Invalid JSON\"}\n\n"
+                
+                return Response(error_generator(), content_type='text/event-stream')
+            
+            # Create async generator for SSE
+            async def sse_generator():
+                async for chunk in agent.handle_task_send_subscribe(data):
+                    yield chunk
+            
+            def sync_generator():
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    async_gen = sse_generator()
+                    while True:
+                        try:
+                            chunk = loop.run_until_complete(async_gen.__anext__())
+                            yield chunk
+                        except StopAsyncIteration:
+                            break
+                finally:
+                    loop.close()
+            
+            return Response(sync_generator(), content_type='text/event-stream')
+            
+        except Exception as e:
+            log.error(f"A2A task send subscribe error: {e}")
+            def error_generator(err):
+                yield f"data: {{\"error\": \"Internal error: {str(err)}\"}}\n\n"
+            
+            return Response(error_generator(e), content_type='text/event-stream')
+    
+    def handle_a2a_task_get(self):
+        """Handle A2A task get request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_get(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task get error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_task_cancel(self):
+        """Handle A2A task cancel request."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_task_cancel(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A task cancel error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500
+    
+    def handle_a2a_push_notification(self):
+        """Handle A2A push notification settings."""
+        agent = self._get_or_create_a2a_agent()
+        if not agent:
+            return jsonify({"error": "A2A agent not enabled"}), 501
+        
+        try:
+            data = request.get_json()
+            if not data:
+                return jsonify({
+                    "jsonrpc": "2.0",
+                    "error": {
+                        "code": -32700,
+                        "message": "Parse error: Invalid JSON"
+                    },
+                    "id": None
+                }), 400
+            
+            # Run async handler
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                response = loop.run_until_complete(agent.handle_push_notification_set(data))
+                return jsonify(response)
+            finally:
+                loop.close()
+                
+        except Exception as e:
+            log.error(f"A2A push notification error: {e}")
+            return jsonify({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                },
+                "id": data.get("id") if 'data' in locals() else None
+            }), 500

{sunholo-0.143.1.dist-info → sunholo-0.143.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.143.1
+Version: 0.143.3
 Summary: AI DevOps - a package to help deploy GenAI to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0
@@ -15,9 +15,10 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: a2a-python>=0.0.1
 Requires-Dist: aiohttp
 Requires-Dist: flask>=3.1.0
 Requires-Dist: google-auth
@@ -126,6 +127,7 @@ Requires-Dist: pytesseract; extra == "pipeline"
 Requires-Dist: tabulate; extra == "pipeline"
 Requires-Dist: unstructured[all-docs,local-inference]; extra == "pipeline"
 Provides-Extra: gcp
+Requires-Dist: a2a-python; extra == "gcp"
 Requires-Dist: aiofiles; extra == "gcp"
 Requires-Dist: anthropic[vertex]; extra == "gcp"
 Requires-Dist: google-api-python-client; extra == "gcp"