agentcrew-ai 0.9.0__tar.gz → 0.9.2__tar.gz

agentcrew_ai-0.9.2/AgentCrew/__init__.py

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

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/app.py

@@ -246,13 +246,24 @@ class AgentCrewApplication:
         except Exception as e:
             raise ValueError(f"Failed to load output schema: {e}")
 
+    def _clean_json_response(self, response: str) -> str:
+        import re
+
+        cleaned = response.strip()
+        pattern = r"^```(?:json)?\s*\n?(.*?)\n?```$"
+        match = re.match(pattern, cleaned, re.DOTALL)
+        if match:
+            cleaned = match.group(1).strip()
+        return cleaned
+
     def _validate_response_against_schema(
         self, response: str, schema_dict: Dict[str, Any]
     ) -> tuple[bool, Optional[str]]:
         from jsonschema import validate, ValidationError
 
         try:
-            response_json = json.loads(response)
+            cleaned_response = self._clean_json_response(response)
+            response_json = json.loads(cleaned_response)
         except json.JSONDecodeError as e:
             return (
                 False,

agentcrew_ai-0.9.2/AgentCrew/modules/a2a/common/client/card_resolver.py

@@ -0,0 +1,39 @@
+import json
+
+import httpx
+
+from a2a.types import AgentCard
+
+DEFAULT_AGENT_CARD_PATHS = [
+    "/.well-known/agent-card.json",
+    "/.well-known/agent.json",
+]
+
+
+class A2ACardResolver:
+    def __init__(self, base_url, agent_card_path: str | None = None):
+        self.base_url = base_url.rstrip("/")
+        self.agent_card_path = agent_card_path.lstrip("/") if agent_card_path else None
+
+    def get_agent_card(self) -> AgentCard:
+        with httpx.Client() as client:
+            if self.agent_card_path:
+                return self._fetch_agent_card(client, self.agent_card_path)
+
+            for path in DEFAULT_AGENT_CARD_PATHS:
+                try:
+                    return self._fetch_agent_card(client, path.lstrip("/"))
+                except httpx.HTTPStatusError:
+                    continue
+
+            raise httpx.RequestError(
+                f"Agent card not found at any of the default paths: {DEFAULT_AGENT_CARD_PATHS}"
+            )
+
+    def _fetch_agent_card(self, client: httpx.Client, path: str) -> AgentCard:
+        response = client.get(self.base_url + "/" + path)
+        response.raise_for_status()
+        try:
+            return AgentCard(**response.json())
+        except json.JSONDecodeError as e:
+            raise httpx.RequestError(str(e)) from e

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/modules/a2a/server.py

@@ -82,6 +82,11 @@ class A2AServer:
             agent_routes = Mount(
                 f"/{agent_name}",
                 routes=[
+                    Route(
+                        "/.well-known/agent-card.json",
+                        self._get_agent_card_factory(agent_name),
+                        methods=["GET"],
+                    ),
                     Route(
                         "/.well-known/agent.json",
                         self._get_agent_card_factory(agent_name),

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/modules/a2a/task_manager.py

@@ -608,6 +608,7 @@ class AgentTaskManager(TaskManager):
 
         except Exception as e:
             logger.error(str(e))
+            logger.debug(self.task_history[task.context_id])
             # Handle errors
             task.status.state = TaskState.failed
             task.status.timestamp = datetime.now().isoformat()

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/modules/chat/message/conversation.py

@@ -198,6 +198,7 @@ class ConversationManager:
     def delete_conversation_by_id(self, conversation_id: str) -> bool:
         """
         Deletes a conversation by its ID, handling file deletion and UI updates.
+        Also deletes associated memory data.
 
         Args:
             conversation_id: The ID of the conversation to delete.
@@ -215,6 +216,22 @@ class ConversationManager:
             logger.info(
                 f"INFO: Successfully deleted conversation file for ID: {conversation_id}"
             )
+
+            if self.message_handler.memory_service:
+                memory_result = (
+                    self.message_handler.memory_service.delete_by_conversation_id(
+                        conversation_id
+                    )
+                )
+                if memory_result.get("success"):
+                    logger.info(
+                        f"INFO: Deleted {memory_result.get('count', 0)} memories for conversation {conversation_id}"
+                    )
+                else:
+                    logger.warning(
+                        f"WARNING: Failed to delete memories for conversation {conversation_id}: {memory_result.get('message')}"
+                    )
+
             self.message_handler._notify("conversations_changed", None)
             self.message_handler._notify(
                 "system_message", f"Conversation {conversation_id[:8]}... deleted."
@@ -224,7 +241,7 @@ class ConversationManager:
                 logger.info(
                     f"INFO: Deleted conversation {conversation_id} was the current one. Starting new conversation."
                 )
-                self.start_new_conversation()  # This will notify "clear_requested"
+                self.start_new_conversation()
             return True
         else:
             error_msg = f"Failed to delete conversation {conversation_id[:8]}..."

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/modules/code_analysis/service.py

@@ -3,13 +3,22 @@ import fnmatch
 import subprocess
 import json
 import asyncio
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
+import base64
+from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
 from loguru import logger
 
 from tree_sitter_language_pack import get_parser
 from tree_sitter import Parser
 
 from .parsers import get_parser_for_language, BaseLanguageParser
+import mimetypes
+
+IMAGE_MIME_TYPES = [
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+]
 
 if TYPE_CHECKING:
     from AgentCrew.modules.llm.base import BaseLLMService
@@ -59,6 +68,7 @@ class CodeAnalysisService:
                         analyzing large repositories (>500 files).
         """
         self.llm_service = llm_service
+        self.file_handler = None
         if self.llm_service:
             if self.llm_service.provider_name == "google":
                 self.llm_service.model = "gemini-2.5-flash-lite"
@@ -666,18 +676,49 @@ Example response format:
         file_path,
         start_line=None,
         end_line=None,
-    ) -> Dict[str, str]:
+    ) -> Union[Tuple[str, str], Tuple[str, Dict[str, Any]]]:
         """
         Return the content of a file, optionally reading only a specific line range.
+        For document files (PDF, DOCX, XLSX, PPTX), uses Docling to convert
+        to text/markdown and ignores start_line/end_line parameters.
+        For image files, returns base64 encoded data in image_url format.
 
         Args:
             file_path: Path to the file to read
-            start_line: Optional starting line number (1-indexed)
-            end_line: Optional ending line number (1-indexed, inclusive)
+            start_line: Optional starting line number (1-indexed) - ignored for document files
+            end_line: Optional ending line number (1-indexed, inclusive) - ignored for document files
 
         Returns:
-            Dictionary with file content (key: "file", value: file content string)
+            Tuple of (file_path, content) where content is either:
+            - str: text content for text/document files
+            - dict: {"type": "image_url", "image_url": {"url": "data:mime;base64,..."}} for images
         """
+
+        from AgentCrew.modules.chat.file_handler import (
+            FileHandler,
+            ALLOWED_MIME_TYPES,
+        )
+
+        mime_type, _ = mimetypes.guess_type(file_path)
+
+        if mime_type and mime_type in IMAGE_MIME_TYPES:
+            with open(file_path, "rb") as file:
+                binary_data = file.read()
+            base64_data = base64.b64encode(binary_data).decode("utf-8")
+            return file_path, {
+                "type": "image_url",
+                "image_url": {"url": f"data:{mime_type};base64,{base64_data}"},
+            }
+
+        if mime_type and mime_type in ALLOWED_MIME_TYPES:
+            if self.file_handler is None:
+                self.file_handler = FileHandler()
+            result = self.file_handler.process_file(file_path)
+            if result and "text" in result:
+                return file_path, result["text"]
+            elif result is None:
+                raise ValueError(f"Failed to process document file: {file_path}")
+
         with open(file_path, "rb") as file:
             content = file.read()
 
@@ -700,9 +741,11 @@ Example response format:
                 end_line = total_lines
 
             selected_lines = lines[start_line - 1 : end_line]
-            return {"file": "\n".join(selected_lines)}
+            return file_path, "\n".join(selected_lines)
+
+        return file_path, decoded_content
 
-        return {"file": decoded_content}
+        return file_path, decoded_content
 
     def _build_file_tree(self, file_paths: List[str]) -> Dict[str, Any]:
         """Build a hierarchical tree structure from flat file paths.

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/modules/code_analysis/tool.py

@@ -109,7 +109,7 @@ def get_file_content_tool_definition(provider="claude"):
     Returns:
         Dict containing the tool definition
     """
-    tool_description = "Gets the content of a file, or a specific lines within that file (function or class body). Use this to examine the logic of specific functions, the structure of classes, or the overall content of a file."
+    tool_description = "Gets the content of a file, or a specific lines within that file (function or class body). Use this to examine the logic of specific functions, the structure of classes, or the overall content of a file. Also supports reading document files (PDF, DOCX, XLSX, PPTX, images) which will be converted to text/markdown - for document files, start_line and end_line parameters are ignored."
 
     tool_arguments = {
         "file_path": {
@@ -157,7 +157,7 @@ def get_file_content_tool_handler(
 ):
     """Returns a function that handles the get_file_content tool."""
 
-    def handler(**params) -> str:
+    def handler(**params):
         file_path = params.get("file_path", "./")
         start_line = params.get("start_line")
         end_line = params.get("end_line")
@@ -168,16 +168,17 @@ def get_file_content_tool_handler(
         if not os.path.isabs(file_path):
             file_path = os.path.abspath(file_path)
 
-        results = code_analysis_service.get_file_content(
+        path, file_content = code_analysis_service.get_file_content(
             file_path, start_line=start_line, end_line=end_line
         )
 
-        content = ""
-
-        for path, code in results.items():
-            content += f"{path}: {code}\n"
+        if isinstance(file_content, dict) and file_content.get("type") == "image_url":
+            return [
+                {"type": "text", "text": f"Image file: {path}"},
+                file_content,
+            ]
 
-        return content
+        return f"`{path}`: {file_content}"
 
     return handler
 

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/modules/console/completers.py

@@ -233,6 +233,10 @@ class ChatCompleter(Completer):
                 "/delete_behavior",
                 "Delete an adaptive behavior (usage: /delete_behavior <id>)",
             ),
+            (
+                "/visual",
+                "Open visual mode to view raw message content with vim-like navigation",
+            ),
             ("/exit", "Exit the application"),
             ("/quit", "Exit the application"),
         ]

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/modules/console/console_ui.py

@@ -494,6 +494,23 @@ class ConsoleUI(Observer):
                         self.print_welcome_message()
                         continue
 
+                    elif user_input.strip() == "/visual":
+                        self.input_handler._stop_input_thread()
+                        try:
+                            from .visual_mode import VisualModeViewer
+
+                            viewer = VisualModeViewer(
+                                console=self.console,
+                                on_copy=self.copy_to_clipboard,
+                            )
+                            viewer.set_messages(
+                                self.message_handler.streamline_messages
+                            )
+                            viewer.show()
+                        finally:
+                            self.input_handler._start_input_thread()
+                        continue
+
                     # Handle toggle_session_yolo command directly (console only, session-based)
                     elif user_input.strip() == "/toggle_session_yolo":
                         self.command_handlers.handle_toggle_session_yolo_command()

{agentcrew_ai-0.9.0 → agentcrew_ai-0.9.2}/AgentCrew/modules/console/display_handlers.py

@@ -494,6 +494,10 @@ class DisplayHandlers:
                 "Use '/unconsolidate' undo last consolidated.",
                 style=RICH_STYLE_YELLOW,
             ),
+            Text(
+                "Use '/visual' to view raw message content with vim-like navigation and copy.",
+                style=RICH_STYLE_YELLOW,
+            ),
             Text(
                 "Tool calls require confirmation before execution.",
                 style=RICH_STYLE_BLUE,

agentcrew_ai-0.9.2/AgentCrew/modules/console/visual_mode/__init__.py

@@ -0,0 +1,5 @@
+"""Visual mode module for viewing raw message content."""
+
+from .viewer import VisualModeViewer
+
+__all__ = ["VisualModeViewer"]

agentcrew_ai-0.9.2/AgentCrew/modules/console/visual_mode/viewer.py

@@ -0,0 +1,41 @@
+"""Visual mode viewer for raw message content."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Dict, Any, Optional, Callable
+
+from rich.console import Console
+from rich.text import Text
+
+from .viewer_ui import VisualModeUI
+from .viewer_input_handler import VisualModeInputHandler
+from ..constants import RICH_STYLE_YELLOW
+
+if TYPE_CHECKING:
+    pass
+
+
+class VisualModeViewer:
+    """Main class for visual mode viewing of raw message content."""
+
+    def __init__(
+        self,
+        console: Console,
+        on_copy: Optional[Callable[[str], None]] = None,
+    ):
+        self._console = console
+        self._on_copy = on_copy
+        self._ui = VisualModeUI(console)
+        self._input_handler = VisualModeInputHandler(self._ui, on_copy=on_copy)
+
+    def set_messages(self, messages: List[Dict[str, Any]]):
+        self._ui.set_messages(messages)
+
+    def show(self):
+        if not self._ui._messages:
+            self._console.print(
+                Text("No messages to display in visual mode.", style=RICH_STYLE_YELLOW)
+            )
+            return
+
+        self._input_handler.run()

agentcrew_ai-0.9.2/AgentCrew/modules/console/visual_mode/viewer_input_handler.py

@@ -0,0 +1,315 @@
+"""Input handler for visual mode viewer."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Callable
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.keys import Keys
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from .viewer_ui import VisualModeUI
+
+
+class VisualModeInputHandler:
+    """Handles keyboard input for the visual mode viewer."""
+
+    def __init__(
+        self,
+        ui: VisualModeUI,
+        on_copy: Optional[Callable[[str], None]] = None,
+    ):
+        self._ui = ui
+        self._running = False
+        self._g_pressed = False
+        self._on_copy = on_copy
+
+    def _create_key_bindings(self) -> KeyBindings:
+        kb = KeyBindings()
+
+        @kb.add(Keys.Up)
+        @kb.add("k")
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("up"):
+                self._ui.render()
+
+        @kb.add(Keys.Down)
+        @kb.add("j")
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("down"):
+                self._ui.render()
+
+        @kb.add(Keys.Left)
+        @kb.add("h")
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("left"):
+                self._ui.render()
+
+        @kb.add(Keys.Right)
+        @kb.add("l")
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("right"):
+                self._ui.render()
+
+        @kb.add("w")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("w")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("word_forward"):
+                self._ui.render()
+
+        @kb.add("b")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("b")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("word_backward"):
+                self._ui.render()
+
+        @kb.add("0")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("0")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("line_start"):
+                self._ui.render()
+
+        @kb.add("$")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("$")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("line_end"):
+                self._ui.render()
+
+        @kb.add("g")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("g")
+                self._ui.render()
+                return
+            if self._g_pressed:
+                self._g_pressed = False
+                if self._ui.move_cursor("top"):
+                    self._ui.render()
+            else:
+                self._g_pressed = True
+
+        @kb.add("G")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("G")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("bottom"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlU)
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("half_up"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlD)
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("half_down"):
+                self._ui.render()
+
+        @kb.add(Keys.PageUp)
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("page_up"):
+                self._ui.render()
+
+        @kb.add(Keys.PageDown)
+        def _(event):
+            if self._ui._search_mode:
+                return
+            self._g_pressed = False
+            if self._ui.move_cursor("page_down"):
+                self._ui.render()
+
+        @kb.add("v")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("v")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._ui.toggle_visual_mode()
+            self._ui.render()
+
+        @kb.add("y")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("y")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            text = self._ui.get_selected_text()
+            if text and self._on_copy:
+                self._on_copy(text)
+            if self._ui._visual_mode:
+                self._ui.toggle_visual_mode()
+                self._ui.render()
+
+        @kb.add("Y")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("Y")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if 0 <= self._ui._cursor_line < len(self._ui._lines):
+                line_text = self._ui._lines[self._ui._cursor_line][0]
+                if self._on_copy:
+                    self._on_copy(line_text)
+
+        @kb.add("/")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("/")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._ui.start_search_mode()
+            self._ui.render()
+
+        @kb.add("n")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("n")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._ui.next_search_match()
+            self._ui.render()
+
+        @kb.add("N")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("N")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._ui.prev_search_match()
+            self._ui.render()
+
+        @kb.add(Keys.Enter)
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.exit_search_mode(clear_results=False)
+                self._ui.render()
+
+        @kb.add(Keys.Backspace)
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.backspace_search()
+                self._ui.render()
+
+        @kb.add(Keys.Escape)
+        def _(event):
+            self._g_pressed = False
+            if self._ui._visual_mode:
+                self._ui.toggle_visual_mode()
+                self._ui.render()
+            elif self._ui._search_mode:
+                self._ui.exit_search_mode(clear_results=True)
+                self._ui.render()
+            else:
+                event.app.exit()
+
+        @kb.add("q")
+        def _(event):
+            if self._ui._search_mode:
+                self._ui.append_search_char("q")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            event.app.exit()
+
+        @kb.add(Keys.ControlC)
+        def _(event):
+            self._g_pressed = False
+            if self._ui._visual_mode:
+                text = self._ui.get_selected_text()
+                if text and self._on_copy:
+                    self._on_copy(text)
+                self._ui.toggle_visual_mode()
+                self._ui.render()
+            elif self._ui._search_mode:
+                self._ui.exit_search_mode(clear_results=True)
+                self._ui.render()
+            else:
+                event.app.exit()
+
+        @kb.add(Keys.Any)
+        def _(event):
+            if self._ui._search_mode:
+                char = event.data
+                if char and char.isprintable():
+                    self._ui.append_search_char(char)
+                    self._ui.render()
+                return
+            self._g_pressed = False
+
+        return kb
+
+    def run(self):
+        self._running = True
+        self._g_pressed = False
+
+        self._ui.start_live()
+
+        kb = self._create_key_bindings()
+
+        try:
+            session = PromptSession(key_bindings=kb)
+            session.prompt("")
+        except (KeyboardInterrupt, EOFError):
+            pass
+        except Exception as e:
+            logger.error(f"Error in visual mode input handler: {e}")
+        finally:
+            self._ui.stop_live()
+
+        self._running = False
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    def stop(self):
+        self._running = False