cecli-dev 1.1.0rc2__tar.gz → 1.1.0rc4__tar.gz

{cecli_dev-1.1.0rc2 → cecli_dev-1.1.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.1.0rc2
+Version: 1.1.0rc4
 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-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.0rc2'
-__version_tuple__ = version_tuple = (1, 1, 0, 'rc2')
+__version__ = version = '1.1.0rc4'
+__version_tuple__ = version_tuple = (1, 1, 0, 'rc4')
 
-__commit_id__ = commit_id = 'g08300992a'
+__commit_id__ = commit_id = 'gc405e1f0a'

{cecli_dev-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli/coders/agent_coder.py

@@ -27,7 +27,6 @@ from cecli.helpers.similarity import (
 )
 from cecli.helpers.skills import SkillsManager
 from cecli.hooks import HookIntegration
-from cecli.llm import litellm
 from cecli.mcp import LocalServer, McpServerManager
 from cecli.tools.utils.base_tool import BaseTool
 from cecli.tools.utils.registry import ToolRegistry
@@ -364,16 +363,12 @@ class AgentCoder(Coder):
             }
             try:
                 session = await server.connect()
-                call_result = await litellm.experimental_mcp_client.call_openai_tool(
-                    session=session, openai_tool=tool_call_dict
-                )
+                call_result = await self.call_mcp_tool_from_session(session, tool_call_dict)
             except Exception as e:
                 if server.is_session_expired_error(e):
                     try:
                         session = await server.reconnect()
-                        call_result = await litellm.experimental_mcp_client.call_openai_tool(
-                            session=session, openai_tool=tool_call_dict
-                        )
+                        call_result = await self.call_mcp_tool_from_session(session, tool_call_dict)
                     except Exception as retry_exc:
                         self.io.tool_warning(
                             f"Executing {tool_name} on {server.name} failed after reconnect:\n"

{cecli_dev-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli/coders/base_coder.py

@@ -851,12 +851,12 @@ class Coder(metaclass=UsageMeta):
         settings_items.append(f"{self.edit_format} (edit format)")
 
         # Thinking tokens
-        thinking_tokens = main_model.get_thinking_tokens()
+        thinking_tokens = self.get_active_model().get_thinking_tokens()
         if thinking_tokens:
             settings_items.append(f"{thinking_tokens} think tokens")
 
         # Reasoning effort
-        reasoning_effort = main_model.get_reasoning_effort()
+        reasoning_effort = self.get_active_model().get_reasoning_effort()
         if reasoning_effort:
             settings_items.append(f"reasoning {reasoning_effort}")
 
@@ -3110,19 +3110,14 @@ class Coder(metaclass=UsageMeta):
 
                         async def do_tool_call():
                             nonlocal session
-                            from litellm import experimental_mcp_client
 
                             try:
-                                return await experimental_mcp_client.call_openai_tool(
-                                    session=session,
-                                    openai_tool=new_tool_call,
-                                )
+                                return await self.call_mcp_tool_from_session(session, new_tool_call)
                             except Exception as e:
                                 if server.is_session_expired_error(e):
                                     session = await server.reconnect()
-                                    return await experimental_mcp_client.call_openai_tool(
-                                        session=session,
-                                        openai_tool=new_tool_call,
+                                    return await self.call_mcp_tool_from_session(
+                                        session, new_tool_call
                                     )
                                 raise
 
@@ -3209,6 +3204,34 @@ class Coder(metaclass=UsageMeta):
 
         return tool_responses
 
+    async def call_mcp_tool_from_session(self, session, tool_call):
+        """Call an MCP tool from an OpenAI-style tool call using the native SDK.
+
+        Accepts either a dict (``{"function": {"name": ..., "arguments": ...}}``)
+        or a tool-call object (e.g. litellm's ChatCompletionMessageToolCall) and
+        invokes the MCP session directly, avoiding litellm's lazily-imported
+        ``experimental_mcp_client`` submodule.
+        """
+        if isinstance(tool_call, dict):
+            function = tool_call.get("function", {})
+            name = function.get("name")
+            arguments = function.get("arguments", {})
+        else:
+            function = getattr(tool_call, "function", None)
+            name = getattr(function, "name", None)
+            arguments = getattr(function, "arguments", {})
+
+        if isinstance(arguments, str):
+            try:
+                arguments = json.loads(arguments)
+            except json.JSONDecodeError:
+                arguments = {}
+
+        if not isinstance(arguments, dict):
+            arguments = {}
+
+        return await session.call_tool(name=name, arguments=arguments)
+
     async def process_tool_calls(self, tool_call_response):
         """Simplified main entry point."""
         # Check if max tool calls exceeded
@@ -4248,15 +4271,12 @@ class Coder(metaclass=UsageMeta):
 
         self.message_tokens_received += completion_tokens
 
-        # Build the new streamlined format
-        tokens_parts = [format_tokens(prompt_tokens)]
-
-        if cache_hit_tokens:
-            tokens_parts.append(f"{format_tokens(cache_hit_tokens)}")
-        if cache_write_tokens:
-            tokens_parts.append(f"{format_tokens(cache_write_tokens)}")
-
-        tokens_str = "/".join(tokens_parts)
+        # Build tokens string as "{prompt} CH {hit_rate:.1f}% ↑ {completion} ↓"
+        if prompt_tokens > 0:
+            hit_rate = round(cache_hit_tokens / prompt_tokens * 100, 1) if cache_hit_tokens else 0.0
+        else:
+            hit_rate = 0.0
+        tokens_str = f"{format_tokens(prompt_tokens)} ◇ {hit_rate:.1f}%"
 
         tokens_report = f"{tokens_str} ↑ {format_tokens(completion_tokens)} ↓"
 
@@ -4271,12 +4291,17 @@ class Coder(metaclass=UsageMeta):
             + self.message_tokens_received
         )
         total_combined_cached = self.total_cached_tokens + self.message_cached_tokens
+        total_input_tokens = self.total_tokens_sent + self.message_tokens_sent
+        if total_input_tokens > 0:
+            total_hit_rate = (
+                round(total_combined_cached / total_input_tokens * 100, 1)
+                if total_combined_cached
+                else 0.0
+            )
+        else:
+            total_hit_rate = 0.0
 
-        total_stats = f"{format_tokens(total_combined_tokens)}"
-        if total_combined_cached:
-            total_stats += f"/{format_tokens(total_combined_cached)}"
-
-        total_stats += " ↑↓"
+        total_stats = f"{format_tokens(total_combined_tokens)} ◇ {total_hit_rate:.1f}% ↑↓"
 
         if not self.get_active_model().info.get("input_cost_per_token"):
             self.usage_report = tokens_report + " " + total_stats

{cecli_dev-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli/commands/add.py

@@ -132,7 +132,24 @@ class AddCommand(BaseCommand):
                         f" {active_model.name} does not support images."
                     )
                     continue
-                content = io.read_text(abs_file_path)
+                try:
+                    content = io.read_text(abs_file_path)
+                except (ValueError, UnicodeError, UnicodeDecodeError, OSError) as exc:
+                    # Binary or undecodable files (e.g. .git/objects/pack/*.rev)
+                    # raise ValueError("Could not determine text encoding ...")
+                    # from decoding.safe_open. Skip them gracefully instead of
+                    # crashing the session.
+                    msg = str(exc)
+                    if "Could not determine text encoding" in msg or isinstance(
+                        exc, (UnicodeError, UnicodeDecodeError)
+                    ):
+                        io.tool_warning(
+                            f"Skipping {matched_file}: not decodable as text "
+                            "(binary or unknown encoding)"
+                        )
+                    else:
+                        io.tool_error(f"Skipping {matched_file}: {exc}")
+                    continue
                 if content is None:
                     io.tool_error(f"Unable to read {matched_file}")
                 else:

{cecli_dev-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli/io.py

@@ -724,7 +724,12 @@ class InputOutput:
             if not silent:
                 self.tool_error(f"{filename}: unable to read: {err}")
             return
-        except UnicodeError as e:
+        except (UnicodeError, ValueError) as e:
+            # ValueError is raised by decoding.safe_open / smart_read when
+            # charset_normalizer cannot determine an encoding (e.g. binary
+            # files like .git/objects/pack/*.rev). Treat it like a decode
+            # error so callers such as /add can skip the file gracefully
+            # instead of crashing the session.
             if not silent:
                 self.tool_error(f"{filename}: {e}")
                 self.tool_error("Use --encoding to set the unicode encoding.")

{cecli_dev-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli/mcp/manager.py

@@ -153,7 +153,6 @@ class McpServerManager:
         Returns:
             Boolean indicating success or failure
         """
-        from litellm import experimental_mcp_client
 
         server = self.get_server(name)
         if not server:
@@ -187,9 +186,8 @@ class McpServerManager:
         for attempt in range(1, max_retries + 1):
             try:
                 session = await server.connect()
-                tools = await experimental_mcp_client.load_mcp_tools(
-                    session=session, format="openai"
-                )
+                tools_result = await session.list_tools()
+                tools = _mcp_tools_to_openai_tools(tools_result.tools)
                 self._server_tools[server.name] = tools
                 self._connected_servers.add(server)
                 self._log_verbose(f"Connected to MCP server: {name}")
@@ -361,3 +359,56 @@ def get_local_tool_schemas():
         if hasattr(tool_module, "SCHEMA"):
             schemas.append(tool_module.SCHEMA)
     return schemas
+
+
+def _mcp_tool_input_schema(tool):
+    """Return the input schema of an mcp Tool across SDK versions.
+
+    mcp SDK 1.x names the field inputSchema; SDK 2.x renamed it to
+    input_schema.
+    """
+    schema = getattr(tool, "input_schema", None)
+    if schema is None:
+        schema = getattr(tool, "inputSchema", None)
+    return schema
+
+
+def _normalize_mcp_input_schema(input_schema):
+    """Normalize an MCP input schema for OpenAI function calling.
+
+    OpenAI requires function parameters to have type 'object', a
+    properties dict, and (recommended) additionalProperties: false.
+    Mirrors litellm's _normalize_mcp_input_schema.
+    """
+    if not input_schema:
+        return {"type": "object", "properties": {}, "additionalProperties": False}
+
+    normalized = dict(input_schema)
+    if "type" not in normalized:
+        normalized["type"] = "object"
+    if "properties" not in normalized:
+        normalized["properties"] = {}
+    if "additionalProperties" not in normalized:
+        normalized["additionalProperties"] = False
+    return normalized
+
+
+def _mcp_tools_to_openai_tools(tools):
+    """Convert a list of mcp Tool objects to OpenAI 'tools' JSON dicts.
+
+    Uses the SDK's own session.list_tools() output and converts to the
+    standard OpenAI chat tools format. Version-aware: mcp SDK 2.x renamed
+    Tool.inputSchema to input_schema.
+    """
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": tool.name,
+                "description": tool.description or "",
+                "parameters": _normalize_mcp_input_schema(_mcp_tool_input_schema(tool)),
+                "strict": False,
+            },
+        }
+        for tool in tools
+    ]

{cecli_dev-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli/mcp/server.py

@@ -256,7 +256,7 @@ class HttpBasedMcpServer(McpServer):
             client_metadata=client_metadata,
             storage=FileBasedTokenStorage(self.name),
             redirect_handler=handle_redirect,
-            callback_handler=get_auth_code,
+            callback_handler=_get_oauth_callback_handler(get_auth_code),
         )
 
         return oauth_provider
@@ -285,10 +285,14 @@ class HttpBasedMcpServer(McpServer):
         try:
             url = self.config.get("url")
             headers = self.config.get("headers", {})
-            oauth_provider = await self._create_oauth_provider()
 
+            oauth_provider = None
+            if not headers:
+                oauth_provider = await self._create_oauth_provider()
+
+            http_client_cls = _get_http_client_module().AsyncClient
             http_client = await self.exit_stack.enter_async_context(
-                httpx.AsyncClient(
+                http_client_cls(
                     auth=oauth_provider,
                     follow_redirects=True,
                     headers=headers,
@@ -301,7 +305,7 @@ class HttpBasedMcpServer(McpServer):
                 self._create_transport(url, http_client=http_client)
             )
 
-            read, write, _ = transport
+            read, write = _unpack_transport(transport)
 
             session = await self.exit_stack.enter_async_context(ClientSession(read, write))
             await session.initialize()
@@ -374,7 +378,7 @@ class HttpBasedMcpServer(McpServer):
                         self._state = ConnectionState.CONNECTED
                         self._failed_pings = 0
                     else:
-                        raise httpx.HTTPStatusError(
+                        raise _get_http_client_module().HTTPStatusError(
                             f"Unexpected status {response.status_code}",
                             request=response.request,
                             response=response,
@@ -518,3 +522,61 @@ class LocalServer(McpServer):
     async def disconnect(self):
         """Disconnect from the MCP server and clean up resources."""
         self.session = None
+
+
+def _get_mcp_major_version() -> int:
+    """Return the installed mcp SDK major version (1, 2, ...).
+
+    Falls back to 1 if the version cannot be determined.
+    """
+    try:
+        from importlib.metadata import version
+
+        return int(version("mcp").split(".")[0])
+    except Exception:
+        return 1
+
+
+def _get_http_client_module():
+    """Return the HTTP client module used by the installed mcp SDK.
+
+    mcp SDK 2.x migrated from httpx to httpx2; earlier versions use httpx.
+    """
+    if _get_mcp_major_version() >= 2:
+        import httpx2
+
+        return httpx2
+
+    return httpx
+
+
+def _get_oauth_callback_handler(get_auth_code):
+    """Return an OAuth callback handler compatible with the installed mcp SDK.
+
+    mcp SDK 1.x expects a callback returning an (auth_code, state) tuple;
+    SDK 2.x expects an AuthorizationCodeResult carrying the same fields.
+    """
+    if _get_mcp_major_version() >= 2:
+        from mcp.shared.auth import AuthorizationCodeResult
+
+        async def sdk2_callback_handler() -> AuthorizationCodeResult:
+            code, state = await get_auth_code()
+            return AuthorizationCodeResult(code=code, state=state)
+
+        return sdk2_callback_handler
+
+    return get_auth_code
+
+
+def _unpack_transport(transport):
+    """Return (read, write) streams from an HTTP transport.
+
+    mcp SDK 1.x yields a 3-tuple (read, write, session_id_getter); SDK 2.x
+    yields a 2-tuple (read, write).
+    """
+    if _get_mcp_major_version() >= 2:
+        read, write = transport
+    else:
+        read, write, _ = transport
+
+    return read, write

{cecli_dev-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.1.0rc2
+Version: 1.1.0rc4
 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-1.1.0rc2 → cecli_dev-1.1.0rc4}/cecli_dev.egg-info/SOURCES.txt

@@ -737,6 +737,7 @@ tests/mcp/test_keepalive_resilience.py
 tests/mcp/test_keepalive_unit.py
 tests/mcp/test_manager.py
 tests/mcp/test_manager_retry.py
+tests/mcp/test_server_sdk_compat.py
 tests/scrape/test_playwright_disable.py
 tests/scrape/test_scrape.py
 tests/subagents/__init__.py