agentcrew-ai 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

AgentCrew/__init__.py

@@ -1 +1 @@
-__version__ = "0.8.4"
+__version__ = "0.8.6"

AgentCrew/modules/a2a/task_manager.py

@@ -27,6 +27,11 @@ from a2a.types import (
     TaskState,
     TaskStatusUpdateEvent,
     TaskArtifactUpdateEvent,
+    Part,
+    TextPart,
+    DataPart,
+    Role,
+    Message,
 )
 
 from AgentCrew.modules.agents import LocalAgent
@@ -58,6 +63,7 @@ class AgentTaskManager(TaskManager):
     """Manages tasks for a specific agent"""
 
     TERMINAL_STATES = {TaskState.completed, TaskState.canceled, TaskState.failed}
+    INPUT_REQUIRED_STATES = {TaskState.input_required}
 
     def __init__(self, agent_name: str, agent_manager: AgentManager):
         self.agent_name = agent_name
@@ -72,6 +78,9 @@ class AgentTaskManager(TaskManager):
         ] = defaultdict(list)
         self.streaming_enabled_tasks: set[str] = set()
 
+        self.pending_ask_responses: Dict[str, asyncio.Event] = {}
+        self.ask_responses: Dict[str, str] = {}
+
         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")
@@ -82,6 +91,19 @@ class AgentTaskManager(TaskManager):
         """Check if a state is terminal."""
         return state in self.TERMINAL_STATES
 
+    def _extract_text_from_message(self, message: Dict[str, Any]) -> str:
+        """Extract text content from a message."""
+        content = message.get("content", [])
+        if isinstance(content, str):
+            return content
+        text_parts = []
+        for part in content:
+            if isinstance(part, str):
+                text_parts.append(part)
+            elif isinstance(part, dict) and part.get("type") == "text":
+                text_parts.append(part.get("text", ""))
+        return " ".join(text_parts)
+
     def _validate_task_not_terminal(
         self, task: Task, operation: str
     ) -> Optional[TaskNotCancelableError]:
@@ -121,7 +143,6 @@ class AgentTaskManager(TaskManager):
                 )
             )
 
-        # Generate task ID from message
         task_id = (
             request.params.message.task_id
             or f"task_{request.params.message.message_id}"
@@ -135,8 +156,19 @@ class AgentTaskManager(TaskManager):
                     root=JSONRPCErrorResponse(id=request.id, error=error)
                 )
 
+            if existing_task.status.state == TaskState.input_required:
+                message = convert_a2a_message_to_agent(request.params.message)
+                user_response = self._extract_text_from_message(message)
+
+                if task_id in self.pending_ask_responses:
+                    self.ask_responses[task_id] = user_response
+                    self.pending_ask_responses[task_id].set()
+
+                return SendMessageResponse(
+                    root=SendMessageSuccessResponse(id=request.id, result=existing_task)
+                )
+
         if task_id not in self.tasks:
-            # Create task with initial state
             task = Task(
                 id=task_id,
                 context_id=request.params.message.context_id or f"ctx_{task_id}",
@@ -147,8 +179,8 @@ class AgentTaskManager(TaskManager):
             self.tasks[task.id] = task
 
         task = self.tasks[task_id]
-        if task_id not in self.task_history:
-            self.task_history[task_id] = []
+        if task.context_id not in self.task_history:
+            self.task_history[task.context_id] = []
 
         # Convert A2A message to SwissKnife format
         message = convert_a2a_message_to_agent(request.params.message)
@@ -185,9 +217,8 @@ class AgentTaskManager(TaskManager):
 
             message["content"] = new_parts
 
-        self.task_history[task_id].append(message)
+        self.task_history[task.context_id].append(message)
 
-        # Process with agent (non-blocking)
         asyncio.create_task(self._process_agent_task(self.agent, task))
 
         # Return initial task state
@@ -243,6 +274,35 @@ class AgentTaskManager(TaskManager):
             # Clean up
             self.streaming_tasks.pop(task_id, None)
 
+    def _create_ask_tool_message(
+        self, question: str, guided_answers: list[str]
+    ) -> Message:
+        """
+        Create an A2A message for the ask tool's input-required state.
+
+        Args:
+            question: The question to ask the user
+            guided_answers: List of suggested answers
+
+        Returns:
+            A2A Message with the question and guided answers
+        """
+        ask_data = {
+            "type": "ask",
+            "question": question,
+            "guided_answers": guided_answers,
+            "instruction": "Please respond with one of the guided answers or provide a custom response.",
+        }
+
+        return Message(
+            message_id=f"ask_{hash(question)}",
+            role=Role.agent,
+            parts=[
+                Part(root=TextPart(text=f"❓ {question}")),
+                Part(root=DataPart(data=ask_data)),
+            ],
+        )
+
     def _record_and_emit_event(
         self, task_id: str, event: Union[TaskStatusUpdateEvent, TaskArtifactUpdateEvent]
     ):
@@ -281,7 +341,7 @@ class AgentTaskManager(TaskManager):
 
         try:
             artifacts = []
-            if task.id not in self.task_history:
+            if task.context_id not in self.task_history:
                 raise ValueError("Task history is not existed")
 
             input_tokens = 0
@@ -308,7 +368,7 @@ class AgentTaskManager(TaskManager):
                     chunk_text,
                     thinking_chunk,
                 ) in agent.process_messages(
-                    self.task_history[task.id], callback=process_result
+                    self.task_history[task.context_id], callback=process_result
                 ):
                     # Update current response
                     if response_message:
@@ -388,9 +448,8 @@ class AgentTaskManager(TaskManager):
                         MessageType.Thinking, {"thinking": thinking_data}
                     )
                     if thinking_message:
-                        self.task_history[task.id].append(thinking_message)
+                        self.task_history[task.context_id].append(thinking_message)
 
-                    # Format assistant message with the response and tool uses
                     assistant_message = agent.format_message(
                         MessageType.Assistant,
                         {
@@ -401,34 +460,99 @@ class AgentTaskManager(TaskManager):
                         },
                     )
                     if assistant_message:
-                        self.task_history[task.id].append(assistant_message)
+                        self.task_history[task.context_id].append(assistant_message)
 
-                    # Process each tool use
                     for tool_use in tool_uses:
-                        try:
-                            tool_result = await agent.execute_tool_call(
-                                tool_use["name"],
-                                tool_use["input"],
+                        tool_name = tool_use["name"]
+
+                        if tool_name == "ask":
+                            question = tool_use["input"].get("question", "")
+                            guided_answers = tool_use["input"].get("guided_answers", [])
+
+                            task.status.state = TaskState.input_required
+                            task.status.timestamp = datetime.now().isoformat()
+                            task.status.message = self._create_ask_tool_message(
+                                question, guided_answers
                             )
 
+                            self._record_and_emit_event(
+                                task.id,
+                                TaskStatusUpdateEvent(
+                                    task_id=task.id,
+                                    context_id=task.context_id,
+                                    status=task.status,
+                                    final=False,
+                                ),
+                            )
+
+                            wait_event = asyncio.Event()
+                            self.pending_ask_responses[task.id] = wait_event
+
+                            try:
+                                await asyncio.wait_for(wait_event.wait(), timeout=300)
+                                user_answer = self.ask_responses.get(
+                                    task.id, "No response received"
+                                )
+                            except asyncio.TimeoutError:
+                                user_answer = "User did not respond in time."
+                            finally:
+                                self.pending_ask_responses.pop(task.id, None)
+                                self.ask_responses.pop(task.id, None)
+
+                            tool_result = f"User's answer: {user_answer}"
+
+                            task.status.state = TaskState.working
+                            task.status.timestamp = datetime.now().isoformat()
+                            task.status.message = None
+
                             tool_result_message = agent.format_message(
                                 MessageType.ToolResult,
                                 {"tool_use": tool_use, "tool_result": tool_result},
                             )
                             if tool_result_message:
-                                self.task_history[task.id].append(tool_result_message)
+                                self.task_history[task.context_id].append(
+                                    tool_result_message
+                                )
 
-                        except Exception as e:
-                            error_message = agent.format_message(
-                                MessageType.ToolResult,
-                                {
-                                    "tool_use": tool_use,
-                                    "tool_result": str(e),
-                                    "is_error": True,
-                                },
+                            self._record_and_emit_event(
+                                task.id,
+                                TaskStatusUpdateEvent(
+                                    task_id=task.id,
+                                    context_id=task.context_id,
+                                    status=task.status,
+                                    final=False,
+                                ),
                             )
-                            if error_message:
-                                self.task_history[task.id].append(error_message)
+
+                        else:
+                            try:
+                                tool_result = await agent.execute_tool_call(
+                                    tool_name,
+                                    tool_use["input"],
+                                )
+
+                                tool_result_message = agent.format_message(
+                                    MessageType.ToolResult,
+                                    {"tool_use": tool_use, "tool_result": tool_result},
+                                )
+                                if tool_result_message:
+                                    self.task_history[task.context_id].append(
+                                        tool_result_message
+                                    )
+
+                            except Exception as e:
+                                error_message = agent.format_message(
+                                    MessageType.ToolResult,
+                                    {
+                                        "tool_use": tool_use,
+                                        "tool_result": str(e),
+                                        "is_error": True,
+                                    },
+                                )
+                                if error_message:
+                                    self.task_history[task.context_id].append(
+                                        error_message
+                                    )
 
                     return await _process_task()
                 return current_response
@@ -442,9 +566,9 @@ class AgentTaskManager(TaskManager):
                     },
                 )
                 if assistant_message:
-                    self.task_history[task.id].append(assistant_message)
+                    self.task_history[task.context_id].append(assistant_message)
                 user_message = (
-                    self.task_history[task.id][0]
+                    self.task_history[task.context_id][0]
                     .get("content", [{}])[0]
                     .get("text", "")
                 )
@@ -604,7 +728,7 @@ class AgentTaskManager(TaskManager):
         Yields:
             Streaming responses with task updates
         """
-        task_id = request.params.task_id
+        task_id = request.params.id
 
         if task_id not in self.tasks:
             error = A2AError.task_not_found(task_id)

AgentCrew/modules/agents/local_agent.py

@@ -111,25 +111,25 @@ class LocalAgent(BaseAgent):
             # self.tool_prompts.append(
             #     delegate_tool_prompt(self.services["agent_manager"])
             # )
+            from AgentCrew.modules.agents.tools.ask import (
+                register as register_ask,
+                ask_tool_prompt,
+            )
+
+            register_ask(self)
+            self.tool_prompts.append(ask_tool_prompt())
+
             if not self.is_remoting_mode:
                 from AgentCrew.modules.agents.tools.transfer import (
                     register as register_transfer,
                     transfer_tool_prompt,
                 )
-                from AgentCrew.modules.agents.tools.ask import (
-                    register as register_ask,
-                    ask_tool_prompt,
-                )
 
                 register_transfer(self.services["agent_manager"], self)
                 self.tool_prompts.append(
                     transfer_tool_prompt(self.services["agent_manager"])
                 )
 
-                # Register the ask tool (always available)
-                register_ask(self)
-                self.tool_prompts.append(ask_tool_prompt())
-
         for tool_name in self.tools:
             if self.services and tool_name in self.services:
                 service = self.services[tool_name]
@@ -642,7 +642,7 @@ Check if `when` condition in <Global_Behavior> or <Project_Behavior> matches, up
                     adaptive_messages["content"].append(
                         {
                             "type": "text",
-                            "text": f"Here are conversations that we have discussed:\n- {'\n- '.join(memory_headers)}",
+                            "text": f"Here are conversations that we have discussed from oldest to latest:\n - {'\n - '.join(memory_headers)}",
                         }
                     )
         if len(adaptive_messages["content"]) > 0:

AgentCrew/modules/browser_automation/element_extractor.py

@@ -68,7 +68,7 @@ def clean_markdown_images(markdown_content: str) -> str:
         Cleaned markdown content
     """
     # Pattern for markdown images: ![alt](url)
-    markdown_img_pattern = r"!\[([^\]]*)\]\(([^)]+)\)"
+    markdown_img_pattern = r"!?\[([^\]]*)\]\(([^)]+)\)"
 
     def replace_markdown_img(match):
         alt_text = match.group(1)

AgentCrew/modules/browser_automation/service.py

@@ -7,7 +7,7 @@ scroll content, and extract page information using Chrome DevTools Protocol.
 
 import time
 from typing import Dict, Any, Optional, List
-from html_to_markdown import convert_to_markdown
+from html_to_markdown import convert, ConversionOptions, PreprocessingOptions
 import urllib.parse
 
 from html.parser import HTMLParser
@@ -344,13 +344,23 @@ class BrowserAutomationService:
                 filtered_html = self._filter_hidden_elements(raw_html)
 
             # Convert HTML to markdown
-            raw_markdown_content = convert_to_markdown(
+            # raw_markdown_content = convert_to_markdown(
+            #     filtered_html,
+            #     source_encoding="utf-8",
+            #     strip_newlines=True,
+            #     extract_metadata=False,
+            #     remove_forms=False,
+            #     remove_navigation=False,
+            # )
+            raw_markdown_content = convert(
                 filtered_html,
-                source_encoding="utf-8",
-                strip_newlines=True,
-                extract_metadata=False,
-                remove_forms=False,
-                remove_navigation=False,
+                ConversionOptions(
+                    strip_newlines=True,
+                    extract_metadata=False,
+                ),
+                PreprocessingOptions(
+                    remove_navigation=False, remove_forms=False, preset="minimal"
+                ),
             )
             if not raw_markdown_content:
                 return {"success": False, "error": "Could not convert HTML to markdown"}

AgentCrew/modules/chat/message/command_processor.py

@@ -101,6 +101,9 @@ class CommandProcessor:
 
     async def _handle_copy_command(self, user_input: str) -> CommandResult:
         copy_idx = user_input[5:].strip() or 1
+        user_input_idxs = [
+            turn.message_index for turn in self.message_handler.conversation_turns
+        ]
 
         asssistant_messages_iterator = reversed(
             [
@@ -108,8 +111,7 @@ class CommandProcessor:
                 for i, msg in enumerate(self.message_handler.streamline_messages)
                 if msg.get("role") == "assistant"
                 and (
-                    self.message_handler.streamline_messages[i + 1].get("role")
-                    == "user"
+                    i + 1 in user_input_idxs
                     if i + 1 < len(self.message_handler.streamline_messages)
                     else True
                 )

AgentCrew/modules/chat/message/conversation.py

@@ -162,6 +162,7 @@ class ConversationManager:
                                 "Memories related to the user request:"
                             )
                             and not message_content.startswith("Content of ")
+                            and not message_content.startswith("<Transfer_Tool>")
                         ):
                             self.store_conversation_turn(message_content, i)
 

AgentCrew/modules/chat/message/handler.py

@@ -279,7 +279,7 @@ class MessageHandler(Observable):
                     # Notify about response progress
                     if not self.agent.is_streaming():
                         # Delays it a bit when using without stream
-                        time.sleep(0.5)
+                        time.sleep(0.3)
                     self._notify("response_chunk", (chunk_text, assistant_response))
                     if voice_sentence is not None:
                         if (
@@ -321,6 +321,8 @@ class MessageHandler(Observable):
                                     .lstrip("\n")
                                 )
 
+            self.stream_generator = None
+
             # End thinking when break the response stream
             if not end_thinking and start_thinking:
                 self._notify("thinking_completed", thinking_content)
@@ -386,11 +388,6 @@ class MessageHandler(Observable):
 
                 return await self.get_assistant_response()
 
-            self.stream_generator = None
-
-            if thinking_content:
-                self._notify("agent_continue", self.agent.name)
-
             # Add assistant response to messages
             if assistant_response.strip():
                 self._messages_append(

AgentCrew/modules/command_execution/constants.py

@@ -15,8 +15,8 @@ MAX_CONCURRENT_COMMANDS = 3
 # Maximum lifetime for a single command execution (seconds)
 MAX_COMMAND_LIFETIME = 600
 
-# Maximum output size per command (bytes)
-MAX_OUTPUT_SIZE = 1 * 1024 * 1024  # 1MB
+# Maximum output lines to keep in rolling buffer per stream (stdout/stderr)
+MAX_OUTPUT_LINES = 300
 
 # Maximum number of commands allowed per minute (application-wide rate limit)
 MAX_COMMANDS_PER_MINUTE = 10