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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: oneshot-python
-Version: 0.28.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.28.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)
@@ -264,3 +264,25 @@ 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.28.0 → oneshot_python-0.29.0}/oneshot/client.py

@@ -57,7 +57,7 @@ try:
 
     SDK_VERSION = _pkg_version("oneshot-python")
 except Exception:  # pragma: no cover - editable/source runs without dist metadata
-    SDK_VERSION = "0.28.0"
+    SDK_VERSION = "0.29.0"
 
 # ---------------------------------------------------------------------------
 # Environment configuration
@@ -789,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"],
@@ -855,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,
@@ -934,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"],
@@ -1495,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.28.0 → oneshot_python-0.29.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "oneshot-python"
-version = "0.28.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.28.0 → oneshot_python-0.29.0}/tests/test_linkedin.py

@@ -116,3 +116,56 @@ def test_reconnect_recovery_error_over_http(monkeypatch, asynchronous, status, b
         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