kl-mcp-client 1.0.0__py3-none-any.whl

kl_mcp_client-1.0.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: kl-mcp-client
+Version: 1.0.0
+Summary: MCP Client
+Author-email: Kyle <hngan.it@gmail.com>
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown

kl_mcp_client-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+mcp_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_client/client.py,sha256=0kkC1oGS4lMbQmsNtKa7fp_2aZdcqVZLssTmsVKmai0,4668
+mcp_client/tools.py,sha256=GC5IRYnWH35wBNCMrFGYE8VQx4bhj5uiJNDPBjDfdvQ,6615
+kl_mcp_client-1.0.0.dist-info/METADATA,sha256=3NUizw9TxUkbninPSWsL0jSiy9FxWNnSB3J6ZMVpls8,193
+kl_mcp_client-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kl_mcp_client-1.0.0.dist-info/top_level.txt,sha256=ZSWRi9Sxwn8pf9wHQny6lLfmYSfG4JpbzGdVrwvQoxM,11
+kl_mcp_client-1.0.0.dist-info/RECORD,,

kl_mcp_client-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kl_mcp_client-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mcp_client

mcp_client/client.py

@@ -0,0 +1,136 @@
+# mcp_client.py
+import time
+import uuid
+from typing import Any, Dict, List, Optional
+
+import requests
+
+DEFAULT_HEADERS = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+}
+
+
+class MCPError(Exception):
+    pass
+
+
+class MCPClient:
+    def __init__(
+        self,
+        base_url: str,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: int = 30,
+        retries: int = 1,
+    ):
+        """
+        base_url: full MCP HTTP endpoint e.g. http://localhost:3000/mcp
+        headers: extra headers (e.g. {"Authorization": "Bearer ..."})
+        timeout: request timeout seconds
+        retries: number of attempts for network errors
+        """
+        self.base_url = base_url.rstrip("/")
+        self.headers = DEFAULT_HEADERS.copy()
+        if headers:
+            self.headers.update(headers)
+        self.timeout = timeout
+        self.retries = max(1, int(retries))
+        # local cache of sessions -> can be used to reuse session ids
+        self._sessions: Dict[str, Dict[str, Any]] = {}
+
+    def _rpc(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        payload = {
+            "jsonrpc": "2.0",
+            "id": str(uuid.uuid4()),
+            "method": method,
+            "params": params,
+        }
+        last_exc = None
+        for attempt in range(self.retries):
+            try:
+                r = requests.post(
+                    self.base_url,
+                    json=payload,
+                    headers=self.headers,
+                    timeout=self.timeout,
+                )
+                r.raise_for_status()
+            except requests.RequestException as e:
+                last_exc = e
+                time.sleep(0.2 * (attempt + 1))
+                continue
+
+            try:
+                data = r.json()
+            except ValueError:
+                raise MCPError(
+                    f"Invalid JSON response (status {r.status_code}): {r.text}"
+                )
+
+            if "error" in data and data["error"] is not None:
+                err = data["error"]
+                raise MCPError(
+                    {
+                        "code": err.get("code"),
+                        "message": err.get("message"),
+                        "data": err.get("data"),
+                    }
+                )
+            return data.get("result", {})
+
+        # all retries failed
+        raise MCPError(f"Request failed after {self.retries} attempts: {last_exc}")
+
+    # ----- Generic callTool wrapper -----
+    def call_tool_structured(
+        self, tool: str, arguments: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        args = {"tool": tool, "arguments": arguments or {}}
+        res = self._rpc("callTool", args)
+        # return structuredContent when possible
+        if isinstance(res, dict) and "structuredContent" in res:
+            return res["structuredContent"]
+        # fallback: maybe top-level result
+        return res
+
+    # ----- Generic callTool wrapper -----
+    def call_tool(
+        self, tool: str, arguments: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        args = {"tool": tool, "arguments": arguments or {}}
+        res = self._rpc("callTool", args)
+        # # return structuredContent when possible
+        # if isinstance(res, dict) and "structuredContent" in res:
+        #     return res["structuredContent"]
+        # # fallback: maybe top-level result
+        return res
+
+    # ----- Session helpers -----
+    def create_session(self, cdpUrl: str) -> str:
+        result = self.call_tool_structured("createSession", {"cdpUrl": cdpUrl})
+        # Many MCP servers put sessionId in structuredContent.sessionId or result.sessionId
+        session_id = None
+        if isinstance(result, dict):
+            session_id = (
+                result.get("sessionId") or result.get("session_id") or result.get("id")
+            )
+        if not session_id:
+            # fallback: try raw result text or content
+            raise MCPError("createSession did not return sessionId")
+        # store meta
+        self._sessions[session_id] = {"created_at": time.time()}
+        return session_id
+
+    def close_session(self, session_id: str) -> bool:
+        try:
+            self.call_tool_structured("closeSession", {"sessionId": session_id})
+            if session_id in self._sessions:
+                del self._sessions[session_id]
+            return True
+        except MCPError:
+            # still remove local record if present
+            self._sessions.pop(session_id, None)
+            raise
+
+    def list_local_sessions(self) -> List[str]:
+        return list(self._sessions.keys())

mcp_client/tools.py

@@ -0,0 +1,173 @@
+from typing import Any, Dict, Optional
+
+from .client import MCPClient
+
+
+class MCPTools:
+    """
+    Wrapper chuẩn cho Google ADK + MCP Server.
+    - Tool nào trả text/html/... → dùng structuredContent
+    - Tool screenshot → trả đúng content để ADK Web hiển thị image
+    """
+
+    def __init__(self, client: MCPClient):
+        self.client = client
+
+    # ======================================================
+    # SESSION MANAGEMENT
+    # ======================================================
+
+    def create_session(self, cdpUrl: str) -> Dict[str, Any]:
+        sid = self.client.create_session(cdpUrl)
+        return {"sessionId": sid}
+
+    def close_session(self, sessionId: str) -> Dict[str, Any]:
+        ok = self.client.close_session(sessionId)
+        return {"ok": bool(ok)}
+
+    def list_sessions(self) -> Dict[str, Any]:
+        return {"sessions": self.client.list_local_sessions()}
+
+    # ======================================================
+    # NAVIGATION & DOM
+    # ======================================================
+
+    def open_page(self, sessionId: str, url: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "openPage", {"sessionId": sessionId, "url": url}
+        ).get("structuredContent", {})
+
+    def get_html(self, sessionId: str) -> Dict[str, Any]:
+        return self.client.call_tool("getHTML", {"sessionId": sessionId}).get(
+            "structuredContent", {}
+        )
+
+    def screenshot(self, sessionId: str) -> Dict[str, Any]:
+        """
+        Trả về đúng phần IMAGE content:
+        {
+          "type": "image",
+          "mimeType": "image/png",
+          "data": "<base64>"
+        }
+        """
+        full = self.client.call_tool("screenshot", {"sessionId": sessionId})
+        return full["content"][0]
+
+    def click(self, sessionId: str, selector: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "click", {"sessionId": sessionId, "selector": selector}
+        ).get("structuredContent", {})
+
+    def type(self, sessionId: str, selector: str, text: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "type", {"sessionId": sessionId, "selector": selector, "text": text}
+        ).get("structuredContent", {})
+
+    def evaluate(self, sessionId: str, expression: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "evaluate", {"sessionId": sessionId, "expression": expression}
+        ).get("structuredContent", {})
+
+    # ======================================================
+    # ELEMENT UTILITIES
+    # ======================================================
+
+    def find_element(self, sessionId: str, selector: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "findElement", {"sessionId": sessionId, "selector": selector}
+        ).get("structuredContent", {})
+
+    def find_all(self, sessionId: str, selector: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "findAll", {"sessionId": sessionId, "selector": selector}
+        ).get("structuredContent", {})
+
+    def get_bounding_box(self, sessionId: str, selector: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "getBoundingBox", {"sessionId": sessionId, "selector": selector}
+        ).get("structuredContent", {})
+
+    def click_bounding_box(self, sessionId: str, selector: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "clickBoundingBox", {"sessionId": sessionId, "selector": selector}
+        ).get("structuredContent", {})
+
+    def upload_file(
+        self, sessionId: str, selector: str, filename: str, base64data: str
+    ) -> Dict[str, Any]:
+        """
+        Upload file vào input[type=file]
+        Args:
+            sessionId: MCP browser session
+            selector: CSS selector, ví dụ 'input[type=file]'
+            filename: tên file trên browser side
+            base64data: dữ liệu base64 (không kèm header)
+        Returns:
+            structured result từ server
+        """
+        return self.client.call_tool(
+            "uploadFile",
+            {
+                "sessionId": sessionId,
+                "selector": selector,
+                "filename": filename,
+                "data": base64data,
+            },
+        ).get("structuredContent", {})
+
+    def wait_for_selector(
+        self, sessionId: str, selector: str, timeoutMs: Optional[int] = None
+    ) -> Dict[str, Any]:
+        args = {"sessionId": sessionId, "selector": selector}
+        if timeoutMs is not None:
+            args["timeoutMs"] = int(timeoutMs)
+
+        return self.client.call_tool("waitForSelector", args).get(
+            "structuredContent", {}
+        )
+
+    # ======================================================
+    # TAB MANAGEMENT
+    # ======================================================
+
+    def new_tab(
+        self, sessionId: str, url: Optional[str] = "about:blank"
+    ) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "newTab", {"sessionId": sessionId, "url": url}
+        ).get("structuredContent", {})
+
+    def switch_tab(self, sessionId: str, targetId: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "switchTab", {"sessionId": sessionId, "targetId": targetId}
+        ).get("structuredContent", {})
+
+    # ======================================================
+    # ADVANCED ACTIONS
+    # ======================================================
+
+    def click_to_text(self, sessionId: str, text: str) -> dict:
+        return self.client.call_tool(
+            "clickToText", {"sessionId": sessionId, "text": text}
+        ).get("structuredContent", {})
+
+    def find_element_xpath(self, sessionId: str, xpath: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "findElementByXPath", {"sessionId": sessionId, "xpath": xpath}
+        ).get("structuredContent", {})
+
+    def find_element_by_text(self, sessionId: str, text: str) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "findElementByText", {"sessionId": sessionId, "text": text}
+        ).get("structuredContent", {})
+
+    def click_by_node_id(self, sessionId: str, nodeId: int) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "clickByNodeId", {"sessionId": sessionId, "nodeId": nodeId}
+        ).get("structuredContent", {})
+
+    def import_cookies(self, sessionId: str, cookies: dict) -> Dict[str, Any]:
+        return self.client.call_tool(
+            "importCookies", {"sessionId": sessionId, "cookies": cookies}
+        ).get("structuredContent", {})