langchain-verifly 0.1.0__tar.gz

langchain_verifly-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Verifly
+
+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_verifly-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: langchain-verifly
+Version: 0.1.0
+Summary: An integration package connecting Verifly (agent-native email verification) and LangChain
+Author-email: Verifly <support@verifly.email>
+License: MIT
+Project-URL: Homepage, https://verifly.email
+Project-URL: Repository, https://github.com/james-sib/langchain-verifly
+Project-URL: Source Code, https://github.com/james-sib/langchain-verifly/tree/master/langchain_verifly
+Keywords: langchain,verifly,email-verification,email-validation,deliverability,agents,tools
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core<0.4,>=0.3
+Requires-Dist: httpx>=0.27
+Provides-Extra: test
+Requires-Dist: pytest>=7.4; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Dynamic: license-file
+
+# langchain-verifly
+
+LangChain integration for [Verifly](https://verifly.email) — **agent-native email verification**.
+
+`langchain-verifly` gives any LangChain agent a single, well-described tool to
+check whether an email address is real and deliverable *before* it sends a
+message or accepts a signup. It wraps the Verifly verification API and returns a
+clean, structured verdict (deliverable / undeliverable / risky), the reason, a
+confidence score, and an actionable send-or-reject recommendation.
+
+## Installation
+
+```bash
+pip install -U langchain-verifly
+```
+
+## Setup
+
+Set your Verifly API key in the environment. You can self-onboard for a key
+(with free credits) at [verifly.email](https://verifly.email).
+
+```bash
+export VERIFLY_API_KEY="vf_..."
+```
+
+## Tool: `VeriflyEmailVerifier`
+
+A LangChain `BaseTool` with both sync and async support.
+
+```python
+from langchain_verifly import VeriflyEmailVerifier
+
+verifier = VeriflyEmailVerifier()  # reads VERIFLY_API_KEY from the environment
+
+verifier.invoke({"email": "lead@example.com"})
+```
+
+```python
+{
+    "email": "lead@example.com",
+    "result": "deliverable",
+    "reason": "Mailbox exists",
+    "confidence": 95,
+    "is_valid": True,
+    "recommendation": "send",
+    "did_you_mean": None,
+    "details": {
+        "syntax_valid": True,
+        "domain_exists": True,
+        "mx_records": True,
+        "smtp_valid": True,
+        "is_disposable": False,
+        "is_role_account": False,
+        "is_catch_all": False,
+        "is_free_provider": False,
+        "provider": "example.com",
+    },
+}
+```
+
+Async works too:
+
+```python
+await verifier.ainvoke({"email": "lead@example.com"})
+```
+
+You can also pass the key explicitly instead of using the environment variable:
+
+```python
+verifier = VeriflyEmailVerifier(api_key="vf_...")
+```
+
+## Use it in an agent
+
+```python
+from langchain.agents import create_react_agent  # or any agent constructor
+from langchain_verifly import VeriflyEmailVerifier
+
+tools = [VeriflyEmailVerifier()]
+# ... wire `tools` into your agent / model.bind_tools(tools) as usual
+```
+
+The agent can now verify an address on its own — for example, scrubbing a lead
+list, validating a user-supplied email at signup, or confirming a contact
+before drafting an outreach email.
+
+## Verdict fields
+
+| Field | Meaning |
+|-------|---------|
+| `result` | `deliverable`, `undeliverable`, or `risky` |
+| `reason` | Human-readable explanation of the verdict |
+| `confidence` | Confidence score, 0–100 |
+| `is_valid` | Whether the address is considered valid/usable |
+| `recommendation` | `send`, `do_not_send`, or `risky` |
+| `did_you_mean` | A suggested correction for likely typos, if any |
+| `details` | Syntax / domain / MX / SMTP / disposable / role / catch-all / free-provider flags |
+
+## License
+
+MIT

langchain_verifly-0.1.0/README.md

@@ -0,0 +1,101 @@
+# langchain-verifly
+
+LangChain integration for [Verifly](https://verifly.email) — **agent-native email verification**.
+
+`langchain-verifly` gives any LangChain agent a single, well-described tool to
+check whether an email address is real and deliverable *before* it sends a
+message or accepts a signup. It wraps the Verifly verification API and returns a
+clean, structured verdict (deliverable / undeliverable / risky), the reason, a
+confidence score, and an actionable send-or-reject recommendation.
+
+## Installation
+
+```bash
+pip install -U langchain-verifly
+```
+
+## Setup
+
+Set your Verifly API key in the environment. You can self-onboard for a key
+(with free credits) at [verifly.email](https://verifly.email).
+
+```bash
+export VERIFLY_API_KEY="vf_..."
+```
+
+## Tool: `VeriflyEmailVerifier`
+
+A LangChain `BaseTool` with both sync and async support.
+
+```python
+from langchain_verifly import VeriflyEmailVerifier
+
+verifier = VeriflyEmailVerifier()  # reads VERIFLY_API_KEY from the environment
+
+verifier.invoke({"email": "lead@example.com"})
+```
+
+```python
+{
+    "email": "lead@example.com",
+    "result": "deliverable",
+    "reason": "Mailbox exists",
+    "confidence": 95,
+    "is_valid": True,
+    "recommendation": "send",
+    "did_you_mean": None,
+    "details": {
+        "syntax_valid": True,
+        "domain_exists": True,
+        "mx_records": True,
+        "smtp_valid": True,
+        "is_disposable": False,
+        "is_role_account": False,
+        "is_catch_all": False,
+        "is_free_provider": False,
+        "provider": "example.com",
+    },
+}
+```
+
+Async works too:
+
+```python
+await verifier.ainvoke({"email": "lead@example.com"})
+```
+
+You can also pass the key explicitly instead of using the environment variable:
+
+```python
+verifier = VeriflyEmailVerifier(api_key="vf_...")
+```
+
+## Use it in an agent
+
+```python
+from langchain.agents import create_react_agent  # or any agent constructor
+from langchain_verifly import VeriflyEmailVerifier
+
+tools = [VeriflyEmailVerifier()]
+# ... wire `tools` into your agent / model.bind_tools(tools) as usual
+```
+
+The agent can now verify an address on its own — for example, scrubbing a lead
+list, validating a user-supplied email at signup, or confirming a contact
+before drafting an outreach email.
+
+## Verdict fields
+
+| Field | Meaning |
+|-------|---------|
+| `result` | `deliverable`, `undeliverable`, or `risky` |
+| `reason` | Human-readable explanation of the verdict |
+| `confidence` | Confidence score, 0–100 |
+| `is_valid` | Whether the address is considered valid/usable |
+| `recommendation` | `send`, `do_not_send`, or `risky` |
+| `did_you_mean` | A suggested correction for likely typos, if any |
+| `details` | Syntax / domain / MX / SMTP / disposable / role / catch-all / free-provider flags |
+
+## License
+
+MIT

langchain_verifly-0.1.0/langchain_verifly/__init__.py

@@ -0,0 +1,18 @@
+"""LangChain integration for Verifly — agent-native email verification.
+
+Exposes :class:`VeriflyEmailVerifier`, a LangChain ``BaseTool`` that verifies
+the deliverability of an email address through the Verifly API
+(https://verifly.email) and returns a structured verdict (result, reason,
+confidence, and deliverability flags).
+"""
+
+from importlib import metadata
+
+from langchain_verifly.tool import VeriflyEmailVerifier, VeriflyToolInput
+
+try:
+    __version__ = metadata.version(__package__)
+except metadata.PackageNotFoundError:  # pragma: no cover - local source tree
+    __version__ = ""
+
+__all__ = ["VeriflyEmailVerifier", "VeriflyToolInput", "__version__"]

langchain_verifly-0.1.0/langchain_verifly/tool.py

@@ -0,0 +1,156 @@
+"""Verifly email-verification tool for LangChain."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, Optional
+
+import httpx
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+DEFAULT_BASE_URL = "https://verifly.email"
+_VERIFY_PATH = "/api/v1/verify"
+_DEFAULT_TIMEOUT = 30.0
+
+
+class VeriflyToolInput(BaseModel):
+    """Input schema for :class:`VeriflyEmailVerifier`."""
+
+    email: str = Field(
+        ...,
+        description="The email address to verify, e.g. 'lead@example.com'.",
+    )
+
+
+class VeriflyEmailVerifier(BaseTool):
+    """Verify the deliverability of an email address with Verifly.
+
+    Agent-native email verification: given a single email address, this tool
+    calls the Verifly API (``GET /api/v1/verify``) and returns a structured
+    verdict describing whether the address is deliverable, undeliverable, or
+    risky, along with the reason, a confidence score, and the actionable
+    send/reject recommendation. Use it to validate a lead or signup before
+    sending mail.
+
+    Setup:
+        Install the package and set your Verifly API key in the environment.
+
+        .. code-block:: bash
+
+            pip install -U langchain-verifly
+            export VERIFLY_API_KEY="vf_..."
+
+        A key (with free credits) can be obtained at https://verifly.email.
+
+    Instantiate:
+        .. code-block:: python
+
+            from langchain_verifly import VeriflyEmailVerifier
+
+            verifier = VeriflyEmailVerifier()
+            # or pass the key explicitly:
+            verifier = VeriflyEmailVerifier(api_key="vf_...")
+
+    Invoke directly:
+        .. code-block:: python
+
+            verifier.invoke({"email": "lead@example.com"})
+
+    The tool returns a dict such as::
+
+        {
+            "email": "lead@example.com",
+            "result": "deliverable",
+            "reason": "Mailbox exists",
+            "confidence": 95,
+            "is_valid": True,
+            "recommendation": "send",
+            "details": {...},
+        }
+    """
+
+    name: str = "verifly_email_verifier"
+    description: str = (
+        "Verify whether a single email address is deliverable using Verifly. "
+        "Input is one email address. Returns the verdict (deliverable, "
+        "undeliverable, or risky), the reason, a confidence score (0-100), "
+        "and a send/reject recommendation. Use before emailing a lead or "
+        "accepting a signup to avoid bounces and bad addresses."
+    )
+    args_schema: type[BaseModel] = VeriflyToolInput
+
+    api_key: Optional[str] = Field(
+        default=None,
+        description=(
+            "Verifly API key. Falls back to the VERIFLY_API_KEY environment "
+            "variable when not set."
+        ),
+    )
+    base_url: str = Field(
+        default=DEFAULT_BASE_URL,
+        description="Base URL of the Verifly API.",
+    )
+    timeout: float = Field(
+        default=_DEFAULT_TIMEOUT,
+        description="HTTP request timeout in seconds.",
+    )
+
+    def _resolve_key(self) -> str:
+        key = self.api_key or os.environ.get("VERIFLY_API_KEY")
+        if not key:
+            raise ValueError(
+                "A Verifly API key is required. Pass api_key=... or set the "
+                "VERIFLY_API_KEY environment variable. Get a free key at "
+                "https://verifly.email."
+            )
+        return key
+
+    @staticmethod
+    def _shape(payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Reduce the raw API response to the relevant verdict fields."""
+        return {
+            "email": payload.get("email"),
+            "result": payload.get("result"),
+            "reason": payload.get("reason"),
+            "confidence": payload.get("confidence"),
+            "is_valid": payload.get("is_valid"),
+            "recommendation": payload.get("recommendation"),
+            "did_you_mean": payload.get("did_you_mean"),
+            "details": payload.get("details"),
+        }
+
+    def _request_args(self, email: str) -> Dict[str, Any]:
+        return {
+            "url": f"{self.base_url.rstrip('/')}{_VERIFY_PATH}",
+            "params": {"email": email},
+            "headers": {
+                "Authorization": f"Bearer {self._resolve_key()}",
+                "Accept": "application/json",
+            },
+            "timeout": self.timeout,
+        }
+
+    def _run(
+        self,
+        email: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> Dict[str, Any]:
+        with httpx.Client() as client:
+            response = client.get(**self._request_args(email))
+            response.raise_for_status()
+            return self._shape(response.json())
+
+    async def _arun(
+        self,
+        email: str,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+    ) -> Dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(**self._request_args(email))
+            response.raise_for_status()
+            return self._shape(response.json())

langchain_verifly-0.1.0/langchain_verifly.egg-info/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: langchain-verifly
+Version: 0.1.0
+Summary: An integration package connecting Verifly (agent-native email verification) and LangChain
+Author-email: Verifly <support@verifly.email>
+License: MIT
+Project-URL: Homepage, https://verifly.email
+Project-URL: Repository, https://github.com/james-sib/langchain-verifly
+Project-URL: Source Code, https://github.com/james-sib/langchain-verifly/tree/master/langchain_verifly
+Keywords: langchain,verifly,email-verification,email-validation,deliverability,agents,tools
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core<0.4,>=0.3
+Requires-Dist: httpx>=0.27
+Provides-Extra: test
+Requires-Dist: pytest>=7.4; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Dynamic: license-file
+
+# langchain-verifly
+
+LangChain integration for [Verifly](https://verifly.email) — **agent-native email verification**.
+
+`langchain-verifly` gives any LangChain agent a single, well-described tool to
+check whether an email address is real and deliverable *before* it sends a
+message or accepts a signup. It wraps the Verifly verification API and returns a
+clean, structured verdict (deliverable / undeliverable / risky), the reason, a
+confidence score, and an actionable send-or-reject recommendation.
+
+## Installation
+
+```bash
+pip install -U langchain-verifly
+```
+
+## Setup
+
+Set your Verifly API key in the environment. You can self-onboard for a key
+(with free credits) at [verifly.email](https://verifly.email).
+
+```bash
+export VERIFLY_API_KEY="vf_..."
+```
+
+## Tool: `VeriflyEmailVerifier`
+
+A LangChain `BaseTool` with both sync and async support.
+
+```python
+from langchain_verifly import VeriflyEmailVerifier
+
+verifier = VeriflyEmailVerifier()  # reads VERIFLY_API_KEY from the environment
+
+verifier.invoke({"email": "lead@example.com"})
+```
+
+```python
+{
+    "email": "lead@example.com",
+    "result": "deliverable",
+    "reason": "Mailbox exists",
+    "confidence": 95,
+    "is_valid": True,
+    "recommendation": "send",
+    "did_you_mean": None,
+    "details": {
+        "syntax_valid": True,
+        "domain_exists": True,
+        "mx_records": True,
+        "smtp_valid": True,
+        "is_disposable": False,
+        "is_role_account": False,
+        "is_catch_all": False,
+        "is_free_provider": False,
+        "provider": "example.com",
+    },
+}
+```
+
+Async works too:
+
+```python
+await verifier.ainvoke({"email": "lead@example.com"})
+```
+
+You can also pass the key explicitly instead of using the environment variable:
+
+```python
+verifier = VeriflyEmailVerifier(api_key="vf_...")
+```
+
+## Use it in an agent
+
+```python
+from langchain.agents import create_react_agent  # or any agent constructor
+from langchain_verifly import VeriflyEmailVerifier
+
+tools = [VeriflyEmailVerifier()]
+# ... wire `tools` into your agent / model.bind_tools(tools) as usual
+```
+
+The agent can now verify an address on its own — for example, scrubbing a lead
+list, validating a user-supplied email at signup, or confirming a contact
+before drafting an outreach email.
+
+## Verdict fields
+
+| Field | Meaning |
+|-------|---------|
+| `result` | `deliverable`, `undeliverable`, or `risky` |
+| `reason` | Human-readable explanation of the verdict |
+| `confidence` | Confidence score, 0–100 |
+| `is_valid` | Whether the address is considered valid/usable |
+| `recommendation` | `send`, `do_not_send`, or `risky` |
+| `did_you_mean` | A suggested correction for likely typos, if any |
+| `details` | Syntax / domain / MX / SMTP / disposable / role / catch-all / free-provider flags |
+
+## License
+
+MIT

langchain_verifly-0.1.0/langchain_verifly.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+langchain_verifly/__init__.py
+langchain_verifly/py.typed
+langchain_verifly/tool.py
+langchain_verifly.egg-info/PKG-INFO
+langchain_verifly.egg-info/SOURCES.txt
+langchain_verifly.egg-info/dependency_links.txt
+langchain_verifly.egg-info/requires.txt
+langchain_verifly.egg-info/top_level.txt
+tests/test_tool.py

langchain_verifly-0.1.0/langchain_verifly.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

langchain_verifly-0.1.0/langchain_verifly.egg-info/requires.txt

@@ -0,0 +1,6 @@
+langchain-core<0.4,>=0.3
+httpx>=0.27
+
+[test]
+pytest>=7.4
+pytest-asyncio>=0.23

langchain_verifly-0.1.0/langchain_verifly.egg-info/top_level.txt

@@ -0,0 +1 @@
+langchain_verifly

langchain_verifly-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "langchain-verifly"
+version = "0.1.0"
+description = "An integration package connecting Verifly (agent-native email verification) and LangChain"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Verifly", email = "support@verifly.email" }]
+keywords = [
+    "langchain",
+    "verifly",
+    "email-verification",
+    "email-validation",
+    "deliverability",
+    "agents",
+    "tools",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Communications :: Email",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "langchain-core>=0.3,<0.4",
+    "httpx>=0.27",
+]
+
+[project.urls]
+Homepage = "https://verifly.email"
+Repository = "https://github.com/james-sib/langchain-verifly"
+"Source Code" = "https://github.com/james-sib/langchain-verifly/tree/master/langchain_verifly"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.4",
+    "pytest-asyncio>=0.23",
+]
+
+[tool.setuptools]
+packages = ["langchain_verifly"]
+
+[tool.setuptools.package-data]
+langchain_verifly = ["py.typed"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

langchain_verifly-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

langchain_verifly-0.1.0/tests/test_tool.py

@@ -0,0 +1,114 @@
+"""Unit tests for VeriflyEmailVerifier (no network calls)."""
+
+import httpx
+import pytest
+
+from langchain_core.tools import BaseTool
+
+from langchain_verifly import VeriflyEmailVerifier, VeriflyToolInput
+
+_SAMPLE_RESPONSE = {
+    "success": True,
+    "email": "lead@example.com",
+    "is_valid": True,
+    "result": "deliverable",
+    "reason": "Mailbox exists",
+    "confidence": 95,
+    "recommendation": "send",
+    "did_you_mean": None,
+    "details": {
+        "syntax_valid": True,
+        "domain_exists": True,
+        "mx_records": True,
+        "smtp_valid": True,
+        "is_disposable": False,
+        "is_role_account": False,
+        "is_catch_all": False,
+        "is_free_provider": False,
+        "provider": "example.com",
+    },
+    "credits": {"used": 1, "remaining": 99},
+    "request_id": "abc-123",
+}
+
+
+def _mock_transport() -> httpx.MockTransport:
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.url.path == "/api/v1/verify"
+        assert request.url.params.get("email") == "lead@example.com"
+        assert request.headers["Authorization"] == "Bearer vf_test"
+        return httpx.Response(200, json=_SAMPLE_RESPONSE)
+
+    return httpx.MockTransport(handler)
+
+
+def test_is_a_langchain_tool():
+    tool = VeriflyEmailVerifier(api_key="vf_test")
+    assert isinstance(tool, BaseTool)
+    assert tool.name == "verifly_email_verifier"
+    assert tool.args_schema is VeriflyToolInput
+
+
+def test_input_schema_requires_email():
+    with pytest.raises(Exception):
+        VeriflyToolInput()  # type: ignore[call-arg]
+    assert VeriflyToolInput(email="a@b.com").email == "a@b.com"
+
+
+def test_missing_key_raises(monkeypatch):
+    monkeypatch.delenv("VERIFLY_API_KEY", raising=False)
+    tool = VeriflyEmailVerifier()
+    with pytest.raises(ValueError, match="VERIFLY_API_KEY"):
+        tool.invoke({"email": "lead@example.com"})
+
+
+def test_run_shapes_verdict(monkeypatch):
+    tool = VeriflyEmailVerifier(api_key="vf_test")
+    real_client = httpx.Client
+
+    def patched_client(*args, **kwargs):
+        kwargs["transport"] = _mock_transport()
+        return real_client(*args, **kwargs)
+
+    monkeypatch.setattr(httpx, "Client", patched_client)
+
+    result = tool.invoke({"email": "lead@example.com"})
+    assert result["result"] == "deliverable"
+    assert result["reason"] == "Mailbox exists"
+    assert result["confidence"] == 95
+    assert result["is_valid"] is True
+    assert result["recommendation"] == "send"
+    assert result["details"]["provider"] == "example.com"
+    # raw-only fields should be stripped out
+    assert "credits" not in result
+    assert "request_id" not in result
+
+
+def test_key_from_env(monkeypatch):
+    monkeypatch.setenv("VERIFLY_API_KEY", "vf_test")
+    tool = VeriflyEmailVerifier()
+    real_client = httpx.Client
+
+    def patched_client(*args, **kwargs):
+        kwargs["transport"] = _mock_transport()
+        return real_client(*args, **kwargs)
+
+    monkeypatch.setattr(httpx, "Client", patched_client)
+    result = tool.invoke({"email": "lead@example.com"})
+    assert result["email"] == "lead@example.com"
+
+
+@pytest.mark.asyncio
+async def test_arun_shapes_verdict(monkeypatch):
+    tool = VeriflyEmailVerifier(api_key="vf_test")
+    real_async_client = httpx.AsyncClient
+
+    def patched_async_client(*args, **kwargs):
+        kwargs["transport"] = _mock_transport()
+        return real_async_client(*args, **kwargs)
+
+    monkeypatch.setattr(httpx, "AsyncClient", patched_async_client)
+
+    result = await tool.ainvoke({"email": "lead@example.com"})
+    assert result["result"] == "deliverable"
+    assert result["confidence"] == 95