oneshot-python 0.24.0__tar.gz → 0.25.0__tar.gz

{oneshot_python-0.24.0 → oneshot_python-0.25.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: oneshot-python
-Version: 0.24.0
-Summary: Core Python SDK for the OneShot API — HTTP client with x402 payment handling — 35 tools
+Version: 0.25.0
+Summary: Core Python SDK for the OneShot API — HTTP client with x402 payment handling — 43 tools
 License-Expression: MIT
 Requires-Python: >=3.10
 Requires-Dist: eth-account>=0.13.0

{oneshot_python-0.24.0 → oneshot_python-0.25.0}/README.md

@@ -192,7 +192,7 @@ Every method has an `a*` async mirror (`acompute`, `aget_compute_goal`, …).
 ## Links
 
 - [Documentation](https://docs.oneshotagent.com/sdk/installation#install-via-pip-python)
-- [LangChain integration](https://pypi.org/project/langchain-oneshot/) — 35 tools as LangChain BaseTool
+- [LangChain integration](https://pypi.org/project/langchain-oneshot/) — 43 tools as LangChain BaseTool
 - [GAME plugin](https://pypi.org/project/game-plugin-oneshot/) — Virtuals Protocol integration
 - [TypeScript SDK](https://www.npmjs.com/package/@oneshot-agent/sdk)
 - [MCP Server](https://www.npmjs.com/package/@oneshot-agent/mcp-server)

{oneshot_python-0.24.0 → oneshot_python-0.25.0}/oneshot/client.py

@@ -51,7 +51,7 @@ try:
 
     SDK_VERSION = _pkg_version("oneshot-python")
 except Exception:  # pragma: no cover - editable/source runs without dist metadata
-    SDK_VERSION = "0.24.0"
+    SDK_VERSION = "0.25.0"
 
 # ---------------------------------------------------------------------------
 # Environment configuration
@@ -312,12 +312,16 @@ class OneShotClient:
     # Headers
     # ------------------------------------------------------------------
 
-    def _headers(self, max_cost: Optional[float] = None) -> dict[str, str]:
+    def _headers(self, max_cost: Optional[float] = None, idempotency_key: Optional[str] = None) -> dict[str, str]:
         headers = {
             "Content-Type": "application/json",
             "X-Agent-ID": self.address,
             "X-OneShot-SDK-Version": SDK_VERSION,
         }
+        # Sent on BOTH x402 legs: the server replays a retry instead of
+        # settling a second payment and repeating the side effect.
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
         # Server-side budget cap. The API rejects with HTTP 400
         # `exceeds_caller_budget` before requesting payment if the quoted
         # total exceeds this cap. The local fast-fail below stays as defense
@@ -331,16 +335,17 @@ class OneShotClient:
         from oneshot.physical_mail import PhysicalMail
         return PhysicalMail(self)
 
-    def _read_headers(self) -> dict[str, str]:
+    def _read_headers(self, scope: str = "read") -> dict[str, str]:
         """Auth headers plus a signed EIP-712 read proof (x-agent-proof) for the
         free READ routes (inbox, sms inbox, notifications, balance, browser
         profiles). These identify the caller by wallet, and wallet addresses are
         public, so without a proof anyone could read another agent's data by
         supplying its address. Signing failure falls back to plain headers (the
-        server runs log-only until read-proof enforcement is enabled)."""
+        server runs log-only until read-proof enforcement is enabled).
+        Free MUTATION routes (e.g. LinkedIn connect/revoke) require scope="write"."""
         headers = self._headers()
         try:
-            headers["x-agent-proof"] = sign_read_proof(self._private_key, self.address)
+            headers["x-agent-proof"] = sign_read_proof(self._private_key, self.address, scope=scope)
         except Exception as e:  # noqa: BLE001
             self._log(f"Failed to sign read proof (continuing without): {e}")
         return headers
@@ -446,6 +451,7 @@ class OneShotClient:
         wait: bool = True,
         wait_for_phones: bool = False,
         phone_timeout_sec: int = 360,
+        idempotency_key: Optional[str] = None,
     ) -> Any:
         """Execute a paid tool call (blocking). Handles the full x402 flow.
 
@@ -467,6 +473,7 @@ class OneShotClient:
                 wait=wait,
                 wait_for_phones=wait_for_phones,
                 phone_timeout_sec=phone_timeout_sec,
+                idempotency_key=idempotency_key,
             )
         )
 
@@ -519,6 +526,7 @@ class OneShotClient:
         wait_for_phones: bool = False,
         phone_timeout_sec: int = 360,
         quote_id: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
     ) -> Any:
         """Execute a paid tool call (async). Handles the full x402 flow.
 
@@ -564,7 +572,7 @@ class OneShotClient:
             # before they ever get to the 402 dance unless x-quote-id rides
             # on this very first attempt, so an already-obtained quote_id
             # must be sent from the start, not just on the paid retry.
-            initial_headers = self._headers(max_cost=max_cost)
+            initial_headers = self._headers(max_cost=max_cost, idempotency_key=idempotency_key)
             if quote_id:
                 initial_headers["x-quote-id"] = quote_id
             resp = await client.post(url, headers=initial_headers, json=payload)
@@ -653,7 +661,7 @@ class OneShotClient:
                     extensions=parsed_req.get("extensions"),
                 )
                 headers = {
-                    **self._headers(max_cost=max_cost),
+                    **self._headers(max_cost=max_cost, idempotency_key=idempotency_key),
                     "payment-signature": encode_payment_header(auth),
                 }
                 if quote_id:
@@ -675,7 +683,7 @@ class OneShotClient:
 
                 # Step 4 — Re-POST with payment headers (x402 format)
                 headers = {
-                    **self._headers(max_cost=max_cost),
+                    **self._headers(max_cost=max_cost, idempotency_key=idempotency_key),
                     "payment-signature": encode_payment_header(auth),
                 }
                 if quote_id:
@@ -750,21 +758,25 @@ class OneShotClient:
         self,
         endpoint: str,
         payload: Optional[dict[str, Any]] = None,
+        *,
+        scope: str = "read",
     ) -> Any:
-        """POST to a free endpoint (blocking)."""
+        """POST to a free endpoint (blocking). Mutations pass scope="write"."""
         return asyncio.get_event_loop().run_until_complete(
-            self.acall_free_post(endpoint, payload)
+            self.acall_free_post(endpoint, payload, scope=scope)
         )
 
     async def acall_free_post(
         self,
         endpoint: str,
         payload: Optional[dict[str, Any]] = None,
+        *,
+        scope: str = "read",
     ) -> Any:
-        """POST to a free endpoint (async)."""
+        """POST to a free endpoint (async). Mutations pass scope="write"."""
         url = f"{self.base_url}{endpoint}"
         async with httpx.AsyncClient(timeout=httpx.Timeout(150.0 if endpoint.startswith("/v1/tools/browser/profiles") else 30.0)) as client:
-            resp = await client.post(url, headers=self._read_headers(), json=payload or {})
+            resp = await client.post(url, headers=self._read_headers(scope), json=payload or {})
             if not resp.is_success:
                 raise ToolError(f"POST {endpoint} failed", resp.status_code, resp.text)
             return resp.json()
@@ -821,20 +833,24 @@ class OneShotClient:
     def call_free_delete(
         self,
         endpoint: str,
+        *,
+        scope: str = "read",
     ) -> Any:
-        """DELETE a free endpoint (blocking)."""
+        """DELETE a free endpoint (blocking). Mutations pass scope="write"."""
         return asyncio.get_event_loop().run_until_complete(
-            self.acall_free_delete(endpoint)
+            self.acall_free_delete(endpoint, scope=scope)
         )
 
     async def acall_free_delete(
         self,
         endpoint: str,
+        *,
+        scope: str = "read",
     ) -> Any:
-        """DELETE a free endpoint (async)."""
+        """DELETE a free endpoint (async). Mutations pass scope="write"."""
         url = f"{self.base_url}{endpoint}"
         async with httpx.AsyncClient(timeout=httpx.Timeout(30.0)) as client:
-            resp = await client.delete(url, headers=self._read_headers())
+            resp = await client.delete(url, headers=self._read_headers(scope))
             if not resp.is_success:
                 raise ToolError(f"DELETE {endpoint} failed", resp.status_code, resp.text)
             if resp.status_code == 204 or not resp.text:
@@ -1160,6 +1176,107 @@ class OneShotClient:
         """Delete a browser profile. Async."""
         return await self.acall_free_delete(f"/v1/tools/browser/profiles/{profile_id}")
 
+    # ------------------------------------------------------------------
+    # LinkedIn — messaging through a human-connected account (issue #756)
+    # ------------------------------------------------------------------
+
+    def linkedin_connect(self, requested_actions: list[str], *, success_redirect_url: Optional[str] = None, failure_redirect_url: Optional[str] = None) -> dict:
+        """Create a hosted LinkedIn login link for a human to connect THEIR OWN account and grant `requested_actions`
+        (read, reply, view_profile, react). The returned url is shown to the human once and expires in 30 minutes. Free."""
+        return self.call_free_post("/v1/tools/linkedin/connect", _linkedin_connect_payload(requested_actions, success_redirect_url, failure_redirect_url), scope="write")
+
+    async def alinkedin_connect(self, requested_actions: list[str], *, success_redirect_url: Optional[str] = None, failure_redirect_url: Optional[str] = None) -> dict:
+        return await self.acall_free_post("/v1/tools/linkedin/connect", _linkedin_connect_payload(requested_actions, success_redirect_url, failure_redirect_url), scope="write")
+
+    def get_linkedin_connection(self, intent_id: str) -> dict:
+        """Status of a connection intent: pending | verifying | completed (with `account`) | failed (`failure_reason`). Free."""
+        return self.call_free_get(f"/v1/tools/linkedin/connect/{quote(intent_id, safe='')}")
+
+    async def aget_linkedin_connection(self, intent_id: str) -> dict:
+        return await self.acall_free_get(f"/v1/tools/linkedin/connect/{quote(intent_id, safe='')}")
+
+    def list_linkedin_accounts(self, *, include_revoked: bool = False) -> dict:
+        """Connected LinkedIn accounts for this agent (`{"accounts": [...]}`). Never exposes upstream ids. Free."""
+        return self.call_free_get("/v1/tools/linkedin/accounts", {"include_revoked": "true"} if include_revoked else None)
+
+    async def alist_linkedin_accounts(self, *, include_revoked: bool = False) -> dict:
+        return await self.acall_free_get("/v1/tools/linkedin/accounts", {"include_revoked": "true"} if include_revoked else None)
+
+    def get_linkedin_account(self, account_id: str) -> dict:
+        return self.call_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}")
+
+    async def aget_linkedin_account(self, account_id: str) -> dict:
+        return await self.acall_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}")
+
+    def reconnect_linkedin_account(self, account_id: str, *, requested_actions: Optional[list[str]] = None, success_redirect_url: Optional[str] = None, failure_redirect_url: Optional[str] = None) -> dict:
+        """Hosted reconnect link for an existing account (keeps ownership; may narrow, never widen, the grant). Free."""
+        return self.call_free_post(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/reconnect", _linkedin_connect_payload(requested_actions, success_redirect_url, failure_redirect_url), scope="write")
+
+    async def areconnect_linkedin_account(self, account_id: str, *, requested_actions: Optional[list[str]] = None, success_redirect_url: Optional[str] = None, failure_redirect_url: Optional[str] = None) -> dict:
+        return await self.acall_free_post(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/reconnect", _linkedin_connect_payload(requested_actions, success_redirect_url, failure_redirect_url), scope="write")
+
+    def revoke_linkedin_account(self, account_id: str) -> dict:
+        """End the grant, cancel queued writes, delete the upstream connection. Free."""
+        return self.call_free_delete(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}", scope="write")
+
+    async def arevoke_linkedin_account(self, account_id: str) -> dict:
+        return await self.acall_free_delete(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}", scope="write")
+
+    def get_linkedin_sync(self, account_id: str) -> dict:
+        """Coverage, sync_state and recent runs for an account. Free."""
+        return self.call_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/sync")
+
+    async def aget_linkedin_sync(self, account_id: str) -> dict:
+        return await self.acall_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/sync")
+
+    def linkedin_sync(self, account_id: str, *, mode: Optional[str] = None, max_pages: Optional[int] = None, max_cost: Optional[float] = None, timeout_sec: int = 600, wait: bool = True, **kwargs: Any) -> Any:
+        """One bounded, paid history-sync run (up to max_pages x 250 messages). Blocking."""
+        return self.call_tool("/v1/tools/linkedin/sync", _linkedin_sync_payload(account_id, mode, max_pages, kwargs), max_cost=max_cost, timeout_sec=timeout_sec, wait=wait)
+
+    async def alinkedin_sync(self, account_id: str, *, mode: Optional[str] = None, max_pages: Optional[int] = None, max_cost: Optional[float] = None, timeout_sec: int = 600, wait: bool = True, **kwargs: Any) -> Any:
+        return await self.acall_tool("/v1/tools/linkedin/sync", _linkedin_sync_payload(account_id, mode, max_pages, kwargs), max_cost=max_cost, timeout_sec=timeout_sec, wait=wait)
+
+    def linkedin_conversations(self, account_id: str, **params: Any) -> dict:
+        """Synced conversations, newest activity first; carries coverage + sync_state. Params: cursor, limit, since, unread. Free."""
+        return self.call_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/conversations", _linkedin_query(params))
+
+    async def alinkedin_conversations(self, account_id: str, **params: Any) -> dict:
+        return await self.acall_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/conversations", _linkedin_query(params))
+
+    def linkedin_messages(self, account_id: str, **params: Any) -> dict:
+        """Synced messages, newest first. Params: conversation_id, direction, since, changed_since, cursor, limit, include_deleted. Free."""
+        return self.call_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/messages", _linkedin_query(params))
+
+    async def alinkedin_messages(self, account_id: str, **params: Any) -> dict:
+        return await self.acall_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/messages", _linkedin_query(params))
+
+    def linkedin_reply(self, account_id: str, conversation_id: str, text: str, *, idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        """Send a reply through the connected account. An Idempotency-Key is generated when not supplied so a retry never double-sends. Blocking."""
+        return self.call_tool("/v1/tools/linkedin/reply", {"account_id": account_id, "conversation_id": conversation_id, "text": text, **kwargs},
+                              max_cost=max_cost, timeout_sec=timeout_sec, wait=wait, idempotency_key=idempotency_key or _new_idempotency_key())
+
+    async def alinkedin_reply(self, account_id: str, conversation_id: str, text: str, *, idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        return await self.acall_tool("/v1/tools/linkedin/reply", {"account_id": account_id, "conversation_id": conversation_id, "text": text, **kwargs},
+                                     max_cost=max_cost, timeout_sec=timeout_sec, wait=wait, idempotency_key=idempotency_key or _new_idempotency_key())
+
+    def linkedin_view_profile(self, account_id: str, identifier: str, *, notify: bool = False, idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        """View a profile through the connected account (public-safe summary). notify=True cannot be undone. Blocking."""
+        return self.call_tool("/v1/tools/linkedin/profile-view", {"account_id": account_id, "identifier": identifier, "notify": bool(notify), **kwargs},
+                              max_cost=max_cost, timeout_sec=timeout_sec, wait=wait, idempotency_key=idempotency_key or _new_idempotency_key())
+
+    async def alinkedin_view_profile(self, account_id: str, identifier: str, *, notify: bool = False, idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        return await self.acall_tool("/v1/tools/linkedin/profile-view", {"account_id": account_id, "identifier": identifier, "notify": bool(notify), **kwargs},
+                                     max_cost=max_cost, timeout_sec=timeout_sec, wait=wait, idempotency_key=idempotency_key or _new_idempotency_key())
+
+    def linkedin_react(self, account_id: str, post_id: str, *, reaction_type: str = "like", idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        """React to a post through the connected account. Blocking."""
+        return self.call_tool("/v1/tools/linkedin/react", {"account_id": account_id, "post_id": post_id, "reaction_type": reaction_type, **kwargs},
+                              max_cost=max_cost, timeout_sec=timeout_sec, wait=wait, idempotency_key=idempotency_key or _new_idempotency_key())
+
+    async def alinkedin_react(self, account_id: str, post_id: str, *, reaction_type: str = "like", idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        return await self.acall_tool("/v1/tools/linkedin/react", {"account_id": account_id, "post_id": post_id, "reaction_type": reaction_type, **kwargs},
+                                     max_cost=max_cost, timeout_sec=timeout_sec, wait=wait, idempotency_key=idempotency_key or _new_idempotency_key())
+
     # ------------------------------------------------------------------
     # Paid tool convenience methods
     # ------------------------------------------------------------------
@@ -1765,3 +1882,37 @@ class OneShotClient:
         # Timeout — return the last snapshot. phones_pending is still True
         # so the caller knows phones never arrived.
         return last_result
+
+
+# ---------------------------------------------------------------------------
+# LinkedIn helpers (module-level so the sync/async twins share them)
+# ---------------------------------------------------------------------------
+
+def _new_idempotency_key() -> str:
+    import secrets
+    return secrets.token_hex(16)
+
+
+def _linkedin_connect_payload(requested_actions: Optional[list[str]], success_redirect_url: Optional[str], failure_redirect_url: Optional[str]) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    if requested_actions is not None:
+        payload["requested_actions"] = list(requested_actions)
+    if success_redirect_url:
+        payload["success_redirect_url"] = success_redirect_url
+    if failure_redirect_url:
+        payload["failure_redirect_url"] = failure_redirect_url
+    return payload
+
+
+def _linkedin_sync_payload(account_id: str, mode: Optional[str], max_pages: Optional[int], extra: dict[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {"account_id": account_id, **extra}
+    if mode:
+        payload["mode"] = mode
+    if max_pages is not None:
+        payload["max_pages"] = int(max_pages)
+    return payload
+
+
+def _linkedin_query(params: dict[str, Any]) -> Optional[dict[str, str]]:
+    query = {k: ("true" if v is True else "false" if v is False else str(v)) for k, v in params.items() if v is not None}
+    return query or None

{oneshot_python-0.24.0 → oneshot_python-0.25.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "oneshot-python"
-version = "0.24.0"
-description = "Core Python SDK for the OneShot API — HTTP client with x402 payment handling — 35 tools"
+version = "0.25.0"
+description = "Core Python SDK for the OneShot API — HTTP client with x402 payment handling — 43 tools"
 readme = {text = "Core Python SDK for the OneShot API", content-type = "text/plain"}
 license = "MIT"
 requires-python = ">=3.10"

oneshot_python-0.25.0/tests/test_linkedin.py

@@ -0,0 +1,72 @@
+"""LinkedIn client methods route to the right endpoints; writes always carry an Idempotency-Key."""
+from unittest.mock import AsyncMock
+
+import pytest
+
+from oneshot.client import OneShotClient
+
+TEST_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+
+
+@pytest.mark.asyncio
+async def test_connect_and_reads_use_free_endpoints():
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    client.acall_free_post = AsyncMock(return_value={"intent_id": "i1", "url": "https://account.unipile.com/x"})
+    client.acall_free_get = AsyncMock(return_value={"accounts": []})
+    client.acall_free_delete = AsyncMock(return_value={"status": "revoked"})
+
+    await client.alinkedin_connect(["read", "reply"], success_redirect_url="https://app/ok")
+    client.acall_free_post.assert_awaited_once_with(
+        "/v1/tools/linkedin/connect", {"requested_actions": ["read", "reply"], "success_redirect_url": "https://app/ok"}, scope="write"
+    )
+    await client.aget_linkedin_connection("i 1")
+    client.acall_free_get.assert_awaited_with("/v1/tools/linkedin/connect/i%201")
+    await client.alist_linkedin_accounts(include_revoked=True)
+    client.acall_free_get.assert_awaited_with("/v1/tools/linkedin/accounts", {"include_revoked": "true"})
+    await client.alinkedin_messages("acc", direction="inbound", since="2026-09-15T00:00:00Z", include_deleted=False, limit=10)
+    client.acall_free_get.assert_awaited_with(
+        "/v1/tools/linkedin/accounts/acc/messages",
+        {"direction": "inbound", "since": "2026-09-15T00:00:00Z", "include_deleted": "false", "limit": "10"},
+    )
+    await client.arevoke_linkedin_account("acc")
+    client.acall_free_delete.assert_awaited_once_with("/v1/tools/linkedin/accounts/acc", scope="write")
+    await client.areconnect_linkedin_account("acc", requested_actions=["read"])
+    client.acall_free_post.assert_awaited_with("/v1/tools/linkedin/accounts/acc/reconnect", {"requested_actions": ["read"]}, scope="write")
+
+
+@pytest.mark.asyncio
+async def test_writes_are_paid_and_idempotency_keyed():
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    client.acall_tool = AsyncMock(return_value={"status": "sent"})
+
+    await client.alinkedin_reply("acc", "conv", "hi", memo="m")
+    args, kwargs = client.acall_tool.await_args
+    assert args == ("/v1/tools/linkedin/reply", {"account_id": "acc", "conversation_id": "conv", "text": "hi", "memo": "m"})
+    assert len(kwargs["idempotency_key"]) == 32  # auto-generated
+
+    await client.alinkedin_reply("acc", "conv", "hi", idempotency_key="fixed")
+    assert client.acall_tool.await_args.kwargs["idempotency_key"] == "fixed"
+
+    await client.alinkedin_view_profile("acc", "https://linkedin.com/in/jane", notify=True)
+    args, kwargs = client.acall_tool.await_args
+    assert args[0] == "/v1/tools/linkedin/profile-view" and args[1]["notify"] is True and kwargs["idempotency_key"]
+
+    await client.alinkedin_react("acc", "urn:li:activity:1")
+    args, _ = client.acall_tool.await_args
+    assert args == ("/v1/tools/linkedin/react", {"account_id": "acc", "post_id": "urn:li:activity:1", "reaction_type": "like"})
+
+    await client.alinkedin_sync("acc", mode="continue", max_pages=5)
+    args, kwargs = client.acall_tool.await_args
+    assert args == ("/v1/tools/linkedin/sync", {"account_id": "acc", "mode": "continue", "max_pages": 5})
+    assert "idempotency_key" not in kwargs  # a sync run is not a side-effecting write
+
+
+def test_free_mutations_sign_a_write_scoped_proof():
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    assert client._read_headers("write")["x-agent-proof"] != client._read_headers("read")["x-agent-proof"]
+
+
+def test_idempotency_key_header_is_set_on_paid_requests():
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    assert client._headers(idempotency_key="k1")["Idempotency-Key"] == "k1"
+    assert "Idempotency-Key" not in client._headers()