pulse-perplexity 0.1.0__tar.gz

pulse_perplexity-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: pulse-perplexity
+Version: 0.1.0
+Summary: Perplexity AI adapter for PULSE Protocol — web search with citations via Sonar models
+Author-email: PULSE Protocol Team <pulse@protocol.org>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/pulseprotocolorg-cyber/pulse-perplexity
+Project-URL: Repository, https://github.com/pulseprotocolorg-cyber/pulse-perplexity
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pulse-protocol>=0.5.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"

pulse_perplexity-0.1.0/pulse_perplexity/__init__.py

@@ -0,0 +1,28 @@
+"""
+PULSE-Perplexity Adapter.
+
+Web search with real-time citations via Perplexity Sonar API.
+
+Setup:
+    export PERPLEXITY_API_KEY="pplx-..."
+    Get key at: https://www.perplexity.ai/settings/api
+
+Example:
+    >>> import os
+    >>> from pulse_perplexity import PerplexityAdapter
+    >>> from pulse.message import PulseMessage
+
+    >>> adapter = PerplexityAdapter(api_key=os.environ["PERPLEXITY_API_KEY"])
+    >>> adapter.connect()
+    >>> response = adapter.send(PulseMessage(
+    ...     action="ACT.SEARCH.WEB",
+    ...     parameters={"query": "PULSE Protocol AI standard 2026"},
+    ... ))
+    >>> print(response.content["parameters"]["answer"])
+    >>> print(response.content["parameters"]["citations"])
+"""
+
+from pulse_perplexity.adapter import PerplexityAdapter
+from pulse_perplexity.version import __version__
+
+__all__ = ["PerplexityAdapter", "__version__"]

pulse_perplexity-0.1.0/pulse_perplexity/adapter.py

@@ -0,0 +1,294 @@
+"""Perplexity AI adapter for PULSE Protocol.
+
+Translates PULSE semantic messages to Perplexity Sonar API calls.
+Returns answers with real-time web citations — unique capability
+not available in standard LLM adapters.
+
+Supported actions:
+    ACT.SEARCH.WEB      — web search with cited answer (main use case)
+    ACT.QUERY.DATA      — general question answering
+    ACT.ANALYZE.PATTERN — deep research synthesis
+    ACT.RESEARCH.TOPIC  — long-form research report (sonar-deep-research)
+
+Available models:
+    sonar               — fast, cost-effective search (default)
+    sonar-pro           — deeper context, 2× more sources
+    sonar-reasoning-pro — chain-of-thought reasoning
+    sonar-deep-research — hundreds of sources, long-form synthesis
+
+Credentials:
+    Set PERPLEXITY_API_KEY environment variable.
+    Get key at: https://www.perplexity.ai/settings/api
+
+Example:
+    >>> import os
+    >>> from pulse_perplexity import PerplexityAdapter
+    >>> from pulse.message import PulseMessage
+
+    >>> adapter = PerplexityAdapter(api_key=os.environ["PERPLEXITY_API_KEY"])
+    >>> adapter.connect()
+
+    >>> msg = PulseMessage(
+    ...     action="ACT.SEARCH.WEB",
+    ...     parameters={"query": "Latest PULSE Protocol news 2026"},
+    ... )
+    >>> response = adapter.send(msg)
+    >>> print(response.content["parameters"]["answer"])
+    >>> print(response.content["parameters"]["citations"])
+"""
+
+import os
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from pulse.message import PulseMessage
+from pulse.adapter import PulseAdapter, AdapterError, AdapterConnectionError
+
+
+_API_BASE = "https://api.perplexity.ai"
+_CHAT_ENDPOINT = "/chat/completions"
+
+# Map PULSE actions to Sonar models and system prompts
+_ACTION_CONFIG: Dict[str, Dict[str, str]] = {
+    "ACT.SEARCH.WEB": {
+        "model": "sonar",
+        "system": (
+            "You are a precise web search assistant. "
+            "Answer concisely with key facts. Always cite your sources."
+        ),
+    },
+    "ACT.QUERY.DATA": {
+        "model": "sonar-pro",
+        "system": (
+            "You are an expert analyst. "
+            "Provide a thorough, well-structured answer with citations."
+        ),
+    },
+    "ACT.ANALYZE.PATTERN": {
+        "model": "sonar-reasoning-pro",
+        "system": (
+            "You are a deep research analyst. Identify patterns, trends, and insights. "
+            "Use chain-of-thought reasoning. Cite all sources."
+        ),
+    },
+    "ACT.RESEARCH.TOPIC": {
+        "model": "sonar-deep-research",
+        "system": (
+            "You are a comprehensive research assistant. "
+            "Synthesize information from many sources into a detailed report."
+        ),
+    },
+}
+
+
+class PerplexityAdapter(PulseAdapter):
+    """PULSE adapter for Perplexity AI Sonar API.
+
+    Unique capability: every response includes real-time web citations.
+    Agents in your system get not just answers but verifiable sources.
+
+    Args:
+        api_key: Perplexity API key. Prefer ``os.environ["PERPLEXITY_API_KEY"]``.
+        model: Default Sonar model (overridable per message via ``parameters.model``).
+        search_recency: Filter results by time — "day", "week", "month", "year".
+        search_domain_filter: List of domains to restrict search to.
+        config: Extra adapter config.
+
+    Example:
+        >>> adapter = PerplexityAdapter(api_key=os.environ["PERPLEXITY_API_KEY"])
+        >>> adapter.connect()
+        >>> msg = PulseMessage(
+        ...     action="ACT.SEARCH.WEB",
+        ...     parameters={"query": "What is PULSE Protocol?"},
+        ... )
+        >>> response = adapter.send(msg)
+        >>> print(response.content["parameters"]["citations"])
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "sonar",
+        search_recency: Optional[str] = None,
+        search_domain_filter: Optional[List[str]] = None,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(
+            name="perplexity",
+            base_url=_API_BASE,
+            config=config or {},
+        )
+        self._api_key = api_key or os.environ.get("PERPLEXITY_API_KEY", "")
+        self._default_model = model
+        self._search_recency = search_recency
+        self._search_domain_filter = search_domain_filter or []
+        self._session: Optional[requests.Session] = None
+
+    # ── Lifecycle ──────────────────────────────────────────────────────────
+
+    def connect(self) -> None:
+        """Initialize HTTP session with auth headers.
+
+        Raises:
+            AdapterConnectionError: If API key is missing.
+        """
+        if not self._api_key:
+            raise AdapterConnectionError(
+                "Perplexity API key required. "
+                "Set PERPLEXITY_API_KEY env var or pass api_key=. "
+                "Get key at https://www.perplexity.ai/settings/api"
+            )
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        })
+        self.connected = True
+
+    def disconnect(self) -> None:
+        """Close HTTP session."""
+        if self._session:
+            self._session.close()
+            self._session = None
+        self.connected = False
+
+    # ── PULSE Protocol Interface ───────────────────────────────────────────
+
+    def to_native(self, message: PulseMessage) -> Dict[str, Any]:
+        """Convert PULSE message to Perplexity API request.
+
+        Args:
+            message: PULSE message with action and parameters.
+
+        Returns:
+            Dict ready for Perplexity /chat/completions endpoint.
+
+        Raises:
+            AdapterError: If action unsupported or query missing.
+        """
+        action = message.content["action"]
+        params = message.content.get("parameters", {})
+
+        action_cfg = _ACTION_CONFIG.get(action)
+        if not action_cfg:
+            raise AdapterError(
+                f"Unsupported action '{action}'. "
+                f"Supported: {sorted(_ACTION_CONFIG.keys())}"
+            )
+
+        query = params.get("query") or params.get("text") or params.get("topic")
+        if not query:
+            raise AdapterError(
+                f"Parameter 'query' is required for {action}"
+            )
+
+        model = params.get("model", action_cfg["model"])
+        system_prompt = params.get("system_prompt", action_cfg["system"])
+
+        body: Dict[str, Any] = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": query},
+            ],
+            "stream": False,
+        }
+
+        # Optional search filters
+        recency = params.get("search_recency", self._search_recency)
+        if recency:
+            body["search_recency_filter"] = recency
+
+        domain_filter = params.get("search_domain_filter", self._search_domain_filter)
+        if domain_filter:
+            body["search_domain_filter"] = domain_filter
+
+        if "max_tokens" in params:
+            body["max_tokens"] = params["max_tokens"]
+
+        if "temperature" in params:
+            body["temperature"] = params["temperature"]
+
+        return body
+
+    def call_api(self, native_request: Dict[str, Any]) -> Dict[str, Any]:
+        """Call Perplexity /chat/completions endpoint.
+
+        Args:
+            native_request: Request dict from to_native().
+
+        Returns:
+            Parsed response dict with answer, citations, usage.
+
+        Raises:
+            AdapterConnectionError: If Perplexity is unreachable.
+            AdapterError: On API error.
+        """
+        if not self._session:
+            self.connect()
+
+        try:
+            resp = self._session.post(
+                f"{self.base_url}{_CHAT_ENDPOINT}",
+                json=native_request,
+                timeout=120,
+            )
+        except requests.ConnectionError as e:
+            raise AdapterConnectionError(f"Cannot reach Perplexity API: {e}") from e
+        except requests.Timeout as e:
+            raise AdapterConnectionError("Perplexity API request timed out") from e
+
+        if resp.status_code == 401:
+            raise AdapterError("Invalid Perplexity API key. Check PERPLEXITY_API_KEY.")
+        if resp.status_code == 429:
+            raise AdapterError("Perplexity rate limit exceeded. Retry later.")
+        if resp.status_code >= 400:
+            raise AdapterError(
+                f"Perplexity API error {resp.status_code}: {resp.text[:200]}"
+            )
+
+        data = resp.json()
+        choice = data["choices"][0]
+
+        return {
+            "answer": choice["message"]["content"],
+            "model": data.get("model", native_request["model"]),
+            "citations": data.get("citations", []),
+            "finish_reason": choice.get("finish_reason", "stop"),
+            "usage": data.get("usage", {}),
+        }
+
+    def from_native(self, native_response: Dict[str, Any]) -> PulseMessage:
+        """Wrap Perplexity response in a PULSE message.
+
+        Args:
+            native_response: Dict from call_api().
+
+        Returns:
+            PULSE response message with answer, citations, model, usage.
+        """
+        return PulseMessage(
+            action="ACT.RESPOND",
+            parameters={
+                "status": "META.STATUS.SUCCESS",
+                "answer": native_response["answer"],
+                "citations": native_response["citations"],
+                "model": native_response["model"],
+                "finish_reason": native_response["finish_reason"],
+                "usage": native_response["usage"],
+            },
+            validate=False,
+        )
+
+    @property
+    def supported_actions(self) -> List[str]:
+        """PULSE actions this adapter handles."""
+        return sorted(_ACTION_CONFIG.keys())
+
+    def __repr__(self) -> str:
+        return (
+            f"PerplexityAdapter(model='{self._default_model}', "
+            f"connected={self.connected})"
+        )

pulse_perplexity-0.1.0/pulse_perplexity/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

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

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: pulse-perplexity
+Version: 0.1.0
+Summary: Perplexity AI adapter for PULSE Protocol — web search with citations via Sonar models
+Author-email: PULSE Protocol Team <pulse@protocol.org>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/pulseprotocolorg-cyber/pulse-perplexity
+Project-URL: Repository, https://github.com/pulseprotocolorg-cyber/pulse-perplexity
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pulse-protocol>=0.5.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"

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

@@ -0,0 +1,10 @@
+pyproject.toml
+pulse_perplexity/__init__.py
+pulse_perplexity/adapter.py
+pulse_perplexity/version.py
+pulse_perplexity.egg-info/PKG-INFO
+pulse_perplexity.egg-info/SOURCES.txt
+pulse_perplexity.egg-info/dependency_links.txt
+pulse_perplexity.egg-info/requires.txt
+pulse_perplexity.egg-info/top_level.txt
+tests/test_adapter.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,8 @@
+pulse-protocol>=0.5.0
+requests>=2.28.0
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0
+black>=23.0
+responses>=0.23.0

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

@@ -0,0 +1 @@
+pulse_perplexity

pulse_perplexity-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pulse-perplexity"
+version = "0.1.0"
+description = "Perplexity AI adapter for PULSE Protocol — web search with citations via Sonar models"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.9"
+authors = [
+    {name = "PULSE Protocol Team", email = "pulse@protocol.org"},
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "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 :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Internet :: WWW/HTTP :: Indexing/Search",
+]
+dependencies = [
+    "pulse-protocol>=0.5.0",
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "black>=23.0",
+    "responses>=0.23.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/pulseprotocolorg-cyber/pulse-perplexity"
+Repository = "https://github.com/pulseprotocolorg-cyber/pulse-perplexity"
+
+[tool.setuptools.packages.find]
+include = ["pulse_perplexity*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.black]
+line-length = 100

pulse_perplexity-0.1.0/setup.cfg

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

pulse_perplexity-0.1.0/tests/test_adapter.py

@@ -0,0 +1,269 @@
+"""Tests for PerplexityAdapter — all HTTP calls mocked."""
+
+import pytest
+import responses as rsps_lib
+from unittest.mock import MagicMock, patch
+
+from pulse.message import PulseMessage
+from pulse.adapter import AdapterError, AdapterConnectionError
+
+from pulse_perplexity import PerplexityAdapter
+
+
+API_URL = "https://api.perplexity.ai/chat/completions"
+
+
+def make_api_response(answer="Paris", model="sonar", citations=None):
+    return {
+        "id": "req-123",
+        "model": model,
+        "choices": [{"message": {"role": "assistant", "content": answer}, "finish_reason": "stop"}],
+        "citations": citations or ["https://example.com/1", "https://example.com/2"],
+        "usage": {"input_tokens": 10, "output_tokens": 50, "total_tokens": 60},
+    }
+
+
+@pytest.fixture
+def adapter():
+    a = PerplexityAdapter(api_key="pplx-test-key")
+    a.connect()
+    return a
+
+
+# ── connect() ─────────────────────────────────────────────────────────────
+
+def test_connect_raises_without_api_key():
+    a = PerplexityAdapter(api_key="")
+    with pytest.raises(AdapterConnectionError, match="PERPLEXITY_API_KEY"):
+        a.connect()
+
+
+def test_connect_sets_auth_header(adapter):
+    assert "Authorization" in adapter._session.headers
+    assert adapter._session.headers["Authorization"] == "Bearer pplx-test-key"
+
+
+def test_connect_sets_connected_flag(adapter):
+    assert adapter.connected is True
+
+
+def test_disconnect_clears_session(adapter):
+    adapter.disconnect()
+    assert adapter._session is None
+    assert adapter.connected is False
+
+
+# ── to_native() ───────────────────────────────────────────────────────────
+
+def test_to_native_search_web(adapter):
+    msg = PulseMessage(
+        action="ACT.SEARCH.WEB",
+        parameters={"query": "What is PULSE Protocol?"},
+        validate=False,
+    )
+    native = adapter.to_native(msg)
+    assert native["model"] == "sonar"
+    assert native["messages"][-1]["content"] == "What is PULSE Protocol?"
+    assert native["stream"] is False
+
+
+def test_to_native_research_uses_deep_model(adapter):
+    msg = PulseMessage(
+        action="ACT.RESEARCH.TOPIC",
+        parameters={"topic": "AI semantic protocols"},
+        validate=False,
+    )
+    native = adapter.to_native(msg)
+    assert native["model"] == "sonar-deep-research"
+
+
+def test_to_native_model_override(adapter):
+    msg = PulseMessage(
+        action="ACT.SEARCH.WEB",
+        parameters={"query": "test", "model": "sonar-pro"},
+        validate=False,
+    )
+    native = adapter.to_native(msg)
+    assert native["model"] == "sonar-pro"
+
+
+def test_to_native_search_recency_filter(adapter):
+    msg = PulseMessage(
+        action="ACT.SEARCH.WEB",
+        parameters={"query": "latest AI news", "search_recency": "day"},
+        validate=False,
+    )
+    native = adapter.to_native(msg)
+    assert native["search_recency_filter"] == "day"
+
+
+def test_to_native_domain_filter(adapter):
+    msg = PulseMessage(
+        action="ACT.SEARCH.WEB",
+        parameters={"query": "q", "search_domain_filter": ["arxiv.org"]},
+        validate=False,
+    )
+    native = adapter.to_native(msg)
+    assert native["search_domain_filter"] == ["arxiv.org"]
+
+
+def test_to_native_raises_without_query(adapter):
+    msg = PulseMessage(
+        action="ACT.SEARCH.WEB", parameters={}, validate=False
+    )
+    with pytest.raises(AdapterError, match="'query'"):
+        adapter.to_native(msg)
+
+
+def test_to_native_raises_unsupported_action(adapter):
+    msg = PulseMessage(
+        action="ACT.STORE.SECRET", parameters={}, validate=False
+    )
+    with pytest.raises(AdapterError, match="Unsupported action"):
+        adapter.to_native(msg)
+
+
+def test_to_native_accepts_text_param(adapter):
+    msg = PulseMessage(
+        action="ACT.QUERY.DATA",
+        parameters={"text": "Explain quantum computing"},
+        validate=False,
+    )
+    native = adapter.to_native(msg)
+    assert native["messages"][-1]["content"] == "Explain quantum computing"
+
+
+# ── call_api() ────────────────────────────────────────────────────────────
+
+@rsps_lib.activate
+def test_call_api_success(adapter):
+    rsps_lib.add(rsps_lib.POST, API_URL, json=make_api_response("Paris is the capital"), status=200)
+    result = adapter.call_api({
+        "model": "sonar",
+        "messages": [{"role": "user", "content": "Capital of France?"}],
+        "stream": False,
+    })
+    assert result["answer"] == "Paris is the capital"
+    assert result["model"] == "sonar"
+    assert len(result["citations"]) == 2
+
+
+@rsps_lib.activate
+def test_call_api_returns_citations(adapter):
+    rsps_lib.add(rsps_lib.POST, API_URL, json=make_api_response(
+        citations=["https://wiki.org/France", "https://britannica.com/paris"]
+    ), status=200)
+    result = adapter.call_api({"model": "sonar", "messages": [], "stream": False})
+    assert "https://wiki.org/France" in result["citations"]
+
+
+@rsps_lib.activate
+def test_call_api_401_raises_auth_error(adapter):
+    rsps_lib.add(rsps_lib.POST, API_URL, json={"error": "unauthorized"}, status=401)
+    with pytest.raises(AdapterError, match="Invalid Perplexity API key"):
+        adapter.call_api({"model": "sonar", "messages": [], "stream": False})
+
+
+@rsps_lib.activate
+def test_call_api_429_raises_rate_limit(adapter):
+    rsps_lib.add(rsps_lib.POST, API_URL, json={"error": "rate limit"}, status=429)
+    with pytest.raises(AdapterError, match="rate limit"):
+        adapter.call_api({"model": "sonar", "messages": [], "stream": False})
+
+
+@rsps_lib.activate
+def test_call_api_500_raises_error(adapter):
+    rsps_lib.add(rsps_lib.POST, API_URL, json={"error": "server error"}, status=500)
+    with pytest.raises(AdapterError, match="500"):
+        adapter.call_api({"model": "sonar", "messages": [], "stream": False})
+
+
+def test_call_api_connection_error(adapter):
+    with patch.object(adapter._session, "post", side_effect=Exception("connection refused")):
+        with pytest.raises(Exception):
+            adapter.call_api({"model": "sonar", "messages": [], "stream": False})
+
+
+# ── from_native() ─────────────────────────────────────────────────────────
+
+def test_from_native_wraps_in_pulse(adapter):
+    response = adapter.from_native({
+        "answer": "42",
+        "model": "sonar",
+        "citations": ["https://example.com"],
+        "finish_reason": "stop",
+        "usage": {"total_tokens": 60},
+    })
+    assert isinstance(response, PulseMessage)
+    p = response.content["parameters"]
+    assert p["answer"] == "42"
+    assert p["citations"] == ["https://example.com"]
+    assert p["status"] == "META.STATUS.SUCCESS"
+
+
+# ── Full send() flow ──────────────────────────────────────────────────────
+
+@rsps_lib.activate
+def test_send_search_web(adapter):
+    rsps_lib.add(rsps_lib.POST, API_URL, json=make_api_response(
+        answer="PULSE Protocol is a semantic AI standard",
+        citations=["https://pulse-protocol.netlify.app"]
+    ), status=200)
+    msg = PulseMessage(
+        action="ACT.SEARCH.WEB",
+        parameters={"query": "What is PULSE Protocol?"},
+        validate=False,
+    )
+    response = adapter.send(msg)
+    p = response.content["parameters"]
+    assert "PULSE Protocol" in p["answer"]
+    assert "https://pulse-protocol.netlify.app" in p["citations"]
+    assert p["status"] == "META.STATUS.SUCCESS"
+
+
+@rsps_lib.activate
+def test_send_with_recency_filter(adapter):
+    rsps_lib.add(rsps_lib.POST, API_URL, json=make_api_response(), status=200)
+    msg = PulseMessage(
+        action="ACT.SEARCH.WEB",
+        parameters={"query": "AI news", "search_recency": "week"},
+        validate=False,
+    )
+    adapter.send(msg)
+    sent_body = rsps_lib.calls[0].request.body.decode()
+    assert "search_recency_filter" in sent_body
+    assert "week" in sent_body
+
+
+# ── supported_actions & repr ──────────────────────────────────────────────
+
+def test_supported_actions(adapter):
+    actions = adapter.supported_actions
+    assert "ACT.SEARCH.WEB" in actions
+    assert "ACT.QUERY.DATA" in actions
+    assert "ACT.ANALYZE.PATTERN" in actions
+    assert "ACT.RESEARCH.TOPIC" in actions
+    assert len(actions) == 4
+
+
+def test_repr(adapter):
+    r = repr(adapter)
+    assert "PerplexityAdapter" in r
+    assert "sonar" in r
+
+
+# ── Global search_recency on adapter level ────────────────────────────────
+
+@rsps_lib.activate
+def test_adapter_level_recency_filter():
+    a = PerplexityAdapter(api_key="pplx-test", search_recency="month")
+    a.connect()
+    rsps_lib.add(rsps_lib.POST, API_URL, json=make_api_response(), status=200)
+    msg = PulseMessage(
+        action="ACT.SEARCH.WEB",
+        parameters={"query": "test"},
+        validate=False,
+    )
+    a.send(msg)
+    sent_body = rsps_lib.calls[0].request.body.decode()
+    assert "month" in sent_body