agentcrew-ai 0.8.5__py3-none-any.whl → 0.8.7__py3-none-any.whl

AgentCrew/__init__.py

@@ -1 +1 @@
-__version__ = "0.8.5"
+__version__ = "0.8.7"

AgentCrew/app.py

@@ -584,7 +584,7 @@ tools = ["memory", "browser", "web_search", "code_analysis"]
                         "No LLM API key found. Please set either ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY, GROQ_API_KEY, or DEEPINFRA_API_KEY"
                     )
 
-            services = self.setup_services(provider, memory_llm)
+            services = self.setup_services(provider, memory_llm, need_memory=False)
 
             if mcp_config:
                 os.environ["MCP_CONFIG_PATH"] = mcp_config

AgentCrew/modules/a2a/registry.py

@@ -4,10 +4,10 @@ from typing import TYPE_CHECKING
 from pydantic import BaseModel
 from .agent_cards import create_agent_card
 from AgentCrew.modules.agents import LocalAgent
+from typing import Any, Dict, List, Optional
 
 
 if TYPE_CHECKING:
-    from typing import Any, Dict, List, Optional
     from AgentCrew.modules.agents import AgentManager
     from a2a.types import AgentCard
 

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,16 +78,32 @@ 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")
 
-        self.memory_service = self.agent.services["memory"]
+        self.memory_service = self.agent.services.get("memory", None)
 
     def _is_terminal_state(self, state: TaskState) -> bool:
         """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
@@ -241,8 +272,38 @@ class AgentTaskManager(TaskManager):
 
         finally:
             # Clean up
+            self.tasks.pop(task_id, None)
             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 +342,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 +369,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 +449,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 +461,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,15 +567,16 @@ 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", "")
                 )
-                self.memory_service.store_conversation(
-                    user_message, current_response, self.agent_name
-                )
+                if self.memory_service:
+                    self.memory_service.store_conversation(
+                        user_message, current_response, self.agent_name
+                    )
 
             # Create artifact from final response
             artifact = convert_agent_response_to_a2a_artifact(

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]
@@ -634,7 +634,7 @@ 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"):
+            if not self.is_remoting_mode and self.services.get("memory"):
                 memory_headers = self.services["memory"].list_memory_headers(
                     agent_name=self.name
                 )

AgentCrew/modules/code_analysis/service.py

@@ -1290,9 +1290,7 @@ class CodeAnalysisService:
                     f"start_line {start_line} exceeds file length ({total_lines} lines)"
                 )
             if end_line > total_lines:
-                raise ValueError(
-                    f"end_line {end_line} exceeds file length ({total_lines} lines)"
-                )
+                end_line = total_lines
 
             # Extract the line range (convert to 0-indexed)
             selected_lines = lines[start_line - 1 : end_line]

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

AgentCrew/modules/command_execution/service.py

@@ -2,7 +2,6 @@ import os
 import sys
 import time
 import uuid
-import queue
 import threading
 import subprocess
 import re
@@ -10,12 +9,11 @@ import atexit
 import hashlib
 from typing import Dict, Any, Optional, Tuple, List
 from datetime import datetime
-from .metric import CommandMetrics
 from .types import CommandState, CommandProcess
 from .constants import (
     MAX_CONCURRENT_COMMANDS,
     MAX_COMMAND_LIFETIME,
-    MAX_OUTPUT_SIZE,
+    MAX_OUTPUT_LINES,
     MAX_COMMANDS_PER_MINUTE,
     MAX_INPUT_SIZE,
     BLOCKED_PATTERNS,
@@ -68,9 +66,6 @@ class CommandExecutionService:
         # Rate limiting (application-wide)
         self._rate_limiter: List[float] = []
 
-        # Metrics
-        self.metrics = CommandMetrics()
-
         # Register cleanup on shutdown
         atexit.register(self.shutdown)
 
@@ -242,40 +237,40 @@ class CommandExecutionService:
     def _reader_thread(
         self,
         stream,
-        output_queue: queue.Queue,
+        output_list: list,
+        output_lock: threading.Lock,
         stop_event: threading.Event,
-        max_size: int,
+        max_lines: int,
     ):
         """
-        Read stream line by line into queue with size enforcement.
+        Read stream line by line into persistent list with rolling buffer.
 
-        Uses sentinel values:
-        - ('data', line): Normal output line
-        - ('eof', None): End of stream
-        - ('error', msg): Error occurred
-        - ('size_limit', None): Output size limit reached
-        """
-        total_bytes = 0
+        When output exceeds max_lines, old lines are removed to keep recent output.
 
+        Args:
+            stream: Process stdout or stderr stream
+            output_list: Persistent list to append output lines
+            output_lock: Threading lock for thread-safe list access
+            stop_event: Event to signal thread stop
+            max_lines: Maximum number of lines to keep (rolling buffer)
+        """
         try:
             for line in iter(stream.readline, b""):
                 if stop_event.is_set():
                     break
 
-                total_bytes += len(line)
-                if total_bytes > max_size:
-                    output_queue.put(("size_limit", None))
-                    logger.warning(f"Output size limit ({max_size} bytes) exceeded")
-                    break
-
                 decoded = line.decode("utf-8", errors="replace")
-                output_queue.put(("data", decoded))
+
+                with output_lock:
+                    output_list.append(decoded)
+
+                    # Keep only recent lines using slice
+                    if len(output_list) > max_lines:
+                        output_list[:] = output_list[-max_lines:]
 
         except Exception as e:
             logger.error(f"Reader thread error: {e}")
-            output_queue.put(("error", str(e)))
         finally:
-            output_queue.put(("eof", None))
             stream.close()
 
     def execute_command(
@@ -371,9 +366,10 @@ class CommandExecutionService:
                 target=self._reader_thread,
                 args=(
                     process.stdout,
-                    cmd_process.output_queue,
+                    cmd_process.stdout_lines,
+                    cmd_process.output_lock,
                     cmd_process.stop_event,
-                    MAX_OUTPUT_SIZE,
+                    MAX_OUTPUT_LINES,
                 ),
                 daemon=True,
                 name=f"stdout-reader-{command_id}",
@@ -383,9 +379,10 @@ class CommandExecutionService:
                 target=self._reader_thread,
                 args=(
                     process.stderr,
-                    cmd_process.error_queue,
+                    cmd_process.stderr_lines,
+                    cmd_process.output_lock,
                     cmd_process.stop_event,
-                    MAX_OUTPUT_SIZE,
+                    MAX_OUTPUT_LINES,
                 ),
                 daemon=True,
                 name=f"stderr-reader-{command_id}",
@@ -405,21 +402,10 @@ class CommandExecutionService:
             cmd_process.exit_code = process.returncode
             cmd_process.transition_to(CommandState.COMPLETING)
 
-            output_lines = []
-            error_lines = []
-
-            while not cmd_process.output_queue.empty():
-                msg_type, data = cmd_process.output_queue.get()
-                if msg_type == "data":
-                    output_lines.append(data)
-
-            while not cmd_process.error_queue.empty():
-                msg_type, data = cmd_process.error_queue.get()
-                if msg_type == "data":
-                    error_lines.append(data)
-
-            output = "".join(output_lines)
-            error_output = "".join(error_lines)
+            # Get output from persistent storage (thread-safe)
+            with cmd_process.output_lock:
+                output = "".join(cmd_process.stdout_lines)
+                error_output = "".join(cmd_process.stderr_lines)
 
             duration = time.time() - start_time
 
@@ -433,7 +419,6 @@ class CommandExecutionService:
                 len(output) + len(error_output),
             )
 
-            self.metrics.record_execution(command, duration, "completed")
             self._cleanup_command_internal(command_id)
 
             result = {
@@ -466,22 +451,20 @@ class CommandExecutionService:
             logger.error(f"Command execution error: {e}")
 
             self._audit_log(command, "error", command_id)
-            self.metrics.record_execution(command, time.time() - start_time, "error")
 
             if command_id in self._instances:
                 self._cleanup_command_internal(command_id)
 
             return {"status": "error", "error": f"Execution failed: {str(e)}"}
 
-    def get_command_status(
-        self, command_id: str, consume_output: bool = True
-    ) -> Dict[str, Any]:
+    def get_command_status(self, command_id: str) -> Dict[str, Any]:
         """
         Check status of running command.
 
+        Output is persistent and will be returned in full on every call.
+
         Args:
             command_id: Command identifier
-            consume_output: If True, drain and return queued output
 
         Returns:
             Dict with status, output, exit_code, elapsed_time
@@ -494,30 +477,11 @@ class CommandExecutionService:
 
         exit_code = cmd_process.process.poll()
 
-        output_lines = []
-        error_lines = []
-
-        if consume_output:
-            while not cmd_process.output_queue.empty():
-                try:
-                    msg_type, data = cmd_process.output_queue.get_nowait()
-                    if msg_type == "data":
-                        output_lines.append(data)
-                    elif msg_type == "size_limit":
-                        output_lines.append("\n[OUTPUT SIZE LIMIT REACHED]\n")
-                except queue.Empty:
-                    break
-
-            while not cmd_process.error_queue.empty():
-                try:
-                    msg_type, data = cmd_process.error_queue.get_nowait()
-                    if msg_type == "data":
-                        error_lines.append(data)
-                except queue.Empty:
-                    break
+        # Get output from persistent storage (thread-safe)
+        with cmd_process.output_lock:
+            output = "".join(cmd_process.stdout_lines)
+            error_output = "".join(cmd_process.stderr_lines)
 
-        output = "".join(output_lines)
-        error_output = "".join(error_lines)
         elapsed = time.time() - cmd_process.start_time
 
         if elapsed > MAX_COMMAND_LIFETIME:
@@ -546,7 +510,6 @@ class CommandExecutionService:
                 duration,
                 len(output) + len(error_output),
             )
-            self.metrics.record_execution(cmd_process.command, duration, "completed")
             self._cleanup_command_internal(command_id)
 
             return {
@@ -690,11 +653,6 @@ class CommandExecutionService:
                             pass
 
                     cmd_process.transition_to(CommandState.KILLED)
-                    self.metrics.record_execution(
-                        cmd_process.command,
-                        time.time() - cmd_process.start_time,
-                        "killed",
-                    )
 
                 except Exception as e:
                     logger.error(f"Process termination error: {e}")
@@ -767,10 +725,6 @@ class CommandExecutionService:
         """
         return self.cleanup_command(command_id)
 
-    def get_metrics(self) -> Dict[str, Any]:
-        """Get command execution metrics"""
-        return self.metrics.get_report()
-
     def shutdown(self):
         """Shutdown service and cleanup all running commands"""
         logger.info("Shutting down CommandExecutionService")