openai-agents-agentsearch 0.1.0__tar.gz

openai_agents_agentsearch-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+dist/
+.pytest_cache/
+*.egg-info/
+.venv/

openai_agents_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.

openai_agents_agentsearch-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.5
+Name: openai-agents-agentsearch
+Version: 0.1.0
+Summary: OpenAI Agents SDK function tools for AgentSearch: free live web search, plus pay-per-call extract and JS render
+Project-URL: Homepage, https://agentsearchhq.com/?utm_source=openai-agents-agentsearch&utm_medium=package
+Project-URL: Documentation, https://agentsearchhq.com/agents.md?utm_source=openai-agents-agentsearch&utm_medium=package
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,agentsearch,openai,openai-agents,tools,web-search,x402
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.25
+Requires-Dist: openai-agents>=0.2
+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
+
+# openai-agents-agentsearch
+
+Function tools for the [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) backed by [AgentSearch](https://agentsearchhq.com/?utm_source=openai-agents-agentsearch&utm_medium=package): live web search for agents. Free search needs no API key.
+
+| Tool | Cost |
+|---|---|
+| `agentsearch_search` | **Free** (25 searches/day per user, up to 5 results, no key). Paid and unlimited if a wallet is set. |
+| `agentsearch_extract` | $0.005/call (USDC on Base via x402) |
+| `agentsearch_render` | $0.005/call (headless browser for JS pages) |
+
+## Install
+
+```bash
+pip install -U openai-agents-agentsearch
+```
+
+## Quickstart
+
+```python
+from agents import Agent, Runner
+from openai_agents_agentsearch import agentsearch_search, agentsearch_tools
+
+agent = Agent(
+    name="Researcher",
+    instructions="Answer with current facts. Cite URLs.",
+    tools=[agentsearch_search],          # or agentsearch_tools() for search + extract + render
+)
+result = Runner.run_sync(agent, "What changed in the latest OpenAI Agents SDK release?")
+print(result.final_output)
+```
+
+## Paid mode
+
+Install the `paid` extra (`pip install "openai-agents-agentsearch[paid]"`) 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 costs $0.005 and is paid over x402 through the Pocket Network Agentic Portal using the official x402 Python SDK. With a key set, search also goes paid and unlimited.
+
+| 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 instead of raising. A 429 from the free relay means the daily limit (25 searches/day per user) was hit, and the message explains how to upgrade.
+
+## Development
+
+```bash
+pip install -e ".[test]" && pytest     # unit tests (mocked)
+AGENTSEARCH_LIVE=1 pytest -k live       # one real free search
+```
+
+Docs: https://agentsearchhq.com/agents.md?utm_source=openai-agents-agentsearch&utm_medium=package
+
+MIT

openai_agents_agentsearch-0.1.0/README.md

@@ -0,0 +1,57 @@
+# openai-agents-agentsearch
+
+Function tools for the [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) backed by [AgentSearch](https://agentsearchhq.com/?utm_source=openai-agents-agentsearch&utm_medium=package): live web search for agents. Free search needs no API key.
+
+| Tool | Cost |
+|---|---|
+| `agentsearch_search` | **Free** (25 searches/day per user, up to 5 results, no key). Paid and unlimited if a wallet is set. |
+| `agentsearch_extract` | $0.005/call (USDC on Base via x402) |
+| `agentsearch_render` | $0.005/call (headless browser for JS pages) |
+
+## Install
+
+```bash
+pip install -U openai-agents-agentsearch
+```
+
+## Quickstart
+
+```python
+from agents import Agent, Runner
+from openai_agents_agentsearch import agentsearch_search, agentsearch_tools
+
+agent = Agent(
+    name="Researcher",
+    instructions="Answer with current facts. Cite URLs.",
+    tools=[agentsearch_search],          # or agentsearch_tools() for search + extract + render
+)
+result = Runner.run_sync(agent, "What changed in the latest OpenAI Agents SDK release?")
+print(result.final_output)
+```
+
+## Paid mode
+
+Install the `paid` extra (`pip install "openai-agents-agentsearch[paid]"`) 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 costs $0.005 and is paid over x402 through the Pocket Network Agentic Portal using the official x402 Python SDK. With a key set, search also goes paid and unlimited.
+
+| 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 instead of raising. A 429 from the free relay means the daily limit (25 searches/day per user) was hit, and the message explains how to upgrade.
+
+## Development
+
+```bash
+pip install -e ".[test]" && pytest     # unit tests (mocked)
+AGENTSEARCH_LIVE=1 pytest -k live       # one real free search
+```
+
+Docs: https://agentsearchhq.com/agents.md?utm_source=openai-agents-agentsearch&utm_medium=package
+
+MIT

openai_agents_agentsearch-0.1.0/openai_agents_agentsearch/__init__.py

@@ -0,0 +1,13 @@
+"""OpenAI Agents SDK function tools for AgentSearch."""
+from importlib import metadata
+
+from ._client import AgentSearchError, FREE_LIMIT_MESSAGE, reset_session_budget, session_spent_atomic
+from .tools import agentsearch_extract, agentsearch_render, agentsearch_search, agentsearch_tools
+
+try:
+    __version__ = metadata.version("openai-agents-agentsearch")
+except metadata.PackageNotFoundError:  # pragma: no cover
+    __version__ = ""
+
+__all__ = ["agentsearch_search", "agentsearch_extract", "agentsearch_render", "agentsearch_tools", "AgentSearchError",
+           "FREE_LIMIT_MESSAGE", "reset_session_budget", "session_spent_atomic", "__version__"]

openai_agents_agentsearch-0.1.0/openai_agents_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=openai-agents-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 openai-agents-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 openai-agents-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 'openai-agents-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)

openai_agents_agentsearch-0.1.0/openai_agents_agentsearch/_ops.py

@@ -0,0 +1,32 @@
+"""Framework-neutral operations. Each returns a JSON string, or an "Error: ..." string (never raises)."""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from . import _client as c
+
+
+def search(query: str, max_results: Optional[int] = None, mode: str = "auto") -> str:
+    try:
+        if not query or not str(query).strip():
+            raise c.AgentSearchError("query must not be empty")
+        if max_results is not None:
+            max_results = max(1, min(int(max_results), 5))
+        if mode == "paid" or (mode == "auto" and c.has_wallet_key()):
+            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 f"Error: {e}"
+
+
+def paid(op: str, **kwargs: Any) -> str:
+    try:
+        if not c.has_wallet_key():
+            raise c.AgentSearchError(c.paid_only_message(f"agentsearch_{op}"))
+        body = {k: v for k, v in kwargs.items() if v is not None}
+        return c.dumps(c.call_portal(op, body))
+    except Exception as e:
+        return f"Error: {e}"

openai_agents_agentsearch-0.1.0/openai_agents_agentsearch/tools.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import List, Literal, Optional
+
+from agents import FunctionTool, function_tool
+
+from . import _ops
+
+
+@function_tool
+def agentsearch_search(query: str, max_results: Optional[int] = None) -> str:
+    """Live web search. Returns JSON with up to 5 ranked results (title, url, content). Free by default.
+
+    Args:
+        query: the search query.
+        max_results: 1-5, default 5.
+    """
+    return _ops.search(query, max_results)
+
+
+@function_tool
+def agentsearch_extract(url: str, max_chars: Optional[int] = None) -> str:
+    """Fetch a URL and return its main content as clean markdown. Paid: $0.005 per call (needs a wallet).
+
+    Args:
+        url: http(s) URL to extract.
+        max_chars: optional cap on returned characters.
+    """
+    return _ops.paid("extract", url=url, formats=["markdown"], max_chars=max_chars)
+
+
+@function_tool
+def agentsearch_render(url: str, max_chars: Optional[int] = None,
+                       wait_until: Optional[Literal["domcontentloaded", "load", "networkidle"]] = None) -> str:
+    """Render a JavaScript-heavy page in a headless browser and return markdown. Paid: $0.005 per call (needs a wallet).
+
+    Args:
+        url: http(s) URL to render.
+        max_chars: optional cap on returned characters.
+        wait_until: page load event to wait for.
+    """
+    return _ops.paid("render", url=url, formats=["markdown"], max_chars=max_chars, wait_until=wait_until)
+
+
+def agentsearch_tools(include_paid: bool = True) -> List[FunctionTool]:
+    """All AgentSearch tools. Pass include_paid=False for free search only."""
+    return [agentsearch_search, agentsearch_extract, agentsearch_render] if include_paid else [agentsearch_search]

openai_agents_agentsearch-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "openai-agents-agentsearch"
+version = "0.1.0"
+description = "OpenAI Agents SDK function tools for AgentSearch: free live web search, plus pay-per-call extract and JS render"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = ["openai-agents>=0.2", "httpx>=0.25", "pydantic>=2"]
+keywords = ["openai-agents", "openai", "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=openai-agents-agentsearch&utm_medium=package"
+Documentation = "https://agentsearchhq.com/agents.md?utm_source=openai-agents-agentsearch&utm_medium=package"
+
+[tool.hatch.build.targets.wheel]
+packages = ["openai_agents_agentsearch"]
+
+[tool.hatch.build.targets.sdist]
+include = ["openai_agents_agentsearch", "tests", "README.md", "LICENSE", "pyproject.toml"]
+

openai_agents_agentsearch-0.1.0/tests/test_tools.py

@@ -0,0 +1,52 @@
+import json
+import os
+
+import httpx
+import pytest
+
+
+def mock(monkeypatch, mod, status, body):
+    real = httpx.Client
+    seen = []
+
+    def handler(r):
+        seen.append(r)
+        return httpx.Response(status, json=body)
+    monkeypatch.setattr(mod.httpx, "Client", lambda **kw: real(transport=httpx.MockTransport(handler)))
+    for n in ("AGENTSEARCH_WALLET_PRIVATE_KEY", "POCKET_PRIVATE_KEY"):
+        monkeypatch.delenv(n, raising=False)
+    return seen
+
+import asyncio
+
+from openai_agents_agentsearch import agentsearch_search, agentsearch_tools, _client
+
+
+def call(tool, args):
+    from agents.tool_context import ToolContext
+    a = json.dumps(args)
+    ctx = ToolContext(context=None, tool_name=tool.name, tool_call_id="1", tool_arguments=a)
+    return asyncio.run(tool.on_invoke_tool(ctx, a))
+
+
+def test_tools_list():
+    assert [t.name for t in agentsearch_tools()] == ["agentsearch_search", "agentsearch_extract", "agentsearch_render"]
+    assert "query" in agentsearch_search.params_json_schema["properties"]
+
+
+def test_free_search(monkeypatch):
+    mock(monkeypatch, _client, 200, {"results": [{"title": "t", "url": "https://a", "content": "c"}]})
+    out = json.loads(call(agentsearch_search, {"query": "hi", "max_results": 1}))
+    assert out["results"][0]["url"] == "https://a"
+
+
+def test_paid_without_wallet(monkeypatch):
+    seen = mock(monkeypatch, _client, 200, {})
+    assert "no call was made" in call(agentsearch_tools()[1], {"url": "https://example.com", "max_chars": None}) and not seen
+
+
+@pytest.mark.skipif(not os.environ.get("AGENTSEARCH_LIVE"), reason="set AGENTSEARCH_LIVE=1")
+def test_live_free_search():
+    from openai_agents_agentsearch import _ops
+    out = json.loads(_ops.search("OpenAI Agents SDK function tools", 2, "free"))
+    assert out["results"][0]["url"].startswith("http")