langchain-agentsearch 0.1.0__tar.gz

langchain_agentsearch-0.1.0/LICENSE

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

@@ -0,0 +1,80 @@
+Metadata-Version: 2.5
+Name: langchain-agentsearch
+Version: 0.1.0
+Summary: LangChain tools for AgentSearch: free live web search, plus pay-per-call extract and JS render ($0.005 USDC on Base via x402)
+Project-URL: Homepage, https://agentsearchhq.com/?utm_source=langchain-agentsearch&utm_medium=package
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,agentsearch,langchain,tools,web-search,x402
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.25
+Requires-Dist: langchain-core<2.0.0,>=0.3.0
+Requires-Dist: pydantic>=2
+Provides-Extra: paid
+Requires-Dist: x402[evm]>=2.0; extra == 'paid'
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# langchain-agentsearch
+
+LangChain (Python) tools for [AgentSearch](https://agentsearchhq.com/?utm_source=langchain-agentsearch&utm_medium=package): live web search for agents.
+
+| Tool | Name | Cost |
+|---|---|---|
+| `AgentSearchTool` | `agentsearch_search` | **Free** (25 searches/day per user, up to 5 results, no key). Paid & unlimited if a wallet is set. |
+| `AgentSearchExtractTool` | `agentsearch_extract` | $0.005/call (USDC on Base via x402) |
+| `AgentSearchRenderTool` | `agentsearch_render` | $0.005/call (headless browser for JS pages) |
+
+## Install
+
+```bash
+pip install -U langchain-agentsearch          # free search
+pip install -U "langchain-agentsearch[paid]"  # + x402 payments for extract/render
+```
+
+## Quick start (free, no key)
+
+```python
+from langchain_agentsearch import AgentSearchTool
+
+search = AgentSearchTool()
+print(search.invoke({"query": "latest LangChain release", "max_results": 3}))
+# JSON string: {"query": ..., "results": [{"title", "url", "content"}, ...]}
+```
+
+With an agent:
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langchain_agentsearch import AgentSearchTool, AgentSearchExtractTool, AgentSearchRenderTool
+
+agent = create_react_agent(llm, [AgentSearchTool(), AgentSearchExtractTool(), AgentSearchRenderTool()])
+```
+
+## Paid mode
+
+Install the `paid` extra and set `AGENTSEARCH_WALLET_PRIVATE_KEY` to the private key of a **new wallet made only for this**, funded with a little USDC on Base (e.g. $1; no ETH needed). Each call is paid over x402 through the Pocket Network Agentic Portal using the official x402 Python SDK. With a key set, `AgentSearchTool` also goes paid; force free with `AgentSearchTool(mode="free")`.
+
+| Env var | Default |
+|---|---|
+| `AGENTSEARCH_MAX_TOTAL_ATOMIC` | `1000000` ($1.00 per process) |
+| `AGENTSEARCH_MAX_PER_CALL_ATOMIC` | `5000` ($0.005; can only be lowered) |
+| `AGENTSEARCH_TIMEOUT_MS` | `30000` |
+
+Limits are checked before anything is signed. The key is never logged or returned. Paid results include a `payment` object.
+
+## Errors
+
+Tools return `"Error: ..."` strings rather than raising. A 429 from the free relay means the daily limit was hit; the message explains how to upgrade.
+
+## Development
+
+```bash
+pip install -e ".[test,paid]" && pytest            # unit tests (mocked)
+AGENTSEARCH_LIVE=1 pytest -k live                    # one real free search
+```
+
+Docs: https://agentsearchhq.com/agents.md?utm_source=langchain-agentsearch&utm_medium=package
+
+MIT

langchain_agentsearch-0.1.0/README.md

@@ -0,0 +1,62 @@
+# langchain-agentsearch
+
+LangChain (Python) tools for [AgentSearch](https://agentsearchhq.com/?utm_source=langchain-agentsearch&utm_medium=package): live web search for agents.
+
+| Tool | Name | Cost |
+|---|---|---|
+| `AgentSearchTool` | `agentsearch_search` | **Free** (25 searches/day per user, up to 5 results, no key). Paid & unlimited if a wallet is set. |
+| `AgentSearchExtractTool` | `agentsearch_extract` | $0.005/call (USDC on Base via x402) |
+| `AgentSearchRenderTool` | `agentsearch_render` | $0.005/call (headless browser for JS pages) |
+
+## Install
+
+```bash
+pip install -U langchain-agentsearch          # free search
+pip install -U "langchain-agentsearch[paid]"  # + x402 payments for extract/render
+```
+
+## Quick start (free, no key)
+
+```python
+from langchain_agentsearch import AgentSearchTool
+
+search = AgentSearchTool()
+print(search.invoke({"query": "latest LangChain release", "max_results": 3}))
+# JSON string: {"query": ..., "results": [{"title", "url", "content"}, ...]}
+```
+
+With an agent:
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langchain_agentsearch import AgentSearchTool, AgentSearchExtractTool, AgentSearchRenderTool
+
+agent = create_react_agent(llm, [AgentSearchTool(), AgentSearchExtractTool(), AgentSearchRenderTool()])
+```
+
+## Paid mode
+
+Install the `paid` extra and set `AGENTSEARCH_WALLET_PRIVATE_KEY` to the private key of a **new wallet made only for this**, funded with a little USDC on Base (e.g. $1; no ETH needed). Each call is paid over x402 through the Pocket Network Agentic Portal using the official x402 Python SDK. With a key set, `AgentSearchTool` also goes paid; force free with `AgentSearchTool(mode="free")`.
+
+| Env var | Default |
+|---|---|
+| `AGENTSEARCH_MAX_TOTAL_ATOMIC` | `1000000` ($1.00 per process) |
+| `AGENTSEARCH_MAX_PER_CALL_ATOMIC` | `5000` ($0.005; can only be lowered) |
+| `AGENTSEARCH_TIMEOUT_MS` | `30000` |
+
+Limits are checked before anything is signed. The key is never logged or returned. Paid results include a `payment` object.
+
+## Errors
+
+Tools return `"Error: ..."` strings rather than raising. A 429 from the free relay means the daily limit was hit; the message explains how to upgrade.
+
+## Development
+
+```bash
+pip install -e ".[test,paid]" && pytest            # unit tests (mocked)
+AGENTSEARCH_LIVE=1 pytest -k live                    # one real free search
+```
+
+Docs: https://agentsearchhq.com/agents.md?utm_source=langchain-agentsearch&utm_medium=package
+
+MIT

langchain_agentsearch-0.1.0/langchain_agentsearch/__init__.py

@@ -0,0 +1,13 @@
+"""LangChain tools for AgentSearch."""
+from importlib import metadata
+
+from ._client import AgentSearchError, FREE_LIMIT_MESSAGE, reset_session_budget, session_spent_atomic
+from .tools import AgentSearchExtractTool, AgentSearchRenderTool, AgentSearchTool
+
+try:
+    __version__ = metadata.version(__package__ or "langchain_agentsearch")
+except metadata.PackageNotFoundError:  # pragma: no cover
+    __version__ = ""
+
+__all__ = ["AgentSearchTool", "AgentSearchExtractTool", "AgentSearchRenderTool", "AgentSearchError",
+           "FREE_LIMIT_MESSAGE", "reset_session_budget", "session_spent_atomic", "__version__"]

langchain_agentsearch-0.1.0/langchain_agentsearch/_client.py

@@ -0,0 +1,264 @@
+"""HTTP layer: free relay search and x402 pay-per-call via the Pocket Network Agentic Portal.
+
+The wallet key is read from env, used only to sign, and never logged or returned.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import threading
+from typing import Any, Optional
+
+import httpx
+
+FREE_RELAY_URL = "https://relay.agentsearchhq.com"
+FREE_RELAY_DAILY_LIMIT = 25
+DEFAULT_PORTAL_URL = "https://agent.pocket.network"
+BASE_NETWORK = "eip155:8453"
+USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+PORTAL_PAYEE = "0xF732ea490c5766071785a2310523f7fA2CEbB829"
+MAX_PER_CALL_ATOMIC = 5000  # $0.005 hard ceiling
+DEFAULT_SESSION_CAP_ATOMIC = 1_000_000  # $1.00
+KEY_ENV_VARS = ("AGENTSEARCH_WALLET_PRIVATE_KEY", "POCKET_PRIVATE_KEY")
+SERVICES = {
+    "search": ("agentsearch-web-search-v1", "/v1/search"),
+    "extract": ("agentsearch-web-extract-v1", "/v1/extract"),
+    "render": ("agentsearch-web-render-v1", "/v1/render"),
+}
+DOCS = "https://agentsearchhq.com/?utm_source=langchain-agentsearch&utm_medium=package"
+
+FREE_LIMIT_MESSAGE = (
+    f"Free search limit reached ({FREE_RELAY_DAILY_LIMIT} searches per day per user; resets daily). "
+    "For unlimited search plus extract/render, set AGENTSEARCH_WALLET_PRIVATE_KEY to the key of a NEW wallet "
+    "funded with a little USDC on Base ($0.005 per call via x402, capped by AGENTSEARCH_MAX_TOTAL_ATOMIC, "
+    f"default $1.00) and install langchain-agentsearch[paid]. Docs: {DOCS}"
+)
+
+
+def paid_only_message(name: str) -> str:
+    return (
+        f"{name} is paid ($0.005 per call in USDC on Base via x402). No wallet is configured, so no call was made. "
+        "Set AGENTSEARCH_WALLET_PRIVATE_KEY to the key of a NEW wallet funded with a little USDC on Base and "
+        f"install langchain-agentsearch[paid]. Docs: {DOCS}"
+    )
+
+
+class AgentSearchError(Exception):
+    def __init__(self, message: str, status: Optional[int] = None):
+        super().__init__(message)
+        self.status = status
+
+
+def timeout_s() -> float:
+    try:
+        n = int(os.environ.get("AGENTSEARCH_TIMEOUT_MS", ""))
+        if 1000 <= n <= 300_000:
+            return n / 1000
+    except ValueError:
+        pass
+    return 30.0
+
+
+def _strip_provider(d: Any) -> Any:
+    if isinstance(d, dict):
+        d.pop("provider", None)
+    return d
+
+
+def free_search(query: str, max_results: Optional[int] = None, client: Optional[httpx.Client] = None) -> Any:
+    body: dict[str, Any] = {"query": query}
+    if max_results is not None:
+        body["max_results"] = max_results
+    c = client or httpx.Client(timeout=timeout_s())
+    try:
+        r = c.post(f"{FREE_RELAY_URL}/v1/search", json=body, headers={"accept": "application/json"})
+    finally:
+        if client is None:
+            c.close()
+    if r.status_code == 429:
+        raise AgentSearchError(FREE_LIMIT_MESSAGE, 429)
+    if r.status_code >= 400:
+        raise AgentSearchError(f"AgentSearch relay HTTP {r.status_code}: {r.text[:500]}", r.status_code)
+    try:
+        return _strip_provider(r.json())
+    except ValueError:
+        return {"raw": r.text}
+
+
+# ---------- paid mode ----------
+
+def has_wallet_key() -> bool:
+    return any((os.environ.get(n) or "").strip() for n in KEY_ENV_VARS)
+
+
+def _read_wallet_key() -> Optional[str]:
+    for name in KEY_ENV_VARS:
+        raw = (os.environ.get(name) or "").strip()
+        if not raw:
+            continue
+        if not re.fullmatch(r"(0x)?[0-9a-fA-F]{64}", raw):
+            raise AgentSearchError(
+                f"{name} is set but is not a private key (expected 64 hex characters, optional 0x prefix). "
+                "The value is not shown. Nothing was signed."
+            )
+        return raw if raw.startswith("0x") else "0x" + raw
+    return None
+
+
+def _atomic_env(names: tuple[str, ...], fallback: int) -> int:
+    for name in names:
+        raw = (os.environ.get(name) or "").strip()
+        if not raw:
+            continue
+        if not raw.isdigit():
+            raise AgentSearchError(f"{name} must be a whole number of USDC atomic units (1000000 = $1.00). Nothing was signed.")
+        return int(raw)
+    return fallback
+
+
+def usd(atomic: int) -> str:
+    return f"${atomic // 1_000_000}.{atomic % 1_000_000:06d}"
+
+
+class _Budget:
+    def __init__(self) -> None:
+        self.spent = 0
+        self.lock = threading.Lock()
+
+
+_budget = _Budget()
+
+
+def reset_session_budget() -> None:
+    global _budget
+    _budget = _Budget()
+
+
+def session_spent_atomic() -> int:
+    return _budget.spent
+
+
+def _eq(a: Any, b: str) -> bool:
+    return isinstance(a, str) and a.lower() == b.lower()
+
+
+def select_accept(accepts: list[Any], ceiling: int) -> Any:
+    why = []
+    for a in accepts or []:
+        if a.scheme != "exact":
+            why.append(f"{a.scheme} scheme"); continue
+        if a.network != BASE_NETWORK:
+            why.append(f"network {a.network}"); continue
+        if not _eq(a.asset, USDC_BASE):
+            why.append(f"asset {a.asset} is not USDC on Base"); continue
+        if not _eq(a.pay_to, PORTAL_PAYEE):
+            why.append(f"payee {a.pay_to} is not the portal's"); continue
+        if not str(a.amount).isdigit() or int(a.amount) <= 0:
+            why.append(f"amount {a.amount}"); continue
+        if int(a.amount) > ceiling:
+            why.append(f"amount {a.amount} exceeds the cap of {ceiling} atomic units"); continue
+        return a
+    raise AgentSearchError(f"No acceptable payment option ({'; '.join(why) or 'none offered'}). Nothing was signed.")
+
+
+def call_portal(op: str, body: dict[str, Any], client: Optional[httpx.Client] = None) -> dict[str, Any]:
+    """Unpaid POST -> 402 -> limits checked -> sign (x402 SDK) -> retry once with PAYMENT-SIGNATURE."""
+    try:
+        from eth_account import Account
+        from x402 import x402ClientSync
+        from x402.http import x402HTTPClientSync
+        from x402.mechanisms.evm.exact import register_exact_evm_client
+    except ImportError as e:  # pragma: no cover
+        raise AgentSearchError(
+            "Paid calls need the x402 SDK: pip install 'langchain-agentsearch[paid]'. Nothing was signed."
+        ) from e
+
+    key = _read_wallet_key()
+    if not key:
+        raise AgentSearchError(paid_only_message(f"agentsearch_{op}"))
+    portal = (os.environ.get("AGENTSEARCH_PORTAL_URL") or DEFAULT_PORTAL_URL).strip().rstrip("/")
+    if not portal.startswith("https://") and not re.match(r"http://(localhost|127\.)", portal):
+        raise AgentSearchError("AGENTSEARCH_PORTAL_URL must be https://. Nothing was signed.")
+    session_cap = _atomic_env(("AGENTSEARCH_MAX_TOTAL_ATOMIC", "POCKET_MAX_TOTAL_ATOMIC"), DEFAULT_SESSION_CAP_ATOMIC)
+    per_call = min(_atomic_env(("AGENTSEARCH_MAX_PER_CALL_ATOMIC", "POCKET_MAX_PER_CALL_ATOMIC"), MAX_PER_CALL_ATOMIC), MAX_PER_CALL_ATOMIC)
+    service_id, path = SERVICES[op]
+    url = f"{portal}/v1/{service_id}{path}"
+
+    c = client or httpx.Client(timeout=timeout_s())
+    try:
+        unpaid = c.post(url, json=body)
+        if unpaid.status_code != 402:
+            raise AgentSearchError(f"Expected 402 from the portal, got {unpaid.status_code}: {unpaid.text[:300]}. Nothing was signed.", unpaid.status_code)
+        http = x402HTTPClientSync(x402ClientSync())
+        try:
+            required = http.get_payment_required_response(lambda n: unpaid.headers.get(n), unpaid.content)
+        except Exception as e:
+            raise AgentSearchError(f"The portal's 402 is not valid x402 v2 ({e}). Nothing was signed.")
+        if getattr(required, "x402_version", None) != 2:
+            raise AgentSearchError("Unsupported x402 version. Nothing was signed.")
+        res_url = (getattr(getattr(required, "resource", None), "url", "") or "").rstrip("/")
+        if not res_url.endswith(f"/v1/{service_id}"):
+            raise AgentSearchError(f"The 402 is for resource {res_url}, not {service_id}. Nothing was signed.")
+
+        with _budget.lock:
+            remaining = max(session_cap - _budget.spent, 0)
+            ceiling = min(per_call, remaining)
+            if ceiling <= 0:
+                raise AgentSearchError(
+                    f"Session spend cap reached: {usd(_budget.spent)} of {usd(session_cap)} signed. "
+                    "Raise AGENTSEARCH_MAX_TOTAL_ATOMIC to spend more. Nothing was signed."
+                )
+            chosen = select_accept(list(required.accepts), ceiling)
+            amount = int(chosen.amount)
+
+            def selector(_v: int, options: list[Any]) -> Any:
+                for o in options:
+                    if o.scheme == chosen.scheme and o.network == chosen.network and _eq(o.asset, chosen.asset) and _eq(o.pay_to, chosen.pay_to) and str(o.amount) == str(chosen.amount):
+                        return o
+                raise AgentSearchError("Selected option disappeared. Nothing was signed.")
+
+            account = Account.from_key(key)
+            signer_client = register_exact_evm_client(x402ClientSync(selector), account, networks=BASE_NETWORK)
+            payer = x402HTTPClientSync(signer_client)
+            signed = payer.create_payment_payload(required)
+            auth = (signed.payload or {}).get("authorization") or {}
+            if not _eq(auth.get("to"), PORTAL_PAYEE) or int(auth.get("value", 0)) != amount:
+                raise AgentSearchError("The signed authorization does not match the approved terms; it was discarded and not sent.")
+            _budget.spent += amount  # counted at signing
+
+        try:
+            paid = c.post(url, json=body, headers=payer.encode_payment_signature_header(signed))
+        except Exception as e:
+            raise AgentSearchError(f"A payment of {usd(amount)} was signed but the paid request failed ({e}). Check the wallet before retrying.")
+        if not 200 <= paid.status_code < 300:
+            raise AgentSearchError(
+                f"The portal answered {paid.status_code}: {paid.text[:300]}. Non-2xx answers are not settled; "
+                f"the signed {usd(amount)} still counts against this session's cap.", paid.status_code)
+        receipt = None
+        try:
+            receipt = payer.get_payment_settle_response(lambda n: paid.headers.get(n))
+        except Exception:
+            pass
+        tx = getattr(receipt, "transaction", None) if receipt else None
+        payment = {
+            "amountAtomic": str(amount), "amountUsd": usd(amount), "asset": "USDC", "network": BASE_NETWORK,
+            "payTo": PORTAL_PAYEE, "payer": account.address, "serviceId": service_id,
+            "settled": bool(getattr(receipt, "success", False)), "transaction": tx,
+        }
+        if tx:
+            payment["explorer"] = f"https://basescan.org/tx/{tx}"
+        try:
+            env = paid.json()
+        except ValueError:
+            env = {"raw": paid.text}
+        data = env.get("data", env) if isinstance(env, dict) else env
+        out = _strip_provider(data) if isinstance(data, dict) else {"data": data}
+        return {**out, "payment": payment}
+    finally:
+        if client is None:
+            c.close()
+
+
+def dumps(v: Any) -> str:
+    return json.dumps(v, ensure_ascii=False)

langchain_agentsearch-0.1.0/langchain_agentsearch/tools.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import Any, Literal, Optional, Type
+
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from . import _client as c
+
+
+class SearchInput(BaseModel):
+    query: str = Field(description="Search query", min_length=1)
+    max_results: Optional[int] = Field(default=None, ge=1, le=5, description="1-5, default 5")
+
+
+class ExtractInput(BaseModel):
+    url: str = Field(description="http(s) URL to extract")
+    formats: Optional[list[str]] = Field(default=None, description='e.g. ["markdown"]')
+    max_chars: Optional[int] = Field(default=None, gt=0)
+
+
+class RenderInput(BaseModel):
+    url: str = Field(description="http(s) URL to render")
+    formats: Optional[list[Literal["markdown", "text", "html", "links"]]] = None
+    max_chars: Optional[int] = Field(default=None, gt=0)
+    screenshot: Optional[bool] = None
+    wait_until: Optional[Literal["domcontentloaded", "load", "networkidle"]] = None
+    wait_for_selector: Optional[str] = None
+    wait_ms: Optional[int] = Field(default=None, ge=0)
+
+
+def _err(e: Exception) -> str:
+    return f"Error: {e}"
+
+
+class AgentSearchTool(BaseTool):
+    """Live web search. Free by default (25/day per user); paid & unlimited when a wallet key is set."""
+
+    name: str = "agentsearch_search"
+    description: str = "Live web search. Returns up to 5 ranked results (title, url, content). Use for current facts or finding URLs."
+    args_schema: Type[BaseModel] = SearchInput
+    mode: Literal["auto", "free", "paid"] = "auto"
+
+    def _run(self, query: str, max_results: Optional[int] = None, run_manager: Any = None) -> str:
+        try:
+            paid = self.mode == "paid" or (self.mode == "auto" and c.has_wallet_key())
+            if paid:
+                body: dict[str, Any] = {"query": query}
+                if max_results:
+                    body["max_results"] = max_results
+                return c.dumps(c.call_portal("search", body))
+            return c.dumps(c.free_search(query, max_results))
+        except Exception as e:
+            return _err(e)
+
+
+class _PaidTool(BaseTool):
+    op: str = ""
+
+    def _run(self, run_manager: Any = None, **kwargs: Any) -> str:
+        try:
+            if not c.has_wallet_key():
+                raise c.AgentSearchError(c.paid_only_message(self.name))
+            body = {k: v for k, v in kwargs.items() if v is not None}
+            return c.dumps(c.call_portal(self.op, body))
+        except Exception as e:
+            return _err(e)
+
+
+class AgentSearchExtractTool(_PaidTool):
+    name: str = "agentsearch_extract"
+    description: str = "Fetch a URL and return its main content as clean text/markdown. Paid: $0.005 per call (needs a wallet)."
+    args_schema: Type[BaseModel] = ExtractInput
+    op: str = "extract"
+
+
+class AgentSearchRenderTool(_PaidTool):
+    name: str = "agentsearch_render"
+    description: str = "Render a JavaScript-heavy page in a headless browser and return markdown/text/html/links. Paid: $0.005 per call (needs a wallet)."
+    args_schema: Type[BaseModel] = RenderInput
+    op: str = "render"

langchain_agentsearch-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-agentsearch"
+version = "0.1.0"
+description = "LangChain tools for AgentSearch: free live web search, plus pay-per-call extract and JS render ($0.005 USDC on Base via x402)"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+dependencies = ["langchain-core>=0.3.0,<2.0.0", "httpx>=0.25", "pydantic>=2"]
+keywords = ["langchain", "agentsearch", "web-search", "tools", "agents", "x402"]
+
+[project.optional-dependencies]
+paid = ["x402[evm]>=2.0"]
+test = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://agentsearchhq.com/?utm_source=langchain-agentsearch&utm_medium=package"
+
+[tool.hatch.build.targets.wheel]
+packages = ["langchain_agentsearch"]
+
+[tool.hatch.build.targets.sdist]
+include = ["langchain_agentsearch", "tests", "README.md", "LICENSE", "pyproject.toml"]

langchain_agentsearch-0.1.0/tests/test_tools.py

@@ -0,0 +1,106 @@
+import json
+import os
+
+import httpx
+import pytest
+
+from langchain_agentsearch import AgentSearchExtractTool, AgentSearchRenderTool, AgentSearchTool, FREE_LIMIT_MESSAGE
+from langchain_agentsearch import _client
+
+
+@pytest.fixture(autouse=True)
+def no_wallet(monkeypatch):
+    for k in _client.KEY_ENV_VARS:
+        monkeypatch.delenv(k, raising=False)
+
+
+def mock(monkeypatch, status, body):
+    seen = {}
+
+    def handler(req):
+        seen["url"] = str(req.url)
+        seen["body"] = json.loads(req.content)
+        return httpx.Response(status, json=body)
+
+    real = httpx.Client
+    monkeypatch.setattr(_client.httpx, "Client", lambda **kw: real(transport=httpx.MockTransport(handler)))
+    return seen
+
+
+def test_names():
+    assert [t().name for t in (AgentSearchTool, AgentSearchExtractTool, AgentSearchRenderTool)] == [
+        "agentsearch_search", "agentsearch_extract", "agentsearch_render"]
+
+
+def test_free_search_mocked(monkeypatch):
+    seen = mock(monkeypatch, 200, {"provider": "p", "results": [{"title": "T", "url": "https://a"}]})
+    out = json.loads(AgentSearchTool().invoke({"query": "x", "max_results": 1}))
+    assert seen["url"] == "https://relay.agentsearchhq.com/v1/search"
+    assert seen["body"] == {"query": "x", "max_results": 1}
+    assert "provider" not in out and out["results"][0]["title"] == "T"
+
+
+def test_429(monkeypatch):
+    mock(monkeypatch, 429, {})
+    assert AgentSearchTool().invoke({"query": "x"}) == f"Error: {FREE_LIMIT_MESSAGE}"
+
+
+def test_paid_without_wallet():
+    assert "No wallet" in AgentSearchExtractTool().invoke({"url": "https://example.com"})
+    assert "No wallet" in AgentSearchRenderTool().invoke({"url": "https://example.com"})
+
+
+def test_bad_key_not_leaked(monkeypatch):
+    monkeypatch.setenv("AGENTSEARCH_WALLET_PRIVATE_KEY", "nothex-secret")
+    out = AgentSearchExtractTool().invoke({"url": "https://example.com"})
+    assert "not a private key" in out and "nothex-secret" not in out
+
+
+def test_select_accept_caps():
+    class A:
+        scheme = "exact"; network = _client.BASE_NETWORK; asset = _client.USDC_BASE; pay_to = _client.PORTAL_PAYEE; amount = "6000"
+    with pytest.raises(_client.AgentSearchError):
+        _client.select_accept([A()], 5000)
+    A.amount = "5000"
+    assert _client.select_accept([A()], 5000).amount == "5000"
+
+
+def test_tool_call_message(monkeypatch):
+    mock(monkeypatch, 200, {"results": []})
+    msg = AgentSearchTool().invoke({"type": "tool_call", "id": "1", "name": "agentsearch_search", "args": {"query": "x"}})
+    assert msg.tool_call_id == "1"
+
+
+@pytest.mark.skipif(not os.environ.get("AGENTSEARCH_LIVE"), reason="set AGENTSEARCH_LIVE=1")
+def test_live_free_search():
+    out = json.loads(AgentSearchTool(mode="free").invoke({"query": "LangChain python tools", "max_results": 2}))
+    assert out["results"] and out["results"][0]["url"].startswith("http")
+
+
+def test_paid_flow_signs_with_x402_sdk(monkeypatch):
+    """Mocked portal: 402 -> SDK signs -> 200. Uses a throwaway random key; no network."""
+    pytest.importorskip("x402")
+    from eth_account import Account
+    from x402.http.utils import encode_payment_required_header
+    from x402.schemas import PaymentRequired, PaymentRequirements, ResourceInfo
+
+    _client.reset_session_budget()
+    monkeypatch.setenv("AGENTSEARCH_WALLET_PRIVATE_KEY", Account.create().key.hex())
+    req = PaymentRequired(x402_version=2, resource=ResourceInfo(url="https://agent.pocket.network/v1/agentsearch-web-extract-v1"),
+        accepts=[PaymentRequirements(scheme="exact", network=_client.BASE_NETWORK, asset=_client.USDC_BASE, amount="5000",
+                                     pay_to=_client.PORTAL_PAYEE, max_timeout_seconds=60, extra={"name": "USD Coin", "version": "2"})])
+    calls = []
+
+    def handler(r):
+        calls.append(r)
+        if "payment-signature" not in r.headers:
+            return httpx.Response(402, headers={"PAYMENT-REQUIRED": encode_payment_required_header(req)}, json={})
+        return httpx.Response(200, json={"portal": {}, "data": {"url": "https://example.com", "content": "hi"}})
+
+    real = httpx.Client
+    monkeypatch.setattr(_client.httpx, "Client", lambda **kw: real(transport=httpx.MockTransport(handler)))
+    out = json.loads(AgentSearchExtractTool().invoke({"url": "https://example.com"}))
+    assert out["content"] == "hi" and out["payment"]["amountAtomic"] == "5000"
+    assert len(calls) == 2 and _client.session_spent_atomic() == 5000
+    monkeypatch.setenv("AGENTSEARCH_MAX_TOTAL_ATOMIC", "5000")
+    assert "cap reached" in AgentSearchExtractTool().invoke({"url": "https://example.com"})