dataify-sdk 0.1.0__py3-none-any.whl

dataify_mcp/client/_sse.py

@@ -0,0 +1,319 @@
+"""SSE (Server-Sent Events) transport for MCP.
+
+Implements the SSE transport: GET ``/sse`` for server-to-client events,
+POST ``/message?sessionId=...`` for client-to-server requests.
+
+Session auth bridging: the initial ``/sse`` connection carries ``?token=``.
+The server stores the auth parameters in Redis keyed by sessionId (24h TTL).
+Subsequent ``/message`` requests only need ``?sessionId=`` — the server
+reads auth from Redis.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from dataify_mcp.types._errors import (
+    AuthenticationError,
+    ConnectionError,
+    ProtocolError,
+    ServerError,
+    TimeoutError,
+)
+from dataify_mcp.types._mcp import JSONRPCError, JSONRPCRequest, JSONRPCResponse
+
+logger = logging.getLogger(__name__)
+
+HEADER_SESSION_ID = "Mcp-Session-Id"
+
+
+@dataclass
+class SSETransport:
+    """SSE transport that uses ``/sse`` + ``/message`` endpoints.
+
+    Parameters
+    ----------
+    base_url:
+        Base URL of the MCP server, e.g. ``http://localhost:7780``.
+    token:
+        Dataify API token passed as ``?token=`` on the initial SSE connection.
+    tool_codes:
+        Optional comma-separated tool codes passed as ``?tools=``.
+    timeout:
+        HTTP request timeout in seconds (default 30).
+    reconnect_delay:
+        Initial delay in seconds before reconnecting on SSE disconnect (default 2).
+    max_reconnect_delay:
+        Maximum delay in seconds for exponential backoff (default 60).
+    """
+
+    base_url: str
+    token: str
+    tool_codes: str | None = None
+    timeout: float = 30.0
+    reconnect_delay: float = 2.0
+    max_reconnect_delay: float = 60.0
+
+    # --- internal state -------------------------------------------------
+
+    _http_client: httpx.AsyncClient | None = None
+    _session_id: str | None = None
+    _pending: dict[int, asyncio.Future[JSONRPCResponse]] | None = None
+    _sse_task: asyncio.Task[None] | None = None
+    _stop_event: asyncio.Event | None = None
+
+    # --- URL construction -----------------------------------------------
+
+    @property
+    def sse_url(self) -> str:
+        """SSE endpoint URL with auth params."""
+        url = f"{self.base_url.rstrip('/')}/sse?token={self.token}"
+        if self.tool_codes:
+            url += f"&tools={self.tool_codes}"
+        return url
+
+    @property
+    def message_url(self) -> str:
+        """Message endpoint URL."""
+        session = self._session_id or ""
+        return f"{self.base_url.rstrip('/')}/message?sessionId={session}"
+
+    # --- lifecycle ------------------------------------------------------
+
+    async def open(self) -> None:
+        """Open the transport: create HTTP client and start the SSE listener."""
+        if self._http_client is not None:
+            return
+
+        self._http_client = httpx.AsyncClient(timeout=httpx.Timeout(self.timeout))
+        self._pending = {}
+        self._stop_event = asyncio.Event()
+        self._sse_task = asyncio.create_task(self._listen_sse())
+
+    async def close(self) -> None:
+        """Close the transport: stop SSE listener and clean up."""
+        if self._stop_event:
+            self._stop_event.set()
+
+        if self._sse_task:
+            self._sse_task.cancel()
+            try:
+                await self._sse_task
+            except asyncio.CancelledError:
+                pass
+            self._sse_task = None
+
+        if self._http_client is not None:
+            await self._http_client.aclose()
+            self._http_client = None
+
+        # Resolve any pending futures as errors
+        if self._pending:
+            for fut in self._pending.values():
+                if not fut.done():
+                    fut.set_exception(ConnectionError("Transport closed"))
+            self._pending.clear()
+
+    @property
+    def is_open(self) -> bool:
+        """Check whether the transport is currently open."""
+        return (
+            self._http_client is not None
+            and not self._http_client.is_closed
+            and self._stop_event is not None
+            and not self._stop_event.is_set()
+        )
+
+    # --- request / response ---------------------------------------------
+
+    async def send_request(self, request: JSONRPCRequest) -> JSONRPCResponse:
+        """Send a JSON-RPC request via POST to ``/message`` and wait for the SSE response.
+
+        Creates a Future keyed by the request id, posts the request, and
+        waits for the SSE listener to resolve the future.
+        """
+        if self._http_client is None or self._pending is None:
+            raise ConnectionError("Transport is not open. Call open() first.")
+
+        if self._session_id is None:
+            raise ConnectionError(
+                "SSE session not yet established. Wait for the SSE listener to connect."
+            )
+
+        # Create a future to bridge POST → SSE
+        fut: asyncio.Future[JSONRPCResponse] = asyncio.get_event_loop().create_future()
+        self._pending[request.id] = fut
+
+        try:
+            body = {
+                "jsonrpc": request.jsonrpc,
+                "id": request.id,
+                "method": request.method,
+                "params": request.params or {},
+            }
+
+            logger.debug("SSE request  id=%d method=%s", request.id, request.method)
+
+            http_resp = await self._http_client.post(
+                self.message_url,
+                json=body,
+                headers={"Content-Type": "application/json"},
+            )
+
+            if http_resp.status_code >= 500:
+                raise ServerError(f"Server returned HTTP {http_resp.status_code}")
+
+            # The response may come back synchronously or via SSE.
+            # If it's a direct response, use it immediately.
+            if http_resp.status_code == 200 and http_resp.text.strip():
+                try:
+                    data = http_resp.json()
+                    resp = JSONRPCResponse(
+                        jsonrpc=data.get("jsonrpc", "2.0"),
+                        id=data.get("id", request.id),
+                        result=data.get("result"),
+                        error=JSONRPCError(**data["error"]) if "error" in data else None,
+                    )
+                    if not fut.done():
+                        fut.set_result(resp)
+                    return resp
+                except json.JSONDecodeError:
+                    pass  # response will come via SSE
+
+            # Wait for the SSE event to deliver the response
+            return await asyncio.wait_for(fut, timeout=self.timeout)
+
+        except asyncio.TimeoutError:
+            raise TimeoutError(
+                f"Request id={request.id} method={request.method} timed out "
+                f"after {self.timeout}s"
+            )
+        except httpx.NetworkError as exc:
+            raise ConnectionError(f"Network error: {exc}") from exc
+        finally:
+            self._pending.pop(request.id, None)
+
+    async def send_notification(self, request: JSONRPCRequest) -> None:
+        """Send a JSON-RPC notification (no response expected)."""
+        if self._http_client is None:
+            raise ConnectionError("Transport is not open.")
+
+        body = {
+            "jsonrpc": request.jsonrpc,
+            "method": request.method,
+            "params": request.params or {},
+        }
+
+        try:
+            await self._http_client.post(
+                self.message_url,
+                json=body,
+                headers={"Content-Type": "application/json"},
+            )
+        except httpx.NetworkError as exc:
+            logger.warning("SSE notification %s failed: %s", request.method, exc)
+
+    # --- SSE listener ---------------------------------------------------
+
+    async def _listen_sse(self) -> None:
+        """Long-running task that consumes SSE events from ``/sse``.
+
+        Handles:
+        * ``endpoint`` event — captures the sessionId for subsequent /message calls.
+        * ``message`` event — delivers JSON-RPC responses, resolving pending futures.
+        * Reconnection with exponential backoff on disconnect.
+        """
+        if self._stop_event is None or self._http_client is None:
+            return
+
+        delay = self.reconnect_delay
+
+        while not self._stop_event.is_set():
+            try:
+                async with self._http_client.stream("GET", self.sse_url) as resp:
+                    if resp.status_code == 401 or resp.status_code == 403:
+                        raise AuthenticationError(
+                            "SSE authentication failed. Check your API token."
+                        )
+                    if resp.status_code >= 500:
+                        raise ServerError(f"SSE server error: HTTP {resp.status_code}")
+
+                    delay = self.reconnect_delay  # reset backoff on successful connect
+
+                    async for line in resp.aiter_lines():
+                        if self._stop_event.is_set():
+                            return
+
+                        if not line:
+                            continue
+
+                        if line.startswith("data:"):
+                            data_str = line[5:].strip()
+                            await self._handle_sse_data(data_str)
+                        elif line.startswith("event:"):
+                            event_type = line[6:].strip()
+                            if event_type == "endpoint":
+                                # The next data line will contain the session endpoint
+                                pass
+
+            except asyncio.CancelledError:
+                return
+            except AuthenticationError:
+                raise  # don't reconnect on auth failures
+            except Exception as exc:
+                logger.warning("SSE stream error: %s. Reconnecting in %.1fs...", exc, delay)
+                try:
+                    await asyncio.wait_for(
+                        self._stop_event.wait(), timeout=delay
+                    )
+                    return  # stop was set
+                except asyncio.TimeoutError:
+                    pass  # time to reconnect
+
+                # Exponential backoff
+                delay = min(delay * 2, self.max_reconnect_delay)
+
+    async def _handle_sse_data(self, data_str: str) -> None:
+        """Parse an SSE data line and dispatch to pending futures."""
+        if not data_str or self._pending is None:
+            return
+
+        try:
+            data = json.loads(data_str)
+        except json.JSONDecodeError:
+            return
+
+        # endpoint event: contains the session URI
+        if isinstance(data, str) and "sessionId=" in data:
+            # Extract sessionId from the URL
+            import urllib.parse
+            parsed = urllib.parse.urlparse(data)
+            qs = urllib.parse.parse_qs(parsed.query)
+            session_ids = qs.get("sessionId", [])
+            if session_ids:
+                self._session_id = session_ids[0]
+                logger.debug("SSE session established: %s", self._session_id)
+            return
+
+        if not isinstance(data, dict):
+            return
+
+        # It's a JSON-RPC response
+        resp_id = data.get("id")
+        if resp_id is not None and resp_id in self._pending:
+            resp = JSONRPCResponse(
+                jsonrpc=data.get("jsonrpc", "2.0"),
+                id=resp_id,
+                result=data.get("result"),
+                error=JSONRPCError(**data["error"]) if "error" in data else None,
+            )
+            fut = self._pending[resp_id]
+            if not fut.done():
+                fut.set_result(resp)

dataify_mcp/tools/__init__.py

@@ -0,0 +1,90 @@
+"""Typed tool wrappers for Dataify MCP tools.
+
+Each sub-module wraps a category of tools with Pydantic models for
+type-safe parameter passing.  These modules are **auto-generated**
+by ``scripts/codegen.py`` from a running Dataify MCP server.
+
+Categories
+----------
+- ``task_status`` — web_unlock_task, web_unlock_statistics, scraper_task_list, etc.
+- ``user`` — query_user_info, query_user_balance, query_user_api_keys, etc.
+- ``web_unlocker`` — request_web_unlocker
+- ``google_serp`` — google_search, google_news, google_images, google_maps, etc.
+- ``google_scraper`` — google_map_details, google_map_comment, google_shopping_info, etc.
+- ``bing`` — bing_search, bing_images, bing_maps, bing_news, etc.
+- ``other_search`` — yandex_search, duckduckgo_search
+- ``amazon`` — scrape_amazon_product, scrape_amazon_comment, etc.
+- ``youtube`` — scrape_youtube_video, scrape_youtube_comment, etc.
+- ``tiktok`` — scrape_tiktok_posts, scrape_tiktok_profiles, etc.
+- ``facebook`` — scrape_facebook_post, scrape_facebook_profile, etc.
+- ``instagram`` — scrape_instagram_profiles, etc.
+- ``reddit`` — scrape_reddit_posts, etc.
+- ``twitter`` — scrape_twitter_post, etc.
+- ``linkedin`` — scrape_linkedin_company_information, etc.
+- ``glassdoor`` — scrape_glassdoor_company, etc.
+- ``indeed`` — scrape_indeed_companies_info, etc.
+- ``other_scrapers`` — airbnb, booking, crunchbase, ebay, github, walmart, zillow
+
+Regenerate with::
+
+    python scripts/codegen.py --server http://localhost:7780 --token YOUR_TOKEN
+"""
+
+from __future__ import annotations
+
+from dataify_mcp.tools import (
+    amazon,
+    bing,
+    facebook,
+    glassdoor,
+    google_scraper,
+    google_serp,
+    indeed,
+    instagram,
+    linkedin,
+    other_scrapers,
+    other_search,
+    reddit,
+    task_status,
+    tiktok,
+    twitter,
+    user,
+    web_unlocker,
+    youtube,
+)
+
+_ALL_MODULES = [
+    task_status,
+    user,
+    web_unlocker,
+    google_serp,
+    google_scraper,
+    bing,
+    other_search,
+    amazon,
+    youtube,
+    tiktok,
+    facebook,
+    instagram,
+    reddit,
+    twitter,
+    linkedin,
+    glassdoor,
+    indeed,
+    other_scrapers,
+]
+
+
+def attach_all(client_cls: type) -> None:
+    """Attach all typed tool methods to a DataifyClient subclass or instance.
+
+    Called automatically by ``DataifyClient.__init__`` so users don't
+    need to invoke this manually.
+
+    Parameters
+    ----------
+    client_cls:
+        The ``DataifyClient`` class (not an instance).
+    """
+    for mod in _ALL_MODULES:
+        mod._attach(client_cls)

dataify_mcp/tools/amazon.py

@@ -0,0 +1,137 @@
+"""Amazon scraper tools.
+
+Wraps all Amazon-related MCP tools: product (5 spider IDs), comment,
+seller, product list, and global product.
+
+Auto-generated.  Regenerate with: python scripts/codegen.py
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+# ---------------------------------------------------------------------------
+# scrape_amazon_product
+# ---------------------------------------------------------------------------
+
+
+class ScrapeAmazonProductParams(BaseModel):
+    """Parameters for ``scrape_amazon_product``.
+
+    采集 Amazon 产品详情。支持 5 种采集方式: by-asin, by-url,
+    by-keywords, by-category-url, by-best-sellers。
+    """
+
+    spider_id: str = Field(
+        default="amazon_product_by-asin",
+        description="采集器标识: amazon_product_by-asin / by-url / by-keywords / by-category-url / by-best-sellers",
+    )
+    asin: str | None = Field(default="B0BZYCJK89", description="ASIN (用于 by-asin)")
+    url: str | None = Field(default="", description="产品/类别/畅销商品 URL (用于 by-url/by-category-url/by-best-sellers)")
+    category_url: str | None = Field(default="", description="畅销类别 URL (用于 by-best-sellers)")
+    keyword: str | None = Field(default="coffee", description="搜索关键词 (用于 by-keywords)")
+    page_turning: str | None = Field(default="", description="采集页数 (用于 by-keywords/by-category-url/by-best-sellers)")
+    lowest_price: str | None = Field(default="20", description="最低价格 (用于 by-keywords)")
+    highest_price: str | None = Field(default="50", description="最高价格 (用于 by-keywords)")
+    sort_by: str | None = Field(default="畅销排行", description="排序方式 (用于 by-category-url)")
+    collect_subcategories: str | None = Field(default="", description="收集子类别 (用于 by-category-url)")
+    zip_code: str | None = Field(default="94107", description="邮政编码 (用于 by-url)")
+    file_name: str | None = Field(default="{{TasksID}}", description="Builder file_name")
+
+
+async def scrape_amazon_product(self, params: ScrapeAmazonProductParams | None = None) -> Any:
+    """Call ``scrape_amazon_product`` — Amazon 产品详情采集。
+
+    通过 ASIN、URL、关键词、类别 URL 或畅销排行榜采集 Amazon 产品详情。
+    """
+    arguments = params.model_dump(exclude_none=True) if params else {}
+    return await self.call_tool("scrape_amazon_product", arguments)
+
+
+# ---------------------------------------------------------------------------
+# scrape_amazon_comment
+# ---------------------------------------------------------------------------
+
+
+class ScrapeAmazonCommentParams(BaseModel):
+    """Parameters for ``scrape_amazon_comment`` — Amazon 评论采集。"""
+
+    url: str = Field(..., description="Amazon 产品评论页面 URL")
+    file_name: str | None = Field(default="{{TasksID}}", description="Builder file_name")
+
+
+async def scrape_amazon_comment(self, params: ScrapeAmazonCommentParams | None = None) -> Any:
+    """Call ``scrape_amazon_comment`` — Amazon 评论采集。"""
+    arguments = params.model_dump(exclude_none=True) if params else {}
+    return await self.call_tool("scrape_amazon_comment", arguments)
+
+
+# ---------------------------------------------------------------------------
+# scrape_amazon_seller
+# ---------------------------------------------------------------------------
+
+
+class ScrapeAmazonSellerParams(BaseModel):
+    """Parameters for ``scrape_amazon_seller`` — Amazon 卖家信息采集。"""
+
+    url: str = Field(..., description="Amazon 卖家页面 URL")
+    file_name: str | None = Field(default="{{TasksID}}", description="Builder file_name")
+
+
+async def scrape_amazon_seller(self, params: ScrapeAmazonSellerParams | None = None) -> Any:
+    """Call ``scrape_amazon_seller`` — Amazon 卖家信息采集。"""
+    arguments = params.model_dump(exclude_none=True) if params else {}
+    return await self.call_tool("scrape_amazon_seller", arguments)
+
+
+# ---------------------------------------------------------------------------
+# scrape_amazon_product_list
+# ---------------------------------------------------------------------------
+
+
+class ScrapeAmazonProductListParams(BaseModel):
+    """Parameters for ``scrape_amazon_product_list`` — Amazon 产品列表采集。"""
+
+    url: str = Field(..., description="Amazon 产品列表/搜索结果 URL")
+    file_name: str | None = Field(default="{{TasksID}}", description="Builder file_name")
+
+
+async def scrape_amazon_product_list(self, params: ScrapeAmazonProductListParams | None = None) -> Any:
+    """Call ``scrape_amazon_product_list`` — Amazon 产品列表采集。"""
+    arguments = params.model_dump(exclude_none=True) if params else {}
+    return await self.call_tool("scrape_amazon_product_list", arguments)
+
+
+# ---------------------------------------------------------------------------
+# scrape_amazon_global_product
+# ---------------------------------------------------------------------------
+
+
+class ScrapeAmazonGlobalProductParams(BaseModel):
+    """Parameters for ``scrape_amazon_global_product`` — Amazon 全球产品采集。"""
+
+    url: str = Field(..., description="Amazon 全球站点产品 URL")
+    file_name: str | None = Field(default="{{TasksID}}", description="Builder file_name")
+
+
+async def scrape_amazon_global_product(self, params: ScrapeAmazonGlobalProductParams | None = None) -> Any:
+    """Call ``scrape_amazon_global_product`` — Amazon 全球产品采集。"""
+    arguments = params.model_dump(exclude_none=True) if params else {}
+    return await self.call_tool("scrape_amazon_global_product", arguments)
+
+
+# ---------------------------------------------------------------------------
+# Attach methods to DataifyClient
+# ---------------------------------------------------------------------------
+
+
+def _attach(client_cls: type) -> None:
+    """Attach all Amazon scraper methods to the client class."""
+    client_cls.scrape_amazon_product = scrape_amazon_product
+    client_cls.scrape_amazon_comment = scrape_amazon_comment
+    client_cls.scrape_amazon_seller = scrape_amazon_seller
+    client_cls.scrape_amazon_product_list = scrape_amazon_product_list
+    client_cls.scrape_amazon_global_product = scrape_amazon_global_product

dataify_mcp/tools/bing.py

@@ -0,0 +1,141 @@
+"""Bing search tools.
+
+Wraps all Bing search variant MCP tools: search, images, maps, news,
+shopping, and videos.
+
+Auto-generated.  Regenerate with: python scripts/codegen.py
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+# ---------------------------------------------------------------------------
+# bing_search
+# ---------------------------------------------------------------------------
+
+
+class BingSearchParams(BaseModel):
+    """Parameters for ``bing_search`` — Bing 网页搜索。
+
+    通过 Bing 搜索公开网页信息，按位置、国家/地区、语言等条件获取结果。
+    """
+
+    model_config = {"protected_namespaces": ()}
+
+    q: str = Field(default="Pizza", description="搜索查询内容")
+    json: str | None = Field(default="1", description="输出格式: 1 JSON, 2 JSON+HTML, 3 HTML, 4 Light JSON")
+    location: str | None = Field(default="", description="搜索发起的地理位置")
+    lat: str | None = Field(default="", description="GPS 纬度")
+    lon: str | None = Field(default="", description="GPS 经度")
+    mkt: str | None = Field(default="", description="显示语言 <语言代码>-<国家/地区代码>，如 en-US")
+    cc: str | None = Field(default="", description="国家/地区代码 (两位)")
+    first: str | None = Field(default="0", description="结果偏移量")
+    safeSearch: str | None = Field(default="", description="成人内容过滤: Off, Moderate, Strict")
+    filters: str | None = Field(default="", description="高级过滤选项")
+    no_cache: str | None = Field(default="false", description="是否跳过缓存")
+
+
+async def bing_search(self, params: BingSearchParams | None = None) -> Any:
+    """Call ``bing_search`` — Bing 网页搜索。"""
+    arguments = params.model_dump(exclude_none=True) if params else {}
+    return await self.call_tool("bing_search", arguments)
+
+
+# ---------------------------------------------------------------------------
+# bing_images
+# ---------------------------------------------------------------------------
+
+
+class BingImagesParams(BaseModel):
+    """Parameters for ``bing_images`` — Bing 图片搜索。"""
+
+    model_config = {"protected_namespaces": ()}
+
+    q: str = Field(default="Pizza", description="搜索查询内容")
+    json: str | None = Field(default="1", description="输出格式")
+    mkt: str | None = Field(default="", description="显示语言")
+    cc: str | None = Field(default="", description="国家/地区代码")
+    first: str | None = Field(default="0", description="结果偏移量")
+    safeSearch: str | None = Field(default="", description="成人内容过滤")
+    no_cache: str | None = Field(default="false", description="是否跳过缓存")
+
+
+async def bing_images(self, params: BingImagesParams | None = None) -> Any:
+    """Call ``bing_images`` — Bing 图片搜索。"""
+    arguments = params.model_dump(exclude_none=True) if params else {}
+    return await self.call_tool("bing_images", arguments)
+
+
+# ---------------------------------------------------------------------------
+# bing_maps, bing_news, bing_shopping, bing_videos
+# ---------------------------------------------------------------------------
+
+
+class _BingVariantParams(BaseModel):
+    """Shared params for Bing variants (maps, news, shopping, videos)."""
+
+    model_config = {"protected_namespaces": ()}
+
+    q: str = Field(default="Pizza", description="搜索查询内容")
+    json: str | None = Field(default="1", description="输出格式")
+    mkt: str | None = Field(default="", description="显示语言")
+    cc: str | None = Field(default="", description="国家/地区代码")
+    first: str | None = Field(default="0", description="结果偏移量")
+    safeSearch: str | None = Field(default="", description="成人内容过滤")
+    no_cache: str | None = Field(default="false", description="是否跳过缓存")
+
+
+class BingMapsParams(_BingVariantParams):
+    """Parameters for ``bing_maps`` — Bing 地图搜索。"""
+    pass
+
+
+class BingNewsParams(_BingVariantParams):
+    """Parameters for ``bing_news`` — Bing 新闻搜索。"""
+    pass
+
+
+class BingShoppingParams(_BingVariantParams):
+    """Parameters for ``bing_shopping`` — Bing 购物搜索。"""
+    pass
+
+
+class BingVideosParams(_BingVariantParams):
+    """Parameters for ``bing_videos`` — Bing 视频搜索。"""
+    pass
+
+
+_BING_TOOLS = {
+    "bing_maps": ("Bing 地图搜索", BingMapsParams),
+    "bing_news": ("Bing 新闻搜索", BingNewsParams),
+    "bing_shopping": ("Bing 购物搜索", BingShoppingParams),
+    "bing_videos": ("Bing 视频搜索", BingVideosParams),
+}
+
+
+def _make_bing_method(tool_name: str, desc: str, param_cls: type[BaseModel]):
+    async def _method(self, params: param_cls | None = None) -> Any:  # type: ignore[valid-type]
+        arguments = params.model_dump(exclude_none=True) if params else {}
+        return await self.call_tool(tool_name, arguments)
+
+    _method.__name__ = tool_name
+    _method.__doc__ = f"""Call ``{tool_name}`` — {desc}."""
+    return _method
+
+
+# ---------------------------------------------------------------------------
+# Attach methods to DataifyClient
+# ---------------------------------------------------------------------------
+
+
+def _attach(client_cls: type) -> None:
+    """Attach all Bing methods to the client class."""
+    client_cls.bing_search = bing_search
+    client_cls.bing_images = bing_images
+
+    for tool_name, (desc, param_cls) in _BING_TOOLS.items():
+        setattr(client_cls, tool_name, _make_bing_method(tool_name, desc, param_cls))