langchain-webz 0.1.0__tar.gz

langchain_webz-0.1.0/.env.example

@@ -0,0 +1,2 @@
+WEBZ_API_TOKEN=
+WEBZ_MCP_URL=https://news-search-mcp.webz.io/mcp

langchain_webz-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+.venv/
+venv/
+.idea/
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.env
+.env.*
+!.env.example
+langchain_tests/
+node_modules/
+*.db

langchain_webz-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Webz.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_webz-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.5
+Name: langchain-webz
+Version: 0.1.0
+Summary: LangChain / LangGraph tools for Webz.io News Search via the hosted MCP server
+Project-URL: Homepage, https://news-search-mcp.webz.io
+Project-URL: Documentation, https://news-search-mcp.webz.io
+Project-URL: Issues, https://github.com/Webhose/webz-news-search/issues
+Author-email: "Webz.io" <support@webz.io>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: langchain,langgraph,mcp,news,search,webz
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: langchain-mcp-adapters>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# langchain-webz
+
+LangChain and LangGraph tools for [Webz.io News Search](https://news-search-mcp.webz.io).
+
+This package does not hardcode search filters. It connects to the hosted MCP server and loads the live tool schema with `tools/list`. When the MCP adds a filter, agents see it on the next connection.
+
+```bash
+pip install langchain-webz
+export WEBZ_API_TOKEN="your-webz-api-token"
+```
+
+## Direct tool call
+
+```python
+from langchain_webz import WebzNewsSearch
+
+# env: WEBZ_API_TOKEN
+tool = WebzNewsSearch()
+
+# or pass the token in code
+tool = WebzNewsSearch(api_token="your-webz-api-token")
+
+print(tool.invoke({"query": "AI regulation Europe"}))
+```
+
+## Agent / LangGraph
+
+```python
+from langchain.agents import create_agent
+from langchain_webz import get_webz_tools
+
+tools = get_webz_tools()
+agent = create_agent("openai:gpt-4.1-mini", tools)
+result = agent.invoke({"messages": [{"role": "user", "content": "What is the latest EU AI news?"}]})
+print(result["messages"][-1].content)
+```
+
+Inside an already running event loop, use the async helpers:
+
+```python
+from langchain_webz import aget_webz_tools, awebz_news_search
+
+tools = await aget_webz_tools()
+tool = await awebz_news_search()
+```
+
+## Config
+
+| Name | Default | Purpose |
+| --- | --- | --- |
+| `WEBZ_API_TOKEN` | required | Webz API token from the dashboard |
+| `WEBZ_MCP_URL` | `https://news-search-mcp.webz.io/mcp` | override for local MCP |
+
+You can also pass `api_token=` and `mcp_url=` to the helpers.
+
+Get a token: https://webz.io

langchain_webz-0.1.0/README.md

@@ -0,0 +1,56 @@
+# langchain-webz
+
+LangChain and LangGraph tools for [Webz.io News Search](https://news-search-mcp.webz.io).
+
+This package does not hardcode search filters. It connects to the hosted MCP server and loads the live tool schema with `tools/list`. When the MCP adds a filter, agents see it on the next connection.
+
+```bash
+pip install langchain-webz
+export WEBZ_API_TOKEN="your-webz-api-token"
+```
+
+## Direct tool call
+
+```python
+from langchain_webz import WebzNewsSearch
+
+# env: WEBZ_API_TOKEN
+tool = WebzNewsSearch()
+
+# or pass the token in code
+tool = WebzNewsSearch(api_token="your-webz-api-token")
+
+print(tool.invoke({"query": "AI regulation Europe"}))
+```
+
+## Agent / LangGraph
+
+```python
+from langchain.agents import create_agent
+from langchain_webz import get_webz_tools
+
+tools = get_webz_tools()
+agent = create_agent("openai:gpt-4.1-mini", tools)
+result = agent.invoke({"messages": [{"role": "user", "content": "What is the latest EU AI news?"}]})
+print(result["messages"][-1].content)
+```
+
+Inside an already running event loop, use the async helpers:
+
+```python
+from langchain_webz import aget_webz_tools, awebz_news_search
+
+tools = await aget_webz_tools()
+tool = await awebz_news_search()
+```
+
+## Config
+
+| Name | Default | Purpose |
+| --- | --- | --- |
+| `WEBZ_API_TOKEN` | required | Webz API token from the dashboard |
+| `WEBZ_MCP_URL` | `https://news-search-mcp.webz.io/mcp` | override for local MCP |
+
+You can also pass `api_token=` and `mcp_url=` to the helpers.
+
+Get a token: https://webz.io

langchain_webz-0.1.0/examples/run_news_search.py

@@ -0,0 +1,39 @@
+"""
+run a single News Search call through the LangChain wrapper.
+
+usage:
+  export WEBZ_API_TOKEN="your-token"
+  python examples/run_news_search.py
+
+or pass the token in code with WebzNewsSearch(api_token="...").
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from langchain_webz import WebzNewsSearch
+
+QUERY = "How many goals does Cristiano have and how many left to 1000?"
+
+
+def main() -> None:
+    # preferred: WEBZ_API_TOKEN in the environment
+    # also valid: WebzNewsSearch(api_token="paste-token-here")
+    token = os.getenv("WEBZ_API_TOKEN")
+    tool = WebzNewsSearch(api_token=token) if token else WebzNewsSearch()
+
+    print("tool name:", tool.name)
+    print("live args from MCP tools/list:", sorted(tool.args))
+    print("---")
+    print(tool.invoke({"query": QUERY, "k": 3}), end="\n\n")
+    print("SUCCESS ! End of tool")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as exc:
+        print(f"search failed: {exc}", file=sys.stderr)
+        raise SystemExit(1)

langchain_webz-0.1.0/langchain_webz/__init__.py

@@ -0,0 +1,18 @@
+from langchain_webz.client import (
+    WebzConfigError,
+    WebzNewsSearch,
+    aget_webz_tools,
+    awebz_news_search,
+    get_webz_tools,
+)
+from langchain_webz.consts import DEFAULT_MCP_URL, TOKEN_ENV_NAME
+
+__all__ = [
+    "DEFAULT_MCP_URL",
+    "TOKEN_ENV_NAME",
+    "WebzConfigError",
+    "WebzNewsSearch",
+    "aget_webz_tools",
+    "awebz_news_search",
+    "get_webz_tools",
+]

langchain_webz-0.1.0/langchain_webz/client.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from collections.abc import Coroutine
+from typing import Any, TypeVar
+
+from langchain_core.tools import BaseTool, StructuredTool
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+from langchain_webz.consts import (
+    DEFAULT_MCP_URL,
+    MCP_SERVER_NAME,
+    MCP_TRANSPORT,
+    MCP_URL_ENV_NAME,
+    PREFERRED_TOOL_NAME,
+    TOKEN_ENV_NAME,
+)
+
+T = TypeVar("T")
+
+
+class WebzConfigError(ValueError):
+    """raised when the Webz MCP client cannot be configured or loaded."""
+
+
+def resolve_api_token(api_token: str | None = None) -> str:
+    token = (api_token or os.getenv(TOKEN_ENV_NAME) or "").strip()
+    if not token:
+        raise WebzConfigError(
+            f"missing Webz API token. set {TOKEN_ENV_NAME} or pass api_token."
+        )
+    return token
+
+
+def resolve_mcp_url(mcp_url: str | None = None) -> str:
+    url = (mcp_url or os.getenv(MCP_URL_ENV_NAME) or DEFAULT_MCP_URL).strip()
+    if not url:
+        raise WebzConfigError("missing MCP url.")
+    return url.rstrip("/")
+
+
+def build_mcp_connection(api_token: str, mcp_url: str) -> dict[str, dict[str, Any]]:
+    return {
+        MCP_SERVER_NAME: {
+            "transport": MCP_TRANSPORT,
+            "url": mcp_url,
+            "headers": {"Authorization": f"Bearer {api_token}"},
+        }
+    }
+
+
+def pick_news_search_tool(tools: list[BaseTool]) -> BaseTool:
+    if not tools:
+        raise WebzConfigError("MCP server returned no tools.")
+    for tool in tools:
+        if tool.name == PREFERRED_TOOL_NAME:
+            return tool
+    if len(tools) == 1:
+        return tools[0]
+    names = ", ".join(tool.name for tool in tools)
+    raise WebzConfigError(
+        f"MCP server did not expose {PREFERRED_TOOL_NAME}. available tools: {names}"
+    )
+
+
+def flatten_tool_result(result: Any) -> str:
+    """turns MCP/LangChain content blocks into the article text string."""
+    if isinstance(result, tuple) and result:
+        result = result[0]
+    if isinstance(result, str):
+        return result
+    if isinstance(result, list):
+        parts: list[str] = []
+        for item in result:
+            if isinstance(item, str):
+                parts.append(item)
+            elif isinstance(item, dict) and item.get("text"):
+                parts.append(str(item["text"]))
+        return "\n".join(parts)
+    return str(result)
+
+
+def enable_sync_invoke(tool: BaseTool) -> BaseTool:
+    """adds sync invoke and flattens MCP content blocks to text."""
+    if not isinstance(tool, StructuredTool) or tool.coroutine is None:
+        return tool
+    coroutine = tool.coroutine
+
+    async def run_async(*args: Any, **kwargs: Any) -> str:
+        return flatten_tool_result(await coroutine(*args, **kwargs))
+
+    def run_sync(*args: Any, **kwargs: Any) -> str:
+        return run_coroutine_sync(run_async(*args, **kwargs))
+
+    return tool.model_copy(
+        update={
+            "func": run_sync,
+            "coroutine": run_async,
+            "response_format": "content",
+        }
+    )
+
+
+def run_coroutine_sync(coro: Coroutine[Any, Any, T]) -> T:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    raise WebzConfigError(
+        "cannot call the sync helper from a running event loop. "
+        "use await aget_webz_tools() or await awebz_news_search()."
+    )
+
+
+async def aget_webz_tools(
+    api_token: str | None = None,
+    mcp_url: str | None = None,
+) -> list[BaseTool]:
+    """
+    loads every tool from the hosted Webz MCP server.
+
+    params:
+    - api_token: webz api token. defaults to WEBZ_API_TOKEN.
+    - mcp_url: mcp endpoint. defaults to production.
+
+    returns:
+    - langchain tools whose schemas come from tools/list.
+    """
+    token = resolve_api_token(api_token)
+    url = resolve_mcp_url(mcp_url)
+    client = MultiServerMCPClient(build_mcp_connection(token, url))
+    # ponytail: schemas come from MCP tools/list; new filters ship with the server, not this package
+    tools = await client.get_tools()
+    if not tools:
+        raise WebzConfigError(f"MCP server at {url} returned no tools.")
+    return [enable_sync_invoke(tool) for tool in tools]
+
+
+def get_webz_tools(
+    api_token: str | None = None,
+    mcp_url: str | None = None,
+) -> list[BaseTool]:
+    return run_coroutine_sync(aget_webz_tools(api_token=api_token, mcp_url=mcp_url))
+
+
+async def awebz_news_search(
+    api_token: str | None = None,
+    mcp_url: str | None = None,
+) -> BaseTool:
+    tools = await aget_webz_tools(api_token=api_token, mcp_url=mcp_url)
+    return pick_news_search_tool(tools)
+
+
+def WebzNewsSearch(
+    api_token: str | None = None,
+    mcp_url: str | None = None,
+) -> BaseTool:
+    """
+    returns the live news search tool from the hosted MCP server.
+
+    params:
+    - api_token: webz api token. defaults to WEBZ_API_TOKEN.
+    - mcp_url: mcp endpoint. defaults to production.
+
+    returns:
+    - langchain tool with the current MCP input schema.
+    """
+    return run_coroutine_sync(
+        awebz_news_search(api_token=api_token, mcp_url=mcp_url)
+    )

langchain_webz-0.1.0/langchain_webz/consts.py

@@ -0,0 +1,6 @@
+DEFAULT_MCP_URL = "https://news-search-mcp.webz.io/mcp"
+TOKEN_ENV_NAME = "WEBZ_API_TOKEN"
+MCP_URL_ENV_NAME = "WEBZ_MCP_URL"
+MCP_SERVER_NAME = "webz-news-search"
+PREFERRED_TOOL_NAME = "news_search_by_webz"
+MCP_TRANSPORT = "http"

langchain_webz-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-webz"
+version = "0.1.0"
+description = "LangChain / LangGraph tools for Webz.io News Search via the hosted MCP server"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Webz.io", email = "support@webz.io" },
+]
+keywords = ["langchain", "langgraph", "webz", "news", "mcp", "search"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "langchain-core>=0.3.0",
+    "langchain-mcp-adapters>=0.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+]
+
+[project.urls]
+Homepage = "https://news-search-mcp.webz.io"
+Documentation = "https://news-search-mcp.webz.io"
+Issues = "https://github.com/Webhose/webz-news-search/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["langchain_webz"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["."]

langchain_webz-0.1.0/tests/test_client.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+from langchain_core.tools import BaseTool, StructuredTool, tool
+
+from langchain_webz.client import (
+    WebzConfigError,
+    WebzNewsSearch,
+    aget_webz_tools,
+    build_mcp_connection,
+    enable_sync_invoke,
+    get_webz_tools,
+    pick_news_search_tool,
+    resolve_api_token,
+    resolve_mcp_url,
+)
+from langchain_webz.consts import (
+    DEFAULT_MCP_URL,
+    MCP_SERVER_NAME,
+    MCP_TRANSPORT,
+    PREFERRED_TOOL_NAME,
+    TOKEN_ENV_NAME,
+)
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+CLIENT_SOURCE = (PACKAGE_ROOT / "langchain_webz" / "client.py").read_text(encoding="utf-8")
+CONSTS_SOURCE = (PACKAGE_ROOT / "langchain_webz" / "consts.py").read_text(encoding="utf-8")
+
+FILTER_NAMES_OWNED_BY_MCP = (
+    "allow_all_dates",
+    "exclude_domain",
+    "domain_rank_gte",
+    "domain_rank_lte",
+    "trust_category",
+    "political_bias",
+    "min_similarity",
+    "allow_multiple_chunks_per_article",
+)
+
+
+@tool(PREFERRED_TOOL_NAME)
+def fake_news_search(query: str, extra_filter: str = "x") -> str:
+    """fake news search tool used in unit tests."""
+    return f"{query}:{extra_filter}"
+
+
+@tool
+def fake_other_tool(value: str) -> str:
+    """second fake tool to prove all MCP tools are forwarded."""
+    return value
+
+
+class FakeMcpClient:
+    def __init__(self, connections: dict) -> None:
+        self.connections = connections
+
+    async def get_tools(self) -> list[BaseTool]:
+        return [fake_news_search, fake_other_tool]
+
+
+class EmptyMcpClient(FakeMcpClient):
+    async def get_tools(self) -> list[BaseTool]:
+        return []
+
+
+def test_resolve_api_token_requires_value(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv(TOKEN_ENV_NAME, raising=False)
+    with pytest.raises(WebzConfigError, match="missing Webz API token"):
+        resolve_api_token()
+
+
+def test_resolve_api_token_prefers_argument(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(TOKEN_ENV_NAME, "from-env")
+    assert resolve_api_token(" from-arg ") == "from-arg"
+
+
+def test_resolve_mcp_url_default_and_override(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("WEBZ_MCP_URL", raising=False)
+    assert resolve_mcp_url() == DEFAULT_MCP_URL
+    assert resolve_mcp_url("https://localhost:8765/mcp/") == "https://localhost:8765/mcp"
+
+
+def test_build_mcp_connection_uses_bearer_header() -> None:
+    connection = build_mcp_connection("secret-token", DEFAULT_MCP_URL)
+    server = connection[MCP_SERVER_NAME]
+    assert server["transport"] == MCP_TRANSPORT
+    assert server["url"] == DEFAULT_MCP_URL
+    assert server["headers"]["Authorization"] == "Bearer secret-token"
+
+
+def test_pick_prefers_named_news_tool() -> None:
+    preferred = SimpleNamespace(name=PREFERRED_TOOL_NAME)
+    other = SimpleNamespace(name="other_tool")
+    assert pick_news_search_tool([other, preferred]) is preferred
+
+
+def test_pick_falls_back_to_single_tool() -> None:
+    only = SimpleNamespace(name="whatever_the_server_exposes")
+    assert pick_news_search_tool([only]) is only
+
+
+def test_pick_errors_when_preferred_missing_among_many() -> None:
+    with pytest.raises(WebzConfigError, match="did not expose"):
+        pick_news_search_tool(
+            [SimpleNamespace(name="alpha"), SimpleNamespace(name="beta")]
+        )
+
+
+@pytest.mark.asyncio
+async def test_aget_webz_tools_loads_whatever_mcp_returns(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured: dict = {}
+
+    def fake_client_ctor(connections: dict) -> FakeMcpClient:
+        captured["connections"] = connections
+        return FakeMcpClient(connections)
+
+    monkeypatch.setattr("langchain_webz.client.MultiServerMCPClient", fake_client_ctor)
+    tools = await aget_webz_tools(api_token="tok", mcp_url="https://example.test/mcp")
+    assert [item.name for item in tools] == [PREFERRED_TOOL_NAME, "fake_other_tool"]
+    assert "extra_filter" in inspect.signature(fake_news_search.func).parameters
+    server = captured["connections"][MCP_SERVER_NAME]
+    assert server["url"] == "https://example.test/mcp"
+    assert server["headers"]["Authorization"] == "Bearer tok"
+
+
+@pytest.mark.asyncio
+async def test_aget_webz_tools_rejects_empty_server(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr("langchain_webz.client.MultiServerMCPClient", EmptyMcpClient)
+    with pytest.raises(WebzConfigError, match="returned no tools"):
+        await aget_webz_tools(api_token="tok")
+
+
+def test_sync_helpers_use_loaded_tools(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("langchain_webz.client.MultiServerMCPClient", FakeMcpClient)
+    tools = get_webz_tools(api_token="tok")
+    news_tool = WebzNewsSearch(api_token="tok")
+    assert [item.name for item in tools] == [PREFERRED_TOOL_NAME, "fake_other_tool"]
+    assert news_tool.name == PREFERRED_TOOL_NAME
+    assert "extra_filter" in news_tool.args
+    assert "query" in news_tool.args
+
+
+def test_wrapper_source_does_not_hardcode_mcp_filters() -> None:
+    combined = CLIENT_SOURCE + CONSTS_SOURCE
+    for name in FILTER_NAMES_OWNED_BY_MCP:
+        assert name not in combined, f"wrapper must not hardcode MCP filter {name}"
+
+
+def test_public_exports() -> None:
+    import langchain_webz
+
+    for name in (
+        "WebzNewsSearch",
+        "get_webz_tools",
+        "aget_webz_tools",
+        "awebz_news_search",
+        "WebzConfigError",
+        "DEFAULT_MCP_URL",
+        "TOKEN_ENV_NAME",
+    ):
+        assert hasattr(langchain_webz, name)
+
+
+def test_enable_sync_invoke_allows_tool_invoke() -> None:
+    async def call_tool(*, query: str) -> str:
+        return f"got {query}"
+
+    async_only = StructuredTool(
+        name=PREFERRED_TOOL_NAME,
+        description="async-only mcp-style tool",
+        args_schema={
+            "type": "object",
+            "properties": {"query": {"type": "string"}},
+            "required": ["query"],
+        },
+        coroutine=call_tool,
+    )
+    with pytest.raises(NotImplementedError, match="sync invocation"):
+        async_only.invoke({"query": "hi"})
+
+    wrapped = enable_sync_invoke(async_only)
+    assert wrapped.invoke({"query": "hi"}) == "got hi"
+
+
+def test_enable_sync_invoke_flattens_content_and_artifact() -> None:
+    async def call_tool(*, query: str) -> list[dict[str, str]]:
+        return [{"type": "text", "text": f"Query: {query}", "id": "lc_test"}]
+
+    mcp_style = StructuredTool(
+        name=PREFERRED_TOOL_NAME,
+        description="mcp content_and_artifact tool",
+        args_schema={
+            "type": "object",
+            "properties": {"query": {"type": "string"}},
+            "required": ["query"],
+        },
+        coroutine=call_tool,
+        response_format="content_and_artifact",
+    )
+    wrapped = enable_sync_invoke(mcp_style)
+    assert wrapped.response_format == "content"
+    assert wrapped.invoke({"query": "AI"}) == "Query: AI"
+
+
+def test_flatten_tool_result_unwraps_content_blocks() -> None:
+    from langchain_webz.client import flatten_tool_result
+
+    blocks = [
+        {
+            "type": "text",
+            "text": "Query: AI regulation Europe\nTitle: Example",
+            "id": "lc_test",
+        }
+    ]
+    assert flatten_tool_result(blocks) == "Query: AI regulation Europe\nTitle: Example"
+    assert flatten_tool_result((blocks, None)) == "Query: AI regulation Europe\nTitle: Example"
+    assert flatten_tool_result("already text") == "already text"

langchain_webz-0.1.0/tests/test_live.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from langchain_webz import WebzNewsSearch, get_webz_tools
+from langchain_webz.consts import PREFERRED_TOOL_NAME
+
+pytestmark = pytest.mark.skipif(
+    not os.getenv("WEBZ_API_TOKEN"),
+    reason="WEBZ_API_TOKEN is not set",
+)
+
+
+def test_live_tools_come_from_hosted_mcp() -> None:
+    tools = get_webz_tools()
+    names = [tool.name for tool in tools]
+    assert PREFERRED_TOOL_NAME in names
+    news_tool = next(tool for tool in tools if tool.name == PREFERRED_TOOL_NAME)
+    assert "query" in news_tool.args
+
+
+def test_live_news_search_invoke() -> None:
+    tool = WebzNewsSearch()
+    result = tool.invoke({"query": "AI regulation Europe", "k": 1})
+    assert isinstance(result, str)
+    assert "Query:" in result
+    assert result.strip()