sqlbuddy-nwi 0.3.4__tar.gz → 0.4.1__tar.gz

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuddy-nwi
-Version: 0.3.4
+Version: 0.4.1
 Summary: MCP server for read-only database access (MySQL, ClickHouse)
 Author: ying.yuxiang
 License: MIT
@@ -23,7 +23,6 @@ License-File: LICENSE
 Requires-Dist: mcp<2,>=1.0.0
 Requires-Dist: pymysql>=1.1.0
 Requires-Dist: clickhouse-driver>=0.2.6
-Requires-Dist: pandas>=2.0.0
 Requires-Dist: platformdirs>=4.0.0
 Dynamic: license-file
 
@@ -67,7 +66,7 @@ SQL Buddy runs **locally** (a small Python program, not a cloud service). It
 
 ## Quickstart
 
-**Install** (current release **0.3.3**, Python ≥ 3.11):
+**Install** (current release [![PyPI](https://img.shields.io/pypi/v/sqlbuddy-nwi.svg)](https://pypi.org/project/sqlbuddy-nwi/), Python ≥ 3.11):
 
 ```bash
 # From PyPI (recommended):

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/README.md

@@ -38,7 +38,7 @@ SQL Buddy runs **locally** (a small Python program, not a cloud service). It
 
 ## Quickstart
 
-**Install** (current release **0.3.3**, Python ≥ 3.11):
+**Install** (current release [![PyPI](https://img.shields.io/pypi/v/sqlbuddy-nwi.svg)](https://pypi.org/project/sqlbuddy-nwi/), Python ≥ 3.11):
 
 ```bash
 # From PyPI (recommended):

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/_version.py

@@ -7,4 +7,4 @@ still report a version. `cli.get_version()` prefers installed metadata when
 available and falls back to this.
 """
 
-__version__ = "0.3.4"
+__version__ = "0.4.1"

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/cli.py

@@ -44,7 +44,6 @@ _RUNTIME_DEPS = [
     ("mcp", "mcp.server.fastmcp"),
     ("pymysql", None),
     ("clickhouse_driver", None),
-    ("pandas", None),
     ("platformdirs", None),
 ]
 
@@ -1025,6 +1024,10 @@ sql-buddy {ver}  — read-only MCP database server
 
 Usage:
   sql-buddy [serve|stdio]        run the MCP server over stdio (default)
+  sql-buddy http [--host H] [--port P]
+                                 run ONE shared MCP server over streamable
+                                 HTTP — N agents, one process, one tunnel
+                                 (default 127.0.0.1:7801; see docs/setup.md)
   sql-buddy version              print version
   sql-buddy doctor [--connect]   validate install + db.ini (+ live pings)
   sql-buddy update-check         compare local checkout to the git remote
@@ -1057,10 +1060,32 @@ def _run_server() -> int:
     return 0
 
 
+def _run_http(host: str, port: int) -> int:
+    import server
+    server.run_http(host=host, port=port)
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     args = list(sys.argv[1:] if argv is None else argv)
     if not args or args[0] in ("serve", "server", "stdio"):
         return _run_server()
+    if args[0] == "http":
+        host, port = "127.0.0.1", 7801
+        it = iter(args[1:])
+        for flag in it:
+            if flag == "--host":
+                host = next(it, host)
+            elif flag == "--port":
+                raw = next(it, "")
+                if not raw.isdigit():
+                    print("error: --port needs an integer", file=sys.stderr)
+                    return 2
+                port = int(raw)
+            else:
+                print(f"error: unknown http option '{flag}'", file=sys.stderr)
+                return 2
+        return _run_http(host, port)
 
     cmd, rest = args[0], args[1:]
 

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/connections/manager.py

@@ -10,7 +10,6 @@ generation bumps (the previous TCP socket is dead after a restart).
 import configparser
 import os
 import sys
-import uuid
 from contextlib import contextmanager
 from typing import Any, Dict, Tuple
 
@@ -29,7 +28,21 @@ from .wrappers import (
 _REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 if _REPO_ROOT not in sys.path:
     sys.path.insert(0, _REPO_ROOT)
-from tunnel import get_manager as _get_tunnel_manager
+
+
+def _get_tunnel_manager():
+    """Return the process-wide TunnelManager (imported lazily).
+
+    A module-level `from tunnel import get_manager` here creates a genuine
+    import cycle: `import tunnel` -> `connections.config_util` ->
+    `connections/__init__` -> manager -> `from tunnel import get_manager`
+    while tunnel is still mid-initialization. tunnel.py's `except ImportError`
+    then silently swallows the collision and its config helpers stay None,
+    breaking every TunnelManager built in that process. Deferring the import
+    to call time breaks the cycle, so `import tunnel` works in any order.
+    """
+    from tunnel import get_manager
+    return get_manager()
 
 
 DEFAULT_REMOTE_DB_CREDS: Dict[str, Tuple[str, str]] = {}
@@ -168,35 +181,6 @@ class DBManager:
             elif hasattr(client, "close"):
                 client.close()
 
-    @contextmanager
-    def session_scope(self, client_name: str = 'ck'):
-        client = getattr(self, client_name)
-        session_id = str(uuid.uuid4())
-        original_execute = client.execute
-        original_query_dataframe = getattr(client, 'query_dataframe', None)
-
-        def scoped_execute(query, params=None, settings=None, **kwargs):
-            if settings is None:
-                settings = {}
-            settings['session_id'] = session_id
-            return original_execute(query, params=params, settings=settings, **kwargs)
-
-        def scoped_query_dataframe(query, params=None, settings=None, **kwargs):
-            if settings is None:
-                settings = {}
-            settings['session_id'] = session_id
-            return original_query_dataframe(query, params=params, settings=settings, **kwargs)
-
-        class SessionClient:
-            def execute(self, *args, **kwargs):
-                return scoped_execute(*args, **kwargs)
-            def query_dataframe(self, *args, **kwargs):
-                if original_query_dataframe:
-                    return scoped_query_dataframe(*args, **kwargs)
-                raise AttributeError("query_dataframe not available on this client")
-
-        yield SessionClient()
-
     @contextmanager
     def transaction_scope(self, connection: str):
         conn = getattr(self, connection)

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/connections/wrappers.py

@@ -10,7 +10,6 @@ See UBIQUITOUS_LANGUAGE.md: "Locked" == the wrapper layer enforcing Read-only.
 
 import pymysql
 from clickhouse_driver import Client
-import pandas as pd
 
 from .readonly import _filter_sql
 
@@ -31,12 +30,19 @@ class MySQLConnectionWrapper:
         finally:
             cursor.close()
 
-    def query_dataframe(self, sql: str) -> pd.DataFrame:
+    def query_rows(self, sql: str):
+        """Read `sql` and return (column_names, rows_as_dicts).
+
+        Replaces the old `query_dataframe` (which wrapped these same rows in a
+        pandas DataFrame — a 45 MiB import per process). Same DictCursor
+        semantics, plain dicts out.
+        """
         cursor = self._conn.cursor(pymysql.cursors.DictCursor)
         try:
             cursor.execute(sql)
             rows = cursor.fetchall()
-            return pd.DataFrame(rows)
+            columns = [d[0] for d in cursor.description] if cursor.description else []
+            return columns, list(rows)
         finally:
             cursor.close()
 
@@ -68,9 +74,9 @@ class LockedMySQLConnectionWrapper:
         _filter_sql(sql)
         return self._wrapped.db_execute(sql, params)
 
-    def query_dataframe(self, sql: str) -> pd.DataFrame:
+    def query_rows(self, sql: str):
         _filter_sql(sql)
-        return self._wrapped.query_dataframe(sql)
+        return self._wrapped.query_rows(sql)
 
 
 class LockedClickHouseClient:
@@ -88,15 +94,6 @@ class LockedClickHouseClient:
             settings=settings, **kwargs
         )
 
-    def query_dataframe(self, query, params=None, settings=None, **kwargs):
-        _filter_sql(query)
-        result = self._wrapped.execute(query, params=params, settings=settings, with_column_types=True, **kwargs)
-        if result:
-            data, columns = result
-            if data:
-                return pd.DataFrame(data, columns=[c[0] for c in columns])
-        return pd.DataFrame()
-
     def disconnect(self):
         return self._wrapped.disconnect()
 

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/db_query.py

@@ -135,31 +135,33 @@ def _is_query_allowed(sql: str) -> bool:
     return any(sql_trimmed.startswith(p) for p in allowed)
 
 
+def _fetch_rows(client, sql: str):
+    """Dialect-agnostic read path: -> (column_names, rows_as_dicts). No pandas.
+
+    MySQL wrapper (raw or Locked) exposes `query_rows`; ClickHouse goes through
+    `execute(with_column_types=True)` (the Locked client filters it first).
+    Replaces the old `hasattr(client, 'query_dataframe')` DataFrame dispatch:
+    same output shape, none of the 45 MiB pandas import.
+    """
+    if hasattr(client, 'query_rows'):
+        return client.query_rows(sql)
+    result = client.execute(sql, with_column_types=True)
+    if not result or not result[0]:
+        return [], []
+    data, columns = result
+    col_names = [c[0] for c in columns]
+    return col_names, [dict(zip(col_names, row)) for row in data]
+
+
 def _result_to_json(client, sql: str) -> str:
     """Execute SQL and return JSON string with columns + rows. Decimals cast to float."""
-    if hasattr(client, 'query_dataframe'):
-        df = client.query_dataframe(sql)
-        if df.empty:
-            return json.dumps({"columns": [], "rows": [], "row_count": 0})
-        rows = [_sanitize_row(r) for r in df.to_dict(orient='records')]
-        return json.dumps({
-            "columns": list(df.columns),
-            "rows": rows,
-            "row_count": len(rows),
-        }, default=str)
-    else:
-        # ClickHouse
-        result = client.execute(sql, with_column_types=True)
-        if not result or not result[0]:
-            return json.dumps({"columns": [], "rows": [], "row_count": 0})
-        data, columns = result
-        col_names = [c[0] for c in columns]
-        rows = [_sanitize_row(dict(zip(col_names, row))) for row in data]
-        return json.dumps({
-            "columns": col_names,
-            "rows": rows,
-            "row_count": len(rows),
-        }, default=str)
+    columns, rows = _fetch_rows(client, sql)
+    rows = [_sanitize_row(r) for r in rows]
+    return json.dumps({
+        "columns": columns,
+        "rows": rows,
+        "row_count": len(rows),
+    }, default=str)
 
 
 # --- Schema ---
@@ -287,12 +289,10 @@ def table_schema_query(tbl_name: str, connection: str = 'ck', force_refresh: boo
         db = DBManager()
         client = getattr(db, connection)
 
-        if hasattr(client, 'query_dataframe'):
-            result = client.query_dataframe(f"SHOW CREATE TABLE {tbl_name}")
-            schema = result.to_string() if not result.empty else ""
-        else:
-            result = client.execute(f"SHOW CREATE TABLE {tbl_name}")
-            schema = str(result[0][0]) if result else ""
+        # MySQL: (Table, Create Table) — the DDL is the LAST column;
+        # ClickHouse: a single `statement` column. columns[-1] serves both.
+        columns, rows = _fetch_rows(client, f"SHOW CREATE TABLE {tbl_name}")
+        schema = str(rows[0][columns[-1]]) if rows and columns else ""
 
         schema = schema.strip().replace('statement\n', '').strip()
         if schema and schema[0].isdigit():
@@ -323,12 +323,13 @@ def table_schema_query(tbl_name: str, connection: str = 'ck', force_refresh: boo
 def _resolve_connection_type(connection: str) -> str:
     """Resolve a connection name to its DBMS type ('clickhouse' | 'mysql').
 
-    Replaces the brittle ``hasattr(client, 'query_dataframe')`` dispatch: BOTH
-    Locked wrappers define ``query_dataframe`` (MySQL natively, ClickHouse via
-    the adapter in connections/wrappers.py), so that attribute check *always*
-    picked the MySQL branch — even for ClickHouse, which then fabricated a
-    fake PRIMARY index from ClickHouse's stub ``SHOW INDEX``. This reads the
-    section's declared ``type`` (with the section-name prefix fallback), the
+    Replaces the brittle ``hasattr(client, 'query_dataframe')`` dialect
+    dispatch of the old pandas era: BOTH Locked wrappers defined it (MySQL
+    natively, ClickHouse via an adapter), so the check *always* picked the
+    MySQL branch -- even for ClickHouse, which then fabricated a fake PRIMARY
+    index from ClickHouse's stub ``SHOW INDEX``. The pandas-free `query_rows`
+    interface is MySQL-only again, but dialect is still read from the
+    section's declared `type` (with the section-name prefix fallback), the
     same source of truth ``find_table_query`` uses. Connection names use
     underscores; db.ini sections use dashes, so normalize the way
     DBManager.__getattr__ does.
@@ -411,14 +412,14 @@ def table_info_query(tbl_name: str, connection: str = 'ck', force_refresh: bool
         if ctype == 'mysql':
             # MySQL: SHOW INDEX returns real BTREE indexes with real cardinality.
             try:
-                result = client.query_dataframe(f"SELECT COUNT(*) as cnt FROM {tbl_name}")
-                info['row_count'] = int(result['cnt'].iloc[0]) if not result.empty else 0
+                _cols, rows = _fetch_rows(client, f"SELECT COUNT(*) as cnt FROM {tbl_name}")
+                info['row_count'] = int(rows[0]['cnt']) if rows else 0
             except Exception:
                 info['row_count'] = None
             try:
-                idx_result = client.query_dataframe(f"SHOW INDEX FROM {tbl_name}")
-                if not idx_result.empty:
-                    info['indexes'] = idx_result.to_dict('records')
+                _cols, rows = _fetch_rows(client, f"SHOW INDEX FROM {tbl_name}")
+                if rows:
+                    info['indexes'] = rows
             except Exception:
                 info['indexes'] = []
         else:
@@ -501,10 +502,7 @@ def check_connection_query(connection: str = 'ck') -> str:
     start = time.time()
     db = DBManager()
     client = getattr(db, connection)  # raises AttributeError if unknown; starts tunnel if Auto
-    if hasattr(client, 'query_dataframe'):
-        client.query_dataframe('SELECT 1')
-    else:
-        client.execute('SELECT 1')
+    _fetch_rows(client, 'SELECT 1')
     return json.dumps({
         "connection": connection,
         "status": "ok",
@@ -518,18 +516,18 @@ def list_tables(connection: str = 'ck', database: str | None = None, like: str |
         db = DBManager()
         client = getattr(db, connection)
 
-        if hasattr(client, 'query_dataframe'):
+        if hasattr(client, 'query_rows'):
             # MySQL
             sql = "SHOW TABLES"
             if database:
                 sql = f"SHOW TABLES FROM `{database}`"
             if like:
                 sql += f" LIKE '{like}'"
-            result = client.query_dataframe(sql)
-            if result.empty:
+            columns, rows = _fetch_rows(client, sql)
+            if not rows:
                 return json.dumps({"tables": [], "count": 0})
-            col = result.columns[0]
-            tables = result[col].tolist()
+            first = columns[0] if columns else ''
+            tables = [str(r.get(first)) for r in rows]
         else:
             # ClickHouse
             if database:
@@ -614,17 +612,16 @@ def _full_catalog_query(ctype: str) -> str:
 
 def _exec_catalog(client, sql: str) -> list:
     """Run a catalog SELECT; return list of (database, table, engine) tuples."""
-    if hasattr(client, 'query_dataframe'):
-        df = client.query_dataframe(sql)
-        if df is None or getattr(df, 'empty', True):
-            return []
-        out = []
-        for row in df.itertuples(index=False, name=None):
-            db_name = str(row[0]) if len(row) > 0 and row[0] is not None else ''
-            tbl = str(row[1]) if len(row) > 1 and row[1] is not None else ''
-            eng = str(row[2]) if len(row) > 2 and row[2] is not None else ''
-            out.append((db_name, tbl, eng))
-        return out
+    if hasattr(client, 'query_rows'):
+        _cols, rows = _fetch_rows(client, sql)
+        return [
+            (
+                str(r.get('db_name')) if r.get('db_name') is not None else '',
+                str(r.get('tbl_name')) if r.get('tbl_name') is not None else '',
+                str(r.get('engine')) if r.get('engine') is not None else '',
+            )
+            for r in rows
+        ]
     result = client.execute(sql, with_column_types=True)
     if not result or not result[0]:
         return []
@@ -757,12 +754,9 @@ def explain_query(sql: str, connection: str = 'ck') -> str:
         db = DBManager()
         client = getattr(db, connection)
 
-        if hasattr(client, 'query_dataframe'):
-            result = client.query_dataframe(explain_sql)
-            if result.empty:
-                return json.dumps({"plan": [], "raw": ""})
-            col = result.columns[0]
-            plan_lines = result[col].tolist()
+        if hasattr(client, 'query_rows'):
+            columns, rows = _fetch_rows(client, explain_sql)
+            plan_lines = [row[columns[0]] for row in rows] if rows and columns else []
         else:
             result = client.execute(explain_sql)
             plan_lines = [row[0] for row in result] if result else []

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlbuddy-nwi"
-version = "0.3.4"
+version = "0.4.1"
 description = "MCP server for read-only database access (MySQL, ClickHouse)"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -25,7 +25,6 @@ dependencies = [
     "mcp>=1.0.0,<2",
     "pymysql>=1.1.0",
     "clickhouse-driver>=0.2.6",
-    "pandas>=2.0.0",
     "platformdirs>=4.0.0",
 ]
 
@@ -54,3 +53,9 @@ packages = ["connections"]
 [project.scripts]
 sql-buddy = "cli:main"
 sql-buddy-init = "init:main"
+
+# Only `tests/` holds pytest tests. Without this, bare `pytest` also collects
+# the root-level test_vendor.py script, whose import-time sys.exit(1) crashes
+# the whole run with an INTERNALERROR.
+[tool.pytest.ini_options]
+testpaths = ["tests"]

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/server.py

@@ -263,6 +263,25 @@ def run_server():
     mcp.run(transport="stdio")
 
 
+def run_http(host: str = "127.0.0.1", port: int = 7801):
+    """Run ONE shared MCP server over streamable HTTP (`sql-buddy http`).
+
+    Every agent connects to http://host:port/mcp — one process, one ssh
+    tunnel, one set of local forward ports, so concurrent agents can never
+    collide on tunnel port binds the way N stdio processes do. Requests are
+    independent: each tool call builds its own DBManager/client (db_query),
+    so there is no shared-connection state between agents.
+
+    Trade-off vs stdio: shared fate. If this process dies, every agent loses
+    DB access until it restarts — run it under a supervisor (systemd --user
+    with Restart=always; see docs/setup.md). Binds localhost by default;
+    do not expose it to a network without an auth layer in front.
+    """
+    mcp.settings.host = host
+    mcp.settings.port = port
+    mcp.run(transport="streamable-http")
+
+
 if __name__ == "__main__":
     # Bare `python server.py` (or `python server.py serve`) starts the MCP
     # server — the common case for MCP client configs. Any other subcommand

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/sqlbuddy_nwi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuddy-nwi
-Version: 0.3.4
+Version: 0.4.1
 Summary: MCP server for read-only database access (MySQL, ClickHouse)
 Author: ying.yuxiang
 License: MIT
@@ -23,7 +23,6 @@ License-File: LICENSE
 Requires-Dist: mcp<2,>=1.0.0
 Requires-Dist: pymysql>=1.1.0
 Requires-Dist: clickhouse-driver>=0.2.6
-Requires-Dist: pandas>=2.0.0
 Requires-Dist: platformdirs>=4.0.0
 Dynamic: license-file
 
@@ -67,7 +66,7 @@ SQL Buddy runs **locally** (a small Python program, not a cloud service). It
 
 ## Quickstart
 
-**Install** (current release **0.3.3**, Python ≥ 3.11):
+**Install** (current release [![PyPI](https://img.shields.io/pypi/v/sqlbuddy-nwi.svg)](https://pypi.org/project/sqlbuddy-nwi/), Python ≥ 3.11):
 
 ```bash
 # From PyPI (recommended):

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/sqlbuddy_nwi.egg-info/SOURCES.txt

@@ -23,5 +23,9 @@ sqlbuddy_nwi.egg-info/requires.txt
 sqlbuddy_nwi.egg-info/top_level.txt
 tests/test_client_timeouts.py
 tests/test_get_info.py
+tests/test_http_server.py
 tests/test_parse_create_table.py
-tests/test_sanitize_search.py
+tests/test_query_rows.py
+tests/test_sanitize_search.py
+tests/test_tunnel.py
+tests/test_version_sync.py

{sqlbuddy_nwi-0.3.4 → sqlbuddy_nwi-0.4.1}/sqlbuddy_nwi.egg-info/requires.txt

@@ -1,5 +1,4 @@
 mcp<2,>=1.0.0
 pymysql>=1.1.0
 clickhouse-driver>=0.2.6
-pandas>=2.0.0
 platformdirs>=4.0.0

sqlbuddy_nwi-0.4.1/tests/test_http_server.py

@@ -0,0 +1,114 @@
+"""End-to-end: the shared streamable-HTTP server serves N agents from one process.
+
+Receipt (2026-11-13): stdio mode spawns one server.py per agent — ~87 MiB each
+after the pandas removal, and each tries to bind the SAME tunnel ports, so
+concurrent agents collide (ExitOnForwardFailure) and all but the first lose
+DB access. `sql-buddy http` runs ONE process; this test spawns it for real and
+drives TWO concurrent MCP clients (installed mcp client stack, real HTTP +
+JSON-RPC), asserting both complete full round-trips while the server stays up.
+
+No DB needed: check_connection on an unconfigured name returns structured
+error JSON — proving the whole path (HTTP -> session -> tool -> db layer ->
+JSON response) without touching a database.
+"""
+
+import asyncio
+import json
+import socket
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parent.parent
+
+
+def _free_port() -> int:
+    s = socket.socket()
+    s.bind(("127.0.0.1", 0))
+    port = s.getsockname()[1]
+    s.close()
+    return port
+
+
+@pytest.fixture
+def http_url():
+    port = _free_port()
+    proc = subprocess.Popen(
+        [sys.executable, "server.py", "http", "--port", str(port)],
+        cwd=str(ROOT), stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
+    )
+    deadline = time.monotonic() + 20
+    while time.monotonic() < deadline:
+        if proc.poll() is not None:
+            pytest.fail(f"http server died at startup: {proc.stderr.read().decode()[:500]}")
+        try:
+            with socket.create_connection(("127.0.0.1", port), timeout=1):
+                break
+        except OSError:
+            time.sleep(0.2)
+    else:
+        proc.kill()
+        pytest.fail("http server never opened its port")
+    yield f"http://127.0.0.1:{port}/mcp"
+    proc.terminate()
+    try:
+        proc.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+
+
+def _roundtrip(url: str, out: dict, idx: int):
+    async def go():
+        import httpx
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamablehttp_client
+
+        def _no_env_proxies(**kwargs):
+            # Loopback must not be routed through a host proxy (a SOCKS
+            # ALL_PROXY without socksio installed kills the client).
+            return httpx.AsyncClient(trust_env=False, **kwargs)
+
+        async with streamablehttp_client(url, httpx_client_factory=_no_env_proxies) as (read, write, _):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                tools = await session.list_tools()
+                res = await session.call_tool(
+                    "check_connection", {"connection": "definitely-not-configured"})
+                payload = json.loads(res.content[0].text)
+                out[idx] = {"n_tools": len(tools.tools),
+                            "payload_keys": sorted(payload.keys()),
+                            "status": payload.get("status")}
+    asyncio.run(go())
+
+
+def test_two_concurrent_clients_share_one_http_server(http_url):
+    out: dict = {}
+    threads = [threading.Thread(target=_roundtrip, args=(http_url, out, i))
+               for i in range(2)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join(timeout=60)
+    assert len(out) == 2, f"both clients must finish: {out}"
+
+    for idx, result in out.items():
+        assert result["n_tools"] >= 8, f"client {idx}: tool catalog came back thin"
+        # unconfigured connection -> structured error JSON, not a crash
+        assert "connection" in result["payload_keys"] and result["status"] == "error"
+
+    assert out[0]["n_tools"] == out[1]["n_tools"], "clients saw different catalogs"
+
+
+def test_http_server_default_is_loopback(http_url):
+    """The shared server must not bind a public interface by accident."""
+    host = http_url.split(":")[1].replace("//", "")
+    assert host in ("127.0.0.1", "localhost", "::1")
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__, "-v"]))