aru-code 0.11.2__tar.gz → 0.12.0__tar.gz

{aru_code-0.11.2/aru_code.egg-info → aru_code-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.11.2
+Version: 0.12.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

aru_code-0.12.0/aru/__init__.py

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

{aru_code-0.11.2 → aru_code-0.12.0}/aru/agent_factory.py

@@ -33,7 +33,7 @@ def create_general_agent(
         compression_manager=CompressionManager(
             model=create_model(get_ctx().small_model_ref, max_tokens=1024),
             compress_tool_results=True,
-            compress_tool_results_limit=15,
+            compress_tool_results_limit=25,
         ),
         tool_call_limit=20,
     )
@@ -67,7 +67,7 @@ def create_custom_agent_instance(agent_def: CustomAgent, session: Session,
         compression_manager=CompressionManager(
             model=create_model(get_ctx().small_model_ref, max_tokens=1024),
             compress_tool_results=True,
-            compress_tool_results_limit=15,
+            compress_tool_results_limit=25,
         ),
         tool_call_limit=agent_def.max_turns or 20,
     )

{aru_code-0.11.2 → aru_code-0.12.0}/aru/agents/executor.py

@@ -53,7 +53,7 @@ def create_executor(model_ref: str = "anthropic/claude-sonnet-4-5", extra_instru
         compression_manager=_SafeCompressionManager(
             model=create_model(get_ctx().small_model_ref, max_tokens=2048),
             compress_tool_results=True,
-            compress_tool_results_limit=15,
+            compress_tool_results_limit=25,
         ),
         tool_call_limit=None,
     )

{aru_code-0.11.2 → aru_code-0.12.0}/aru/agents/planner.py

@@ -79,7 +79,7 @@ def create_planner(model_ref: str = "anthropic/claude-sonnet-4-5", extra_instruc
         compression_manager=CompressionManager(
             model=create_model(get_ctx().small_model_ref, max_tokens=1024),
             compress_tool_results=True,
-            compress_tool_results_limit=15,
+            compress_tool_results_limit=25,
         ),
         tool_call_limit=20,
     )

{aru_code-0.11.2 → aru_code-0.12.0}/aru/config.py

@@ -173,8 +173,9 @@ class AgentConfig:
             lightweight: If True, skip README.md and skill catalog to save tokens.
         """
         parts = []
-        if self.readme_md and not lightweight:
-            parts.append(f"## Project Overview (README.md)\n\n{self.readme_md}")
+        # README.md is no longer included by default — it's written for humans
+        # (badges, install instructions, contributing guides) and wastes ~2K tokens
+        # per turn. AGENTS.md is the proper place for model-facing context.
         if self.agents_md:
             parts.append(f"## Project Instructions (AGENTS.md)\n\n{self.agents_md}")
         if self.rules_instructions:
@@ -195,6 +196,15 @@ class AgentConfig:
                 lines.append(f"- `/{name}{hint}`: {skill.description}")
             parts.append("\n".join(lines))
 
+        # Include MCP tool catalog (lazy mode — lightweight text instead of full schemas)
+        try:
+            from aru.runtime import get_ctx
+            catalog_text = get_ctx().mcp_catalog_text
+            if catalog_text and not lightweight:
+                parts.append(catalog_text)
+        except LookupError:
+            pass
+
         return "\n\n".join(parts)
 
 

{aru_code-0.11.2 → aru_code-0.12.0}/aru/context.py

@@ -24,18 +24,45 @@ TRUNCATE_KEEP_START = 350  # lines to keep from the start
 TRUNCATE_KEEP_END = 100  # lines to keep from the end
 
 # Compaction: trigger when cumulative input tokens exceed this fraction of model limit
-COMPACTION_THRESHOLD_RATIO = 0.50
+COMPACTION_THRESHOLD_RATIO = 0.85
 # Default model context limits (input tokens)
 MODEL_CONTEXT_LIMITS: dict[str, int] = {
+    # Anthropic
     "claude-sonnet-4-5-20250929": 200_000,
     "claude-sonnet-4-20250514": 200_000,
     "claude-haiku-4-5-20251001": 200_000,
     "claude-opus-4-20250514": 200_000,
     "claude-opus-4-6": 1_000_000,
     "claude-sonnet-4-6": 1_000_000,
+    # OpenAI
     "gpt-4o": 128_000,
     "gpt-4o-mini": 128_000,
-    "default": 200_000,
+    "gpt-4.1": 1_000_000,
+    "gpt-4.1-mini": 1_000_000,
+    "gpt-4.1-nano": 1_000_000,
+    "o3": 200_000,
+    "o3-mini": 200_000,
+    "o4-mini": 200_000,
+    # Qwen (AlibabaCloud)
+    "qwen3-plus": 128_000,
+    "qwen3.6-plus": 128_000,
+    "qwen-plus": 128_000,
+    "qwen-max": 128_000,
+    "qwen-turbo": 128_000,
+    "qwen3-coder-plus": 128_000,
+    # DeepSeek
+    "deepseek-chat": 128_000,
+    "deepseek-reasoner": 128_000,
+    # Meta Llama (common Ollama/Groq)
+    "llama3.1": 128_000,
+    "llama-3.1-70b-versatile": 128_000,
+    "llama-3.3-70b-versatile": 128_000,
+    "llama4-scout": 512_000,
+    # Google Gemini (OpenRouter)
+    "gemini-2.5-pro": 1_000_000,
+    "gemini-2.5-flash": 1_000_000,
+    # Fallback
+    "default": 128_000,
 }
 
 COMPACTION_TEMPLATE = """\

{aru_code-0.11.2 → aru_code-0.12.0}/aru/providers.py

@@ -6,10 +6,13 @@ Maps provider names to Agno model classes and handles provider-specific configur
 
 from __future__ import annotations
 
+import logging
 import os
 from dataclasses import dataclass, field
 from typing import Any
 
+logger = logging.getLogger("aru.providers")
+
 
 # ---------------------------------------------------------------------------
 # Built-in provider definitions
@@ -150,7 +153,7 @@ def load_providers_from_config(config_data: dict[str, Any]):
         "ollama": {
           "base_url": "http://localhost:11434",
           "models": {
-            "deepseek-coder-v2": {"id": "deepseek-coder-v2:latest"}
+            "deepseek-coder-v2": {"id": "deepseek-coder-v2:latest", "context_limit": 128000}
           }
         },
         "my-custom": {
@@ -158,18 +161,28 @@ def load_providers_from_config(config_data: dict[str, Any]):
           "name": "My Custom Provider",
           "api_key_env": "MY_API_KEY",
           "base_url": "https://my-api.example.com/v1",
+          "context_limit": 128000,
           "models": {
-            "my-model": {"id": "my-model-v1"}
+            "my-model": {"id": "my-model-v1", "context_limit": 64000}
           }
         }
       }
     }
+
+    context_limit can be set per-model or per-provider (provider-level serves as
+    default for all its models). Values are merged into MODEL_CONTEXT_LIMITS so
+    compaction triggers at the correct threshold.
     """
+    from aru.context import MODEL_CONTEXT_LIMITS
+
     providers_data = config_data.get("providers", {})
     for key, pdata in providers_data.items():
         if not isinstance(pdata, dict):
             continue
 
+        # Provider-level context_limit (applies to all models as default)
+        provider_context_limit = pdata.get("context_limit")
+
         # If this extends a built-in, start from that base
         existing = _providers.get(key)
         if existing:
@@ -200,6 +213,23 @@ def load_providers_from_config(config_data: dict[str, Any]):
             if "type" in pdata:
                 _providers[key].options["_provider_type"] = pdata["type"]
 
+        # Register context_limit values into MODEL_CONTEXT_LIMITS
+        models_data = pdata.get("models", {})
+        for model_name, model_cfg in models_data.items():
+            if not isinstance(model_cfg, dict):
+                continue
+            limit = model_cfg.get("context_limit") or provider_context_limit
+            if isinstance(limit, int) and limit > 0:
+                model_id = model_cfg.get("id", model_name)
+                MODEL_CONTEXT_LIMITS[model_id] = limit
+
+        # If provider has context_limit but no per-model overrides, register default model
+        if isinstance(provider_context_limit, int) and provider_context_limit > 0:
+            provider_obj = _providers.get(key)
+            if provider_obj and provider_obj.default_model:
+                default_id = _get_actual_model_id(provider_obj, provider_obj.default_model)
+                MODEL_CONTEXT_LIMITS.setdefault(default_id, provider_context_limit)
+
 
 # ---------------------------------------------------------------------------
 # Model resolution
@@ -300,6 +330,38 @@ def create_model(
     )
 
 
+def _make_cached_openai_chat_class():
+    """Create a CachedOpenAIChat subclass (lazy import to avoid top-level dependency)."""
+    from agno.models.openai import OpenAIChat
+    from agno.models.message import Message
+
+    class CachedOpenAIChat(OpenAIChat):
+        """OpenAIChat subclass that injects cache_control into system messages.
+
+        DashScope (Qwen) and other OpenAI-compatible APIs support explicit prompt caching
+        via cache_control: {"type": "ephemeral"} on content blocks. This subclass
+        automatically adds that marker to system messages so the provider can cache
+        the system prompt between turns (up to 90% cost reduction on cached tokens).
+        """
+
+        def _format_message(self, message: Message, compress_tool_results: bool = False):
+            formatted = super()._format_message(message, compress_tool_results)
+
+            if message.role == "system" and isinstance(formatted.get("content"), str):
+                text = formatted["content"]
+                formatted["content"] = [
+                    {
+                        "type": "text",
+                        "text": text,
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ]
+
+            return formatted
+
+    return CachedOpenAIChat
+
+
 def _create_provider_model(
     provider_type: str,
     provider: ProviderConfig,
@@ -322,7 +384,6 @@ def _create_provider_model(
         return Claude(**params)
 
     elif provider_type == "openai":
-        from agno.models.openai import OpenAIChat
         api_key = _resolve_api_key(provider)
         params = {"id": model_id, "max_tokens": max_tokens}
         if api_key:
@@ -338,6 +399,10 @@ def _create_provider_model(
                 "model": "assistant",
             }
         params.update(kwargs)
+        if cache_system_prompt:
+            CachedOpenAIChat = _make_cached_openai_chat_class()
+            return CachedOpenAIChat(**params)
+        from agno.models.openai import OpenAIChat
         return OpenAIChat(**params)
 
     elif provider_type == "ollama":
@@ -382,14 +447,25 @@ def _create_provider_model(
 
     else:
         # Fallback: try OpenAI-compatible (works for many providers)
-        from agno.models.openai import OpenAIChat
         api_key = _resolve_api_key(provider)
         params = {"id": model_id, "max_tokens": max_tokens}
         if api_key:
             params["api_key"] = api_key
         if provider.base_url:
             params["base_url"] = provider.base_url
+        if provider.options.get("use_system_role"):
+            params["role_map"] = {
+                "system": "system",
+                "user": "user",
+                "assistant": "assistant",
+                "tool": "tool",
+                "model": "assistant",
+            }
         params.update(kwargs)
+        if cache_system_prompt:
+            CachedOpenAIChat = _make_cached_openai_chat_class()
+            return CachedOpenAIChat(**params)
+        from agno.models.openai import OpenAIChat
         return OpenAIChat(**params)
 
 

{aru_code-0.11.2 → aru_code-0.12.0}/aru/runtime.py

@@ -115,6 +115,9 @@ class RuntimeContext:
     # -- Tasklist --
     task_store: TaskStore = field(default_factory=TaskStore)
 
+    # -- MCP --
+    mcp_catalog_text: str = ""
+
 
 # ── ContextVar plumbing ──────────────────────────────────────────────
 

{aru_code-0.11.2 → aru_code-0.12.0}/aru/tools/codebase.py

@@ -1211,16 +1211,77 @@ def _update_delegate_task_docstring():
     delegate_task.__doc__ = base_doc
 
 
-async def load_mcp_tools():
-    """Initialize MCP servers and inject their tools into tool lists dynamically."""
+async def load_mcp_tools(eager: bool = False):
+    """Initialize MCP servers and expose their tools to agents.
+
+    Args:
+        eager: If True, inject each MCP tool as its own Agno Function (legacy mode).
+               If False (default), inject a single gateway tool + lightweight catalog
+               in the system prompt — saves thousands of tokens per turn.
+    """
     from aru.tools.mcp_client import init_mcp
     try:
-        mcp_tools = await init_mcp()
-        if mcp_tools:
-            get_ctx().console.print(f"[dim]Loaded {len(mcp_tools)} tools from MCP servers.[/dim]")
+        manager = await init_mcp()
+        if manager is None or not manager.catalog:
+            return
+
+        tool_count = len(manager.catalog)
+
+        if eager:
+            # Legacy: each MCP tool = one Agno Function (expensive)
+            mcp_tools = manager.get_eager_tools()
+            get_ctx().console.print(f"[dim]Loaded {tool_count} tools from MCP servers (eager mode).[/dim]")
             for t in mcp_tools:
                 ALL_TOOLS.append(t)
                 EXECUTOR_TOOLS.append(t)
                 GENERAL_TOOLS.append(t)
+        else:
+            # Lazy: single gateway tool + text catalog
+            gateway = _build_mcp_gateway(manager)
+            ALL_TOOLS.append(gateway)
+            EXECUTOR_TOOLS.append(gateway)
+            GENERAL_TOOLS.append(gateway)
+            # Store catalog text for injection into system prompt
+            get_ctx().mcp_catalog_text = manager.get_catalog_text()
+            get_ctx().console.print(f"[dim]Loaded {tool_count} tools from MCP servers.[/dim]")
+
     except Exception as e:
         get_ctx().console.print(f"[dim]Failed to load MCP tools: {e}[/dim]")
+
+
+def _build_mcp_gateway(manager):
+    """Build the single gateway Function that routes to any MCP tool."""
+    from agno.tools import Function
+
+    async def use_mcp_tool(tool_name: str, arguments: dict | None = None) -> str:
+        """Call an external MCP tool by name.
+
+        Use this to invoke any tool from the MCP Tools catalog listed in your instructions.
+        Pass the exact tool name and its arguments as a JSON object.
+
+        Args:
+            tool_name: The MCP tool name (e.g. "github__search_repositories").
+            arguments: The arguments to pass to the tool as key-value pairs.
+        """
+        return await manager.call_tool(tool_name, arguments)
+
+    return Function(
+        name="use_mcp_tool",
+        description="Call an external MCP tool by name. See the MCP Tools catalog in your instructions for available tools and their parameters.",
+        parameters={
+            "type": "object",
+            "properties": {
+                "tool_name": {
+                    "type": "string",
+                    "description": "The MCP tool name from the catalog (e.g. 'github__search_repositories')"
+                },
+                "arguments": {
+                    "type": "object",
+                    "description": "Arguments to pass to the tool as key-value pairs",
+                    "additionalProperties": True
+                }
+            },
+            "required": ["tool_name"]
+        },
+        entrypoint=use_mcp_tool,
+    )

aru_code-0.12.0/aru/tools/mcp_client.py

@@ -0,0 +1,283 @@
+"""Model Context Protocol (MCP) client manager and tool generation.
+
+Supports two modes for exposing MCP tools to agents:
+- **Eager** (legacy): Each MCP tool becomes its own Agno Function with full JSON Schema.
+  Sends all tool schemas in every request — expensive with many tools.
+- **Lazy** (default): A single gateway tool `use_mcp_tool` replaces all individual tools.
+  The tool catalog (name + description) is injected as lightweight text in the system prompt.
+  Full schema resolution happens only when the model invokes a specific tool.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from contextlib import AsyncExitStack
+from dataclasses import dataclass, field
+
+from agno.tools import Function
+from mcp.client.stdio import stdio_client, StdioServerParameters
+from mcp.client.session import ClientSession
+
+
+@dataclass
+class McpToolEntry:
+    """Lightweight catalog entry for a discovered MCP tool."""
+    name: str           # safe_name: "server__tool_name"
+    description: str    # "[server] original description"
+    parameters: dict    # full JSON Schema (only used on invocation)
+    server_name: str    # originating MCP server
+    original_name: str  # tool name as the MCP server knows it
+    session: ClientSession = field(repr=False)
+
+
+class McpSessionManager:
+    """Manages MCP server subprocesses and active client sessions."""
+
+    def __init__(self, config_path: str = "arc.mcp.json"):
+        self.config_path = config_path
+        self._exit_stack = AsyncExitStack()
+        self.sessions: dict[str, ClientSession] = {}
+        self.catalog: dict[str, McpToolEntry] = {}
+
+    async def initialize(self):
+        """Read config and spawn all MCP servers concurrently."""
+        if not os.path.exists(self.config_path):
+            return
+
+        with open(self.config_path, "r", encoding="utf-8") as f:
+            try:
+                config = json.load(f)
+            except json.JSONDecodeError:
+                print(f"[Warning] Failed to parse {self.config_path}")
+                return
+
+        servers = config.get("mcpServers", {})
+        tasks = []
+        for name, svr_config in servers.items():
+            cmd = svr_config.get("command")
+            if not cmd:
+                continue
+            tasks.append(self._start_server(name, svr_config))
+
+        if tasks:
+            await asyncio.gather(*tasks)
+
+    async def _start_server(self, name: str, svr_config: dict):
+        """Start a single MCP server and register its session."""
+        cmd = svr_config.get("command")
+        args = svr_config.get("args", [])
+        env = svr_config.get("env", None)
+
+        server_params = StdioServerParameters(
+            command=cmd,
+            args=args,
+            env={**os.environ.copy(), **env} if env else None
+        )
+
+        try:
+            read_stream, write_stream = await self._exit_stack.enter_async_context(
+                stdio_client(server_params)
+            )
+            session = await self._exit_stack.enter_async_context(
+                ClientSession(read_stream, write_stream)
+            )
+
+            await session.initialize()
+            self.sessions[name] = session
+        except Exception as e:
+            print(f"[Warning] Failed to start MCP server '{name}': {e}")
+
+    async def discover_tools(self) -> int:
+        """Fetch all tools from connected servers and populate the catalog.
+
+        Returns the number of tools discovered.
+        """
+        async def _fetch(server_name: str, session: ClientSession) -> list[McpToolEntry]:
+            try:
+                result = await session.list_tools()
+                entries = []
+                for tool in result.tools:
+                    safe_name = f"{server_name}__{tool.name}".replace("-", "_")
+                    entries.append(McpToolEntry(
+                        name=safe_name,
+                        description=f"[{server_name}] {tool.description or ''}",
+                        parameters=tool.inputSchema,
+                        server_name=server_name,
+                        original_name=tool.name,
+                        session=session,
+                    ))
+                return entries
+            except Exception as e:
+                print(f"[Warning] Failed to fetch tools from MCP server '{server_name}': {e}")
+                return []
+
+        results = await asyncio.gather(
+            *[_fetch(name, sess) for name, sess in self.sessions.items()]
+        )
+        for entries in results:
+            for entry in entries:
+                self.catalog[entry.name] = entry
+
+        return len(self.catalog)
+
+    async def call_tool(self, tool_name: str, arguments: dict | None = None) -> str:
+        """Execute an MCP tool by its safe name."""
+        entry = self.catalog.get(tool_name)
+        if entry is None:
+            available = ", ".join(sorted(self.catalog.keys()))
+            return f"Error: Unknown MCP tool '{tool_name}'. Available: {available}"
+
+        try:
+            result = await entry.session.call_tool(entry.original_name, arguments=arguments or {})
+            output = []
+            for content in result.content:
+                if hasattr(content, "text"):
+                    output.append(content.text)
+            if result.isError:
+                return f"Error from {entry.original_name}: " + "\n".join(output)
+            return "\n".join(output)
+        except Exception as e:
+            return f"Error executing {entry.original_name} on {entry.server_name}: {e}"
+
+    def get_catalog_text(self) -> str:
+        """Build a lightweight text catalog of available MCP tools.
+
+        This text is injected into the system prompt so the model knows
+        which tools exist — without the cost of full JSON Schema per tool.
+        """
+        if not self.catalog:
+            return ""
+
+        lines = ["## MCP Tools (external)\n"]
+        lines.append("Call these via `use_mcp_tool(tool_name=\"<name>\", arguments={...})`.\n")
+
+        # Group by server
+        by_server: dict[str, list[McpToolEntry]] = {}
+        for entry in self.catalog.values():
+            by_server.setdefault(entry.server_name, []).append(entry)
+
+        for server, entries in sorted(by_server.items()):
+            lines.append(f"### {server}")
+            for entry in sorted(entries, key=lambda e: e.name):
+                desc = entry.description.split("] ", 1)[-1] if "] " in entry.description else entry.description
+                # Include parameter names as hints
+                props = entry.parameters.get("properties", {})
+                if props:
+                    param_hints = ", ".join(props.keys())
+                    lines.append(f"- `{entry.name}({param_hints})`: {desc}")
+                else:
+                    lines.append(f"- `{entry.name}()`: {desc}")
+            lines.append("")
+
+        return "\n".join(lines)
+
+    def get_eager_tools(self) -> list[Function]:
+        """Create individual Agno Functions for each MCP tool (legacy eager mode)."""
+        functions = []
+        for entry in self.catalog.values():
+            async def mcp_caller(*, _entry=entry, **kwargs) -> str:
+                return await self.call_tool(_entry.name, kwargs)
+
+            mcp_caller.__name__ = entry.name
+
+            functions.append(Function(
+                name=entry.name,
+                description=entry.description,
+                parameters=entry.parameters,
+                entrypoint=mcp_caller,
+            ))
+        return functions
+
+    # -- Backward-compatible API (used by tests and eager mode) --
+
+    async def get_tools(self) -> list[Function]:
+        """Fetch tools and return as Agno Functions (legacy API).
+
+        Calls discover_tools() if catalog is empty, then returns eager functions.
+        """
+        if not self.catalog:
+            await self.discover_tools()
+        return self.get_eager_tools()
+
+    def _create_agno_function(self, server_name: str, session: ClientSession, tool) -> Function:
+        """Create a single Agno Function from an MCP tool (legacy API)."""
+        safe_name = f"{server_name}__{tool.name}".replace("-", "_")
+        description = f"[{server_name}] {tool.description or ''}"
+        original_name = tool.name
+
+        async def mcp_caller(**kwargs) -> str:
+            try:
+                result = await session.call_tool(original_name, arguments=kwargs)
+                output = []
+                for content in result.content:
+                    if hasattr(content, "text"):
+                        output.append(content.text)
+                if result.isError:
+                    return f"Error from {original_name}: " + "\n".join(output)
+                return "\n".join(output)
+            except Exception as e:
+                return f"Error executing {original_name} on {server_name}: {e}"
+
+        mcp_caller.__name__ = safe_name
+
+        return Function(
+            name=safe_name,
+            description=description,
+            parameters=tool.inputSchema,
+            entrypoint=mcp_caller,
+        )
+
+    async def cleanup(self):
+        """Close all active MCP client sessions and terminate server subprocesses."""
+        try:
+            await self._exit_stack.aclose()
+        except (RuntimeError, Exception):
+            pass
+
+
+# Global Singleton manager to be used entirely inside aru's async loops
+_manager: McpSessionManager | None = None
+
+
+async def init_mcp() -> McpSessionManager | None:
+    """Initialize MCP servers, discover tools, and return the manager.
+
+    Returns None if no MCP config is found.
+    """
+    global _manager
+    if _manager is None:
+        config_path = None
+        for path in [
+            ".aru/mcp_servers.json",
+            "aru.mcp.json",
+            ".mcp.json",
+            "mcp.json"
+        ]:
+            if os.path.exists(path):
+                config_path = path
+                break
+
+        if config_path:
+            _manager = McpSessionManager(config_path=config_path)
+            await _manager.initialize()
+            await _manager.discover_tools()
+        else:
+            _manager = McpSessionManager(config_path="")
+            return None
+
+    return _manager
+
+
+def get_mcp_manager() -> McpSessionManager | None:
+    """Return the global MCP manager (None if not initialized)."""
+    return _manager
+
+
+async def cleanup_mcp():
+    """Cleanup global manager."""
+    global _manager
+    if _manager:
+        await _manager.cleanup()
+        _manager = None

{aru_code-0.11.2 → aru_code-0.12.0/aru_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.11.2
+Version: 0.12.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

{aru_code-0.11.2 → aru_code-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aru-code"
-version = "0.11.2"
+version = "0.12.0"
 description = "A Claude Code clone built with Agno agents"
 readme = "README.md"
 license = "MIT"

{aru_code-0.11.2 → aru_code-0.12.0}/tests/test_config.py

@@ -109,11 +109,11 @@ class TestDataClasses:
         result = config.get_extra_instructions()
         assert result == ""
 
-    def test_agent_config_get_extra_instructions_readme_only(self):
+    def test_agent_config_get_extra_instructions_readme_not_included(self):
+        """README.md is no longer included in the system prompt by default."""
         config = AgentConfig(readme_md="# My Project\n\nDescription")
         result = config.get_extra_instructions()
-        assert "## Project Overview (README.md)" in result
-        assert "# My Project" in result
+        assert "README" not in result
 
     def test_agent_config_get_extra_instructions_agents_md_only(self):
         config = AgentConfig(agents_md="Follow these rules")

{aru_code-0.11.2 → aru_code-0.12.0}/tests/test_mcp_client.py

@@ -996,15 +996,14 @@ class TestGlobalFunctions:
         """Test init_mcp when no config file exists."""
         # Change to temp directory with no config files
         monkeypatch.chdir(tmp_path)
-        
+
         # Reset global manager
         import aru.tools.mcp_client as mcp_module
         mcp_module._manager = None
-        
-        tools = await init_mcp()
-        
-        assert tools == []
-        assert mcp_module._manager is not None
+
+        result = await init_mcp()
+
+        assert result is None
 
     @pytest.mark.asyncio
     async def test_init_mcp_with_config(self, tmp_path, monkeypatch):
@@ -1021,12 +1020,12 @@ class TestGlobalFunctions:
         mcp_module._manager = None
         
         with patch.object(McpSessionManager, 'initialize', new_callable=AsyncMock) as mock_init, \
-             patch.object(McpSessionManager, 'get_tools', new_callable=AsyncMock, return_value=[]):
-            
-            tools = await init_mcp()
-            
+             patch.object(McpSessionManager, 'discover_tools', new_callable=AsyncMock, return_value=0):
+
+            result = await init_mcp()
+
             mock_init.assert_called_once()
-            assert isinstance(tools, list)
+            assert isinstance(result, McpSessionManager)
 
     @pytest.mark.asyncio
     async def test_init_mcp_config_priority(self, tmp_path, monkeypatch):
@@ -1043,10 +1042,10 @@ class TestGlobalFunctions:
         mcp_module._manager = None
         
         with patch.object(McpSessionManager, 'initialize', new_callable=AsyncMock), \
-             patch.object(McpSessionManager, 'get_tools', new_callable=AsyncMock, return_value=[]):
-            
+             patch.object(McpSessionManager, 'discover_tools', new_callable=AsyncMock, return_value=0):
+
             await init_mcp()
-            
+
             # Should use .aru/mcp_servers.json (first in priority)
             assert mcp_module._manager.config_path == ".aru/mcp_servers.json"
 
@@ -1060,16 +1059,16 @@ class TestGlobalFunctions:
         mcp_module._manager = None
         
         with patch.object(McpSessionManager, 'initialize', new_callable=AsyncMock), \
-             patch.object(McpSessionManager, 'get_tools', new_callable=AsyncMock, return_value=[]):
-            
+             patch.object(McpSessionManager, 'discover_tools', new_callable=AsyncMock, return_value=0):
+
             # First call
             await init_mcp()
             first_manager = mcp_module._manager
-            
+
             # Second call
             await init_mcp()
             second_manager = mcp_module._manager
-            
+
             # Should be the same instance
             assert first_manager is second_manager
 
@@ -1122,12 +1121,12 @@ class TestGlobalFunctions:
         mcp_module._manager = None
         
         with patch.object(McpSessionManager, '_start_server', new_callable=AsyncMock), \
-             patch.object(McpSessionManager, 'get_tools', new_callable=AsyncMock, return_value=[]):
-            
+             patch.object(McpSessionManager, 'discover_tools', new_callable=AsyncMock, return_value=0):
+
             # Initialize
-            tools = await init_mcp()
+            result = await init_mcp()
             assert mcp_module._manager is not None
-            
+
             # Cleanup
             await cleanup_mcp()
             assert mcp_module._manager is None

aru_code-0.11.2/aru/__init__.py

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

aru_code-0.11.2/aru/tools/mcp_client.py

@@ -1,158 +0,0 @@
-"""Model Context Protocol (MCP) client manager and tool generation."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-from contextlib import AsyncExitStack
-
-from agno.tools import Function
-from mcp.client.stdio import stdio_client, StdioServerParameters
-from mcp.client.session import ClientSession
-
-
-class McpSessionManager:
-    """Manages MCP server subprocesses and active client sessions."""
-
-    def __init__(self, config_path: str = "arc.mcp.json"):
-        self.config_path = config_path
-        self._exit_stack = AsyncExitStack()
-        self.sessions: dict[str, ClientSession] = {}
-        
-    async def initialize(self):
-        """Read config and spawn all MCP servers concurrently."""
-        if not os.path.exists(self.config_path):
-            return
-
-        with open(self.config_path, "r", encoding="utf-8") as f:
-            try:
-                config = json.load(f)
-            except json.JSONDecodeError:
-                print(f"[Warning] Failed to parse {self.config_path}")
-                return
-
-        servers = config.get("mcpServers", {})
-        tasks = []
-        for name, svr_config in servers.items():
-            cmd = svr_config.get("command")
-            if not cmd:
-                continue
-            tasks.append(self._start_server(name, svr_config))
-
-        if tasks:
-            await asyncio.gather(*tasks)
-
-    async def _start_server(self, name: str, svr_config: dict):
-        """Start a single MCP server and register its session."""
-        cmd = svr_config.get("command")
-        args = svr_config.get("args", [])
-        env = svr_config.get("env", None)
-
-        server_params = StdioServerParameters(
-            command=cmd,
-            args=args,
-            env={**os.environ.copy(), **env} if env else None
-        )
-
-        try:
-            read_stream, write_stream = await self._exit_stack.enter_async_context(
-                stdio_client(server_params)
-            )
-            session = await self._exit_stack.enter_async_context(
-                ClientSession(read_stream, write_stream)
-            )
-
-            await session.initialize()
-            self.sessions[name] = session
-        except Exception as e:
-            print(f"[Warning] Failed to start MCP server '{name}': {e}")
-
-    async def get_tools(self) -> list[Function]:
-        """Fetch all tools from connected servers concurrently and convert to Agno Functions."""
-
-        async def _fetch(server_name: str, session: ClientSession) -> list[Function]:
-            try:
-                result = await session.list_tools()
-                return [self._create_agno_function(server_name, session, tool) for tool in result.tools]
-            except Exception as e:
-                print(f"[Warning] Failed to fetch tools from MCP server '{server_name}': {e}")
-                return []
-
-        results = await asyncio.gather(
-            *[_fetch(name, sess) for name, sess in self.sessions.items()]
-        )
-        return [tool for tools in results for tool in tools]
-
-    def _create_agno_function(self, server_name: str, session: ClientSession, tool) -> Function:
-        """Dynamically create an Agno Function that routes to the remote MCP tool."""
-        
-        # We need to capture 'session' and 'tool.name' cleanly.
-        # Python's default arguments trick captures loop variables.
-        async def mcp_caller(**kwargs) -> str:
-            try:
-                result = await session.call_tool(tool.name, arguments=kwargs)
-                # Parse MCP ToolResultContent
-                output = []
-                for content in result.content:
-                    if hasattr(content, "text"):
-                        output.append(content.text)
-                if result.isError:
-                    return f"Error from {tool.name}: " + "\n".join(output)
-                return "\n".join(output)
-            except Exception as e:
-                return f"Error executing {tool.name} on {server_name}: {e}"
-
-        # Assign __name__ to the callable for Agno's internal representation
-        safe_name = f"{server_name}__{tool.name}".replace("-", "_")
-        mcp_caller.__name__ = safe_name
-
-        return Function(
-            name=safe_name,
-            description=f"[{server_name}] {tool.description or ''}",
-            parameters=tool.inputSchema,
-            entrypoint=mcp_caller
-        )
-
-    async def cleanup(self):
-        """Close all active MCP client sessions and terminate server subprocesses."""
-        try:
-            await self._exit_stack.aclose()
-        except (RuntimeError, Exception):
-            pass
-
-
-# Global Singleton manager to be used entirely inside aru's async loops
-_manager: McpSessionManager | None = None
-
-async def init_mcp() -> list[Function]:
-    """Initialize MCP servers and return the loaded Agno functions."""
-    global _manager
-    if _manager is None:
-        config_path = None
-        for path in [
-            ".aru/mcp_servers.json",
-            "aru.mcp.json",
-            ".mcp.json",
-            "mcp.json"
-        ]:
-            if os.path.exists(path):
-                config_path = path
-                break
-                
-        if config_path:
-            _manager = McpSessionManager(config_path=config_path)
-            await _manager.initialize()
-        else:
-            # Create an empty manager so cleanup doesn't fail, but return no tools
-            _manager = McpSessionManager(config_path="")
-            return []
-    
-    return await _manager.get_tools()
-
-async def cleanup_mcp():
-    """Cleanup global manager."""
-    global _manager
-    if _manager:
-        await _manager.cleanup()
-        _manager = None