agentcrew-ai 0.8.12__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.12 → agentcrew_ai-0.9.0}/AgentCrew/main.py

@@ -86,7 +86,7 @@ def check_and_update():
         current_version = get_current_version()
 
         click.echo(f"Current version: {current_version}\nChecking for updates...")
-        latest_version = get_latest_github_version()
+        latest_version, release_notes = get_latest_release_info()
 
         if not current_version or not latest_version:
             click.echo("⚠️ Could not determine version information", err=True)
@@ -98,8 +98,20 @@ def check_and_update():
             system = platform.system().lower()
 
             if system == "linux" or system == "darwin":
+                click.echo("\n" + "=" * 60)
+                click.echo("🔄 New version available!")
+                click.echo("=" * 60)
+
+                if release_notes:
+                    click.echo("\n📝 Release Notes:")
+                    click.echo("-" * 40)
+                    click.echo(release_notes)
+                    click.echo("-" * 40 + "\n")
+                else:
+                    click.echo("\n⚠️ Could not fetch release notes.")
+
                 if click.confirm(
-                    "🔄 New version available! Do you want to update now?",
+                    "\nDo you want to update now?",
                     default=False,
                 ):
                     click.echo("🔄 Starting update...")
@@ -109,7 +121,18 @@ def check_and_update():
                     click.echo("⏭️ Skipping update. Starting application...")
             else:
                 command = "uv tool install --python=3.12 --reinstall agentcrew-ai[cpu]@latest --index https://download.pytorch.org/whl/cpu --index-strategy unsafe-best-match"
-                click.echo(f"🔄 New version available!\nRun {command} to update.")
+
+                click.echo("\n" + "=" * 60)
+                click.echo("🔄 New version available!")
+                click.echo("=" * 60)
+
+                if release_notes:
+                    click.echo("\n📝 Release Notes:")
+                    click.echo("-" * 40)
+                    click.echo(release_notes)
+                    click.echo("-" * 40 + "\n")
+
+                click.echo(f"Run the following command to update:\n\n{command}")
         else:
             click.echo("✅ You are running the latest version")
 
@@ -157,6 +180,35 @@ def get_latest_github_version():
         return None
 
 
+def get_latest_release_info():
+    """Get the latest release information including version and release notes from GitHub
+
+    Returns:
+        tuple: (version, release_notes) where both can be None if not found.
+    """
+    try:
+        api_url = (
+            "https://api.github.com/repos/saigontechnology/AgentCrew/releases/latest"
+        )
+        response = requests.get(api_url, timeout=10)
+
+        if response.status_code == 200:
+            release_data = response.json()
+            tag_name = release_data.get("tag_name", "").lstrip("v")
+            name = release_data.get("name", "")
+            body = release_data.get("body", "")
+
+            release_notes = None
+            if body:
+                release_notes = f"## {name or tag_name}\n\n{body}"
+
+            return tag_name, release_notes
+
+        return None, None
+    except Exception:
+        return None, None
+
+
 def version_is_older(current: str, latest: str) -> bool:
     """
     Compare two semantic version strings to check if current is older than latest.

{agentcrew_ai-0.8.12 → 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.12 → agentcrew_ai-0.9.0}/AgentCrew/modules/agents/local_agent.py

@@ -604,6 +604,21 @@ Whenever condition on `when` clause in a **Behavior** matches, tailor your respo
             )
         return adaptive_messages
 
+    def _get_directory_structure(self) -> str:
+        try:
+            cwd = os.getcwd()
+            entries = []
+            for entry in sorted(os.listdir(cwd)):
+                full_path = os.path.join(cwd, entry)
+                if os.path.isdir(full_path):
+                    entries.append(f"{entry}/")
+                else:
+                    entries.append(entry)
+            return "\n".join(entries) if entries else ""
+        except Exception as e:
+            logger.warning(f"Failed to get directory structure: {e}")
+            return ""
+
     def _enhance_agent_context_messages(self, final_messages: List[Dict[str, Any]]):
         last_user_index = next(
             (
@@ -651,6 +666,16 @@ Whenever condition on `when` clause in a **Behavior** matches, tailor your respo
             - Skip agent evaluation if user request is when...,[action]... related to adaptive behaviors call `adapt` tool instead.""",
                     },
                 )
+        if last_user_index == 0:
+            dir_structure = self._get_directory_structure()
+            if dir_structure:
+                adaptive_messages["content"].append(
+                    {
+                        "type": "text",
+                        "text": f"cwd `{os.getcwd()}` structure:\n{dir_structure}",
+                    }
+                )
+
         if len(adaptive_messages["content"]) > 0:
             final_messages.insert(last_user_index, adaptive_messages)
 
@@ -738,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.12 → 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.12 → 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.12 → agentcrew_ai-0.9.0}/AgentCrew/modules/code_analysis/__init__.py

@@ -6,7 +6,15 @@ capabilities with platform-specific optimizations.
 """
 
 from .service import CodeAnalysisService
+from .parsers import (
+    BaseLanguageParser,
+    get_parser_for_language,
+    LANGUAGE_PARSER_MAP,
+)
 
 __all__ = [
     "CodeAnalysisService",
+    "BaseLanguageParser",
+    "get_parser_for_language",
+    "LANGUAGE_PARSER_MAP",
 ]