agentcrew-ai 0.8.13__py3-none-any.whl → 0.9.0__py3-none-any.whl

AgentCrew/main_docker.py

@@ -1,6 +1,7 @@
 import click
 import os
 import sys
+from AgentCrew.app import common_options
 
 
 def _custom_unraisable_hook(unraisable):
@@ -48,36 +49,6 @@ def cli():
     )
 
 
-def common_options(func):
-    import functools
-
-    @click.option(
-        "--provider",
-        type=click.Choice(PROVIDER_LIST),
-        default=None,
-        help="LLM provider to use (claude, groq, openai, google, github_copilot, or deepinfra)",
-    )
-    @click.option(
-        "--agent-config", default=None, help="Path/URL to the agent configuration file."
-    )
-    @click.option(
-        "--mcp-config", default=None, help="Path to the mcp servers configuration file."
-    )
-    @click.option(
-        "--memory-llm",
-        type=click.Choice(
-            ["claude", "groq", "openai", "google", "deepinfra", "github_copilot"]
-        ),
-        default=None,
-        help="LLM Model use for analyzing and processing memory",
-    )
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
 def cli_prod():
     if sys.argv[1] == "--version":
         click.echo(f"AgentCrew version: {get_current_version()}")

AgentCrew/modules/agents/local_agent.py

@@ -672,7 +672,7 @@ Whenever condition on `when` clause in a **Behavior** matches, tailor your respo
                 adaptive_messages["content"].append(
                     {
                         "type": "text",
-                        "text": f"Cwd structure:\n{dir_structure}",
+                        "text": f"cwd `{os.getcwd()}` structure:\n{dir_structure}",
                     }
                 )
 
@@ -763,7 +763,7 @@ Whenever condition on `when` clause in a **Behavior** matches, tailor your respo
                     continue
 
                 if is_shrinkable and i < shrink_threshold:
-                    msg["content"] = "[REDACTED]"
+                    msg["content"] = "[PRUNED]"
                     continue
 
                 # Check if content starts with [UNIQUE]

AgentCrew/modules/chat/message/command_processor.py

@@ -43,14 +43,8 @@ class CommandProcessor:
             return CommandResult(handled=True, clear_flag=True)
         elif user_input.lower().startswith("/copy"):
             return await self._handle_copy_command(user_input)
-        elif user_input.lower() == "/debug":
-            self.message_handler._notify(
-                "debug_requested", self.message_handler.agent.clean_history
-            )
-            self.message_handler._notify(
-                "debug_requested", self.message_handler.streamline_messages
-            )
-            return CommandResult(handled=True, clear_flag=True)
+        elif user_input.lower().startswith("/debug"):
+            return self._handle_debug_command(user_input)
         elif user_input.lower().startswith("/think "):
             try:
                 budget = user_input[7:].strip()
@@ -759,6 +753,37 @@ class CommandProcessor:
             self.message_handler._notify("voice_recording_completed", None)
             return CommandResult(handled=True, clear_flag=True)
 
+    def _handle_debug_command(self, user_input: str) -> CommandResult:
+        """Handle /debug command with optional filtering.
+
+        Usage:
+            /debug         - Show both agent and chat messages
+            /debug agent   - Show only agent messages
+            /debug chat    - Show only chat/streamline messages
+        """
+        parts = user_input.lower().split()
+        filter_type = parts[1] if len(parts) > 1 else None
+
+        if filter_type and filter_type not in ("agent", "chat"):
+            self.message_handler._notify(
+                "error", f"Invalid filter '{filter_type}'. Use 'agent' or 'chat'."
+            )
+            return CommandResult(handled=True, clear_flag=True)
+
+        if filter_type is None or filter_type == "agent":
+            self.message_handler._notify(
+                "debug_requested",
+                {"type": "agent", "messages": self.message_handler.agent.clean_history},
+            )
+
+        if filter_type is None or filter_type == "chat":
+            self.message_handler._notify(
+                "debug_requested",
+                {"type": "chat", "messages": self.message_handler.streamline_messages},
+            )
+
+        return CommandResult(handled=True, clear_flag=True)
+
     def _handle_toggle_transfer_command(self, user_input: str) -> CommandResult:
         """Handle /toggle_transfer command to toggle the enforce_transfer property of agent_manager."""
         try:

AgentCrew/modules/chat/message/handler.py

@@ -470,9 +470,13 @@ class MessageHandler(Observable):
             if isinstance(e, BadRequestError):
                 if e.code == "model_max_prompt_tokens_exceeded":
                     from AgentCrew.modules.agents import LocalAgent
+                    from AgentCrew.modules.llm.model_registry import ModelRegistry
 
                     if isinstance(self.agent, LocalAgent):
-                        self.agent.input_tokens_usage = 128_000
+                        max_token = ModelRegistry.get_model_limit(
+                            self.agent.get_model()
+                        )
+                        self.agent.input_tokens_usage = max_token
                         return await self.get_assistant_response()
             if self.current_user_input:
                 self.conversation_manager.store_conversation_turn(

AgentCrew/modules/console/completers.py

@@ -174,7 +174,7 @@ class ChatCompleter(Completer):
             ),
             (
                 "/debug",
-                "Show debug information (agent history and streamline messages)",
+                "Show debug info (usage: /debug [agent|chat])",
             ),
             ("/think", "Set thinking budget (usage: /think <budget>)"),
             (

AgentCrew/modules/console/console_ui.py

@@ -71,14 +71,6 @@ class ConsoleUI(Observer):
         self.conversation_handler = ConversationHandler(self)
         self.command_handlers = CommandHandlers(self)
 
-    def _get_conversation_history(self, conversation_id: str):
-        """Get conversation history for preview in browser."""
-        if self.message_handler.persistent_service:
-            return self.message_handler.persistent_service.get_conversation_history(
-                conversation_id
-            )
-        return None
-
     def listen(self, event: str, data: Any = None):
         """
         Update method required by the Observer interface. Handles events from the MessageHandler.
@@ -223,8 +215,10 @@ class ConsoleUI(Observer):
             )
         elif event == "conversations_listed":
             self.display_handlers.display_conversations(
-                data
-            )  # data is list of conversation metadata
+                data,
+                get_history_callback=self.conversation_handler.get_conversation_history,
+                delete_callback=self.conversation_handler.delete_conversations,
+            )
             self.conversation_handler.update_cached_conversations(data)
         elif event == "conversation_loaded":
             loaded_text = Text("Loaded conversation: ", style=RICH_STYLE_YELLOW)
@@ -466,7 +460,8 @@ class ConsoleUI(Observer):
                         try:
                             selected_id = self.display_handlers.display_conversations(
                                 conversations,
-                                get_history_callback=self._get_conversation_history,
+                                get_history_callback=self.conversation_handler.get_conversation_history,
+                                delete_callback=self.conversation_handler.delete_conversations,
                             )
                             if selected_id:
                                 self.conversation_handler.handle_load_conversation(

AgentCrew/modules/console/conversation_browser/__init__.py

@@ -0,0 +1,9 @@
+from .browser import ConversationBrowser
+from .browser_ui import ConversationBrowserUI
+from .browser_input_handler import ConversationBrowserInputHandler
+
+__all__ = [
+    "ConversationBrowser",
+    "ConversationBrowserUI",
+    "ConversationBrowserInputHandler",
+]

AgentCrew/modules/console/conversation_browser/browser.py

@@ -0,0 +1,84 @@
+"""Conversation browser with split-panel interface.
+
+Provides Rich-based UI for listing and loading conversations with preview.
+"""
+
+from __future__ import annotations
+
+from typing import List, Dict, Any, Optional, Callable
+
+from rich.console import Console
+from rich.text import Text
+
+from ..constants import RICH_STYLE_YELLOW
+from .browser_ui import ConversationBrowserUI
+from .browser_input_handler import ConversationBrowserInputHandler
+
+
+class ConversationBrowser:
+    """Interactive conversation browser with split-panel layout.
+
+    This class orchestrates the UI rendering and input handling components
+    to provide a complete interactive conversation browsing experience.
+    """
+
+    def __init__(
+        self,
+        console: Console,
+        get_conversation_history: Optional[
+            Callable[[str], List[Dict[str, Any]]]
+        ] = None,
+        on_delete: Optional[Callable[[List[str]], bool]] = None,
+    ):
+        """Initialize the conversation browser.
+
+        Args:
+            console: Rich console for rendering
+            get_conversation_history: Optional callback to fetch full conversation history
+            on_delete: Optional callback to delete conversations by IDs. Returns True if successful.
+        """
+        self._console = console
+        self._ui = ConversationBrowserUI(
+            console=console,
+            get_conversation_history=get_conversation_history,
+        )
+        self._input_handler = ConversationBrowserInputHandler(
+            ui=self._ui,
+            on_delete=on_delete,
+        )
+
+    def set_conversations(self, conversations: List[Dict[str, Any]]):
+        """Set the conversations list to browse."""
+        self._ui.set_conversations(conversations)
+
+    def get_selected_conversation_id(self) -> Optional[str]:
+        """Get the ID of the currently selected conversation."""
+        return self._ui.get_selected_conversation_id()
+
+    def get_selected_conversation_index(self) -> int:
+        """Get the 1-based index of the currently selected conversation."""
+        return self._ui.get_selected_conversation_index()
+
+    @property
+    def ui(self) -> ConversationBrowserUI:
+        """Access the UI component directly."""
+        return self._ui
+
+    @property
+    def input_handler(self) -> ConversationBrowserInputHandler:
+        """Access the input handler component directly."""
+        return self._input_handler
+
+    def show(self) -> Optional[str]:
+        """Show the interactive conversation browser.
+
+        Returns:
+            The ID of the selected conversation, or None if cancelled.
+        """
+        if not self._ui.conversations:
+            self._console.print(
+                Text("No conversations available.", style=RICH_STYLE_YELLOW)
+            )
+            return None
+
+        return self._input_handler.run()

AgentCrew/modules/console/conversation_browser/browser_input_handler.py

@@ -0,0 +1,279 @@
+"""Conversation browser input handling."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Callable, List
+
+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 .browser_ui import ConversationBrowserUI
+
+
+class ConversationBrowserInputHandler:
+    """Handles keyboard input for the conversation browser."""
+
+    def __init__(
+        self,
+        ui: ConversationBrowserUI,
+        on_select: Optional[Callable[[str], None]] = None,
+        on_cancel: Optional[Callable[[], None]] = None,
+        on_delete: Optional[Callable[[List[str]], bool]] = None,
+    ):
+        self._ui = ui
+        self._running = False
+        self._g_pressed = False
+        self._d_pressed = False
+        self._selected_id: Optional[str] = None
+        self._on_select = on_select
+        self._on_cancel = on_cancel
+        self._on_delete = on_delete
+
+    def _create_key_bindings(self) -> KeyBindings:
+        """Create and configure key bindings for the browser."""
+        kb = KeyBindings()
+
+        @kb.add(Keys.Up)
+        @kb.add("k")
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("up"):
+                self._ui.render()
+
+        @kb.add(Keys.Down)
+        @kb.add("j")
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("down"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlP)
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("up"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlN)
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("down"):
+                self._ui.render()
+
+        @kb.add("g")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("g")
+                self._ui.render()
+                return
+            self._d_pressed = False
+            if self._g_pressed:
+                self._g_pressed = False
+                if self._ui.handle_navigation("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
+            self._d_pressed = False
+            if self._ui.handle_navigation("bottom"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlU)
+        @kb.add(Keys.PageUp)
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("page_up"):
+                self._ui.render()
+
+        @kb.add(Keys.ControlD)
+        @kb.add(Keys.PageDown)
+        def _(event):
+            if self._ui.search_mode:
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.handle_navigation("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._d_pressed = False
+            if self._ui.toggle_selection():
+                self._ui.render()
+
+        @kb.add("d")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("d")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            if self._d_pressed:
+                self._d_pressed = False
+                self._handle_delete()
+            else:
+                self._d_pressed = True
+
+        @kb.add("/")
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.append_search_char("/")
+                self._ui.render()
+                return
+            self._g_pressed = False
+            self._d_pressed = False
+            self._ui.start_search_mode()
+            self._ui.render()
+
+        @kb.add(Keys.Backspace)
+        def _(event):
+            if self._ui.search_mode:
+                self._ui.backspace_search()
+                self._ui.render()
+
+        @kb.add(Keys.Enter)
+        @kb.add("l")
+        def _(event):
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.search_mode:
+                self._ui.exit_search_mode(clear_filter=False)
+                self._ui.render()
+                return
+            self._selected_id = self._ui.get_selected_conversation_id()
+            event.app.exit()
+
+        @kb.add(Keys.Escape)
+        def _(event):
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.search_mode:
+                self._ui.exit_search_mode(clear_filter=True)
+                self._ui.render()
+                return
+            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
+            self._d_pressed = False
+            event.app.exit()
+
+        @kb.add(Keys.ControlC)
+        def _(event):
+            self._g_pressed = False
+            self._d_pressed = False
+            if self._ui.search_mode:
+                self._ui.exit_search_mode(clear_filter=True)
+                self._ui.render()
+                return
+            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
+            self._d_pressed = False
+
+        return kb
+
+    def _handle_delete(self):
+        """Handle delete action for selected or current conversation."""
+        if not self._ui.conversations:
+            return
+
+        if self._ui.selected_items:
+            indices_to_delete = list(self._ui.selected_items)
+            ids_to_delete = self._ui.get_selected_conversation_ids()
+        else:
+            indices_to_delete = [self._ui.selected_index]
+            current_id = self._ui.get_selected_conversation_id()
+            ids_to_delete = [current_id] if current_id else []
+
+        if not ids_to_delete:
+            return
+
+        if self._on_delete:
+            success = self._on_delete(ids_to_delete)
+            if success:
+                self._ui.remove_conversations(indices_to_delete)
+                self._ui.render()
+        else:
+            self._ui.remove_conversations(indices_to_delete)
+            self._ui.render()
+
+    def run(self) -> Optional[str]:
+        """Run the input handler loop.
+
+        Returns:
+            The ID of the selected conversation, or None if cancelled.
+        """
+        self._running = True
+        self._g_pressed = False
+        self._d_pressed = False
+        self._selected_id = None
+
+        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 conversation browser input handler: {e}")
+        finally:
+            self._ui.stop_live()
+
+        self._running = False
+        return self._selected_id
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the input handler is currently running."""
+        return self._running
+
+    def stop(self):
+        """Stop the input handler."""
+        self._running = False