agentcrew-ai 0.8.2__tar.gz → 0.8.4__tar.gz

agentcrew_ai-0.8.4/AgentCrew/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.4"

{agentcrew_ai-0.8.2 → agentcrew_ai-0.8.4}/AgentCrew/main.py

@@ -58,7 +58,9 @@ def common_options(func):
         help="LLM provider to use (claude, groq, openai, google, github_copilot, or deepinfra)",
     )
     @click.option(
-        "--agent-config", default=None, help="Path/URL to the agent configuration file."
+        "--agent-config",
+        default=None,
+        help="Path/URL to the agent configuration file.",
     )
     @click.option(
         "--mcp-config", default=None, help="Path to the mcp servers configuration file."

{agentcrew_ai-0.8.2 → agentcrew_ai-0.8.4}/AgentCrew/modules/a2a/agent_cards.py

@@ -11,6 +11,8 @@ from a2a.types import (
     SecurityScheme,
     APIKeySecurityScheme,
     AgentProvider,
+    AgentInterface,
+    TransportProtocol,
 )
 from AgentCrew import __version__
 
@@ -107,16 +109,20 @@ def create_agent_card(agent: LocalAgent, base_url: str) -> AgentCard:
     )
 
     return AgentCard(
+        protocol_version="0.3.0",
         name=agent.name if hasattr(agent, "name") else "AgentCrew Assistant",
         description=agent.description
         if hasattr(agent, "description")
         else "An AI assistant powered by AgentCrew",
         url=base_url,
+        preferred_transport=TransportProtocol.jsonrpc,
+        additional_interfaces=[
+            AgentInterface(url=base_url, transport=TransportProtocol.jsonrpc)
+        ],
         provider=provider,
-        version=__version__,  # Should match AgentCrew version
+        version=__version__,
         capabilities=capabilities,
         skills=skills,
-        # Most SwissKnife agents work with text and files
         default_input_modes=["text/plain", "application/octet-stream"],
         default_output_modes=["text/plain", "application/octet-stream"],
         security_schemes={"apiKey": security_schemes},

agentcrew_ai-0.8.4/AgentCrew/modules/a2a/errors.py

@@ -0,0 +1,72 @@
+"""
+A2A-specific error code helpers for proper error handling.
+
+This module provides convenience functions for creating A2A-specific errors
+with contextual data according to the A2A protocol v0.3.0 specification.
+
+Error Codes (Section 8.2):
+- -32001: TaskNotFoundError
+- -32002: TaskNotCancelableError
+- -32003: PushNotificationNotSupportedError
+- -32004: UnsupportedOperationError
+- -32005: ContentTypeNotSupportedError
+- -32006: InvalidAgentResponseError
+- -32007: AuthenticatedExtendedCardNotConfiguredError
+"""
+
+from typing import Optional
+from a2a.types import (
+    TaskNotFoundError,
+    TaskNotCancelableError,
+    PushNotificationNotSupportedError,
+    UnsupportedOperationError,
+    ContentTypeNotSupportedError,
+    InvalidAgentResponseError,
+    AuthenticatedExtendedCardNotConfiguredError,
+)
+
+
+class A2AError:
+    @staticmethod
+    def task_not_found(task_id: str) -> TaskNotFoundError:
+        error = TaskNotFoundError()
+        error.data = {"task_id": task_id}
+        return error
+
+    @staticmethod
+    def task_not_cancelable(task_id: str, current_state: str) -> TaskNotCancelableError:
+        error = TaskNotCancelableError()
+        error.data = {"task_id": task_id, "state": current_state}
+        return error
+
+    @staticmethod
+    def push_notification_not_supported() -> PushNotificationNotSupportedError:
+        return PushNotificationNotSupportedError()
+
+    @staticmethod
+    def unsupported_operation(operation: str) -> UnsupportedOperationError:
+        error = UnsupportedOperationError()
+        error.data = {"operation": operation}
+        return error
+
+    @staticmethod
+    def content_type_not_supported(
+        mime_type: str, supported_types: Optional[list[str]] = None
+    ) -> ContentTypeNotSupportedError:
+        error = ContentTypeNotSupportedError()
+        error.data = {"mime_type": mime_type}
+        if supported_types:
+            error.data["supported_types"] = supported_types
+        return error
+
+    @staticmethod
+    def invalid_agent_response(details: str) -> InvalidAgentResponseError:
+        error = InvalidAgentResponseError()
+        error.data = {"details": details}
+        return error
+
+    @staticmethod
+    def authenticated_extended_card_not_configured() -> (
+        AuthenticatedExtendedCardNotConfiguredError
+    ):
+        return AuthenticatedExtendedCardNotConfiguredError()

{agentcrew_ai-0.8.2 → agentcrew_ai-0.8.4}/AgentCrew/modules/a2a/server.py

@@ -20,7 +20,6 @@ from .registry import AgentRegistry
 from .task_manager import MultiAgentTaskManager
 from a2a.types import (
     A2ARequest,
-    JSONRPCError,
     JSONRPCResponse,
     JSONRPCErrorResponse,
     InvalidRequestError,
@@ -30,6 +29,8 @@ from a2a.types import (
     SendStreamingMessageRequest,
     GetTaskRequest,
     CancelTaskRequest,
+    TaskResubscriptionRequest,
+    MethodNotFoundError,
 )
 
 
@@ -228,13 +229,31 @@ class A2AServer:
                     result = await task_manager.on_cancel_task(json_rpc_request.root)
                     return JSONResponse(result.model_dump(exclude_none=True))
 
+                elif method == "tasks/resubscribe" and isinstance(
+                    json_rpc_request.root, TaskResubscriptionRequest
+                ):
+                    result_stream = task_manager.on_resubscribe_to_task(
+                        json_rpc_request.root
+                    )
+
+                    if isinstance(result_stream, JSONRPCResponse):
+                        return JSONResponse(result_stream.model_dump(exclude_none=True))
+
+                    async def event_generator():
+                        async for item in result_stream:  # type: ignore
+                            yield {
+                                "data": json.dumps(item.model_dump(exclude_none=True))
+                            }
+
+                    return EventSourceResponse(event_generator())
+
                 else:
                     logger.error(f"Invalid method requested: {method}")
                     logger.error(f"Request ID: {json_rpc_request.root.id}")
                     logger.error(f"Request params: {json_rpc_request.root.params}")  # type: ignore
                     error = JSONRPCErrorResponse(
                         id=json_rpc_request.root.id,
-                        error=JSONRPCError(code=-32601, message="Method not found"),
+                        error=MethodNotFoundError(),
                     )
                     return JSONResponse(
                         error.model_dump(exclude_none=True), status_code=400

{agentcrew_ai-0.8.2 → agentcrew_ai-0.8.4}/AgentCrew/modules/a2a/task_manager.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 from datetime import datetime
 from typing import TYPE_CHECKING
+from collections import defaultdict
 from AgentCrew.modules.agents.base import MessageType
 from loguru import logger
 import tempfile
@@ -26,8 +27,6 @@ from a2a.types import (
     TaskState,
     TaskStatusUpdateEvent,
     TaskArtifactUpdateEvent,
-    TaskNotFoundError,
-    TaskNotCancelableError,
 )
 
 from AgentCrew.modules.agents import LocalAgent
@@ -37,12 +36,14 @@ from .adapters import (
     convert_agent_message_to_a2a,
 )
 from .common.server.task_manager import TaskManager
+from .errors import A2AError
 
 if TYPE_CHECKING:
     from typing import Any, AsyncIterable, Dict, Optional, Union
     from AgentCrew.modules.agents import AgentManager
     from a2a.types import (
         CancelTaskRequest,
+        TaskNotCancelableError,
         GetTaskPushNotificationConfigRequest,
         GetTaskRequest,
         SendMessageRequest,
@@ -56,6 +57,8 @@ if TYPE_CHECKING:
 class AgentTaskManager(TaskManager):
     """Manages tasks for a specific agent"""
 
+    TERMINAL_STATES = {TaskState.completed, TaskState.canceled, TaskState.failed}
+
     def __init__(self, agent_name: str, agent_manager: AgentManager):
         self.agent_name = agent_name
         self.agent_manager = agent_manager
@@ -64,12 +67,38 @@ class AgentTaskManager(TaskManager):
         self.streaming_tasks: Dict[str, asyncio.Queue] = {}
         self.file_handler = None
 
+        self.task_events: Dict[
+            str, list[Union[TaskStatusUpdateEvent, TaskArtifactUpdateEvent]]
+        ] = defaultdict(list)
+        self.streaming_enabled_tasks: set[str] = set()
+
         self.agent = self.agent_manager.get_agent(self.agent_name)
         if self.agent is None or not isinstance(self.agent, LocalAgent):
             raise ValueError(f"Agent {agent_name} not found or is not a LocalAgent")
 
         self.memory_service = self.agent.services["memory"]
 
+    def _is_terminal_state(self, state: TaskState) -> bool:
+        """Check if a state is terminal."""
+        return state in self.TERMINAL_STATES
+
+    def _validate_task_not_terminal(
+        self, task: Task, operation: str
+    ) -> Optional[TaskNotCancelableError]:
+        """
+        Validate that task is not in terminal state.
+
+        Args:
+            task: Task to check
+            operation: Operation being attempted
+
+        Returns:
+            JSONRPCError if invalid, None if valid
+        """
+        if self._is_terminal_state(task.status.state):
+            return A2AError.task_not_cancelable(task.id, task.status.state.value)
+        return None
+
     async def on_send_message(
         self, request: SendMessageRequest | SendStreamingMessageRequest
     ) -> SendMessageResponse:
@@ -98,6 +127,14 @@ class AgentTaskManager(TaskManager):
             or f"task_{request.params.message.message_id}"
         )
 
+        if task_id in self.tasks:
+            existing_task = self.tasks[task_id]
+            error = self._validate_task_not_terminal(existing_task, "send message")
+            if error:
+                return SendMessageResponse(
+                    root=JSONRPCErrorResponse(id=request.id, error=error)
+                )
+
         if task_id not in self.tasks:
             # Create task with initial state
             task = Task(
@@ -176,6 +213,8 @@ class AgentTaskManager(TaskManager):
             or f"task_{request.params.message.message_id}"
         )
 
+        self.streaming_enabled_tasks.add(task_id)
+
         # Create streaming queue
         queue = asyncio.Queue()
         self.streaming_tasks[task_id] = queue
@@ -204,6 +243,27 @@ class AgentTaskManager(TaskManager):
             # Clean up
             self.streaming_tasks.pop(task_id, None)
 
+    def _record_and_emit_event(
+        self, task_id: str, event: Union[TaskStatusUpdateEvent, TaskArtifactUpdateEvent]
+    ):
+        """
+        Record event for replay and broadcast to all active subscribers.
+
+        Args:
+            task_id: Task ID
+            event: Event to record and emit
+        """
+        self.task_events[task_id].append(event)
+
+        for key, queue in list(self.streaming_tasks.items()):
+            if key.startswith(task_id):
+                try:
+                    queue.put_nowait(event)
+                except asyncio.QueueFull:
+                    logger.warning(f"Queue full for {key}")
+                except Exception as e:
+                    logger.error(f"Error emitting event to {key}: {e}")
+
     async def _process_agent_task(self, agent: LocalAgent, task: Task):
         """
         Process a task with the agent (background task).
@@ -213,6 +273,12 @@ class AgentTaskManager(TaskManager):
             message: The message to process
             task: The task object to update
         """
+        if self._is_terminal_state(task.status.state):
+            logger.warning(
+                f"Attempted to process task {task.id} in terminal state {task.status.state}"
+            )
+            return
+
         try:
             artifacts = []
             if task.id not in self.task_history:
@@ -253,15 +319,14 @@ class AgentTaskManager(TaskManager):
                     task.status.timestamp = datetime.now().isoformat()
 
                     # If this is a streaming task, send updates
-                    if task.id in self.streaming_tasks:
-                        queue = self.streaming_tasks[task.id]
-
+                    if task.id in self.streaming_enabled_tasks:
                         # Send thinking update if available
                         if thinking_chunk:
                             think_text_chunk, signature = thinking_chunk
                             if think_text_chunk:
                                 thinking_content += think_text_chunk
-                                await queue.put(
+                                self._record_and_emit_event(
+                                    task.id,
                                     TaskStatusUpdateEvent(
                                         task_id=task.id,
                                         context_id=task.context_id,
@@ -276,7 +341,7 @@ class AgentTaskManager(TaskManager):
                                             ),
                                         ),
                                         final=False,
-                                    )
+                                    ),
                                 )
                             if signature:
                                 thinking_signature += signature
@@ -287,30 +352,30 @@ class AgentTaskManager(TaskManager):
                                 chunk_text,
                                 artifact_id=f"artifact_{task.id}_{len(artifacts)}",
                             )
-                            await queue.put(
+                            self._record_and_emit_event(
+                                task.id,
                                 TaskArtifactUpdateEvent(
                                     task_id=task.id,
                                     context_id=task.context_id,
                                     artifact=artifact,
-                                )
+                                ),
                             )
 
                 if tool_uses and len(tool_uses) > 0:
-                    if task.id in self.streaming_tasks:
-                        queue = self.streaming_tasks[task.id]
+                    if task.id in self.streaming_enabled_tasks:
                         artifact = convert_agent_response_to_a2a_artifact(
                             "",
                             artifact_id=f"artifact_{task.id}_{len(artifacts)}",
                             tool_uses=tool_uses,
                         )
-                        await queue.put(
+                        self._record_and_emit_event(
+                            task.id,
                             TaskArtifactUpdateEvent(
                                 task_id=task.id,
                                 context_id=task.context_id,
                                 artifact=artifact,
-                            )
+                            ),
                         )
-                        # prevent the execute_tool_call take the control of event loop before queue has been process
                         await asyncio.sleep(0.7)
 
                     # Add thinking content as a separate message if available
@@ -399,21 +464,21 @@ class AgentTaskManager(TaskManager):
             task.artifacts = artifacts
 
             # If this is a streaming task, send final update
-            if task.id in self.streaming_tasks:
-                queue = self.streaming_tasks[task.id]
-
-                # Send final status
-                await queue.put(
+            if task.id in self.streaming_enabled_tasks:
+                self._record_and_emit_event(
+                    task.id,
                     TaskStatusUpdateEvent(
                         task_id=task.id,
                         context_id=task.context_id,
                         status=task.status,
                         final=True,
-                    )
+                    ),
                 )
 
-                # Mark queue as done
-                await queue.put(None)
+                for key in list(self.streaming_tasks.keys()):
+                    if key.startswith(task.id):
+                        queue = self.streaming_tasks[key]
+                        await queue.put(None)
 
         except Exception as e:
             logger.error(str(e))
@@ -422,17 +487,21 @@ class AgentTaskManager(TaskManager):
             task.status.timestamp = datetime.now().isoformat()
 
             # If this is a streaming task, send error
-            if task.id in self.streaming_tasks:
-                queue = self.streaming_tasks[task.id]
-                await queue.put(
+            if task.id in self.streaming_enabled_tasks:
+                self._record_and_emit_event(
+                    task.id,
                     TaskStatusUpdateEvent(
                         task_id=task.id,
                         context_id=task.context_id,
                         status=task.status,
                         final=True,
-                    )
+                    ),
                 )
-                await queue.put(None)
+
+                for key in list(self.streaming_tasks.keys()):
+                    if key.startswith(task.id):
+                        queue = self.streaming_tasks[key]
+                        await queue.put(None)
 
     async def on_get_task(self, request: GetTaskRequest) -> GetTaskResponse:
         """
@@ -447,7 +516,9 @@ class AgentTaskManager(TaskManager):
         task_id = request.params.id
         if task_id not in self.tasks:
             return GetTaskResponse(
-                root=JSONRPCErrorResponse(id=request.id, error=TaskNotFoundError())
+                root=JSONRPCErrorResponse(
+                    id=request.id, error=A2AError.task_not_found(task_id)
+                )
             )
 
         return GetTaskResponse(
@@ -467,19 +538,17 @@ class AgentTaskManager(TaskManager):
         task_id = request.params.id
         if task_id not in self.tasks:
             return CancelTaskResponse(
-                root=JSONRPCErrorResponse(id=request.id, error=TaskNotFoundError())
+                root=JSONRPCErrorResponse(
+                    id=request.id, error=A2AError.task_not_found(task_id)
+                )
             )
 
         task = self.tasks[task_id]
 
-        # Check if task can be canceled
-        if task.status.state in [
-            TaskState.completed,
-            TaskState.failed,
-            TaskState.canceled,
-        ]:
+        error = self._validate_task_not_terminal(task, "cancel")
+        if error:
             return CancelTaskResponse(
-                root=JSONRPCErrorResponse(id=request.id, error=TaskNotCancelableError())
+                root=JSONRPCErrorResponse(id=request.id, error=error)
             )
 
         # Update task status
@@ -506,17 +575,89 @@ class AgentTaskManager(TaskManager):
     async def on_set_task_push_notification(
         self, request: SetTaskPushNotificationConfigRequest
     ) -> SetTaskPushNotificationConfigResponse:
-        raise NotImplementedError("")
+        return SetTaskPushNotificationConfigResponse(
+            root=JSONRPCErrorResponse(
+                id=request.id, error=A2AError.push_notification_not_supported()
+            )
+        )
 
     async def on_get_task_push_notification(
         self, request: GetTaskPushNotificationConfigRequest
     ) -> GetTaskPushNotificationConfigResponse:
-        raise NotImplementedError("")
+        return GetTaskPushNotificationConfigResponse(
+            root=JSONRPCErrorResponse(
+                id=request.id, error=A2AError.push_notification_not_supported()
+            )
+        )
 
     async def on_resubscribe_to_task(
         self, request: TaskResubscriptionRequest
     ) -> Union[AsyncIterable[SendStreamingMessageResponse], JSONRPCResponse]:
-        raise NotImplementedError("")
+        """
+        Handle tasks/resubscribe request.
+
+        Replays all events from task creation and continues with live updates.
+
+        Args:
+            request: The resubscription request
+
+        Yields:
+            Streaming responses with task updates
+        """
+        task_id = request.params.task_id
+
+        if task_id not in self.tasks:
+            error = A2AError.task_not_found(task_id)
+            yield SendStreamingMessageResponse(
+                root=JSONRPCErrorResponse(id=request.id, error=error)
+            )
+            return
+
+        if task_id not in self.streaming_enabled_tasks:
+            error = A2AError.unsupported_operation(
+                "Task was not created with streaming enabled"
+            )
+            yield SendStreamingMessageResponse(
+                root=JSONRPCErrorResponse(id=request.id, error=error)
+            )
+            return
+
+        task = self.tasks[task_id]
+
+        if task_id in self.task_events:
+            for event in self.task_events[task_id]:
+                yield SendStreamingMessageResponse(
+                    root=SendStreamingMessageSuccessResponse(
+                        id=request.id, result=event
+                    )
+                )
+
+        if self._is_terminal_state(task.status.state):
+            return
+
+        queue = asyncio.Queue()
+        resubscribe_key = f"{task_id}_resub_{request.id}"
+        self.streaming_tasks[resubscribe_key] = queue
+
+        try:
+            while True:
+                event = await queue.get()
+                if event is None:
+                    break
+
+                yield SendStreamingMessageResponse(
+                    root=SendStreamingMessageSuccessResponse(
+                        id=request.id, result=event
+                    )
+                )
+
+                if isinstance(event, TaskStatusUpdateEvent):
+                    if self._is_terminal_state(event.status.state):
+                        break
+
+        finally:
+            if resubscribe_key in self.streaming_tasks:
+                del self.streaming_tasks[resubscribe_key]
 
     # Legacy methods for backward compatibility
     async def on_send_task(self, request: SendMessageRequest) -> SendMessageResponse:

{agentcrew_ai-0.8.2 → agentcrew_ai-0.8.4}/AgentCrew/modules/agents/local_agent.py

@@ -634,6 +634,17 @@ Check if `when` condition in <Global_Behavior> or <Project_Behavior> matches, up
     - Skip agent evaluation if user request is when...,[action]... related to adaptive behaviors call `adapt` tool instead.""",
                     },
                 )
+            if self.services.get("memory"):
+                memory_headers = self.services["memory"].list_memory_headers(
+                    agent_name=self.name
+                )
+                if memory_headers:
+                    adaptive_messages["content"].append(
+                        {
+                            "type": "text",
+                            "text": f"Here are conversations that we have discussed:\n- {'\n- '.join(memory_headers)}",
+                        }
+                    )
         if len(adaptive_messages["content"]) > 0:
             final_messages.insert(last_user_index, adaptive_messages)
 

{agentcrew_ai-0.8.2 → agentcrew_ai-0.8.4}/AgentCrew/modules/browser_automation/element_extractor.py

@@ -162,12 +162,13 @@ def extract_clickable_elements(chrome_interface, uuid_mapping: Dict[str, str]) -
         markdown_output.append(
             "\n\n## Clickable Elements\nUse browser_click with UUID to click elements.\n"
         )
-        markdown_output.append("| UUID | Text/Alt |\n")
-        markdown_output.append("|------|----------|\n")
+        markdown_output.append("| UUID | Type | Text/Alt |\n")
+        markdown_output.append("|------|------|-----------|\n")
 
         for element in elements_data:
             xpath = element.get("xpath", "")
             text = element.get("text", "").strip()
+            element_type = element.get("type", "").strip()
 
             # Skip empty text entries
             if not text:
@@ -180,7 +181,7 @@ def extract_clickable_elements(chrome_interface, uuid_mapping: Dict[str, str]) -
             # Escape pipe characters in text for markdown table
             text = text.replace("|", "\\|")
 
-            markdown_output.append(f"| `{element_uuid}` | {text} |\n")
+            markdown_output.append(f"| `{element_uuid}` | {element_type} | {text} |\n")
 
         return "".join(markdown_output)