oneshot-python 0.27.0__tar.gz → 0.29.0__tar.gz

{oneshot_python-0.27.0 → oneshot_python-0.29.0}/PKG-INFO

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

{oneshot_python-0.27.0 → oneshot_python-0.29.0}/README.md

@@ -217,7 +217,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/) — 43 tools as LangChain BaseTool
+- [LangChain integration](https://pypi.org/project/langchain-oneshot/) — 45 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)
@@ -239,3 +239,50 @@ Use `create_browser_profile(name)`, then `start_browser_profile_setup(profile_id
 Finish inspects cookie metadata in a fresh browser before navigation, without returning values. Later `browser(profile_id=..., task=...)` calls reuse the saved profile; verify site authentication with a read before relying on it. Setup expires after 15 minutes, with abandoned-session cleanup by the lifecycle sweep; the profile is retained for reconnection. Never log private live URLs or put credentials/codes in task prompts.
 
 Alternatively, `create_browser_profile(name, cookies=[...])` or `storage_state={...}` imports cookies and localStorage. The legacy browser `secrets` field is rejected, and `max_steps` must be an integer from 25 through 100. Failed `JobError`s expose `code` and `partial_result`. Browser `cost` is provider cost; `billed_cost` is the reconciled customer charge, or null while pending.
+
+### Missing LinkedIn connections
+
+Both `reconnect_linkedin_account()` and `areconnect_linkedin_account()` raise
+`LinkedInConnectRequiredError` when the API confirms that the saved connection
+no longer exists. It remains a `ToolError` subclass and exposes
+`code == "connect_required"`, `next_action == "connect"`, `status_code == 409`,
+and the original `response_body`.
+
+```python
+from oneshot import LinkedInConnectRequiredError
+
+try:
+    intent = client.reconnect_linkedin_account(account_id)
+except LinkedInConnectRequiredError:
+    # Show “Connect LinkedIn” and ask the human to choose grants again.
+    # After confirmation: client.linkedin_connect(["read"])
+    pass
+```
+
+Account reads stop offering reconnect after confirming upstream deletion.
+Missing accounts are excluded from the active list; `include_revoked=True`
+lets you inspect their `deleted_upstream` status and `reconnect_required=False`.
+Authentication failures and timeouts remain ordinary errors and do not instruct
+the consumer to create a new connection.
+
+### LinkedIn invitations and withdrawal
+
+Available in `oneshot-python` 0.29.0 and later. Both operations require a connected account with the `invite` grant.
+
+```python
+invitation = client.linkedin_invite(
+    account_id,
+    "https://www.linkedin.com/in/jane-doe/",
+    note="Enjoyed your presentation.",
+    idempotency_key="event-jane-invite",
+)
+
+# To withdraw that pending invitation later:
+client.linkedin_withdraw_invitation(
+    account_id,
+    invitation["invitation_id"],
+    idempotency_key="event-jane-withdraw",
+)
+```
+
+Async equivalents are `alinkedin_invite()` and `alinkedin_withdraw_invitation()`. Use the OneShot `invitation_id`, not the provider invitation ID. Withdrawal can cancel a queued invitation and never disconnects an established connection. Invitations default to 25 per account per UTC day; withdrawal does not restore capacity for an invitation already sent. Reuse the same key when retrying an operation.

{oneshot_python-0.27.0 → oneshot_python-0.29.0}/oneshot/__init__.py

@@ -13,6 +13,7 @@ from oneshot._errors import (
     OneShotError,
     PaymentError,
     ToolError,
+    LinkedInConnectRequiredError,
     ValidationError,
 )
 from oneshot._types import (
@@ -43,6 +44,7 @@ __all__ = [
     "OneShotClient",
     "OneShotError",
     "ToolError",
+    "LinkedInConnectRequiredError",
     "PaymentError",
     "BudgetExceededError",
     "BudgetSyncError",

{oneshot_python-0.27.0 → oneshot_python-0.29.0}/oneshot/_errors.py

@@ -14,6 +14,17 @@ class ToolError(OneShotError):
         self.response_body = response_body
 
 
+class LinkedInConnectRequiredError(ToolError):
+    """The saved connection is gone; ask the human to authorize a fresh connect."""
+
+    code = "connect_required"
+    next_action = "connect"
+
+    def __init__(self, response_body: str) -> None:
+        super().__init__("This LinkedIn connection no longer exists. Start a new connection.",
+                         409, response_body)
+
+
 class PaymentError(OneShotError):
     """The facilitator rejected the payment signed for this request.
 

{oneshot_python-0.27.0 → oneshot_python-0.29.0}/oneshot/client.py

@@ -31,6 +31,7 @@ from oneshot._errors import (
     OneShotError,
     PaymentError,
     ToolError,
+    LinkedInConnectRequiredError,
     ValidationError,
 )
 from oneshot._types import (
@@ -56,7 +57,7 @@ try:
 
     SDK_VERSION = _pkg_version("oneshot-python")
 except Exception:  # pragma: no cover - editable/source runs without dist metadata
-    SDK_VERSION = "0.27.0"
+    SDK_VERSION = "0.29.0"
 
 # ---------------------------------------------------------------------------
 # Environment configuration
@@ -788,7 +789,7 @@ class OneShotClient:
                     "processing",
                 ):
                     if not wait:
-                        return {"request_id": result["request_id"], "status": result["status"]}
+                        return result if endpoint.endswith(("/linkedin/invite", "/linkedin/invite/withdraw")) else {"request_id": result["request_id"], "status": result["status"]}
                     return await self._poll_job(
                         client,
                         result["request_id"],
@@ -854,7 +855,7 @@ class OneShotClient:
                 result = resp2.json()
                 if isinstance(result, dict) and result.get("request_id") and result.get("status") in ("pending", "processing"):
                     if not wait:
-                        return {"request_id": result["request_id"], "status": result["status"]}
+                        return result if endpoint.endswith(("/linkedin/invite", "/linkedin/invite/withdraw")) else {"request_id": result["request_id"], "status": result["status"]}
                     return await self._poll_job(
                         client, result["request_id"], timeout_sec,
                         wait_for_phones=wait_for_phones, phone_timeout_sec=phone_timeout_sec,
@@ -933,7 +934,7 @@ class OneShotClient:
             ):
                 self._log(f"Job queued: {result['request_id']}")
                 if not wait:
-                    return {"request_id": result["request_id"], "status": result["status"]}
+                    return result if endpoint.endswith(("/linkedin/invite", "/linkedin/invite/withdraw")) else {"request_id": result["request_id"], "status": result["status"]}
                 return await self._poll_job(
                     client,
                     result["request_id"],
@@ -995,6 +996,13 @@ class OneShotClient:
         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(scope), json=payload or {})
             if not resp.is_success:
+                if endpoint.startswith("/v1/tools/linkedin/") and resp.status_code == 409:
+                    try:
+                        body = resp.json()
+                    except ValueError:
+                        body = None
+                    if isinstance(body, dict) and body.get("error") == "connect_required":
+                        raise LinkedInConnectRequiredError(resp.text)
                 raise ToolError(f"POST {endpoint} failed", resp.status_code, resp.text)
             return resp.json()
 
@@ -1487,6 +1495,43 @@ class OneShotClient:
     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_invitation_call(self, endpoint: str, payload: dict, **kwargs: Any) -> Any:
+        return asyncio.get_event_loop().run_until_complete(self._alinkedin_invitation_call(endpoint, payload, **kwargs))
+
+    async def _alinkedin_invitation_call(self, endpoint: str, payload: dict, **kwargs: Any) -> Any:
+        try:
+            return await self.acall_tool(endpoint, payload, **kwargs)
+        except (ToolError, httpx.HTTPStatusError) as error:
+            status_code = error.status_code if isinstance(error, ToolError) else error.response.status_code
+            response_body = error.response_body if isinstance(error, ToolError) else error.response.text
+            try:
+                body = json.loads(response_body)
+            except (ValueError, TypeError):
+                raise error
+            details = body.get("details") if isinstance(body, dict) else None
+            if status_code != 409 or not isinstance(details, dict) or body.get("error") != "duplicate_request" or not details.get("request_id"):
+                raise
+            if not kwargs.get("wait", True):
+                return {"request_id": details["request_id"], "receipt_id": details.get("receipt_id"), "status": "processing",
+                        "linkedin": {"invitation_id": details.get("invitation_id"), "action_request_id": details.get("action_request_id")}}
+            return await self.await_result(details["request_id"], timeout_sec=kwargs.get("timeout_sec", 180))
+
+    def linkedin_invite(self, account_id: str, profile: str, *, note: Optional[str] = None, idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        return self._linkedin_invitation_call("/v1/tools/linkedin/invite", {"account_id": account_id, "profile": profile, **({"note": note} if note is not None else {}), **kwargs},
+                              idempotency_key=idempotency_key or _new_idempotency_key(), max_cost=max_cost, timeout_sec=timeout_sec, wait=wait)
+
+    async def alinkedin_invite(self, account_id: str, profile: str, *, note: Optional[str] = None, idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        return await self._alinkedin_invitation_call("/v1/tools/linkedin/invite", {"account_id": account_id, "profile": profile, **({"note": note} if note is not None else {}), **kwargs},
+                              idempotency_key=idempotency_key or _new_idempotency_key(), max_cost=max_cost, timeout_sec=timeout_sec, wait=wait)
+
+    def linkedin_withdraw_invitation(self, account_id: str, invitation_id: str, *, idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        return self._linkedin_invitation_call("/v1/tools/linkedin/invite/withdraw", {"account_id": account_id, "invitation_id": invitation_id, **kwargs},
+                              idempotency_key=idempotency_key or _new_idempotency_key(), max_cost=max_cost, timeout_sec=timeout_sec, wait=wait)
+
+    async def alinkedin_withdraw_invitation(self, account_id: str, invitation_id: str, *, idempotency_key: Optional[str] = None, max_cost: Optional[float] = None, timeout_sec: int = 180, wait: bool = True, **kwargs: Any) -> Any:
+        return await self._alinkedin_invitation_call("/v1/tools/linkedin/invite/withdraw", {"account_id": account_id, "invitation_id": invitation_id, **kwargs},
+                              idempotency_key=idempotency_key or _new_idempotency_key(), max_cost=max_cost, timeout_sec=timeout_sec, wait=wait)
+
     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},

{oneshot_python-0.27.0 → oneshot_python-0.29.0}/pyproject.toml

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

oneshot_python-0.29.0/tests/conftest.py

@@ -0,0 +1,21 @@
+"""Give blocking SDK tests an event loop independent of pytest-asyncio cleanup."""
+import asyncio
+import inspect
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def blocking_test_event_loop(request):
+    if inspect.iscoroutinefunction(request.function):
+        yield
+        return
+    # Blocking SDK methods call run_until_complete. Async tests may have closed
+    # or cleared the thread's previous loop; no test should depend on its order.
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        yield
+    finally:
+        loop.close()
+        asyncio.set_event_loop(None)

oneshot_python-0.29.0/tests/test_linkedin.py

@@ -0,0 +1,171 @@
+"""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()
+
+
+@pytest.mark.parametrize("asynchronous", [False, True])
+@pytest.mark.parametrize("status,body,typed", [
+    (409, {"error": "connect_required", "details": {"next_action": "connect"}}, True),
+    (409, {"error": "grant_widening_not_allowed"}, False),
+    (502, {"error": "linkedin_link_unavailable"}, False),
+    (401, {"error": "connect_required"}, False),
+    (409, ["connect_required"], False),
+    (409, "not JSON", False),
+])
+def test_reconnect_recovery_error_over_http(monkeypatch, asynchronous, status, body, typed):
+    import asyncio
+    import httpx
+    from oneshot import LinkedInConnectRequiredError, ToolError
+
+    requests = []
+    def handler(request):
+        requests.append(request)
+        if isinstance(body, str):
+            return httpx.Response(status, text=body)
+        return httpx.Response(status, json=body)
+
+    original = httpx.AsyncClient
+    monkeypatch.setattr("oneshot.client.httpx.AsyncClient", lambda **kw: original(transport=httpx.MockTransport(handler), **kw))
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    loop = asyncio.new_event_loop()
+    monkeypatch.setattr(asyncio, "get_event_loop", lambda: loop)
+    try:
+        with pytest.raises(ToolError) as caught:
+            if asynchronous:
+                loop.run_until_complete(client.areconnect_linkedin_account("account/id"))
+            else:
+                client.reconnect_linkedin_account("account/id")
+        error = caught.value
+        assert isinstance(error, LinkedInConnectRequiredError) is typed
+        assert error.status_code == status
+        if typed:
+            assert error.code == "connect_required"
+            assert error.next_action == "connect"
+            assert '"next_action":"connect"' in error.response_body.replace(" ", "")
+        assert len(requests) == 1  # No automatic reconnect or new grant.
+        assert requests[0].url.raw_path.endswith(b"/account%2Fid/reconnect")
+        assert "x-agent-proof" in requests[0].headers
+    finally:
+        loop.close()
+
+
+@pytest.mark.asyncio
+async def test_invite_and_withdraw_generate_keys_and_preserve_note():
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    client.acall_tool = AsyncMock(return_value={"invitation_id": "invite"})
+    await client.alinkedin_invite('account', 'profile', note='  note  ')
+    args, kwargs = client.acall_tool.await_args
+    assert args == ('/v1/tools/linkedin/invite', {'account_id': 'account', 'profile': 'profile', 'note': '  note  '})
+    assert len(kwargs['idempotency_key']) == 32
+    await client.alinkedin_withdraw_invitation('account', 'invite', idempotency_key='withdraw')
+    args, kwargs = client.acall_tool.await_args
+    assert args == ('/v1/tools/linkedin/invite/withdraw', {'account_id': 'account', 'invitation_id': 'invite'})
+    assert kwargs['idempotency_key'] == 'withdraw'
+
+@pytest.mark.asyncio
+async def test_invitation_durable_duplicate_recovery():
+    import json
+    from oneshot._errors import ToolError
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    client.acall_tool = AsyncMock(side_effect=ToolError('duplicate', 409, json.dumps({'error': 'duplicate_request', 'details': {'request_id': 'job', 'invitation_id': 'invite'}})))
+    result = await client.alinkedin_invite('account', 'profile', wait=False)
+    assert result['linkedin']['invitation_id'] == 'invite'
+    client.await_result = AsyncMock(return_value={'status': 'sent', 'invitation_id': 'invite'})
+    await client.alinkedin_invite('account', 'profile')
+    client.await_result.assert_awaited_once_with('job', timeout_sec=180)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('withdraw', [False, True])
+async def test_invitation_recovers_http_status_error(withdraw):
+    import httpx
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    response = httpx.Response(409, json={'error': 'duplicate_request', 'details': {'request_id': 'job', 'invitation_id': 'invite'}}, request=httpx.Request('POST', 'https://example.test'))
+    client.acall_tool = AsyncMock(side_effect=httpx.HTTPStatusError('duplicate', request=response.request, response=response))
+    method = client.alinkedin_withdraw_invitation if withdraw else client.alinkedin_invite
+    assert (await method('account', 'target', wait=False))['request_id'] == 'job'
+    client.await_result = AsyncMock(return_value={'status': 'sent'})
+    await method('account', 'target')
+    client.await_result.assert_awaited_once_with('job', timeout_sec=180)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('status,body', [(409, {'error': 'idempotency_conflict'}), (502, {'error': 'duplicate_request', 'details': {'request_id': 'job'}}), (409, []), (409, {'error': 'duplicate_request', 'details': []}), (409, 'not json')])
+async def test_invitation_preserves_unrelated_http_errors(status, body):
+    import httpx
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    response = httpx.Response(status, json=body, request=httpx.Request('POST', 'https://example.test'))
+    error = httpx.HTTPStatusError('original', request=response.request, response=response)
+    client.acall_tool = AsyncMock(side_effect=error)
+    with pytest.raises(httpx.HTTPStatusError) as caught:
+        await client.alinkedin_invite('account', 'target')
+    assert caught.value is error

oneshot_python-0.27.0/tests/test_linkedin.py

@@ -1,72 +0,0 @@
-"""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()