fix(mcp): pass timedelta to streamablehttp_client for old-SDK compat (codex P2)

Codex P2 review on #72: streamablehttp_client's timeout signature
drifted between mcp SDK releases. 1.8 / 1.9-era releases required
``datetime.timedelta`` and dereferenced ``.total_seconds()`` on the
value, so passing the loader's raw ``float`` raises ``AttributeError``
before discovery initializes. ~1.10+ widened the type to
``float | timedelta``, and the modern signature still happily accepts
``timedelta``.

Since cubepi's mcp floor is ``mcp>=1.0``, supporting only the modern
shape would silently break legitimate installs that pin an older
1.x SDK. Convert the timeout to a ``timedelta`` for streamable_http so
the loader works on every advertised mcp version. ``sse_client``'s
signature is unchanged across versions (always ``float``), so the
SSE branch is left alone.

Test: updated the streamable_transport regression test to assert the
recorded sh_calls receive ``timedelta`` values rather than raw floats.

Author: xfgong

cubepi/mcp/http_loader.py

@@ -5,6 +5,7 @@
 import asyncio
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
+from datetime import timedelta
 from typing import Any, Literal
 
 from cubepi.agent.types import AgentTool
@@ -34,11 +35,17 @@ async def _open_session(
     if transport == "streamable_http":
         from mcp.client.streamable_http import streamablehttp_client
 
+        # streamablehttp_client's timeout signature drifted across mcp SDK
+        # versions: 1.8/1.9-era releases required ``timedelta`` and called
+        # ``.total_seconds()`` internally, while ~1.10+ accepts ``float |
+        # timedelta``. Passing a ``timedelta`` works on every version we
+        # declare in our ``mcp>=1.0`` floor, so we always convert here.
+        timeout_td = timedelta(seconds=timeout)
         async with streamablehttp_client(
             server_url,
             headers=headers,
-            timeout=timeout,
-            sse_read_timeout=timeout,
+            timeout=timeout_td,
+            sse_read_timeout=timeout_td,
         ) as (read_stream, write_stream, _get_session_id):
             async with ClientSession(read_stream, write_stream) as session:
                 yield session

tests/mcp/test_http_loader.py

@@ -280,11 +280,17 @@ async def test_load_mcp_tools_http_streamable_transport(monkeypatch) -> None:
 
     # Discovery used streamable_http (sse must not be touched).
     assert sse_calls == []
+    # streamablehttp_client expects ``timedelta`` on older mcp SDKs (1.8/1.9
+    # era) and ``float | timedelta`` on newer ones; we always pass a
+    # ``timedelta`` so the loader works on every release in our ``mcp>=1.0``
+    # dependency range.
+    from datetime import timedelta
+
     assert sh_calls[0] == {
         "url": "https://mcp.example/mcp",
         "headers": {"authorization": "Bearer x"},
-        "timeout": 7.5,
-        "sse_read_timeout": 7.5,
+        "timeout": timedelta(seconds=7.5),
+        "sse_read_timeout": timedelta(seconds=7.5),
     }
     assert len(sessions) == 1