cecli-dev 0.100.12rc2__tar.gz → 0.100.12rc5__tar.gz

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.12rc2
+Version: 0.100.12rc5
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.12rc2'
-__version_tuple__ = version_tuple = (0, 100, 12, 'rc2')
+__version__ = version = '0.100.12rc5'
+__version_tuple__ = version_tuple = (0, 100, 12, 'rc5')
 
-__commit_id__ = commit_id = 'g221e9f433'
+__commit_id__ = commit_id = 'g7a6568913'

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/args.py

@@ -132,6 +132,15 @@ def get_parser(default_config_files, git_root):
             "Specify a file with model tag overrides (e.g., gpt-4o:high -> reasoning_effort: high)"
         ),
     ).complete = shtab.FILE
+    group.add_argument(
+        "--model-providers",
+        metavar="MODEL_PROVIDERS_JSON",
+        help=(
+            "Specify custom OpenAI-compatible model providers as a JSON/YAML string (e.g.,"
+            ' \'{"my-provider": {"api_base": "https://...", "api_key_env": ["MY_KEY"]}}\')'
+        ),
+        default=None,
+    )
     group.add_argument(
         "--reasoning-effort",
         type=str,

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/coders/agent_coder.py

@@ -165,6 +165,7 @@ class AgentCoder(Coder):
         config["command_timeout"] = nested.getter(config, "command_timeout", 30)
         config["allowed_commands"] = nested.getter(config, "allowed_commands", [])
         config["hot_reload"] = nested.getter(config, "hot_reload", False)
+        config["diff_colors"] = nested.getter(config, "diff_colors", True)
         config["allow_nested_delegation"] = nested.getter(config, "allow_nested_delegation", False)
 
         config["tools_paths"] = nested.getter(config, ["tools_paths", "tool_paths"], [])

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/commands/clear.py

@@ -25,10 +25,9 @@ class ClearCommand(BaseCommand):
 
         # Clear TUI output if available
         if coder.tui and coder.tui():
-            coder.tui().action_clear_output()
+            coder.tui().call_later(coder.tui().action_clear_output)
 
-        io.tool_output("All chat history cleared.")
-        return format_command_result(io, "clear", "Cleared chat history")
+        return format_command_result(io, "clear", "All chat history cleared.")
 
     @classmethod
     def get_completions(cls, io, coder, args) -> List[str]:

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/commands/reset.py

@@ -29,7 +29,7 @@ class ResetCommand(BaseCommand):
 
             # Clear TUI output if available
             if coder.tui and coder.tui():
-                coder.tui().action_clear_output()
+                coder.tui().call_later(coder.tui().action_clear_output)
             else:
                 io.tool_output("All files dropped and chat history cleared.")
 

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/helpers/hashline.py

@@ -409,6 +409,7 @@ def get_hashline_diff(
     end_line_hash,
     operation,
     text=None,
+    pretty=False,
 ):
     """
     Generate a diff for a hashline operation in the format used by the original format_output.
@@ -420,6 +421,8 @@ def get_hashline_diff(
         end_line_hash: Hashline format for end line: "{4 char hash}" (without the braces)
         operation: One of "replace", "insert", or "delete"
         text: Text to insert or replace with (required for replace/insert operations)
+        pretty: When True, color removed lines in magenta (\x1b[95m) and added lines
+               in light green (\033[32m). When False, all diff lines use \033[92m.
 
     Returns:
         str: A formatted diff snippet showing changes, or empty string if no changes
@@ -523,7 +526,18 @@ def get_hashline_diff(
     diff_lines = list(diff)[2:]
 
     if diff_lines:
-        return "\n".join([line for line in diff_lines])
+        if pretty:
+            colored_lines = []
+            for line in diff_lines:
+                if line.startswith("-"):
+                    colored_lines.append(f"\033[38;5;96m{line}\x1b[0m")
+                elif line.startswith("+"):
+                    colored_lines.append(f"\033[32m{line}\x1b[0m")
+                else:
+                    colored_lines.append(line)
+            return "\n".join(colored_lines)
+        else:
+            return "\n".join([line for line in diff_lines])
     else:
         return ""
 

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/helpers/model_providers.py

@@ -289,6 +289,16 @@ class ModelProviderManager:
     def set_verify_ssl(self, verify_ssl: bool) -> None:
         self.verify_ssl = verify_ssl
 
+    def merge_provider_configs(self, user_configs: Dict[str, Dict]) -> None:
+        """Merge user-defined provider configs into the existing provider configs."""
+        for slug, cfg in user_configs.items():
+            if slug in self.provider_configs:
+                self.provider_configs[slug] = _deep_merge(self.provider_configs[slug], cfg)
+            else:
+                self.provider_configs[slug] = deepcopy(cfg)
+                self._provider_cache[slug] = None
+                self._cache_loaded[slug] = False
+
     def supports_provider(self, provider: Optional[str]) -> bool:
         return bool(provider and provider in self.provider_configs)
 
@@ -571,6 +581,12 @@ class ModelProviderManager:
         return None
 
 
+def register_user_providers_with_litellm(user_configs: Dict[str, Dict]) -> None:
+    """Register user-defined providers with LiteLLM for custom handler support."""
+    for slug, cfg in user_configs.items():
+        _register_provider_with_litellm(slug, cfg)
+
+
 def ensure_litellm_providers_registered() -> None:
     """One-time registration guard for LiteLLM provider metadata."""
     global _PROVIDERS_REGISTERED

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/helpers/skills.py

@@ -69,7 +69,7 @@ class SkillsManager:
         # Always include the default skills directory in the user's home
         default_skill_dir = str(Path.home() / ".cecli" / "skills")
         if default_skill_dir not in directory_paths:
-            directory_paths = list(directory_paths) + [default_skill_dir]
+            directory_paths = [default_skill_dir] + list(directory_paths)
 
         self.directory_paths = [Path(p).expanduser().resolve() for p in directory_paths]
         self.include_list = set(include_list) if include_list else None

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/hooks/__init__.py

@@ -1,6 +1,7 @@
 """Hooks module for extending cecli functionality."""
 
 from .base import BaseHook, CommandHook
+from .helpers import HookHelpers
 from .integration import HookIntegration
 from .manager import HookManager
 from .registry import HookRegistry
@@ -10,6 +11,7 @@ from .types import METADATA_TEMPLATES, HookType
 __all__ = [
     "BaseHook",
     "CommandHook",
+    "HookHelpers",
     "HookIntegration",
     "HookManager",
     "HookRegistry",

cecli_dev-0.100.12rc5/cecli/hooks/helpers.py

@@ -0,0 +1,188 @@
+"""Helpers for writing Python hooks.
+
+Provides a higher-level API for accessing conversation history, making model
+calls, and working with sub-agents from within hook implementations.
+
+Typical usage::
+
+    from cecli.hooks import HookHelpers
+
+    class MyHook(BaseHook):
+        type = HookType.POST_TOOL
+
+        async def execute(self, coder, metadata):
+            recent = HookHelpers.get_messages(coder, last_n=5)
+            reply = await HookHelpers.call(coder, prompt="Summarize the above.")
+            HookHelpers.append_message(coder, {"role": "assistant", "content": reply})
+            summary = await HookHelpers.call_subagent(
+                coder, "reviewer", "Review these changes"
+            )
+            return True
+"""
+
+from typing import Any, Dict, List, Optional
+
+
+class HookHelpers:
+    """Collection of static helper methods for Python hooks.
+
+    All methods receive the ``coder`` instance as their first argument
+    so they can access conversation history, make model calls, and
+    invoke sub-agents on behalf of the agent running the hook.
+    """
+
+    @staticmethod
+    def get_messages(
+        coder: Any,
+        last_n: Optional[int] = None,
+        tag: Optional[str] = None,
+        reload: bool = False,
+    ) -> List[Dict[str, Any]]:
+        """Retrieve conversation messages for the given coder.
+
+        This is a convenience wrapper around
+        ``ConversationService.get_manager(coder).get_messages_dict()``.
+
+        Args:
+            coder: The coder instance (passed to hook's ``execute()``).
+            last_n: If set, return only the *last_n* messages (most recent first).
+            tag: Optional tag to filter by (e.g. ``"cur"``, ``"done"``).
+                 If ``None``, returns all messages.
+            reload: If ``True``, bypass the internal cache.
+
+        Returns:
+            A list of message dicts sorted by priority then timestamp,
+            each with keys ``role``, ``content``, etc.
+        """
+        from cecli.helpers.conversation.service import ConversationService
+
+        manager = ConversationService.get_manager(coder)
+        messages = manager.get_messages_dict(tag=tag, reload=reload)
+
+        if last_n is not None and last_n > 0:
+            messages = messages[-last_n:]
+
+        return messages
+
+    @staticmethod
+    def append_message(
+        coder: Any,
+        message_dict: Dict[str, Any],
+        tag: str = "cur",
+        **kwargs: Any,
+    ) -> Any:
+        """Append a message to the coder's conversation history.
+
+        This is a convenience wrapper around
+        ``ConversationService.get_manager(coder).add_message()``.
+
+        Args:
+            coder: The coder instance (passed to hook's ``execute()``).
+            message_dict: The message content dict (e.g.
+                ``{"role": "user", "content": "..."}``).
+            tag: Message tag to use (default ``"cur"``).
+            **kwargs: Additional keyword arguments forwarded to
+                ``add_message()``, such as ``hash_key``, ``force``,
+                ``priority``, ``promotion``, etc.
+
+        Returns:
+            The ``BaseMessage`` instance that was created or updated.
+        """
+        from cecli.helpers.conversation.service import ConversationService
+
+        return ConversationService.get_manager(coder).add_message(
+            message_dict=message_dict,
+            tag=tag,
+            **kwargs,
+        )
+
+    @staticmethod
+    async def call(
+        coder: Any,
+        messages: Optional[List[Dict[str, Any]]] = None,
+        prompt: Optional[str] = None,
+        system: Optional[str] = None,
+        model_name: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        **kwargs: Any,
+    ) -> Optional[str]:
+        """Make a language model generation call.
+
+        You can provide ``messages`` directly (a list of message dicts), or
+        use ``prompt`` (with an optional ``system`` message) to build a
+        simple user/assistant exchange.
+
+        Args:
+            coder: The coder instance (passed to hook's ``execute()``).
+            messages: A list of message dicts (``{"role": ..., "content": ...}``).
+                If provided, ``prompt`` and ``system`` are ignored.
+            prompt: A simple user prompt string.  Ignored if ``messages`` is set.
+            system: An optional system prompt.  Only used when ``prompt`` is set
+                and ``messages`` is ``None``.
+            model_name: Override the model to use (e.g. ``"gpt-4o"``).
+                If ``None``, uses ``coder.main_model``.
+            max_tokens: Maximum tokens for the response.
+            **kwargs: Additional keyword arguments forwarded to
+                ``Model.simple_send_with_retries()``.
+
+        Returns:
+            The generated text content, or ``None`` on failure.
+        """
+        from cecli.models import Model
+
+        if messages is None:
+            msgs: List[Dict[str, Any]] = []
+            if system:
+                msgs.append({"role": "system", "content": system})
+            if prompt:
+                msgs.append({"role": "user", "content": prompt})
+            messages = msgs
+
+        if not messages:
+            return None
+
+        if model_name:
+            model = Model(
+                model_name,
+                from_model=coder.main_model,
+            )
+        else:
+            model = coder.main_model
+
+        return await model.simple_send_with_retries(
+            messages=messages,
+            max_tokens=max_tokens,
+            coder=coder,
+            override_kwargs=kwargs,
+        )
+
+    @staticmethod
+    async def call_subagent(
+        coder: Any,
+        name: str,
+        prompt: str,
+        **kwargs: Any,
+    ) -> Optional[str]:
+        """Invoke a sub-agent by name with the given prompt (blocking).
+
+        This is a convenience wrapper around
+        ``AgentService.get_instance(coder).invoke()``.
+
+        Args:
+            coder: The coder instance (passed to hook's ``execute()``).
+            name: The registered name of the sub-agent (e.g.
+                ``"reviewer"``, ``"tester"``).
+            prompt: The user message to pass to the sub-agent.
+            **kwargs: Additional keyword arguments forwarded to
+                ``AgentService.invoke()``, such as ``blocking``,
+                ``parent``, ``auto_reap``.
+
+        Returns:
+            The sub-agent's summary string, or ``None`` if it failed or
+            was invoked non-blocking.
+        """
+        from cecli.helpers.agents.service import AgentService
+
+        agent_service = AgentService.get_instance(coder)
+
+        return await agent_service.invoke(name, prompt, **kwargs)

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/llm.py

@@ -53,7 +53,11 @@ class LazyLiteLLM:
         self._lazy_module.suppress_debug_info = True
         self._lazy_module.set_verbose = False
         self._lazy_module.drop_params = True
-        self._lazy_module._logging._disable_debugging()
+        try:
+            self._lazy_module._logging._disable_debugging()
+        except AttributeError:
+            # litellm >= 1.62.0 removed the _logging module
+            pass
 
         # Make sure JSON-based OpenAI-compatible providers are registered
         ensure_litellm_providers_registered()

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/main.py

@@ -311,6 +311,12 @@ def load_dotenv_files(git_root, dotenv_fname, encoding="utf-8"):
     if oauth_keys_file.exists():
         dotenv_files.insert(0, str(oauth_keys_file.resolve()))
         dotenv_files = list(dict.fromkeys(dotenv_files))
+
+    # Also check ~/.cecli/.env as a default dotenv file (lowest priority)
+    cecli_env_file = Path.home() / ".cecli" / ".env"
+    if cecli_env_file.exists():
+        dotenv_files.insert(0, str(cecli_env_file.resolve()))
+        dotenv_files = list(dict.fromkeys(dotenv_files))
     loaded = []
     for fname in dotenv_files:
         try:
@@ -623,6 +629,8 @@ async def main_async(
         args.hooks = convert_yaml_to_json_string(args.hooks)
     if hasattr(args, "workspaces") and args.workspaces is not None:
         args.workspaces = convert_yaml_to_json_string(args.workspaces)
+    if hasattr(args, "model_providers") and args.model_providers is not None:
+        args.model_providers = convert_yaml_to_json_string(args.model_providers)
 
     # Interpolate environment variables in all string arguments
     for key, value in vars(args).items():
@@ -856,6 +864,23 @@ async def main_async(
     await check_and_load_imports(io, is_first_run, verbose=args.verbose)
     register_models(git_root, args.model_settings_file, io, verbose=args.verbose)
     register_litellm_models(git_root, args.model_metadata_file, io, verbose=args.verbose)
+    if args.model_providers:
+        try:
+            user_providers = json.loads(args.model_providers)
+            if isinstance(user_providers, dict):
+                models.model_info_manager.provider_manager.merge_provider_configs(user_providers)
+                from cecli.helpers.model_providers import (
+                    register_user_providers_with_litellm,
+                )
+
+                register_user_providers_with_litellm(user_providers)
+                if args.verbose:
+                    io.tool_output(f"Loaded {len(user_providers)} custom model provider(s):")
+                    for slug in user_providers:
+                        io.tool_output(f"  - {slug}")
+        except json.JSONDecodeError as e:
+            io.tool_error(f"Failed to parse --model-providers JSON: {e}")
+
     if args.list_models:
         models.print_matching_models(io, args.list_models)
         return await graceful_exit(None)

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/mcp/manager.py

@@ -48,6 +48,36 @@ class McpServerManager:
         if self.io:
             self.io.tool_warning(message)
 
+    @staticmethod
+    def _validate_server_config(config: dict) -> dict:
+        """
+        Validate keepalive_interval in the server configuration.
+
+        Args:
+            config: Server configuration dictionary
+
+        Returns:
+            The validated configuration dictionary
+
+        Raises:
+            ValueError: If keepalive_interval is invalid
+        """
+        keepalive_interval = config.get("keepalive_interval")
+
+        if keepalive_interval is not None:
+            if not isinstance(keepalive_interval, int) or isinstance(keepalive_interval, bool):
+                raise ValueError(
+                    f"keepalive_interval must be an integer, got {type(keepalive_interval).__name__}"
+                )
+
+            if keepalive_interval < 5:
+                raise ValueError(f"keepalive_interval {keepalive_interval} is below minimum of 5")
+
+            if keepalive_interval > 300:
+                raise ValueError(f"keepalive_interval {keepalive_interval} is above maximum of 300")
+
+        return config
+
     @property
     def servers(self) -> list["McpServer"]:
         """Get the list of managed MCP servers."""

{cecli_dev-0.100.12rc2 → cecli_dev-0.100.12rc5}/cecli/mcp/server.py

@@ -1,8 +1,10 @@
 import asyncio
 import logging
 import os
+import random
 import webbrowser
 from contextlib import AsyncExitStack
+from enum import Enum, auto
 from urllib.parse import urlparse
 
 import httpx
@@ -20,6 +22,18 @@ from .oauth import (
     save_mcp_oauth_token,
 )
 
+MIN_KEEPALIVE_INTERVAL = 5
+MAX_KEEPALIVE_INTERVAL = 300
+FAILED_PING_THRESHOLD = 3
+
+logger = logging.getLogger(__name__)
+
+
+class ConnectionState(Enum):
+    CONNECTED = auto()
+    UNHEALTHY = auto()
+    DISCONNECTED = auto()
+
 
 class McpServer:
     """
@@ -120,6 +134,13 @@ class McpServer:
 class HttpBasedMcpServer(McpServer):
     """Base class for HTTP-based MCP servers (HTTP streaming and SSE)."""
 
+    def __init__(self, server_config, io=None, verbose=False):
+        super().__init__(server_config, io, verbose)
+        self._state: ConnectionState = ConnectionState.CONNECTED
+        self._failed_pings: int = 0
+        self._keepalive_task: asyncio.Task | None = None
+        self._http_client: httpx.AsyncClient | None = None
+
     async def _create_oauth_provider(self):
         """Create an OAuthClientProvider using the MCP SDK."""
         parsed = urlparse(self.config.get("url"))
@@ -228,6 +249,7 @@ class HttpBasedMcpServer(McpServer):
                     timeout=30,
                 )
             )
+            self._http_client = http_client
 
             transport = await self.exit_stack.enter_async_context(
                 self._create_transport(url, http_client=http_client)
@@ -238,9 +260,10 @@ class HttpBasedMcpServer(McpServer):
             session = await self.exit_stack.enter_async_context(ClientSession(read, write))
             await session.initialize()
             self.session = session
+            await self.start_keepalive()
             self._connection_loop = current_loop
 
-            if oauth_provider.context.oauth_metadata:
+            if oauth_provider is not None and oauth_provider.context.oauth_metadata:
                 token_endpoint = oauth_provider._get_token_endpoint()
                 server_info = get_mcp_oauth_token(self.name)
                 if "client_info" not in server_info:
@@ -249,17 +272,132 @@ class HttpBasedMcpServer(McpServer):
                 server_info["client_info"]["token_endpoint"] = token_endpoint
 
                 save_mcp_oauth_token(self.name, server_info)
-
-            return session
         except Exception as e:
             logging.error(f"Error initializing {self.name}: {e}")
             await self.disconnect()
             raise
 
-    async def disconnect(self):
+    async def start_keepalive(self):
+        """Start the background keepalive loop if configured."""
+        interval = self.config.get("keepalive_interval")
+        if interval is None:
+            return
+
+        try:
+            interval = int(interval)
+            if not (MIN_KEEPALIVE_INTERVAL <= interval <= MAX_KEEPALIVE_INTERVAL):
+                if self.verbose and self.io:
+                    self.io.tool_warning(
+                        f"Keepalive interval {interval} out of range ({MIN_KEEPALIVE_INTERVAL}-"
+                        f"{MAX_KEEPALIVE_INTERVAL}). Ignoring."
+                    )
+                return
+        except (ValueError, TypeError):
+            if self.verbose and self.io:
+                self.io.tool_warning(f"Invalid keepalive interval {interval}. Must be an integer.")
+            return
+
+        if self._keepalive_task and not self._keepalive_task.done():
+            self._keepalive_task.cancel()
+
+        self._keepalive_task = asyncio.create_task(self._keepalive_loop(interval))
+        logger.info(f"Keepalive task started for {self.name} (interval: {interval}s)")
+        if self.verbose and self.io:
+            self.io.tool_output(f"Started keepalive loop for {self.name} (interval: {interval}s)")
+
+    async def _keepalive_loop(self, interval: int):
+        """Background loop that sends periodic heartbeats to the MCP server."""
+        try:
+            while True:
+                # Jitter: ±10% to prevent timing analysis
+                jitter = interval * 0.1 * (2 * random.random() - 1)
+                await asyncio.sleep(interval + jitter)
+
+                if not self._http_client:
+                    continue
+
+                try:
+                    url = self.config.get("url")
+                    headers = self.config.get("headers", {})
+
+                    # Use OPTIONS request as a lightweight heartbeat
+                    response = await self._http_client.options(url, headers=headers)
+                    if response.status_code == 200:
+                        self._state = ConnectionState.CONNECTED
+                        self._failed_pings = 0
+                    else:
+                        raise httpx.HTTPStatusError(
+                            f"Unexpected status {response.status_code}",
+                            request=response.request,
+                            response=response,
+                        )
+                except Exception:
+                    self._failed_pings += 1
+                    if self._failed_pings >= FAILED_PING_THRESHOLD:
+                        self._state = ConnectionState.DISCONNECTED
+                        if self.verbose and self.io:
+                            self.io.tool_warning(
+                                f"MCP server {self.name} disconnected after {self._failed_pings} failed"
+                                " pings. Attempting reconnect..."
+                            )
+                        await self.reconnect()
+                    else:
+                        self._state = ConnectionState.UNHEALTHY
+                        if self.verbose and self.io:
+                            self.io.tool_output(
+                                f"MCP server {self.name} unhealthy (ping {self._failed_pings}/{FAILED_PING_THRESHOLD})"
+                            )
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logging.error(f"Keepalive loop for {self.name} crashed: {e}")
+
+    async def reconnect(self):
+        """Attempt to reconnect to the server using exponential backoff."""
+        initial_delay = 1
+        multiplier = 2
+        max_delay = 300
+
+        attempt = 0
+        while self._state == ConnectionState.DISCONNECTED:
+            delay = min(initial_delay * (multiplier**attempt), max_delay)
+            # Jitter: ±20%
+            jitter = delay * 0.2 * (2 * random.random() - 1)
+            await asyncio.sleep(delay + jitter)
+
+            try:
+                if self.verbose and self.io:
+                    self.io.tool_output(
+                        f"Attempting to reconnect to {self.name} (attempt {attempt + 1})..."
+                    )
+
+                # Clean up old session/client without cancelling the keepalive task
+                await self.disconnect(cancel_keepalive=False)
+                await self.connect()
+
+                self._state = ConnectionState.CONNECTED
+                self._failed_pings = 0
+                if self.verbose and self.io:
+                    self.io.tool_output(f"Successfully reconnected to {self.name}")
+                break
+            except Exception as e:
+                attempt += 1
+                if self.verbose and self.io:
+                    self.io.tool_warning(
+                        f"Reconnection attempt {attempt} failed for {self.name}: {e}"
+                    )
+
+    async def disconnect(self, cancel_keepalive: bool = True):
         """Disconnect from the MCP server and clean up resources."""
         async with self._cleanup_lock:
             try:
+                if cancel_keepalive and self._keepalive_task:
+                    self._keepalive_task.cancel()
+                    try:
+                        await asyncio.wait_for(self._keepalive_task, timeout=15)
+                    except asyncio.CancelledError:
+                        pass
+                    logger.info(f"Keepalive task stopped for {self.name}")
                 if hasattr(self, "_oauth_shutdown"):
                     self._oauth_shutdown()
                 await self.exit_stack.aclose()
@@ -271,6 +409,7 @@ class HttpBasedMcpServer(McpServer):
                 logging.error(f"Error during cleanup of server {self.name}: {e}")
             finally:
                 self.session = None
+                self._http_client = None
 
 
 class HttpStreamingServer(HttpBasedMcpServer):