perplexity-haystack 0.1.1__tar.gz → 0.2.0__tar.gz

{perplexity_haystack-0.1.1 → perplexity_haystack-0.2.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [integrations/perplexity-v0.1.1] - 2026-05-27
+
+### 🐛 Bug Fixes
+
+- *(perplexity)* Decode embedding API responses (#3344)
+
+
 ## [integrations/perplexity-v0.1.0] - 2026-05-13
 
 ### 🌀 Miscellaneous

{perplexity_haystack-0.1.1 → perplexity_haystack-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: perplexity-haystack
-Version: 0.1.1
+Version: 0.2.0
 Summary: Haystack integration for Perplexity Web Search
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/perplexity#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues

{perplexity_haystack-0.1.1 → perplexity_haystack-0.2.0}/src/haystack_integrations/components/embedders/perplexity/document_embedder.py

@@ -142,9 +142,9 @@ class PerplexityDocumentEmbedder(OpenAIDocumentEmbedder):
             max_retries=max_retries,
             http_client_kwargs=_http_client_kwargs_with_attribution(http_client_kwargs),
         )
-        self.http_client_kwargs = http_client_kwargs
-        self.timeout = timeout
-        self.max_retries = max_retries
+        # self.http_client_kwargs keeps the attribution header so that haystack-ai >= 3.0 builds the clients
+        # with it at warm-up; the user-provided value is preserved for serialization
+        self._http_client_kwargs = http_client_kwargs
 
     def _decode_response_embeddings(self, response: CreateEmbeddingResponse) -> list[list[float]]:
         return [_decode_embedding(str(el.embedding), self.encoding_format) for el in response.data]
@@ -168,7 +168,8 @@ class PerplexityDocumentEmbedder(OpenAIDocumentEmbedder):
             }
 
             try:
-                response = self.client.embeddings.create(**args)
+                # with haystack-ai >= 3.0 the client is Optional and built by the warm_up call in run
+                response = self.client.embeddings.create(**args)  # type: ignore[union-attr]
             except APIError as exc:
                 ids = ", ".join(b[0] for b in batch)
                 msg = "Failed embedding of documents {ids} caused by {exc}"
@@ -212,7 +213,8 @@ class PerplexityDocumentEmbedder(OpenAIDocumentEmbedder):
             }
 
             try:
-                response = await self.async_client.embeddings.create(**args)
+                # with haystack-ai >= 3.0 the client is Optional and built by the warm_up_async call in run_async
+                response = await self.async_client.embeddings.create(**args)  # type: ignore[union-attr]
             except APIError as exc:
                 ids = ", ".join(b[0] for b in batch)
                 msg = "Failed embedding of documents {ids} caused by {exc}"
@@ -255,7 +257,7 @@ class PerplexityDocumentEmbedder(OpenAIDocumentEmbedder):
             encoding_format=self.encoding_format,
             timeout=self.timeout,
             max_retries=self.max_retries,
-            http_client_kwargs=self.http_client_kwargs,
+            http_client_kwargs=self._http_client_kwargs,
         )
 
     @classmethod

{perplexity_haystack-0.1.1 → perplexity_haystack-0.2.0}/src/haystack_integrations/components/embedders/perplexity/text_embedder.py

@@ -114,9 +114,9 @@ class PerplexityTextEmbedder(OpenAITextEmbedder):
             max_retries=max_retries,
             http_client_kwargs=_http_client_kwargs_with_attribution(http_client_kwargs),
         )
-        self.http_client_kwargs = http_client_kwargs
-        self.timeout = timeout
-        self.max_retries = max_retries
+        # self.http_client_kwargs keeps the attribution header so that haystack-ai >= 3.0 builds the clients
+        # with it at warm-up; the user-provided value is preserved for serialization
+        self._http_client_kwargs = http_client_kwargs
 
     def _prepare_input(self, text: str) -> dict[str, Any]:
         kwargs = OpenAITextEmbedder._prepare_input(self, text=text)
@@ -147,7 +147,7 @@ class PerplexityTextEmbedder(OpenAITextEmbedder):
             encoding_format=self.encoding_format,
             timeout=self.timeout,
             max_retries=self.max_retries,
-            http_client_kwargs=self.http_client_kwargs,
+            http_client_kwargs=self._http_client_kwargs,
         )
 
     @classmethod

{perplexity_haystack-0.1.1 → perplexity_haystack-0.2.0}/src/haystack_integrations/components/generators/perplexity/chat/chat_generator.py

@@ -25,20 +25,15 @@ def _attribution_header() -> str:
     return f"{_INTEGRATION_SLUG}/{version}"
 
 
-def _perplexity_headers(extra_headers: dict[str, Any] | None = None) -> dict[str, Any]:
-    return {
-        **(extra_headers or {}),
-        "X-Pplx-Integration": _attribution_header(),
-    }
-
-
-def _with_default_headers(client: Any, headers: dict[str, Any]) -> Any:
-    with_options = getattr(client, "with_options", None)
-    if with_options is not None:
-        return with_options(default_headers=headers)
-
-    client._custom_headers = {**getattr(client, "_custom_headers", {}), **headers}
-    return client
+def _http_client_kwargs_with_headers(
+    http_client_kwargs: dict[str, Any] | None,
+    extra_headers: dict[str, Any] | None,
+) -> dict[str, Any]:
+    kwargs = dict(http_client_kwargs or {})
+    headers = {**kwargs.get("headers", {}), **(extra_headers or {})}
+    headers["X-Pplx-Integration"] = _attribution_header()
+    kwargs["headers"] = headers
+    return kwargs
 
 
 @component
@@ -133,12 +128,12 @@ class PerplexityChatGenerator(OpenAIResponsesChatGenerator):
             max_retries=max_retries,
             tools=tools,
             tools_strict=tools_strict,
-            http_client_kwargs=http_client_kwargs,
+            http_client_kwargs=_http_client_kwargs_with_headers(http_client_kwargs, extra_headers),
         )
-
-        default_headers = _perplexity_headers(extra_headers)
-        self.client = _with_default_headers(self.client, default_headers)
-        self.async_client = _with_default_headers(self.async_client, default_headers)
+        # self.http_client_kwargs carries the attribution (and extra) headers so that the parent bakes them into
+        # the httpx client whether it is built eagerly (haystack-ai 2.x) or at warm-up (haystack-ai >= 3.0);
+        # the user-provided value is preserved for serialization
+        self._http_client_kwargs = http_client_kwargs
 
     def to_dict(self) -> dict[str, Any]:
         """
@@ -150,6 +145,8 @@ class PerplexityChatGenerator(OpenAIResponsesChatGenerator):
         data = super(PerplexityChatGenerator, self).to_dict()  # noqa: UP008
         data["type"] = generate_qualified_class_name(type(self))
         data["init_parameters"]["extra_headers"] = self.extra_headers
+        # serialize the user-provided value, not the internal one enriched with attribution headers
+        data["init_parameters"]["http_client_kwargs"] = self._http_client_kwargs
         return data
 
     @classmethod

{perplexity_haystack-0.1.1 → perplexity_haystack-0.2.0}/tests/test_perplexity_chat_generator.py

@@ -6,6 +6,7 @@ import os
 from datetime import datetime, timezone
 from unittest.mock import patch
 
+import httpx
 import pytest
 from haystack.components.generators.utils import print_streaming_chunk
 from haystack.dataclasses import ChatMessage
@@ -37,6 +38,27 @@ def _make_response() -> Response:
     return Response.construct(**response_data)
 
 
+def _make_transport(captured: list[httpx.Request]) -> httpx.MockTransport:
+    def handler(request: httpx.Request) -> httpx.Response:
+        captured.append(request)
+        return httpx.Response(
+            200,
+            json={
+                "id": "resp_test",
+                "created_at": datetime.now(tz=timezone.utc).timestamp(),
+                "model": "openai/gpt-5.4",
+                "object": "response",
+                "output": [],
+                "parallel_tool_calls": True,
+                "tool_choice": "auto",
+                "tools": [],
+            },
+            headers={"Content-Type": "application/json"},
+        )
+
+    return httpx.MockTransport(handler)
+
+
 @pytest.fixture
 def chat_messages() -> list[ChatMessage]:
     return [
@@ -63,7 +85,7 @@ class TestPerplexityChatGenerator:
 
         component = PerplexityChatGenerator()
 
-        assert component.client.api_key == "test-api-key"
+        assert component.api_key.resolve_value() == "test-api-key"
         assert component.model == "openai/gpt-5.4"
         assert component.api_base_url == "https://api.perplexity.ai/v1"
         assert component.streaming_callback is None
@@ -84,7 +106,7 @@ class TestPerplexityChatGenerator:
             http_client_kwargs={"proxy": "http://localhost:8080"},
         )
 
-        assert component.client.api_key == "test-api-key"
+        assert component.api_key.resolve_value() == "test-api-key"
         assert component.model == "anthropic/claude-sonnet-4-6"
         assert component.streaming_callback is print_streaming_chunk
         assert component.generation_kwargs == {
@@ -96,7 +118,16 @@ class TestPerplexityChatGenerator:
         assert component.extra_headers == {"test-header": "test-value"}
         assert component.timeout == 10
         assert component.max_retries == 2
-        assert component.http_client_kwargs == {"proxy": "http://localhost:8080"}
+
+        assert component._http_client_kwargs == {"proxy": "http://localhost:8080"}
+        assert component.http_client_kwargs["headers"]["test-header"] == "test-value"
+        assert component.http_client_kwargs["headers"]["X-Pplx-Integration"].startswith("haystack/")
+
+    def test_warm_up(self, monkeypatch):
+        monkeypatch.setenv("PERPLEXITY_API_KEY", "test-api-key")
+        component = PerplexityChatGenerator()
+        component.warm_up()  # with haystack-ai >= 3.0 the client is created during warm-up
+        assert component.client.api_key == "test-api-key"
 
     def test_to_dict_default_round_trip(self, monkeypatch):
         monkeypatch.setenv("PERPLEXITY_API_KEY", "test-api-key")
@@ -177,7 +208,7 @@ class TestPerplexityChatGenerator:
         assert deserialized.extra_headers == {"test-header": "test-value"}
         assert deserialized.timeout == 10
         assert deserialized.max_retries == 2
-        assert deserialized.http_client_kwargs == {"proxy": "http://localhost:8080"}
+        assert deserialized._http_client_kwargs == {"proxy": "http://localhost:8080"}
 
     def test_run_uses_responses_create(self, chat_messages):
         component = PerplexityChatGenerator(api_key=Secret.from_token("test-api-key"))
@@ -193,16 +224,48 @@ class TestPerplexityChatGenerator:
         assert "messages" not in call_kwargs
         assert call_kwargs["stream"] is False
 
-    def test_default_headers_include_perplexity_attribution(self):
+    def test_http_client_kwargs_with_headers_merges_extra_and_attribution(self):
+        kwargs = chat_generator_module._http_client_kwargs_with_headers(
+            {"headers": {"existing-header": "existing-value"}},
+            {"test-header": "test-value"},
+        )
+
+        assert kwargs["headers"]["existing-header"] == "existing-value"
+        assert kwargs["headers"]["test-header"] == "test-value"
+        assert kwargs["headers"]["X-Pplx-Integration"].startswith("haystack/")
+
+    def test_run_sends_attribution_header(self, chat_messages):
+        captured: list[httpx.Request] = []
         component = PerplexityChatGenerator(
             api_key=Secret.from_token("test-api-key"),
             extra_headers={"test-header": "test-value"},
+            http_client_kwargs={"transport": _make_transport(captured)},
         )
 
-        assert component.client.default_headers["X-Pplx-Integration"].startswith("haystack/")
-        assert component.client.default_headers["test-header"] == "test-value"
-        assert component.async_client.default_headers["X-Pplx-Integration"].startswith("haystack/")
-        assert component.async_client.default_headers["test-header"] == "test-value"
+        component.run(chat_messages)
+
+        assert len(captured) == 1
+        request = captured[0]
+        assert request.headers["Authorization"] == "Bearer test-api-key"
+        assert request.headers["X-Pplx-Integration"].startswith("haystack/")
+        assert request.headers["test-header"] == "test-value"
+
+    @pytest.mark.asyncio
+    async def test_run_async_sends_attribution_header(self, chat_messages):
+        captured: list[httpx.Request] = []
+        component = PerplexityChatGenerator(
+            api_key=Secret.from_token("test-api-key"),
+            extra_headers={"test-header": "test-value"},
+            http_client_kwargs={"transport": _make_transport(captured)},
+        )
+
+        await component.run_async(chat_messages)
+
+        assert len(captured) == 1
+        request = captured[0]
+        assert request.headers["Authorization"] == "Bearer test-api-key"
+        assert request.headers["X-Pplx-Integration"].startswith("haystack/")
+        assert request.headers["test-header"] == "test-value"
 
 
 @pytest.mark.skipif(

{perplexity_haystack-0.1.1 → perplexity_haystack-0.2.0}/tests/test_perplexity_document_embedder.py

@@ -236,7 +236,8 @@ class TestPerplexityDocumentEmbedder:
         assert component.encoding_format == "base64_binary"
         assert component.timeout is None
         assert component.max_retries is None
-        assert component.http_client_kwargs is None
+        # the user-provided value; component.http_client_kwargs carries the attribution header
+        assert component._http_client_kwargs is None
 
     def test_run_sends_attribution_header(self):
         captured: list[httpx.Request] = []

{perplexity_haystack-0.1.1 → perplexity_haystack-0.2.0}/tests/test_perplexity_text_embedder.py

@@ -179,7 +179,8 @@ class TestPerplexityTextEmbedder:
         assert component.encoding_format == "base64_binary"
         assert component.timeout is None
         assert component.max_retries is None
-        assert component.http_client_kwargs is None
+        # the user-provided value; component.http_client_kwargs carries the attribution header
+        assert component._http_client_kwargs is None
 
     def test_run_sends_attribution_header(self):
         captured: list[httpx.Request] = []