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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oneshot-python
-Version: 0.26.0
+Version: 0.28.0
 Summary: Core Python SDK for the OneShot API — HTTP client with x402 payment handling — 43 tools
 License-Expression: MIT
 Requires-Python: >=3.10

{oneshot_python-0.26.0 → oneshot_python-0.28.0}/README.md

@@ -239,3 +239,28 @@ 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.

{oneshot_python-0.26.0 → oneshot_python-0.28.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.26.0 → oneshot_python-0.28.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.
 
@@ -33,12 +44,18 @@ class PaymentError(OneShotError):
         expected: dict | None = None,
         received: dict | None = None,
         quote_id: str | None = None,
+        payment_attempt_id: str | None = None,
+        stage: str | None = None,
+        diagnostics: dict | None = None,
     ) -> None:
         super().__init__(message)
         self.reason = reason
         self.expected = expected or {}
         self.received = received or {}
         self.quote_id = quote_id
+        self.payment_attempt_id = payment_attempt_id
+        self.stage = stage
+        self.diagnostics = diagnostics
 
 
 class JobError(OneShotError):

{oneshot_python-0.26.0 → oneshot_python-0.28.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.26.0"
+    SDK_VERSION = "0.28.0"
 
 # ---------------------------------------------------------------------------
 # Environment configuration
@@ -206,13 +207,13 @@ def _parse_payment_rejection(resp: Any) -> Optional[PaymentError]:
     payment is refused. Returns None for any other response so the caller can
     fall back to ``ToolError``.
     """
-    if resp.status_code != 402:
+    if resp.status_code not in (402, 500):
         return None
     try:
         data = resp.json()
     except Exception:  # noqa: BLE001 - non-JSON body
         return None
-    if not isinstance(data, dict) or data.get("error") != "payment_verification_failed":
+    if not isinstance(data, dict) or data.get("error") not in ("payment_verification_failed", "payment_processing_error"):
         return None
 
     reason = data.get("reason") or "unknown"
@@ -230,6 +231,9 @@ def _parse_payment_rejection(resp: Any) -> Optional[PaymentError]:
     if data.get("message"):
         message += f" ({data['message']})"
 
+    if data.get("payment_attempt_id"):
+        message += f" [payment attempt {data['payment_attempt_id']}]"
+
     return PaymentError(
         message,
         reason,
@@ -241,6 +245,9 @@ def _parse_payment_rejection(resp: Any) -> Optional[PaymentError]:
         },
         received={"amount": received.get("amount")},
         quote_id=data.get("quote_id"),
+        payment_attempt_id=data.get("payment_attempt_id"),
+        stage=data.get("stage"),
+        diagnostics=data.get("diagnostics"),
     )
 
 
@@ -989,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()
 

{oneshot_python-0.26.0 → oneshot_python-0.28.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oneshot-python"
-version = "0.26.0"
+version = "0.28.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"

oneshot_python-0.28.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.26.0 → oneshot_python-0.28.0}/tests/test_linkedin.py

@@ -70,3 +70,49 @@ 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()

{oneshot_python-0.26.0 → oneshot_python-0.28.0}/tests/test_payment_rejection.py

@@ -86,3 +86,25 @@ class TestParsePaymentRejection:
         err = _parse_payment_rejection(_Resp(402, REJECTION))
         assert isinstance(err, OneShotError)
         assert isinstance(err, Exported)
+
+
+def test_diagnostics_and_attempt_correlation():
+    diagnostics = {"status": "complete", "findings": [{"code": "unknown"}]}
+    error = _parse_payment_rejection(_Resp(402, {
+        **REJECTION, "payment_attempt_id": "attempt-123", "stage": "verification", "diagnostics": diagnostics,
+    }))
+    assert error.payment_attempt_id == "attempt-123"
+    assert "attempt-123" in str(error)
+    assert error.stage == "verification"
+    assert error.diagnostics == diagnostics
+    assert PaymentError("old", "unknown").diagnostics is None
+
+
+def test_transport_and_settlement_correlation():
+    error = _parse_payment_rejection(_Resp(500, {
+        "error": "payment_processing_error", "payment_attempt_id": "transport-123", "stage": "verification_transport",
+    }))
+    assert error.payment_attempt_id == "transport-123"
+    assert error.stage == "verification_transport"
+    error = _parse_payment_rejection(_Resp(402, {**REJECTION, "stage": "settlement"}))
+    assert error.stage == "settlement"

{oneshot_python-0.26.0 → oneshot_python-0.28.0}/uv.lock

@@ -549,7 +549,7 @@ wheels = [
 
 [[package]]
 name = "oneshot-python"
-version = "0.24.0"
+version = "0.27.0"
 source = { editable = "." }
 dependencies = [
     { name = "eth-account" },