agentcrew-ai 0.8.5__tar.gz → 0.8.6__tar.gz

agentcrew_ai-0.8.6/AgentCrew/__init__.py

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

{agentcrew_ai-0.8.5 → agentcrew_ai-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", "")
                 )

{agentcrew_ai-0.8.5 → agentcrew_ai-0.8.6}/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]

{agentcrew_ai-0.8.5 → agentcrew_ai-0.8.6}/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_ai-0.8.5 → agentcrew_ai-0.8.6}/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")

{agentcrew_ai-0.8.5 → agentcrew_ai-0.8.6}/AgentCrew/modules/command_execution/tool.py

@@ -6,6 +6,7 @@ Tool definitions and handlers for secure shell command execution.
 
 from typing import Dict, Any, Callable
 from .service import CommandExecutionService
+import os
 
 
 def get_run_command_tool_definition(provider="claude") -> Dict[str, Any]:
@@ -34,8 +35,7 @@ def get_run_command_tool_definition(provider="claude") -> Dict[str, Any]:
         },
         "working_dir": {
             "type": "string",
-            "default": "./",
-            "description": "Working directory.",
+            "description": f"Working directory. Current working directory is {os.getcwd()}. Use ./ for current dir.",
         },
         "env_vars": {
             "type": "object",
@@ -50,7 +50,7 @@ def get_run_command_tool_definition(provider="claude") -> Dict[str, Any]:
             "input_schema": {
                 "type": "object",
                 "properties": args,
-                "required": ["command"],
+                "required": ["command", "working_dir"],
             },
         }
     else:
@@ -62,7 +62,7 @@ def get_run_command_tool_definition(provider="claude") -> Dict[str, Any]:
                 "parameters": {
                     "type": "object",
                     "properties": args,
-                    "required": ["command"],
+                    "required": ["command", "working_dir"],
                 },
             },
         }
@@ -258,9 +258,7 @@ def get_check_command_status_tool_handler(
         if not command_id:
             raise ValueError("Missing required parameter: command_id")
 
-        result = command_service.get_command_status(
-            command_id=command_id, consume_output=True
-        )
+        result = command_service.get_command_status(command_id=command_id)
 
         if result["status"] == "completed":
             response = f"Command completed.\nExit Code: {result['exit_code']}\nDuration: {result['duration_seconds']}s\n\n"

{agentcrew_ai-0.8.5 → agentcrew_ai-0.8.6}/AgentCrew/modules/command_execution/types.py

@@ -1,4 +1,3 @@
-import queue
 import threading
 import subprocess
 from enum import Enum
@@ -31,13 +30,13 @@ class CommandProcess:
     process: subprocess.Popen
     platform: str
     start_time: float
-    output_queue: queue.Queue = field(default_factory=queue.Queue)
-    error_queue: queue.Queue = field(default_factory=queue.Queue)
+    stdout_lines: List[str] = field(default_factory=list)
+    stderr_lines: List[str] = field(default_factory=list)
+    output_lock: threading.Lock = field(default_factory=threading.Lock)
     state: CommandState = CommandState.QUEUED
     exit_code: Optional[int] = None
     reader_threads: List[threading.Thread] = field(default_factory=list)
     stop_event: threading.Event = field(default_factory=threading.Event)
-    total_output_size: int = 0
     working_dir: Optional[str] = None
 
     def transition_to(self, new_state: CommandState):