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

agentcrew_ai-0.9.0/AgentCrew/__init__.py

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

agentcrew_ai-0.9.0/AgentCrew/app.py

@@ -0,0 +1,405 @@
+import os
+import sys
+import json
+import asyncio
+import functools
+import nest_asyncio
+from typing import Optional, Dict, Any, List
+
+import click
+
+from AgentCrew.setup import ApplicationSetup, PROVIDER_LIST
+from AgentCrew.modules.config import ConfigManagement
+from AgentCrew.modules.llm.service_manager import ServiceManager
+from AgentCrew.modules.agents.local_agent import LocalAgent
+
+nest_asyncio.apply()
+
+
+def common_options(func):
+    @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",
+    )
+    @click.option(
+        "--memory-path", default=None, help="Path to the memory database location"
+    )
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+class AgentCrewApplication:
+    def __init__(self):
+        self.config_manager = ConfigManagement()
+        self.setup = ApplicationSetup(self.config_manager)
+        self.setup.load_api_keys_from_config()
+
+    @property
+    def services(self) -> Optional[Dict[str, Any]]:
+        return self.setup.services
+
+    @property
+    def agent_manager(self):
+        return self.setup.agent_manager
+
+    def run_console(
+        self,
+        provider: Optional[str] = None,
+        agent_config: Optional[str] = None,
+        mcp_config: Optional[str] = None,
+        memory_llm: Optional[str] = None,
+        with_voice: bool = False,
+    ) -> None:
+        from AgentCrew.modules.console import ConsoleUI
+        from AgentCrew.modules.chat import MessageHandler
+        from AgentCrew.modules.mcpclient import MCPSessionManager
+
+        try:
+            if provider is None:
+                provider = self.setup.detect_provider()
+                if provider is None:
+                    raise ValueError(
+                        "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.setup_services(provider, memory_llm)
+
+            if mcp_config:
+                os.environ["MCP_CONFIG_PATH"] = mcp_config
+
+            self.setup.setup_agents(services, agent_config)
+            self.setup.restore_last_agent()
+
+            message_handler = MessageHandler(
+                services["memory"], services["context_persistent"], with_voice
+            )
+            global_config = self.config_manager.read_global_config_data()
+
+            ui = ConsoleUI(
+                message_handler,
+                global_config.get("global_settings", {}).get("swap_enter", False),
+            )
+            ui.start()
+        except Exception as e:
+            import traceback
+
+            print(traceback.format_exc())
+            click.echo(f"❌ Error: {str(e)}", err=True)
+        finally:
+            MCPSessionManager.get_instance().cleanup()
+
+    def run_gui(
+        self,
+        provider: Optional[str] = None,
+        agent_config: Optional[str] = None,
+        mcp_config: Optional[str] = None,
+        memory_llm: Optional[str] = None,
+        with_voice: bool = False,
+    ) -> None:
+        from PySide6.QtCore import QCoreApplication
+        from PySide6.QtCore import Qt
+        from PySide6.QtWidgets import QApplication
+        from AgentCrew.modules.gui import ChatWindow
+        from AgentCrew.modules.chat import MessageHandler
+        from AgentCrew.modules.mcpclient import MCPSessionManager
+
+        try:
+            if provider is None:
+                provider = self.setup.detect_provider()
+                if provider is None:
+                    from AgentCrew.modules.gui.widgets.config_window import ConfigWindow
+
+                    app = QApplication(sys.argv)
+                    config_window = ConfigWindow()
+                    config_window.tab_widget.setCurrentIndex(3)
+                    config_window.show()
+                    sys.exit(app.exec())
+
+            services = self.setup.setup_services(provider, memory_llm)
+
+            if mcp_config:
+                os.environ["MCP_CONFIG_PATH"] = mcp_config
+
+            self.setup.setup_agents(services, agent_config)
+            self.setup.restore_last_agent()
+
+            message_handler = MessageHandler(
+                services["memory"], services["context_persistent"], with_voice
+            )
+
+            QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_UseOpenGLES)
+            app = QApplication(sys.argv)
+            chat_window = ChatWindow(message_handler)
+            chat_window.show()
+            sys.exit(app.exec())
+        except Exception as e:
+            import traceback
+
+            print(traceback.format_exc())
+            click.echo(f"❌ Error: {str(e)}", err=True)
+        finally:
+            MCPSessionManager.get_instance().cleanup()
+
+    def run_server(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 41241,
+        base_url: Optional[str] = None,
+        provider: Optional[str] = None,
+        model_id: Optional[str] = None,
+        agent_config: Optional[str] = None,
+        api_key: Optional[str] = None,
+        mcp_config: Optional[str] = None,
+        memory_llm: Optional[str] = None,
+    ) -> None:
+        from AgentCrew.modules.a2a.server import A2AServer
+        from AgentCrew.modules.mcpclient import MCPSessionManager
+
+        try:
+            if not base_url:
+                base_url = f"http://{host}:{port}"
+
+            if provider is None:
+                provider = self.setup.detect_provider()
+                if provider is None:
+                    raise ValueError(
+                        "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.setup_services(
+                provider, memory_llm, need_memory=False
+            )
+
+            if mcp_config:
+                os.environ["MCP_CONFIG_PATH"] = mcp_config
+
+            os.environ["AGENTCREW_DISABLE_GUI"] = "true"
+
+            self.setup.setup_agents(services, agent_config, provider, model_id)
+
+            if self.agent_manager is None:
+                raise ValueError("Agent manager is not initialized")
+
+            self.agent_manager.enforce_transfer = False
+
+            server = A2AServer(
+                agent_manager=self.agent_manager,
+                host=host,
+                port=port,
+                base_url=base_url,
+                api_key=api_key,
+            )
+
+            click.echo(f"Starting A2A server on {host}:{port}")
+            click.echo(
+                f"Available agents: {', '.join(self.agent_manager.agents.keys())}"
+            )
+            server.start()
+        except Exception as e:
+            import traceback
+
+            print(traceback.format_exc())
+            click.echo(f"❌ Error: {str(e)}", err=True)
+        finally:
+            MCPSessionManager.get_instance().cleanup()
+
+    def _parse_output_schema(self, schema_input: str) -> tuple[str, dict]:
+        try:
+            from AgentCrew.modules.prompts.constants import SCHEMA_ENFORCEMENT_PROMPT
+
+            if os.path.exists(schema_input):
+                with open(schema_input, "r", encoding="utf-8") as f:
+                    schema_dict = json.load(f)
+            else:
+                schema_dict = json.loads(schema_input)
+
+            schema_json = json.dumps(schema_dict, indent=2)
+
+            enforcement_prompt = SCHEMA_ENFORCEMENT_PROMPT.replace(
+                "{schema_json}", schema_json
+            )
+            return enforcement_prompt, schema_dict
+
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON schema: {e}")
+        except Exception as e:
+            raise ValueError(f"Failed to load output schema: {e}")
+
+    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)
+        except json.JSONDecodeError as e:
+            return (
+                False,
+                f"Response is not valid JSON: {e}\n\nResponse received:\n{response[:500]}",
+            )
+
+        try:
+            validate(instance=response_json, schema=schema_dict)
+            return True, None
+        except ValidationError as e:
+            error_details = (
+                "JSON Schema Validation Error:\n"
+                f"  - Path: {' -> '.join(str(p) for p in e.path) if e.path else 'root'}\n"
+                f"  - Error: {e.message}\n"
+                f"  - Failed value: {json.dumps(e.instance, indent=2)}\n"
+            )
+            if e.schema_path:
+                error_details += (
+                    f"  - Schema path: {' -> '.join(str(p) for p in e.schema_path)}\n"
+                )
+            return False, error_details
+
+    def run_job(
+        self,
+        agent: str,
+        task: str,
+        files: Optional[List[str]] = None,
+        provider: Optional[str] = None,
+        model_id: Optional[str] = None,
+        agent_config: Optional[str] = None,
+        mcp_config: Optional[str] = None,
+        memory_llm: Optional[str] = None,
+        output_schema: Optional[str] = None,
+    ) -> str:
+        from AgentCrew.modules.chat import MessageHandler
+        from AgentCrew.modules.mcpclient import MCPSessionManager
+        from AgentCrew.modules.llm.model_registry import ModelRegistry
+
+        try:
+            if provider is None:
+                provider = self.setup.detect_provider()
+                if provider is None:
+                    raise ValueError(
+                        "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.setup_services(
+                provider, memory_llm, need_memory=False
+            )
+
+            if mcp_config:
+                os.environ["MCP_CONFIG_PATH"] = mcp_config
+
+            os.environ["AGENTCREW_DISABLE_GUI"] = "true"
+
+            self.setup.setup_agents(services, agent_config)
+
+            llm_manager = ServiceManager.get_instance()
+
+            llm_service = llm_manager.get_service(provider)
+            if model_id:
+                llm_service.model = model_id
+
+            if self.agent_manager is None:
+                raise ValueError("Agent manager is not initialized")
+
+            self.agent_manager.update_llm_service(llm_service)
+
+            for local_agent in self.agent_manager.agents:
+                if isinstance(local_agent, LocalAgent):
+                    local_agent.is_remoting_mode = True
+
+            self.agent_manager.enforce_transfer = False
+            self.agent_manager.one_turn_process = True
+
+            current_agent = self.agent_manager.get_local_agent(agent)
+
+            if current_agent:
+                schema_dict = None
+                if output_schema:
+                    schema_prompt, schema_dict = self._parse_output_schema(
+                        output_schema
+                    )
+                    if "structured_output" in ModelRegistry.get_model_capabilities(
+                        f"{provider}/{model_id}"
+                    ):
+                        current_agent.llm.structured_output = schema_dict
+                    else:
+                        current_agent.set_custom_system_prompt(schema_prompt)
+
+                self.agent_manager.select_agent(current_agent.name)
+
+                message_handler = MessageHandler(
+                    services["memory"], services["context_persistent"]
+                )
+                message_handler.is_non_interactive = True
+                message_handler.agent = current_agent
+
+                if files:
+                    for file_path in files:
+                        asyncio.run(
+                            message_handler.process_user_input(f"/file {file_path}")
+                        )
+
+                max_attempts = 4
+                attempt = 0
+                response = None
+
+                asyncio.run(message_handler.process_user_input(task))
+
+                while attempt < max_attempts:
+                    attempt += 1
+                    response, _, _ = asyncio.run(
+                        message_handler.get_assistant_response()
+                    )
+                    if not output_schema or not schema_dict:
+                        break
+
+                    if response is None:
+                        asyncio.run(
+                            message_handler.process_user_input(
+                                "No response was generated. Please try again."
+                            )
+                        )
+                        continue
+
+                    success, retry_message = self._validate_response_against_schema(
+                        response, schema_dict
+                    )
+                    if success:
+                        break
+                    else:
+                        if retry_message:
+                            asyncio.run(
+                                message_handler.process_user_input(retry_message)
+                            )
+
+                MCPSessionManager.get_instance().cleanup()
+                return response.strip() if response else ""
+            else:
+                raise ValueError(f"Agent '{agent}' not found")
+
+        except Exception:
+            import traceback
+
+            print(traceback.format_exc())
+            raise
+
+    def login(self) -> bool:
+        return self.setup.login()

{agentcrew_ai-0.8.13 → agentcrew_ai-0.9.0}/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_ai-0.8.13 → agentcrew_ai-0.9.0}/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_ai-0.8.13 → agentcrew_ai-0.9.0}/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_ai-0.8.13 → agentcrew_ai-0.9.0}/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_ai-0.8.13 → agentcrew_ai-0.9.0}/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_ai-0.8.13 → agentcrew_ai-0.9.0}/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_ai-0.9.0/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_ai-0.9.0/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()