oneshot-python 0.40.0__tar.gz → 0.40.1__tar.gz

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.40.1
+
+- Restore synchronous pause/resume calls when no event loop is current.
+- Send person quote IDs through the request header, excluding them from tool payloads.
+- Describe Changes queries for published dataset attributes.
+
 ## 0.40.0 — breaking release (#1336)
 
 - Renamed `commerce_search()` / `acommerce_search()` → `product_find()` / `aproduct_find()`, without aliases.

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/PKG-INFO

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

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/README.md

@@ -34,6 +34,11 @@ balance = client.call_free_get("/v1/wallet/balance")
 
 ### Async
 
+Blocking `OneShotClient` methods reuse the current open event loop, or run on a
+temporary loop when none is available (including after `asyncio.run()`). Inside
+a running event loop, use the async method instead; blocking calls raise an
+error naming the async method to await.
+
 ```python
 import asyncio
 from oneshot import OneShotClient
@@ -346,7 +351,7 @@ MIT
 
 ## Optional phone lookup
 
-Phone lookup is off by default. Source-returned numbers and published business or record numbers still appear. `include_phone=True` adds $0.10 × the requested search limit (default 100 → $10), or $0.10 for profile/dossier, for up to that many people with no guaranteed hit. Fallbacks and callbacks cost nothing extra. A completed lookup with no phone match is charged; a failed job is refunded.
+Phone lookup is off by default. Source-returned numbers and published business or record numbers still appear. `include_phone=True` adds the per-person add-on listed on the pricing page × the requested search limit (default 100) for a search, or once for profile/dossier, for up to that many people with no guaranteed hit. Fallbacks and callbacks cost nothing extra. A completed lookup with no phone match is charged; a failed job is refunded.
 
 `max_cost` and per-transaction budgets apply to the full quote before authorization, even when credits cover it. Wallet and access-token sessions both obtain a quote before execution and retry with `x-quote-id`.
 

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/oneshot/client.py

@@ -13,7 +13,7 @@ import json
 import re
 import time
 from decimal import Decimal
-from typing import Any, Optional
+from typing import Any, Coroutine, Optional, TypeVar
 from urllib.parse import quote
 
 import httpx
@@ -60,7 +60,7 @@ try:
 
     SDK_VERSION = _pkg_version("oneshot-python")
 except Exception:  # pragma: no cover - editable/source runs without dist metadata
-    SDK_VERSION = "0.40.0"
+    SDK_VERSION = "0.40.1"
 
 _BASE_URL = "https://win.oneshotagent.com"
 _HUNT_BASE_URL = "https://api.soulhunt.ai"
@@ -77,6 +77,31 @@ _POLL_RETRY_BASE = 2.0  # seconds, transient-error retry backoff base
 _MAX_POLL_RETRIES = 3
 _BUILD_TRANSPORT_KWARGS = ("max_cost", "timeout_sec", "wait", "approval_id", "idempotency_key")
 
+_T = TypeVar("_T")
+
+
+def _run_sync(coro: Coroutine[Any, Any, _T], async_method: str) -> _T:
+    """Run a blocking call on the current open loop, or a temporary loop."""
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        pass
+    else:
+        # The wrapper already created this coroutine; do not leave it unawaited.
+        coro.close()
+        raise RuntimeError(
+            f"Cannot make a blocking SDK call inside a running event loop; "
+            f"use await client.{async_method}(...) instead."
+        )
+
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = None
+    if loop is None or loop.is_closed():
+        return asyncio.run(coro)
+    return loop.run_until_complete(coro)
+
 
 def _build_email_payload(
     to: Optional[str],
@@ -486,8 +511,9 @@ class OneShotClient:
         debug: bool = False,
     ) -> "OneShotClient":
         """Blocking wrapper for :meth:`acreate`."""
-        return asyncio.get_event_loop().run_until_complete(
-            cls.acreate(access_token=access_token, address=address, base_url=base_url, debug=debug)
+        return _run_sync(
+            cls.acreate(access_token=access_token, address=address, base_url=base_url, debug=debug),
+            "acreate",
         )
 
     def _assert_wallet_session(self, action: str) -> None:
@@ -501,7 +527,7 @@ class OneShotClient:
         return self._unwrap_data(await self.acall_free_post("/v1/agents/me/access-tokens", {"name": name} if name else {}, scope="write"))
 
     def create_access_token(self, name: Optional[str] = None) -> AccessTokenCreated:
-        return asyncio.get_event_loop().run_until_complete(self.acreate_access_token(name))
+        return _run_sync(self.acreate_access_token(name), "acreate_access_token")
 
     async def alist_access_tokens(self, *, active_only: bool = False) -> list[AccessTokenInfo]:
         self._assert_wallet_session("list access tokens")
@@ -510,14 +536,14 @@ class OneShotClient:
         return data.get("tokens", data) if isinstance(data, dict) else data
 
     def list_access_tokens(self, *, active_only: bool = False) -> list[AccessTokenInfo]:
-        return asyncio.get_event_loop().run_until_complete(self.alist_access_tokens(active_only=active_only))
+        return _run_sync(self.alist_access_tokens(active_only=active_only), "alist_access_tokens")
 
     async def arevoke_access_token(self, token_id: str) -> None:
         self._assert_wallet_session("revoke access tokens")
         await self.acall_free_delete(f"/v1/agents/me/access-tokens/{quote(token_id, safe='')}", scope="write")
 
     def revoke_access_token(self, token_id: str) -> None:
-        asyncio.get_event_loop().run_until_complete(self.arevoke_access_token(token_id))
+        _run_sync(self.arevoke_access_token(token_id), "arevoke_access_token")
 
     async def aprovision_voice_number(self) -> dict[str, Any]:
         """Get this agent a voice number without placing a call.
@@ -529,14 +555,14 @@ class OneShotClient:
         return self._unwrap_data(await self.acall_free_post("/v1/tools/voice/numbers", {}, scope="write"))
 
     def provision_voice_number(self) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.aprovision_voice_number())
+        return _run_sync(self.aprovision_voice_number(), "aprovision_voice_number")
 
     async def avoice_numbers(self) -> dict[str, Any]:
         """The agent's phone numbers, from ``provision_voice_number`` or the first outbound voice call."""
         return self._unwrap_data(await self.acall_free_get("/v1/tools/voice/numbers"))
 
     def voice_numbers(self) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.avoice_numbers())
+        return _run_sync(self.avoice_numbers(), "avoice_numbers")
 
     async def aset_inbound_voice(self, phone_number_id: str, config: dict[str, Any]) -> dict[str, Any]:
         """Answer calls to one of the agent's numbers (replaces the whole config).
@@ -548,14 +574,14 @@ class OneShotClient:
         return self._unwrap_data(await self.acall_free_put(path, config))
 
     def set_inbound_voice(self, phone_number_id: str, config: dict[str, Any]) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.aset_inbound_voice(phone_number_id, config))
+        return _run_sync(self.aset_inbound_voice(phone_number_id, config), "aset_inbound_voice")
 
     async def aget_inbound_voice(self, phone_number_id: str) -> dict[str, Any]:
         path = f"/v1/tools/voice/numbers/{quote(phone_number_id, safe='')}/inbound"
         return self._unwrap_data(await self.acall_free_get(path))
 
     def get_inbound_voice(self, phone_number_id: str) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.aget_inbound_voice(phone_number_id))
+        return _run_sync(self.aget_inbound_voice(phone_number_id), "aget_inbound_voice")
 
     async def adisable_inbound_voice(self, phone_number_id: str) -> dict[str, Any]:
         """Stop answering calls to a number; the settings are kept, disabled."""
@@ -563,7 +589,7 @@ class OneShotClient:
         return self._unwrap_data(await self.acall_free_delete(path, scope="write"))
 
     def disable_inbound_voice(self, phone_number_id: str) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.adisable_inbound_voice(phone_number_id))
+        return _run_sync(self.adisable_inbound_voice(phone_number_id), "adisable_inbound_voice")
 
     async def ainbound_calls(
         self,
@@ -586,14 +612,14 @@ class OneShotClient:
         return self._unwrap_data(await self.acall_free_get("/v1/tools/voice/inbound", params or None))
 
     def inbound_calls(self, **kwargs: Any) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.ainbound_calls(**kwargs))
+        return _run_sync(self.ainbound_calls(**kwargs), "ainbound_calls")
 
     async def ainbound_call(self, call_id: str) -> dict[str, Any]:
         """One inbound call, with transcript."""
         return self._unwrap_data(await self.acall_free_get(f"/v1/tools/voice/inbound/{quote(call_id, safe='')}"))
 
     def inbound_call(self, call_id: str) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.ainbound_call(call_id))
+        return _run_sync(self.ainbound_call(call_id), "ainbound_call")
 
     @staticmethod
     def _with_approval(headers: dict[str, str], approval_id: Optional[str]) -> dict[str, str]:
@@ -772,7 +798,7 @@ class OneShotClient:
 
     def get_budgets(self) -> AgentBudgetStatus:
         """Current spend budget and today's utilization. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.aget_budgets())
+        return _run_sync(self.aget_budgets(), "aget_budgets")
 
     async def aget_budgets(self) -> AgentBudgetStatus:
         """Current spend budget and today's utilization. Async."""
@@ -789,6 +815,7 @@ class OneShotClient:
         wait: bool = True,
         wait_for_phones: bool = False,
         phone_timeout_sec: int = 360,
+        quote_id: Optional[str] = None,
         idempotency_key: Optional[str] = None,
         approval_id: Optional[str] = None,
     ) -> Any:
@@ -802,8 +829,11 @@ class OneShotClient:
         until Apollo's async phone-reveal webhook delivers phone numbers
         (or until ``phone_timeout_sec`` expires, default 6 min — Apollo says
         "several minutes"). Default is False for backwards compat.
+
+        ``quote_id`` rides on the ``x-quote-id`` header from the first attempt,
+        as in :meth:`acall_tool`; it is never part of the quoted body.
         """
-        return asyncio.get_event_loop().run_until_complete(
+        return _run_sync(
             self.acall_tool(
                 endpoint,
                 payload,
@@ -812,9 +842,11 @@ class OneShotClient:
                 wait=wait,
                 wait_for_phones=wait_for_phones,
                 phone_timeout_sec=phone_timeout_sec,
+                quote_id=quote_id,
                 idempotency_key=idempotency_key,
                 approval_id=approval_id,
-            )
+            ),
+            "acall_tool",
         )
 
     def call_lookup(self, name: str, /, **params: Any) -> Any:
@@ -831,7 +863,7 @@ class OneShotClient:
         method, pricing, path, payload = lookup_request(entry, params)
         if pricing in PAID_PRICING:
             return self.call_tool(path, payload)
-        return asyncio.get_event_loop().run_until_complete(self._acall_free_lookup(method, path, payload))
+        return _run_sync(self._acall_free_lookup(method, path, payload), "acall_lookup")
 
     async def acall_lookup(self, name: str, /, **params: Any) -> Any:
         """Async form of :meth:`call_lookup`, sent through :meth:`acall_tool`."""
@@ -864,13 +896,14 @@ class OneShotClient:
         phone_timeout_sec: int = 360,
     ) -> Any:
         """Wait for a previously dispatched job (e.g. from ``wait=False``) and return its result."""
-        return asyncio.get_event_loop().run_until_complete(
+        return _run_sync(
             self.await_result(
                 request_id,
                 timeout_sec=timeout_sec,
                 wait_for_phones=wait_for_phones,
                 phone_timeout_sec=phone_timeout_sec,
-            )
+            ),
+            "await_result",
         )
 
     async def await_result(
@@ -1179,8 +1212,9 @@ class OneShotClient:
         params: Optional[dict[str, str]] = None,
     ) -> Any:
         """GET a free endpoint (blocking)."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.acall_free_get(endpoint, params)
+        return _run_sync(
+            self.acall_free_get(endpoint, params),
+            "acall_free_get",
         )
 
     async def acall_free_get(
@@ -1204,8 +1238,9 @@ class OneShotClient:
         scope: str = "read",
     ) -> Any:
         """POST to a free endpoint (blocking). Mutations pass scope="write"."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.acall_free_post(endpoint, payload, scope=scope)
+        return _run_sync(
+            self.acall_free_post(endpoint, payload, scope=scope),
+            "acall_free_post",
         )
 
     async def acall_free_post(
@@ -1238,8 +1273,9 @@ class OneShotClient:
         scope: str = "read",
     ) -> Any:
         """PATCH a free endpoint (blocking). Mutations pass scope="write"."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.acall_free_patch(endpoint, payload, scope=scope)
+        return _run_sync(
+            self.acall_free_patch(endpoint, payload, scope=scope),
+            "acall_free_patch",
         )
 
     async def acall_free_patch(
@@ -1266,8 +1302,9 @@ class OneShotClient:
         payload: Optional[dict[str, Any]] = None,
     ) -> Any:
         """PUT to a signed mutation endpoint (blocking)."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.acall_free_put(endpoint, payload)
+        return _run_sync(
+            self.acall_free_put(endpoint, payload),
+            "acall_free_put",
         )
 
     async def acall_free_put(
@@ -1290,8 +1327,9 @@ class OneShotClient:
         scope: str = "read",
     ) -> Any:
         """DELETE a free endpoint (blocking). Mutations pass scope="write"."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.acall_free_delete(endpoint, scope=scope)
+        return _run_sync(
+            self.acall_free_delete(endpoint, scope=scope),
+            "acall_free_delete",
         )
 
     async def acall_free_delete(
@@ -1333,7 +1371,7 @@ class OneShotClient:
 
     def create_approval(self, action_summary: str, **kwargs: Any) -> dict[str, Any]:
         """Ask a named human to decide something. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.acreate_approval(action_summary, **kwargs))
+        return _run_sync(self.acreate_approval(action_summary, **kwargs), "acreate_approval")
 
     async def aget_approval(self, approval_id: str) -> dict[str, Any]:
         """One approval — poll it for the decision. Async."""
@@ -1341,7 +1379,7 @@ class OneShotClient:
 
     def get_approval(self, approval_id: str) -> dict[str, Any]:
         """One approval — poll it for the decision. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.aget_approval(approval_id))
+        return _run_sync(self.aget_approval(approval_id), "aget_approval")
 
     async def alist_approvals(self, status: Optional[str] = None, limit: Optional[int] = None) -> list[dict[str, Any]]:
         """This agent's approvals, newest first. Async."""
@@ -1351,7 +1389,7 @@ class OneShotClient:
 
     def list_approvals(self, status: Optional[str] = None, limit: Optional[int] = None) -> list[dict[str, Any]]:
         """This agent's approvals, newest first. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.alist_approvals(status, limit))
+        return _run_sync(self.alist_approvals(status, limit), "alist_approvals")
 
     async def acancel_approval(self, approval_id: str) -> dict[str, Any]:
         """Withdraw a pending approval. Async."""
@@ -1359,7 +1397,7 @@ class OneShotClient:
 
     def cancel_approval(self, approval_id: str) -> dict[str, Any]:
         """Withdraw a pending approval. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.acancel_approval(approval_id))
+        return _run_sync(self.acancel_approval(approval_id), "acancel_approval")
 
     async def aget_action_policy(self) -> Optional[dict[str, Any]]:
         """The agent's action policy, or None. Async."""
@@ -1367,7 +1405,7 @@ class OneShotClient:
 
     def get_action_policy(self) -> Optional[dict[str, Any]]:
         """The agent's action policy, or None. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.aget_action_policy())
+        return _run_sync(self.aget_action_policy(), "aget_action_policy")
 
     async def aset_action_policy(self, policy: dict[str, Any]) -> dict[str, Any]:
         """Replace the action policy (rules, approver, timeout_seconds, enabled). Wallet sessions only. Async."""
@@ -1375,7 +1413,7 @@ class OneShotClient:
 
     def set_action_policy(self, policy: dict[str, Any]) -> dict[str, Any]:
         """Replace the action policy. Wallet sessions only. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.aset_action_policy(policy))
+        return _run_sync(self.aset_action_policy(policy), "aset_action_policy")
 
     async def adelete_action_policy(self) -> None:
         """Remove the action policy. Wallet sessions only. Async."""
@@ -1383,7 +1421,7 @@ class OneShotClient:
 
     def delete_action_policy(self) -> None:
         """Remove the action policy. Wallet sessions only. Blocking."""
-        asyncio.get_event_loop().run_until_complete(self.adelete_action_policy())
+        _run_sync(self.adelete_action_policy(), "adelete_action_policy")
 
     @staticmethod
     def _unwrap_data(envelope: Any) -> Any:
@@ -1410,7 +1448,7 @@ class OneShotClient:
         memo: Optional[str] = None,
     ) -> Any:
         """Create a compute goal. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
+        return _run_sync(
             self.acompute(
                 objective,
                 params=params,
@@ -1422,7 +1460,8 @@ class OneShotClient:
                 approvals=approvals,
                 max_cost=max_cost,
                 memo=memo,
-            )
+            ),
+            "acompute",
         )
 
     async def acompute(
@@ -1469,8 +1508,9 @@ class OneShotClient:
 
     def get_compute_goal(self, goal_id: str) -> Any:
         """Get goal status. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.aget_compute_goal(goal_id)
+        return _run_sync(
+            self.aget_compute_goal(goal_id),
+            "aget_compute_goal",
         )
 
     async def aget_compute_goal(self, goal_id: str) -> Any:
@@ -1479,8 +1519,9 @@ class OneShotClient:
 
     def get_compute_tasks(self, goal_id: str) -> Any:
         """List tasks under a goal. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.aget_compute_tasks(goal_id)
+        return _run_sync(
+            self.aget_compute_tasks(goal_id),
+            "aget_compute_tasks",
         )
 
     async def aget_compute_tasks(self, goal_id: str) -> Any:
@@ -1491,8 +1532,9 @@ class OneShotClient:
         """List what a goal produced: the files its sandbox tasks left and the
         tool results too large for a task row. The goal's short answer is
         ``result`` on ``get_compute_goal``. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.aget_compute_outputs(goal_id)
+        return _run_sync(
+            self.aget_compute_outputs(goal_id),
+            "aget_compute_outputs",
         )
 
     async def aget_compute_outputs(self, goal_id: str) -> Any:
@@ -1503,8 +1545,9 @@ class OneShotClient:
         """Read one output of a goal by the ``key`` from ``get_compute_outputs``
         (or a task's ``outputs``). ``content`` is None when the output was too
         large to keep (``readable`` False). Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.aget_compute_output(goal_id, key)
+        return _run_sync(
+            self.aget_compute_output(goal_id, key),
+            "aget_compute_output",
         )
 
     async def aget_compute_output(self, goal_id: str, key: str) -> Any:
@@ -1515,8 +1558,9 @@ class OneShotClient:
 
     def get_compute_budget(self, goal_id: str) -> Any:
         """Get budget breakdown. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.aget_compute_budget(goal_id)
+        return _run_sync(
+            self.aget_compute_budget(goal_id),
+            "aget_compute_budget",
         )
 
     async def aget_compute_budget(self, goal_id: str) -> Any:
@@ -1530,8 +1574,9 @@ class OneShotClient:
         refund is deferred: the result then has ``status == "pending_settlement"``
         (no exception is raised).
         """
-        return asyncio.get_event_loop().run_until_complete(
-            self.acancel_compute_goal(goal_id, reason)
+        return _run_sync(
+            self.acancel_compute_goal(goal_id, reason),
+            "acancel_compute_goal",
         )
 
     async def acancel_compute_goal(
@@ -1558,10 +1603,11 @@ class OneShotClient:
         approved: Optional[bool] = None,
     ) -> Any:
         """Respond to a human-in-the-loop approval task. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
+        return _run_sync(
             self.arespond_to_compute_task(
                 goal_id, task_id, response=response, approved=approved
-            )
+            ),
+            "arespond_to_compute_task",
         )
 
     async def arespond_to_compute_task(
@@ -1584,8 +1630,9 @@ class OneShotClient:
 
     def pause_compute_goal(self, goal_id: str, reason: Optional[str] = None) -> Any:
         """Pause a recurring goal. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.apause_compute_goal(goal_id, reason)
+        return _run_sync(
+            self.apause_compute_goal(goal_id, reason),
+            "apause_compute_goal",
         )
 
     async def apause_compute_goal(
@@ -1599,8 +1646,9 @@ class OneShotClient:
 
     def resume_compute_goal(self, goal_id: str) -> Any:
         """Resume a paused recurring goal. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.aresume_compute_goal(goal_id)
+        return _run_sync(
+            self.aresume_compute_goal(goal_id),
+            "aresume_compute_goal",
         )
 
     async def aresume_compute_goal(self, goal_id: str) -> Any:
@@ -1611,8 +1659,9 @@ class OneShotClient:
 
     def fund_compute_goal(self, goal_id: str, amount: float) -> Any:
         """Top up budget on a recurring goal. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
-            self.afund_compute_goal(goal_id, amount)
+        return _run_sync(
+            self.afund_compute_goal(goal_id, amount),
+            "afund_compute_goal",
         )
 
     async def afund_compute_goal(self, goal_id: str, amount: float) -> Any:
@@ -1641,7 +1690,7 @@ class OneShotClient:
 
     def top_up_credits(self, amount: float) -> Any:
         """Blocking wrapper for :meth:`atop_up_credits`."""
-        return asyncio.get_event_loop().run_until_complete(self.atop_up_credits(amount))
+        return _run_sync(self.atop_up_credits(amount), "atop_up_credits")
 
     def browser(
         self,
@@ -1657,13 +1706,14 @@ class OneShotClient:
         timeout_sec: int = 300,
     ) -> Any:
         """Run a browser automation task. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(
+        return _run_sync(
             self.abrowser(
                 task, output_schema=output_schema, start_url=start_url,
                 allowed_domains=allowed_domains, profile_id=profile_id,
                 secrets=secrets, max_steps=max_steps, max_cost=max_cost,
                 timeout_sec=timeout_sec,
-            )
+            ),
+            "abrowser",
         )
 
     async def abrowser(
@@ -1842,7 +1892,7 @@ class OneShotClient:
         return await self.acall_free_get(f"/v1/tools/linkedin/accounts/{quote(account_id, safe='')}/invitations", _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))
+        return _run_sync(self._alinkedin_invitation_call(endpoint, payload, **kwargs), "_alinkedin_invitation_call")
 
     async def _alinkedin_invitation_call(self, endpoint: str, payload: dict, **kwargs: Any) -> Any:
         try:
@@ -1979,13 +2029,14 @@ class OneShotClient:
         ``mailbox_mode == 'mailbox'``, and read ``mailbox_provisioning_fee`` on
         the quote for the exact amount before paying.
         """
-        return asyncio.get_event_loop().run_until_complete(
+        return _run_sync(
             self.aemail(
                 to, subject, body,
                 from_domain=from_domain, from_mailbox=from_mailbox, from_name=from_name,
                 reply_to_email_id=reply_to_email_id, mailbox_mode=mailbox_mode,
                 **kwargs,
-            )
+            ),
+            "aemail",
         )
 
     async def aemail(
@@ -2082,7 +2133,7 @@ class OneShotClient:
         """Keep SDK controls out of the canonical quoted input."""
         return {key: kwargs.pop(key) for key in (
             "max_cost", "timeout_sec", "wait", "wait_for_phones",
-            "phone_timeout_sec", "idempotency_key", "approval_id",
+            "phone_timeout_sec", "idempotency_key", "approval_id", "quote_id",
         ) if key in kwargs}
 
     def person_find(self, *, include_phone: bool = False, **kwargs: Any) -> Any:
@@ -2361,7 +2412,7 @@ class OneShotClient:
 
     def pause_domain(self, domain: str) -> DomainPoolStatusResult:
         """Take a domain out of rotation without releasing it. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.apause_domain(domain))
+        return _run_sync(self.apause_domain(domain), "apause_domain")
 
     async def apause_domain(self, domain: str) -> DomainPoolStatusResult:
         """Take a domain out of rotation without releasing it. Async."""
@@ -2369,7 +2420,7 @@ class OneShotClient:
 
     def resume_domain(self, domain: str) -> DomainPoolStatusResult:
         """Put a paused domain back into rotation. Blocking."""
-        return asyncio.get_event_loop().run_until_complete(self.aresume_domain(domain))
+        return _run_sync(self.aresume_domain(domain), "aresume_domain")
 
     async def aresume_domain(self, domain: str) -> DomainPoolStatusResult:
         """Put a paused domain back into rotation. Async.
@@ -2410,10 +2461,11 @@ class OneShotClient:
         ``savings``, ``engagement``. Stored as ``pending`` until a judge service
         confirms them against inbound signals.
         """
-        return asyncio.get_event_loop().run_until_complete(
+        return _run_sync(
             self.atag_receipt_value(
                 receipt_id, value_tag, request_id=request_id, goal_id=goal_id
-            )
+            ),
+            "atag_receipt_value",
         )
 
     async def atag_receipt_value(
@@ -2685,7 +2737,7 @@ class HuntsClient:
             return self.client._unwrap_data(resp.json())
 
     def list(self, status: str = "active", limit: int = 20, offset: int = 0) -> list[dict[str, Any]]:
-        return asyncio.get_event_loop().run_until_complete(self.alist(status, limit, offset))
+        return _run_sync(self.alist(status, limit, offset), "hunts.alist")
 
     async def astatus(self, hunt_id: str) -> dict[str, Any]:
         async with httpx.AsyncClient(timeout=30.0) as transport:
@@ -2697,7 +2749,7 @@ class HuntsClient:
             return self.client._unwrap_data(resp.json())
 
     def status(self, hunt_id: str) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.astatus(hunt_id))
+        return _run_sync(self.astatus(hunt_id), "hunts.astatus")
 
     async def apredict(
         self, hunt_id: str, predicted_tool: str, predicted_action: str, predicted_motivation: str
@@ -2719,8 +2771,9 @@ class HuntsClient:
     def predict(
         self, hunt_id: str, predicted_tool: str, predicted_action: str, predicted_motivation: str
     ) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(
-            self.apredict(hunt_id, predicted_tool, predicted_action, predicted_motivation)
+        return _run_sync(
+            self.apredict(hunt_id, predicted_tool, predicted_action, predicted_motivation),
+            "hunts.apredict",
         )
 
     async def acapture(self, hunt_id: str) -> dict[str, Any]:
@@ -2734,7 +2787,7 @@ class HuntsClient:
             return self.client._unwrap_data(resp.json())
 
     def capture(self, hunt_id: str) -> dict[str, Any]:
-        return asyncio.get_event_loop().run_until_complete(self.acapture(hunt_id))
+        return _run_sync(self.acapture(hunt_id), "hunts.acapture")
 
     async def acollection(self) -> list[dict[str, Any]]:
         async with httpx.AsyncClient(timeout=30.0) as transport:
@@ -2746,7 +2799,7 @@ class HuntsClient:
             return self.client._unwrap_data(resp.json())
 
     def collection(self) -> list[dict[str, Any]]:
-        return asyncio.get_event_loop().run_until_complete(self.acollection())
+        return _run_sync(self.acollection(), "hunts.acollection")
 
     async def aleaderboard(
         self, period: str = "all", sort: str = "captures", limit: int = 25, offset: int = 0
@@ -2763,7 +2816,7 @@ class HuntsClient:
     def leaderboard(
         self, period: str = "all", sort: str = "captures", limit: int = 25, offset: int = 0
     ) -> list[dict[str, Any]]:
-        return asyncio.get_event_loop().run_until_complete(self.aleaderboard(period, sort, limit, offset))
+        return _run_sync(self.aleaderboard(period, sort, limit, offset), "hunts.aleaderboard")
 
 
 def _new_idempotency_key() -> str:

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/oneshot/lookup_manifest.py

@@ -1368,13 +1368,13 @@ LOOKUP_MANIFEST: list[dict[str, Any]] = [
         "method": "POST",
         "pricing": "fixed",
         "title": "Changes",
-        "description": "What changed about one entity since a date, from the observations OneShot recorded: each change has the earlier value, the later value, when it was seen and the source. Give `attribute` (the name of a data tool that keeps history), `since`, and exactly one of `key` and `input`. For healthcare_exclusions, input selects a held monthly release and optional exact name/NPI/UPIN; returns row membership and full-row additions/removals, with coverage. A corrected row is removal plus addition, never person identity. A window with no changes is a completed, charged result. Paid per call.",
+        "description": "What changed about one entity since a date, from the observations OneShot recorded: each change has the earlier value, the later value, when it was seen and the source. Give `attribute` (the name of a data tool that keeps history, or of a published dataset attribute such as company_operating_authority), `since`, and exactly one of `key` and `input`. For healthcare_exclusions, input selects a held monthly release and optional exact name/NPI/UPIN; returns row membership and full-row additions/removals, with coverage. A corrected row is removal plus addition, never person identity. A window with no changes is a completed, charged result. Paid per call.",
         "input_schema": {
             "type": "object",
             "properties": {
                 "attribute": {
                     "type": "string",
-                    "description": "Name of a data tool that keeps history, e.g. vehicle_identification",
+                    "description": "Name of a data tool that keeps history, e.g. vehicle_identification, or of a published dataset attribute, e.g. company_operating_authority",
                 },
                 "key": {
                     "type": "string",

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oneshot-python"
-version = "0.40.0"
+version = "0.40.1"
 description = "Core Python SDK for the OneShot API — HTTP client with x402 payment handling — 48 tools"
 readme = {text = "Core Python SDK for the OneShot API", content-type = "text/plain"}
 license = "MIT"

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/tests/conftest.py

@@ -10,8 +10,8 @@ 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.
+    # Exercise reuse of a caller-owned loop, independent of async test cleanup.
+    # test_sync_without_loop covers the absent/closed-loop fallback separately.
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
     try:

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/tests/test_access_token.py

@@ -31,14 +31,12 @@ BASE = "http://test.local"
 
 @pytest.fixture(autouse=True)
 def _fresh_event_loop():
-    """Sync wrappers use ``get_event_loop().run_until_complete``; pytest-asyncio
-    closes loops between async tests, so give every test a fresh one."""
+    """Exercise sync wrappers with a caller-owned loop for each test."""
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
     yield
     loop.close()
-    # Leave an OPEN loop behind: this module sorts first, and later modules'
-    # sync wrappers call get_event_loop().run_until_complete on the current one.
+    # Leave an open loop for later tests that drive coroutines directly.
     asyncio.set_event_loop(asyncio.new_event_loop())
 
 

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/tests/test_email_payload.py

@@ -25,14 +25,9 @@ REPLY_ID = "4fa85f64-5717-4562-b3fc-2c963f66afa6"
 def _fresh_event_loop():
     """Give every test in this module its own event loop.
 
-    The sync surface (``email()``) bridges to ``aemail()`` via
-    ``asyncio.get_event_loop().run_until_complete(...)``. pytest-asyncio
-    clears the current event loop after each async test, which otherwise
-    breaks any *sync* test — mocked or not — that happens to run afterward
-    in the same session ("There is no current event loop in thread
-    'MainThread'"). Without this fixture the suite's pass/fail would depend
-    on test collection order, which is exactly the kind of environment-
-    dependent test this correction round was asked to avoid introducing.
+    The sync surface (``email()``) bridges to ``aemail()`` via ``_run_sync``.
+    Keep these payload tests on a caller-owned loop; absent and closed loops
+    are covered separately in ``test_sync_without_loop.py``.
     """
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)

{oneshot_python-0.40.0 → oneshot_python-0.40.1}/tests/test_hunts.py

@@ -131,6 +131,27 @@ def test_default_and_overridden_hunt_url():
     assert custom.hunt_url == "https://custom.hunt.example"
 
 
+@pytest.mark.parametrize("sync_name,args", [
+    ("list", ()),
+    ("status", ("hunt_1",)),
+    ("predict", ("hunt_1", "tool", "action", "motivation")),
+    ("capture", ("hunt_1",)),
+    ("collection", ()),
+    ("leaderboard", ()),
+])
+def test_sync_inside_running_loop_names_bound_async_method(sync_name, args):
+    client = _wallet_client()
+    async_name = "a" + sync_name
+    assert callable(getattr(client.hunts, async_name))
+
+    async def scenario():
+        with pytest.raises(RuntimeError) as error:
+            getattr(client.hunts, sync_name)(*args)
+        assert f"use await client.hunts.{async_name}(...) instead." in str(error.value)
+
+    asyncio.run(scenario())
+
+
 # ---------------------------------------------------------------- wallet session: reads
 
 @pytest.mark.asyncio

oneshot_python-0.40.1/tests/test_person_quote_id.py

@@ -0,0 +1,87 @@
+"""A person call's ``quote_id`` is the ``x-quote-id`` header, never body input (#1945).
+
+``person_find(quote_id=...)``, ``person_profile``, ``person_dossier`` and their
+async variants hand ``quote_id`` to ``call_tool`` / ``acall_tool`` with the other
+SDK controls, so the quoted input the API hashes is the person input alone and
+the header carries the quote from the very first attempt.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from oneshot.client import OneShotClient
+
+TEST_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+QUOTE_ID = "q-person-1945"
+PERSON_METHODS = [
+    ("person_find", "/v1/tools/find/person"),
+    ("person_profile", "/v1/tools/lookup/person-profile"),
+    ("person_dossier", "/v1/tools/lookup/person-dossier"),
+]
+
+
+def _queued() -> MagicMock:
+    resp = MagicMock()
+    resp.status_code = 202
+    resp.is_success = True
+    resp.json.return_value = {"request_id": "job-1", "status": "processing"}
+    resp.text = ""
+    resp.headers = {}
+    return resp
+
+
+def _http() -> MagicMock:
+    http = MagicMock()
+    http.post = AsyncMock(return_value=_queued())
+    http.__aenter__ = AsyncMock(return_value=http)
+    http.__aexit__ = AsyncMock(return_value=False)
+    return http
+
+
+def _client() -> OneShotClient:
+    client = OneShotClient(TEST_PRIVATE_KEY)
+    client._budget_synced = True
+    return client
+
+
+def _assert_header_only(http: MagicMock, endpoint: str) -> None:
+    http.post.assert_awaited_once()
+    call = http.post.await_args
+    assert call.args[0].endswith(endpoint)
+    assert call.kwargs["headers"]["x-quote-id"] == QUOTE_ID
+    assert "quote_id" not in call.kwargs["json"]
+    assert call.kwargs["json"] == {"name": "Jane", "include_phone": True}
+
+
+@pytest.mark.parametrize("method,endpoint", PERSON_METHODS)
+def test_blocking_person_call_sends_quote_id_as_the_header_and_not_in_the_body(method, endpoint):
+    client = _client()
+    http = _http()
+    with patch("oneshot.client.httpx.AsyncClient", return_value=http):
+        result = getattr(client, method)(name="Jane", include_phone=True, quote_id=QUOTE_ID, wait=False)
+    assert result["request_id"] == "job-1"
+    _assert_header_only(http, endpoint)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("method,endpoint", PERSON_METHODS)
+async def test_async_person_call_sends_quote_id_as_the_header_and_not_in_the_body(method, endpoint):
+    client = _client()
+    http = _http()
+    with patch("oneshot.client.httpx.AsyncClient", return_value=http):
+        result = await getattr(client, f"a{method}")(name="Jane", include_phone=True, quote_id=QUOTE_ID, wait=False)
+    assert result["request_id"] == "job-1"
+    _assert_header_only(http, endpoint)
+
+
+def test_call_tool_forwards_quote_id_to_the_async_flow():
+    """The blocking ``call_tool`` accepts ``quote_id`` and sends the same header."""
+    client = _client()
+    http = _http()
+    with patch("oneshot.client.httpx.AsyncClient", return_value=http):
+        client.call_tool("/v1/tools/find/person", {"name": "Jane"}, quote_id=QUOTE_ID, wait=False)
+    assert http.post.await_args.kwargs["headers"]["x-quote-id"] == QUOTE_ID
+    assert http.post.await_args.kwargs["json"] == {"name": "Jane"}

oneshot_python-0.40.1/tests/test_sync_without_loop.py

@@ -0,0 +1,72 @@
+"""Blocking SDK calls tolerate absent/closed loops and reject running loops."""
+
+import asyncio
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from oneshot.client import OneShotClient
+
+
+@pytest.fixture
+def client():
+    # Restore the caller's loop so these regressions do not alter other tests.
+    try:
+        previous_loop = asyncio.get_event_loop()
+    except RuntimeError:
+        previous_loop = None
+    try:
+        yield OneShotClient(access_token="oneshot_" + "a" * 64, address="0x" + "1" * 40)
+    finally:
+        asyncio.set_event_loop(previous_loop)
+
+
+METHODS = [
+    ("pause_domain", "apause_domain", ("example.com",)),
+    ("resume_domain", "aresume_domain", ("example.com",)),
+    ("voice_numbers", "avoice_numbers", ()),
+]
+
+
+@pytest.mark.parametrize("sync_name,async_name,args", METHODS)
+def test_sync_after_asyncio_run(client, sync_name, async_name, args):
+    asyncio.run(asyncio.sleep(0))
+    expected = {"result": sync_name}
+    with patch.object(client, async_name, new_callable=AsyncMock, return_value=expected) as twin:
+        assert getattr(client, sync_name)(*args) is expected
+    twin.assert_awaited_once_with(*args)
+
+
+def test_sync_reuses_open_current_loop(client):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        with patch.object(client, "apause_domain", new_callable=AsyncMock,
+                          side_effect=lambda *_: asyncio.get_running_loop()) as twin:
+            assert client.pause_domain("example.com") is loop
+        twin.assert_awaited_once_with("example.com")
+        assert asyncio.get_event_loop() is loop
+        assert not loop.is_closed()
+    finally:
+        loop.close()
+
+
+def test_sync_with_closed_current_loop(client):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.close()
+    expected = {"pool_status": "paused"}
+    with patch.object(client, "apause_domain", new_callable=AsyncMock, return_value=expected) as twin:
+        assert client.pause_domain("example.com") is expected
+    twin.assert_awaited_once_with("example.com")
+
+
+@pytest.mark.parametrize("sync_name,async_name,args", METHODS)
+def test_sync_inside_running_loop_names_async_method(client, sync_name, async_name, args):
+    async def scenario():
+        with patch.object(client, async_name, new_callable=AsyncMock) as twin:
+            with pytest.raises(RuntimeError, match=rf"running event loop.*{async_name}"):
+                getattr(client, sync_name)(*args)
+            twin.assert_not_awaited()
+
+    asyncio.run(scenario())