"""MCP 客户端管理：工具发现、调用与 OpenAI 工具映射。"""

from __future__ import annotations

import hashlib
import json
import os
import select
import shutil
import subprocess
import time
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Dict, Iterable, List, Optional, Tuple, TYPE_CHECKING

import httpx

from config import MCP_PROTOCOL_VERSION, MCP_DEFAULT_TIMEOUT_SECONDS
from modules.mcp_server_registry import MCPServerRegistry

if TYPE_CHECKING:
    from modules.user_container_manager import ContainerHandle


class MCPClientError(Exception):
    """MCP 客户端异常。"""


@dataclass
class MCPToolBinding:
    alias: str
    server_id: str
    server_name: str
    remote_name: str
    transport: str
    timeout_seconds: int


class _StdioMCPClient:
    """最小可用 stdio MCP 客户端（JSON-RPC over newline-delimited JSON）。"""

    CONTAINER_PREFIXES = (
        "/workspace",
        "/usr/",
        "/bin/",
        "/sbin/",
        "/lib/",
        "/lib64/",
        "/opt/",
        "/etc/",
        "/tmp/",
        "/var/",
        "/home/",
        "/root/",
    )
    PATH_OPTION_KEYS = {
        "--path",
        "--dir",
        "--directory",
        "--root",
        "--cwd",
        "--workspace",
    }

    def __init__(
        self,
        server: Dict[str, Any],
        timeout_seconds: int,
        protocol_version: str,
        container_session: Optional["ContainerHandle"] = None,
    ):
        self.server = server
        self.timeout_seconds = max(3, int(timeout_seconds or MCP_DEFAULT_TIMEOUT_SECONDS))
        self.protocol_version = protocol_version
        self.container_session = container_session
        self.process: Optional[subprocess.Popen] = None
        self._seq = 0

    def _next_id(self) -> int:
        self._seq += 1
        return self._seq

    @staticmethod
    def _is_windows_abs_path(value: str) -> bool:
        return len(value) > 2 and value[1] == ":" and value[0].isalpha()

    @staticmethod
    def _normalize_mount_path(value: str) -> str:
        mount = str(value or "/workspace").strip()
        mount = mount.rstrip("/")
        return mount or "/workspace"

    def _normalize_workspace_path(self, value: Any) -> str:
        raw = str(value or "").strip()
        if not raw:
            return ""
        try:
            return str(Path(raw).expanduser().resolve())
        except Exception:
            return raw

    def _map_workspace_path(self, raw: str, workspace_host: str, mount_path: str) -> str:
        if not raw or not workspace_host:
            return raw
        if raw.startswith(mount_path):
            return raw
        if self._is_windows_abs_path(raw):
            return raw
        if not raw.startswith("/"):
            return raw
        try:
            normalized = str(Path(raw).expanduser().resolve())
        except Exception:
            normalized = raw
        if normalized == workspace_host:
            return mount_path
        prefix = workspace_host + os.sep
        if normalized.startswith(prefix):
            rel = normalized[len(prefix):].replace("\\", "/")
            return f"{mount_path}/{rel}" if rel else mount_path
        return raw

    def _rewrite_path_like_value_for_container(
        self,
        value: str,
        workspace_host: str,
        mount_path: str,
    ) -> str:
        raw = str(value or "").strip()
        if not raw:
            return raw
        mapped = self._map_workspace_path(raw, workspace_host, mount_path)
        return mapped if mapped != raw else raw

    @staticmethod
    def _command_basename(value: str) -> str:
        text = str(value or "").strip().replace("\\", "/").rstrip("/")
        if not text:
            return ""
        if "/" in text:
            return text.split("/")[-1]
        return text

    def _rewrite_command_for_container(self, command: str, workspace_host: str, mount_path: str) -> str:
        raw = str(command or "").strip()
        if not raw:
            return raw
        mapped = self._map_workspace_path(raw, workspace_host, mount_path)
        if mapped != raw:
            return mapped
        # command 若是宿主机绝对路径（如 /opt/homebrew/bin/npx），
        # 在容器内通常应退化为命令名（npx/python3），避免无意义路径校验阻断。
        if raw.startswith("/") or self._is_windows_abs_path(raw) or "\\" in raw:
            candidate = self._command_basename(raw)
            return candidate or raw
        return raw

    def _rewrite_arg_for_container(
        self,
        arg: str,
        *,
        index: int,
        workspace_host: str,
        mount_path: str,
    ) -> str:
        raw = str(arg or "")
        stripped = raw.strip()
        if not stripped:
            return raw
        if "=" in stripped:
            left, right = stripped.split("=", 1)
            if left in self.PATH_OPTION_KEYS and right:
                rewritten = self._rewrite_path_like_value_for_container(
                    right,
                    workspace_host=workspace_host,
                    mount_path=mount_path,
                )
                return f"{left}={rewritten}"
        return self._rewrite_path_like_value_for_container(
            stripped,
            workspace_host=workspace_host,
            mount_path=mount_path,
        )

    def _prepare_launch(self) -> Tuple[List[str], Optional[str], Dict[str, str]]:
        command_raw = str(self.server.get("command") or "").strip()
        args_raw = [str(item) for item in (self.server.get("args") or [])]
        env_raw = dict(self.server.get("env") or {})
        cwd_raw = str(self.server.get("cwd") or "").strip() or None
        if not command_raw:
            raise MCPClientError("stdio 服务缺少 command")

        session = self.container_session
        use_container = bool(session and getattr(session, "mode", None) == "docker")
        if not use_container:
            env = dict(os.environ)
            env.update(env_raw)
            return [command_raw, *args_raw], cwd_raw, env

        container_name = str(getattr(session, "container_name", "") or "").strip()
        if not container_name:
            raise MCPClientError("docker 模式下 stdio MCP 缺少 container_name")
        docker_bin = str(getattr(session, "sandbox_bin", "") or "docker").strip() or "docker"
        docker_path = shutil.which(docker_bin) or docker_bin
        mount_path = self._normalize_mount_path(getattr(session, "mount_path", "/workspace"))
        workspace_host = self._normalize_workspace_path(getattr(session, "workspace_path", ""))

        command = self._rewrite_command_for_container(
            command_raw,
            workspace_host=workspace_host,
            mount_path=mount_path,
        )
        args: List[str] = []
        for idx, item in enumerate(args_raw):
            args.append(
                self._rewrite_arg_for_container(
                    item,
                    index=idx,
                    workspace_host=workspace_host,
                    mount_path=mount_path,
                )
            )
        cwd = (
            self._rewrite_path_like_value_for_container(
                cwd_raw,
                workspace_host=workspace_host,
                mount_path=mount_path,
            )
            if cwd_raw
            else None
        )

        cmd: List[str] = [docker_path, "exec", "-i"]
        if cwd:
            cmd += ["-w", cwd]

        exec_env = {
            "PYTHONIOENCODING": "utf-8",
            "TERM": "xterm-256color",
        }
        for key, value in env_raw.items():
            if value is not None:
                exec_env[str(key)] = str(value)
        for key, value in exec_env.items():
            cmd += ["-e", f"{key}={value}"]
        cmd += [container_name, command, *args]

        return cmd, None, dict(os.environ)

    def start(self) -> None:
        launch_cmd, cwd, env = self._prepare_launch()
        try:
            self.process = subprocess.Popen(
                launch_cmd,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True,
                bufsize=1,
                cwd=cwd or None,
                env=env,
            )
        except Exception as exc:
            raise MCPClientError(f"启动 stdio MCP 服务失败: {exc}") from exc

    def _send(self, payload: Dict[str, Any]) -> None:
        if not self.process or not self.process.stdin:
            raise MCPClientError("stdio 进程未启动")
        raw = json.dumps(payload, ensure_ascii=False)
        try:
            self.process.stdin.write(raw + "\n")
            self.process.stdin.flush()
        except Exception as exc:
            raise MCPClientError(f"写入 stdio 消息失败: {exc}") from exc

    def _read_message(self, timeout_seconds: Optional[float] = None) -> Dict[str, Any]:
        if not self.process or not self.process.stdout:
            raise MCPClientError("stdio 进程未启动")
        timeout = self.timeout_seconds if timeout_seconds is None else max(0.1, float(timeout_seconds))
        deadline = time.monotonic() + timeout
        stdout = self.process.stdout
        last_text_line = ""
        while True:
            if self.process.poll() is not None:
                stderr_text = ""
                stdout_text = ""
                try:
                    if self.process.stderr:
                        stderr_text = self.process.stderr.read() or ""
                except Exception:
                    pass
                try:
                    if self.process.stdout:
                        stdout_text = self.process.stdout.read() or ""
                except Exception:
                    pass
                detail = (stderr_text or stdout_text or last_text_line or "")[:400]
                raise MCPClientError(f"stdio 进程已退出（code={self.process.returncode}）{detail}")

            remain = deadline - time.monotonic()
            if remain <= 0:
                raise MCPClientError("读取 stdio MCP 响应超时")

            readable, _, _ = select.select([stdout], [], [], min(0.3, remain))
            if not readable:
                continue
            line = stdout.readline()
            if not line:
                continue
            line = line.strip()
            if not line:
                continue
            try:
                return json.loads(line)
            except Exception:
                last_text_line = line
                continue

    def request(self, method: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        req_id = self._next_id()
        payload = {"jsonrpc": "2.0", "id": req_id, "method": method, "params": params or {}}
        self._send(payload)
        while True:
            msg = self._read_message()
            if msg.get("id") == req_id:
                if "error" in msg:
                    error = msg.get("error") or {}
                    raise MCPClientError(f"{method} 调用失败: {error}")
                return msg.get("result") or {}
            # 服务器主动向客户端发起请求时，返回 method not found，避免阻塞
            if "id" in msg and "method" in msg:
                self._send(
                    {
                        "jsonrpc": "2.0",
                        "id": msg.get("id"),
                        "error": {"code": -32601, "message": "Client method not implemented"},
                    }
                )

    def notify(self, method: str, params: Optional[Dict[str, Any]] = None) -> None:
        self._send({"jsonrpc": "2.0", "method": method, "params": params or {}})

    def initialize(self) -> Dict[str, Any]:
        result = self.request(
            "initialize",
            {
                "protocolVersion": self.protocol_version,
                "capabilities": {},
                "clientInfo": {"name": "agents-mcp-bridge", "version": "1.0.0"},
            },
        )
        self.notify("notifications/initialized")
        return result

    def close(self) -> None:
        if not self.process:
            return
        try:
            if self.process.stdin:
                self.process.stdin.close()
        except Exception:
            pass
        try:
            if self.process.poll() is None:
                self.process.terminate()
                self.process.wait(timeout=1.5)
        except Exception:
            try:
                self.process.kill()
            except Exception:
                pass
        finally:
            try:
                if self.process.stdout:
                    self.process.stdout.close()
            except Exception:
                pass
            try:
                if self.process.stderr:
                    self.process.stderr.close()
            except Exception:
                pass
            self.process = None


class _StreamableHTTPMCPClient:
    """最小可用 streamable HTTP MCP 客户端。"""

    def __init__(self, server: Dict[str, Any], timeout_seconds: int, protocol_version: str):
        self.server = server
        self.url = str(server.get("url") or "").strip()
        self.timeout_seconds = max(3, int(timeout_seconds or MCP_DEFAULT_TIMEOUT_SECONDS))
        self.protocol_version = protocol_version
        self._session_id: Optional[str] = None
        self._seq = 0
        self._client = httpx.Client(timeout=self.timeout_seconds)

    def _next_id(self) -> int:
        self._seq += 1
        return self._seq

    @staticmethod
    def _header_pick(headers: httpx.Headers, key: str) -> Optional[str]:
        for hk, hv in headers.items():
            if hk.lower() == key.lower():
                return hv
        return None

    def _build_headers(self) -> Dict[str, str]:
        headers = {
            "Accept": "application/json, text/event-stream",
            "Content-Type": "application/json",
            "MCP-Protocol-Version": self.protocol_version,
        }
        if self._session_id:
            headers["Mcp-Session-Id"] = self._session_id
        headers.update(self.server.get("headers") or {})
        return headers

    @staticmethod
    def _parse_sse_json_events(raw_text: str) -> List[Dict[str, Any]]:
        events: List[Dict[str, Any]] = []
        blocks = raw_text.split("\n\n")
        for block in blocks:
            data_lines: List[str] = []
            for line in block.splitlines():
                if line.startswith("data:"):
                    data_lines.append(line[5:].lstrip())
            if not data_lines:
                continue
            payload = "\n".join(data_lines).strip()
            if not payload or payload == "[DONE]":
                continue
            try:
                parsed = json.loads(payload)
            except Exception:
                continue
            if isinstance(parsed, dict):
                events.append(parsed)
        return events

    def _request(self, method: str, params: Optional[Dict[str, Any]] = None, notification: bool = False) -> Dict[str, Any]:
        if not self.url:
            raise MCPClientError("streamable_http 服务缺少 url")
        req_id = None if notification else self._next_id()
        payload: Dict[str, Any] = {"jsonrpc": "2.0", "method": method, "params": params or {}}
        if req_id is not None:
            payload["id"] = req_id
        try:
            resp = self._client.post(self.url, headers=self._build_headers(), json=payload)
        except Exception as exc:
            raise MCPClientError(f"HTTP MCP 请求失败: {exc}") from exc

        session_id = self._header_pick(resp.headers, "Mcp-Session-Id")
        if session_id:
            self._session_id = session_id

        if resp.status_code >= 400:
            raise MCPClientError(f"HTTP MCP 状态异常: {resp.status_code} {resp.text[:400]}")

        if notification:
            return {}

        content_type = (resp.headers.get("content-type") or "").lower()
        message: Optional[Dict[str, Any]] = None
        if "application/json" in content_type:
            parsed = resp.json()
            if isinstance(parsed, dict):
                message = parsed
        elif "text/event-stream" in content_type:
            for event in self._parse_sse_json_events(resp.text):
                if event.get("id") == req_id:
                    message = event
                    break
        else:
            try:
                parsed = resp.json()
                if isinstance(parsed, dict):
                    message = parsed
            except Exception:
                pass

        if not message:
            raise MCPClientError(f"HTTP MCP 未返回可解析响应（method={method}）")
        if "error" in message:
            raise MCPClientError(f"{method} 调用失败: {message.get('error')}")
        return message.get("result") or {}

    def initialize(self) -> Dict[str, Any]:
        result = self._request(
            "initialize",
            {
                "protocolVersion": self.protocol_version,
                "capabilities": {},
                "clientInfo": {"name": "agents-mcp-bridge", "version": "1.0.0"},
            },
        )
        self._request("notifications/initialized", {}, notification=True)
        return result

    def request(self, method: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        return self._request(method, params, notification=False)

    def close(self) -> None:
        try:
            if self._session_id and self.url:
                self._client.delete(self.url, headers=self._build_headers())
        except Exception:
            pass
        try:
            self._client.close()
        except Exception:
            pass


class MCPClientManager:
    """MCP 客户端主协调器。"""

    def __init__(
        self,
        registry: MCPServerRegistry,
        protocol_version: str = MCP_PROTOCOL_VERSION,
        container_session: Optional["ContainerHandle"] = None,
    ):
        self.registry = registry
        self.protocol_version = str(protocol_version or MCP_PROTOCOL_VERSION)
        self.container_session = container_session
        self._latest_alias_map: Dict[str, MCPToolBinding] = {}

    def set_container_session(self, session: Optional["ContainerHandle"]) -> None:
        self.container_session = session

    @staticmethod
    def _sanitize_input_schema(schema: Any) -> Dict[str, Any]:
        if not isinstance(schema, dict):
            return {"type": "object", "properties": {}}
        output = dict(schema)
        if output.get("type") != "object":
            output["type"] = "object"
        if not isinstance(output.get("properties"), dict):
            output["properties"] = {}
        if "required" in output and not isinstance(output.get("required"), list):
            output.pop("required", None)
        return output

    @staticmethod
    def _compact_tool_entry(tool: Dict[str, Any]) -> Dict[str, Any]:
        return {
            "name": str(tool.get("name") or "").strip(),
            "description": str(tool.get("description") or ""),
            "title": str(tool.get("title") or ""),
            "inputSchema": tool.get("inputSchema") if isinstance(tool.get("inputSchema"), dict) else {"type": "object", "properties": {}},
        }

    @staticmethod
    def _build_call_message(result: Dict[str, Any]) -> str:
        content = result.get("content")
        if isinstance(content, list):
            for item in content:
                if isinstance(item, dict) and item.get("type") == "text":
                    text = str(item.get("text") or "").strip()
                    if text:
                        return text[:500]
        structured = result.get("structuredContent")
        if structured is not None:
            try:
                return json.dumps(structured, ensure_ascii=False)[:500]
            except Exception:
                return str(structured)[:500]
        return "MCP 工具调用完成"

    @staticmethod
    def _content_preview(content_items: Any) -> str:
        if not isinstance(content_items, list):
            return ""
        previews: List[str] = []
        for item in content_items:
            if not isinstance(item, dict):
                continue
            ctype = item.get("type")
            if ctype == "text":
                text = str(item.get("text") or "").strip()
                if text:
                    previews.append(text[:300])
            elif ctype:
                previews.append(f"[{ctype}]")
            if len(previews) >= 4:
                break
        return "\n".join(previews).strip()

    def _make_client(self, server: Dict[str, Any], timeout_seconds: int):
        transport = server.get("transport")
        if transport == "stdio":
            return _StdioMCPClient(
                server,
                timeout_seconds,
                self.protocol_version,
                container_session=self.container_session,
            )
        if transport == "streamable_http":
            return _StreamableHTTPMCPClient(server, timeout_seconds, self.protocol_version)
        raise MCPClientError(f"不支持的 MCP transport: {transport}")

    def _paged_list_tools(self, client, max_pages: int = 20) -> List[Dict[str, Any]]:
        cursor: Optional[str] = None
        tools: List[Dict[str, Any]] = []
        for _ in range(max_pages):
            params = {"cursor": cursor} if cursor else {}
            result = client.request("tools/list", params)
            page_tools = result.get("tools") if isinstance(result, dict) else []
            if isinstance(page_tools, list):
                for item in page_tools:
                    if isinstance(item, dict):
                        compact = self._compact_tool_entry(item)
                        if compact.get("name"):
                            tools.append(compact)
            cursor = (result or {}).get("nextCursor") if isinstance(result, dict) else None
            if not cursor:
                break
        return tools

    def discover_tools_for_server(self, server_id: str, *, timeout_seconds: Optional[int] = None) -> Dict[str, Any]:
        server = self.registry.get_server(server_id)
        if not server:
            return {"success": False, "error": f"未找到 MCP 服务: {server_id}"}
        timeout = int(timeout_seconds or server.get("timeout_seconds") or MCP_DEFAULT_TIMEOUT_SECONDS)
        started = time.time()
        client = None
        try:
            client = self._make_client(server, timeout)
            client.start() if hasattr(client, "start") else None
            init_result = client.initialize()
            tools = self._paged_list_tools(client)
            self.registry.update_tools_cache(server_id, tools=tools, error="", touched=True)
            elapsed_ms = int((time.time() - started) * 1000)
            return {
                "success": True,
                "server_id": server_id,
                "protocol_version": init_result.get("protocolVersion") if isinstance(init_result, dict) else None,
                "tools_count": len(tools),
                "tools": tools,
                "elapsed_ms": elapsed_ms,
            }
        except Exception as exc:
            self.registry.update_tools_cache(server_id, error=str(exc), touched=True)
            return {"success": False, "server_id": server_id, "error": str(exc)}
        finally:
            try:
                if client:
                    client.close()
            except Exception:
                pass

    def sync_servers(self, server_id: Optional[str] = None) -> Dict[str, Any]:
        # 先从磁盘重载一次，避免「文件已改但进程内缓存未刷新」导致同步遗漏，
        # 以及后续 update_tools_cache 把旧缓存反写覆盖新配置。
        self.registry.reload()
        if server_id:
            return self.discover_tools_for_server(server_id)
        results = []
        for server in self.registry.list_enabled_servers():
            sid = server.get("id")
            if not sid:
                continue
            results.append(self.discover_tools_for_server(sid))
        ok_count = sum(1 for item in results if item.get("success"))
        overall_success = (not results) or (ok_count == len(results))
        return {
            "success": overall_success,
            "servers_total": len(results),
            "servers_success": ok_count,
            "servers_failed": len(results) - ok_count,
            "results": results,
        }

    def _iter_visible_tools(self, server: Dict[str, Any]) -> Iterable[Dict[str, Any]]:
        include_tools = set(server.get("include_tools") or [])
        exclude_tools = set(server.get("exclude_tools") or [])
        for item in server.get("tools_cache") or []:
            if not isinstance(item, dict):
                continue
            name = str(item.get("name") or "").strip()
            if not name:
                continue
            if include_tools and name not in include_tools:
                continue
            if name in exclude_tools:
                continue
            yield item

    def build_openai_tools(
        self,
        *,
        ensure_discovery: bool = True,
        discovery_timeout_seconds: int = 12,
    ) -> Tuple[List[Dict[str, Any]], Dict[str, MCPToolBinding]]:
        tools: List[Dict[str, Any]] = []
        alias_map: Dict[str, MCPToolBinding] = {}

        servers = self.registry.list_enabled_servers()
        for server in servers:
            sid = str(server.get("id") or "").strip()
            if not sid:
                continue
            if ensure_discovery and not (server.get("tools_cache") or []):
                self.discover_tools_for_server(sid, timeout_seconds=discovery_timeout_seconds)
                server = self.registry.get_server(sid) or server

            for item in self._iter_visible_tools(server):
                remote_name = str(item.get("name") or "").strip()
                alias_base = self.registry.make_tool_alias(sid, remote_name)
                alias = alias_base
                if alias in alias_map:
                    suffix = hashlib.sha1(f"{sid}:{remote_name}".encode("utf-8")).hexdigest()[:6]
                    max_len = max(8, 64 - len(suffix) - 2)
                    alias = f"{alias_base[:max_len]}__{suffix}"

                description = str(item.get("description") or "").strip()
                if description:
                    description = f"[MCP:{sid}] {description}"
                else:
                    description = f"[MCP:{sid}] 通过 MCP 服务调用远程工具 {remote_name}"

                schema = self._sanitize_input_schema(item.get("inputSchema"))
                tools.append(
                    {
                        "type": "function",
                        "function": {
                            "name": alias,
                            "description": description,
                            "parameters": schema,
                        },
                    }
                )
                alias_map[alias] = MCPToolBinding(
                    alias=alias,
                    server_id=sid,
                    server_name=str(server.get("name") or sid),
                    remote_name=remote_name,
                    transport=str(server.get("transport") or ""),
                    timeout_seconds=int(server.get("timeout_seconds") or MCP_DEFAULT_TIMEOUT_SECONDS),
                )

        self._latest_alias_map = alias_map
        return tools, alias_map

    def _resolve_binding(
        self,
        tool_alias: str,
        alias_map: Optional[Dict[str, MCPToolBinding]] = None,
    ) -> Optional[MCPToolBinding]:
        if alias_map and tool_alias in alias_map:
            return alias_map[tool_alias]
        if tool_alias in self._latest_alias_map:
            return self._latest_alias_map[tool_alias]

        # 容错：从缓存动态重建一遍
        _, rebuilt = self.build_openai_tools(ensure_discovery=False)
        return rebuilt.get(tool_alias)

    def call_tool_by_alias(
        self,
        tool_alias: str,
        arguments: Dict[str, Any],
        *,
        alias_map: Optional[Dict[str, MCPToolBinding]] = None,
    ) -> Dict[str, Any]:
        binding = self._resolve_binding(tool_alias, alias_map)
        if not binding:
            return {"success": False, "error": f"未找到 MCP 工具映射: {tool_alias}"}
        server = self.registry.get_server(binding.server_id)
        if not server:
            return {"success": False, "error": f"未找到 MCP 服务: {binding.server_id}"}
        if not server.get("enabled", True):
            return {"success": False, "error": f"MCP 服务已禁用: {binding.server_id}"}

        timeout = int(server.get("timeout_seconds") or binding.timeout_seconds or MCP_DEFAULT_TIMEOUT_SECONDS)
        client = None
        started = time.time()
        try:
            client = self._make_client(server, timeout)
            client.start() if hasattr(client, "start") else None
            client.initialize()
            call_result = client.request(
                "tools/call",
                {"name": binding.remote_name, "arguments": arguments or {}},
            )
            is_error = bool((call_result or {}).get("isError"))
            content_items = (call_result or {}).get("content") or []
            preview = self._content_preview(content_items)
            elapsed_ms = int((time.time() - started) * 1000)
            message = self._build_call_message(call_result)

            return {
                "success": not is_error,
                "server_id": binding.server_id,
                "server_name": binding.server_name,
                "tool_alias": binding.alias,
                "tool_name": binding.remote_name,
                "transport": binding.transport,
                "elapsed_ms": elapsed_ms,
                "is_error": is_error,
                "message": message,
                "preview": preview,
                "content": content_items,
                "structured_content": (call_result or {}).get("structuredContent"),
                "raw_result": call_result,
            }
        except Exception as exc:
            return {
                "success": False,
                "server_id": binding.server_id,
                "server_name": binding.server_name,
                "tool_alias": binding.alias,
                "tool_name": binding.remote_name,
                "transport": binding.transport,
                "error": str(exc),
            }
        finally:
            try:
                if client:
                    client.close()
            except Exception:
                pass