devpilot-agentic-cli 1.0.0__py3-none-any.whl

agent/mcp_client.py

@@ -0,0 +1,104 @@
+"""
+agent/mcp_client.py
+───────────────────
+MCP Client Integration (Sprint 3).
+Connects to servers defined in mcp_servers.json, discovers tools,
+and registers them into the ToolRegistry.
+"""
+
+import json
+from contextlib import AsyncExitStack
+from pathlib import Path
+
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+from mcp.types import TextContent
+
+from agent.tools import ToolRegistry, ToolResult
+from agent.ui import UI
+
+
+class MCPManager:
+    """Manages connections to multiple MCP servers."""
+
+    def __init__(self, config_path: Path):
+        self.config_path = config_path
+        self.exit_stack = AsyncExitStack()
+        self.sessions: dict[str, ClientSession] = {}
+
+    async def connect_all(self, registry: ToolRegistry) -> None:
+        """Connect to all servers in mcp_servers.json and register tools."""
+        if not self.config_path.exists():
+            return
+
+        try:
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                servers = data.get("mcpServers", data.get("servers", {}))
+        except (json.JSONDecodeError, OSError) as e:
+            UI.print_error(f"Failed to read mcp_servers.json: {e}")
+            return
+
+        # Handle both list of dicts and dict of dicts formats for mcp_servers.json
+        if isinstance(servers, dict):
+            # In official MCP config format, it's a dict mapping name to config
+            server_items = servers.items()
+        else:
+            # Fallback if it's a list
+            server_items = [(s.get("name", f"server_{i}"), s) for i, s in enumerate(servers)]
+
+        for name, server_config in server_items:
+            if server_config.get("enabled", True) is False:
+                continue
+            
+            command = server_config.get("command")
+            args = server_config.get("args", [])
+
+            if not command:
+                UI.print_error(f"MCP server '{name}' missing 'command'. Skipping.")
+                continue
+
+            try:
+                server_params = StdioServerParameters(command=command, args=args, env=server_config.get("env"))
+                stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+                read, write = stdio_transport
+                session = await self.exit_stack.enter_async_context(ClientSession(read, write))
+                await session.initialize()
+
+                self.sessions[name] = session
+
+                # Fetch and register tools
+                tools_response = await session.list_tools()
+                for mcp_tool in tools_response.tools:
+                    # Convert to canonical schema format
+                    canonical_schema = {
+                        "name": mcp_tool.name,
+                        "description": mcp_tool.description or "",
+                        "input_schema": mcp_tool.inputSchema,
+                        "_mcp_server_id": name,
+                    }
+
+                    # Create closure for execution
+                    def make_executor(session_ref: ClientSession, tool_name: str):
+                        async def _executor(tool_input: dict) -> ToolResult:
+                            try:
+                                result = await session_ref.call_tool(tool_name, tool_input)
+                                # Flatten result text
+                                text_contents = [c.text for c in result.content if isinstance(c, TextContent)]
+                                output = "\n".join(text_contents)
+                                return ToolResult(output, is_error=result.isError)
+                            except Exception as e:
+                                return ToolResult(f"MCP execution error: {e}", is_error=True)
+                        return _executor
+
+                    registry.register_mcp_tool(canonical_schema, make_executor(session, mcp_tool.name))
+
+                UI.print_info(f"Connected to MCP server: {name} ({len(tools_response.tools)} tools)")
+            except Exception as e:
+                UI.print_error(f"Failed to connect to MCP server '{name}': {e}")
+                registry.deregister_mcp_tools(name)
+
+    async def close(self) -> None:
+        """Close all connections."""
+        await self.exit_stack.aclose()
+        self.sessions.clear()

agent/providers/__init__.py

@@ -0,0 +1,4 @@
+# Providers sub-package
+from agent.providers.base import BaseProvider, ProviderResponse, ToolUseBlock
+
+__all__ = ["BaseProvider", "ProviderResponse", "ToolUseBlock"]

agent/providers/anthropic_provider.py

@@ -0,0 +1,169 @@
+"""
+agent/providers/anthropic_provider.py
+───────────────────────────────────────
+Anthropic (Claude) model provider.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import anthropic
+
+from agent.config import Config
+from agent.providers.base import BaseProvider, ProviderResponse, ToolUseBlock
+from agent.providers.system_prompt import build_system_prompt
+
+_MAX_TOKENS = 16000
+_MAX_TOKENS_NO_THINKING = 8096
+_MAX_RETRIES = 3
+_RETRY_BASE_DELAY = 1.0
+
+
+class AnthropicProvider(BaseProvider):
+
+    def __init__(self, config: Config) -> None:
+        config.validate_api_key()
+        self._config = config
+        self._client = anthropic.AsyncAnthropic(api_key=config.active_api_key)
+
+    async def _create_with_retry(self, **kwargs: Any) -> anthropic.types.Message:
+        for attempt in range(_MAX_RETRIES + 1):
+            try:
+                return await self._client.messages.create(**kwargs)  # type: ignore[call-overload]
+            except (anthropic.RateLimitError, anthropic.APIStatusError) as exc:
+                if attempt == _MAX_RETRIES:
+                    raise
+                delay = _RETRY_BASE_DELAY * (2 ** attempt)
+                print(
+                    f"  [DevPilot] API error ({exc.__class__.__name__}), "
+                    f"retrying in {delay:.0f}s … (attempt {attempt + 1}/{_MAX_RETRIES})"
+                )
+                await asyncio.sleep(delay)
+        raise RuntimeError("Retry loop exited unexpectedly")
+
+    async def chat(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        system: str | None = None,
+    ) -> ProviderResponse:
+        kwargs: dict[str, Any] = dict(
+            model=self._config.model,
+            system=system or build_system_prompt(),
+            messages=messages,
+            tools=tools,
+        )
+
+        if self._config.extended_thinking:
+            kwargs["betas"] = ["interleaved-thinking-2025-05-14"]
+            kwargs["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": self._config.thinking_budget,
+            }
+            kwargs["max_tokens"] = max(_MAX_TOKENS, self._config.thinking_budget + 4096)
+        else:
+            kwargs["max_tokens"] = _MAX_TOKENS_NO_THINKING
+
+        response = await self._create_with_retry(**kwargs)
+
+        text: str | None = None
+        tool_uses: list[ToolUseBlock] = []
+        raw_content: list[dict] = []
+        thinking_text: str | None = None
+
+        for block in response.content:
+            if block.type == "thinking":
+                thinking_text = block.thinking
+                raw_content.append({"type": "thinking", "thinking": block.thinking})
+            elif block.type == "text":
+                text = block.text
+                raw_content.append({"type": "text", "text": block.text})
+            elif block.type == "tool_use":
+                tool_uses.append(
+                    ToolUseBlock(id=block.id, name=block.name, input=block.input)
+                )
+                raw_content.append(
+                    {"type": "tool_use", "id": block.id, "name": block.name, "input": block.input}
+                )
+
+        stop_reason = "tool_use" if tool_uses else (response.stop_reason or "end_turn")
+        return ProviderResponse(
+            text=text,
+            tool_uses=tool_uses,
+            stop_reason=stop_reason,
+            assistant_message={"role": "assistant", "content": raw_content},
+            thinking=thinking_text,
+        )
+
+    async def chat_stream(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        system: str | None = None,
+    ) -> ProviderResponse:
+        if self._config.extended_thinking:
+            return await self.chat(messages, tools, system=system)
+
+        from agent.ui import console
+
+        kwargs: dict[str, Any] = dict(
+            model=self._config.model,
+            max_tokens=_MAX_TOKENS_NO_THINKING,
+            system=system or build_system_prompt(),
+            messages=messages,
+            tools=tools,
+        )
+
+        try:
+            async with self._client.messages.stream(**kwargs) as stream:
+                from agent.ui import UI
+                if not getattr(UI, "_tui_app", None):
+                    console.print()
+
+                async for text_delta in stream.text_stream:
+                    UI.print_stream_token(text_delta)
+
+                if not getattr(UI, "_tui_app", None):
+                    console.print()
+                    console.print()
+
+                final = await stream.get_final_message()
+
+        except (anthropic.RateLimitError, anthropic.APIStatusError):
+            return await self.chat(messages, tools, system=system)
+
+        text = None
+        tool_uses = []
+        raw_content = []
+
+        for block in final.content:
+            if block.type == "text":
+                text = block.text
+                raw_content.append({"type": "text", "text": block.text})
+            elif block.type == "tool_use":
+                tool_uses.append(
+                    ToolUseBlock(id=block.id, name=block.name, input=block.input)
+                )
+                raw_content.append(
+                    {"type": "tool_use", "id": block.id, "name": block.name, "input": block.input}
+                )
+
+        stop_reason = "tool_use" if tool_uses else (final.stop_reason or "end_turn")
+        return ProviderResponse(
+            text=text,
+            tool_uses=tool_uses,
+            stop_reason=stop_reason,
+            assistant_message={"role": "assistant", "content": raw_content},
+            streamed_text=True,
+        )
+
+    def make_tool_result_message(self, tool_use_id: str, content: str, is_error: bool = False) -> dict:
+        return {
+            "role": "user",
+            "content": [{"type": "tool_result", "tool_use_id": tool_use_id, "content": content, "is_error": is_error}],
+        }
+
+    def make_user_message(self, text: str) -> dict:
+        return {"role": "user", "content": text}

agent/providers/base.py

@@ -0,0 +1,148 @@
+"""
+agent/providers/base.py
+────────────────────────
+Abstract interface and shared data types for all model providers.
+
+The agentic loop works exclusively with these types — it has zero knowledge
+of whether Anthropic, OpenAI, or any other provider is underneath.
+
+─── Canonical message format (stored in conversation history) ───────────────
+
+  User text message:
+    {"role": "user", "content": "some text"}
+
+  User message carrying tool results:
+    {"role": "user", "content": [
+        {
+          "type":        "tool_result",
+          "tool_use_id": "<id that matches the tool_use block>",
+          "content":     "<tool output string>",
+          "is_error":    False
+        }
+    ]}
+
+  Assistant message (text and/or tool calls):
+    {"role": "assistant", "content": [
+        {"type": "text",     "text": "..."},
+        {"type": "tool_use", "id": "...", "name": "...", "input": {...}}
+    ]}
+
+─── Canonical tool schema format (fed to the provider) ──────────────────────
+
+  {
+    "name":         "tool_name",
+    "description":  "What the tool does.",
+    "input_schema": {          ← Anthropic-style JSON Schema
+      "type": "object",
+      "properties": { ... },
+      "required":   [ ... ]
+    }
+  }
+
+  Providers that use a different schema format (e.g., OpenAI uses
+  "function.parameters") are responsible for converting internally.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+
+
+# ── Shared data types ─────────────────────────────────────────────────────────
+
+@dataclass
+class ToolUseBlock:
+    """A single tool invocation requested by the model."""
+    id: str       # Unique ID — used to pair with the tool_result
+    name: str     # Must match a tool name in the registry
+    input: dict   # Arguments the model wants to pass to the tool
+
+
+@dataclass
+class ProviderResponse:
+    """
+    Normalised response returned by every provider's chat() call.
+    The agentic loop reads only this object — never raw SDK types.
+    """
+    text: str | None                    # Prose text, if any
+    tool_uses: list[ToolUseBlock]       # Zero or more tool invocations
+    stop_reason: str                    # "end_turn" | "tool_use" | "max_tokens"
+    assistant_message: dict             # Ready-to-append canonical history entry
+    thinking: str | None = None         # Extended thinking inner monologue (Anthropic only)
+    streamed_text: bool = False         # True if the text was already printed live to stdout
+
+    @property
+    def has_tool_uses(self) -> bool:
+        """True when the model wants to call one or more tools."""
+        return len(self.tool_uses) > 0
+
+
+# ── Abstract provider interface ───────────────────────────────────────────────
+
+class BaseProvider(ABC):
+    """
+    Every model provider must implement this interface.
+    No other module should import SDK-specific types.
+    """
+
+    @abstractmethod
+    async def chat(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        system: str | None = None,
+    ) -> ProviderResponse:
+        """
+        Send the conversation to the model and return a normalised response.
+
+        Args:
+            messages : Full conversation history in canonical format.
+            tools    : Tool schemas in canonical (Anthropic-style) format.
+            system   : Optional system prompt override.
+
+        Returns:
+            ProviderResponse — text, tool_uses, stop_reason, assistant_message.
+        """
+        ...
+
+    async def chat_stream(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        system: str | None = None,
+    ) -> ProviderResponse:
+        """
+        Stream the model response, printing tokens to the console in real time,
+        then return the same ProviderResponse as chat().
+
+        Providers that don't support streaming should fall back to chat().
+        The default implementation does exactly that.
+        """
+        return await self.chat(messages, tools, system=system)
+
+    @abstractmethod
+    def make_tool_result_message(
+        self,
+        tool_use_id: str,
+        content: str,
+        is_error: bool = False,
+    ) -> dict:
+        """
+        Build the canonical history message that carries a tool's output back
+        to the model. This is appended to history immediately after a tool runs.
+
+        Args:
+            tool_use_id : The ID from the matching ToolUseBlock.
+            content     : The tool's output (stringified).
+            is_error    : True if the tool raised an exception.
+        """
+        ...
+
+    @abstractmethod
+    def make_user_message(self, text: str) -> dict:
+        """
+        Wrap a plain text string in a canonical user message dict.
+        Used to inject the initial task into the conversation.
+        """
+        ...

agent/providers/factory.py

@@ -0,0 +1,35 @@
+"""
+agent/providers/factory.py
+───────────────────────────
+Single factory function that reads config and instantiates
+the correct provider. All other modules use this instead of
+importing individual providers directly.
+"""
+
+from __future__ import annotations
+
+from agent.config import Config
+from agent.providers.base import BaseProvider
+
+
+def create_provider(config: Config) -> BaseProvider:
+    """
+    Instantiate and return the correct BaseProvider for the given config.
+
+    Raises:
+        ValueError  : If config.provider is not a recognised name.
+        ConfigError : If the provider's API key is missing (raised inside __init__).
+    """
+    # Import here (not at module level) to avoid loading unused SDKs
+    if config.provider == "anthropic":
+        from agent.providers.anthropic_provider import AnthropicProvider
+        return AnthropicProvider(config)
+
+    if config.provider == "openai":
+        from agent.providers.openai_provider import OpenAIProvider
+        return OpenAIProvider(config)
+
+    raise ValueError(
+        f"Unknown provider '{config.provider}'. "
+        "Valid options are: 'anthropic', 'openai'."
+    )

agent/providers/openai_provider.py

@@ -0,0 +1,194 @@
+"""
+agent/providers/openai_provider.py
+────────────────────────────────────
+OpenAI-compatible model provider.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, cast
+
+import openai
+from openai import AsyncOpenAI
+from openai.types.chat import ChatCompletion
+from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall
+
+from agent.config import Config
+from agent.providers.base import BaseProvider, ProviderResponse, ToolUseBlock
+from agent.providers.system_prompt import build_system_prompt
+
+_MAX_TOKENS = 4096
+_MAX_RETRIES = 3
+_RETRY_BASE_DELAY = 1.0
+
+_STOP_REASON_MAP: dict[str, str] = {
+    "stop":           "end_turn",
+    "tool_calls":     "tool_use",
+    "length":         "max_tokens",
+    "content_filter": "end_turn",
+}
+
+
+class OpenAIProvider(BaseProvider):
+
+    def __init__(self, config: Config) -> None:
+        config.validate_api_key()
+        self._config = config
+        self._client = AsyncOpenAI(api_key=config.active_api_key, base_url=config.base_url)
+
+    @staticmethod
+    def _to_openai_messages(messages: list[dict]) -> list[dict]:
+        result: list[dict] = []
+        for msg in messages:
+            role: str = msg["role"]
+            content: Any = msg["content"]
+
+            if isinstance(content, str):
+                result.append({"role": role, "content": content})
+                continue
+
+            if role == "assistant":
+                text_parts: list[str] = []
+                tool_calls: list[dict] = []
+                for block in content:
+                    if block["type"] == "text":
+                        text_parts.append(block["text"])
+                    elif block["type"] == "tool_use":
+                        tool_calls.append({
+                            "id": block["id"],
+                            "type": "function",
+                            "function": {"name": block["name"], "arguments": json.dumps(block["input"])},
+                        })
+                oai_msg: dict[str, Any] = {
+                    "role": "assistant",
+                    "content": " ".join(text_parts) if text_parts else None,
+                }
+                if tool_calls:
+                    oai_msg["tool_calls"] = tool_calls
+                result.append(oai_msg)
+
+            elif role == "user":
+                for block in content:
+                    if block["type"] == "tool_result":
+                        result.append({
+                            "role": "tool",
+                            "tool_call_id": block["tool_use_id"],
+                            "content": block["content"],
+                        })
+                    else:
+                        result.append({"role": "user", "content": block.get("text", "")})
+
+        return result
+
+    @staticmethod
+    def _to_openai_tools(tools: list[dict]) -> list[dict]:
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": t["name"],
+                    "description": t.get("description", ""),
+                    "parameters": t.get("input_schema", {}),
+                },
+            }
+            for t in tools
+        ]
+
+    async def _create_with_retry(self, **kwargs: Any) -> ChatCompletion:
+        for attempt in range(_MAX_RETRIES + 1):
+            try:
+                return cast(ChatCompletion, await self._client.chat.completions.create(**kwargs))
+            except (openai.RateLimitError, openai.APIStatusError) as exc:
+                if attempt == _MAX_RETRIES:
+                    raise
+                delay = _RETRY_BASE_DELAY * (2 ** attempt)
+                print(
+                    f"  [DevPilot] API error ({exc.__class__.__name__}), "
+                    f"retrying in {delay:.0f}s … (attempt {attempt + 1}/{_MAX_RETRIES})"
+                )
+                await asyncio.sleep(delay)
+        raise RuntimeError("Unreachable")
+
+    async def chat(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        system: str | None = None,
+    ) -> ProviderResponse:
+        oai_messages = self._to_openai_messages(messages)
+        oai_messages.insert(0, {"role": "system", "content": system or build_system_prompt()})
+
+        call_kwargs: dict[str, Any] = {
+            "model": self._config.model,
+            "max_completion_tokens": _MAX_TOKENS,
+            "messages": oai_messages,
+        }
+        oai_tools = self._to_openai_tools(tools)
+        if oai_tools:
+            call_kwargs["tools"] = oai_tools
+
+        response = await self._create_with_retry(**call_kwargs)
+        choice = response.choices[0]
+        oai_msg = choice.message
+
+        text: str | None = oai_msg.content or None
+        tool_uses: list[ToolUseBlock] = []
+        raw_content: list[dict] = []
+
+        if text:
+            raw_content.append({"type": "text", "text": text})
+
+        tool_calls = oai_msg.tool_calls
+        if tool_calls:
+            for tc in tool_calls:
+                tc_typed = cast(ChatCompletionMessageToolCall, tc)
+                fn_name: str = tc_typed.function.name
+                fn_args: str = tc_typed.function.arguments or "{}"
+                try:
+                    tool_input: dict = json.loads(fn_args)
+                except json.JSONDecodeError:
+                    tool_input = {}
+                tool_uses.append(ToolUseBlock(id=tc_typed.id, name=fn_name, input=tool_input))
+                raw_content.append(
+                    {"type": "tool_use", "id": tc_typed.id, "name": fn_name, "input": tool_input}
+                )
+        elif text:
+            # Fallback: detect JSON tool calls hallucinated inline by local models (e.g. Ollama)
+            try:
+                import re, uuid
+                match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
+                if match:
+                    potential_json, start_idx, end_idx = match.group(1), match.start(), match.end()
+                else:
+                    start_idx, end_idx = text.find("{"), text.rfind("}")
+                    potential_json = text[start_idx:end_idx + 1] if start_idx != -1 and end_idx > start_idx else ""
+
+                if potential_json:
+                    parsed = json.loads(potential_json)
+                    if isinstance(parsed, dict) and "name" in parsed and "arguments" in parsed:
+                        fake_id = f"call_{uuid.uuid4().hex[:8]}"
+                        tool_uses.append(ToolUseBlock(id=fake_id, name=parsed["name"], input=parsed.get("arguments", {})))
+                        raw_content.append(
+                            {"type": "tool_use", "id": fake_id, "name": parsed["name"], "input": parsed.get("arguments", {})}
+                        )
+            except Exception:
+                pass
+
+        stop_reason = _STOP_REASON_MAP.get(choice.finish_reason or "stop", "end_turn")
+        return ProviderResponse(
+            text=text,
+            tool_uses=tool_uses,
+            stop_reason=stop_reason,
+            assistant_message={"role": "assistant", "content": raw_content},
+        )
+
+    def make_tool_result_message(self, tool_use_id: str, content: str, is_error: bool = False) -> dict:
+        return {
+            "role": "user",
+            "content": [{"type": "tool_result", "tool_use_id": tool_use_id, "content": content, "is_error": is_error}],
+        }
+
+    def make_user_message(self, text: str) -> dict:
+        return {"role": "user", "content": text}