imperal-sdk 4.2.10__tar.gz → 4.2.12__tar.gz

{imperal_sdk-4.2.10 → imperal_sdk-4.2.12}/CHANGELOG.md

@@ -2,6 +2,77 @@
 
 All notable changes to `imperal-sdk` are documented here.
 
+## 4.2.12 — 2026-05-14
+
+**Feat: LONGRUN-V1 Session 1 — long-running operations primitives**
+
+Three new SDK surfaces for ops that exceed the 30s `ctx.http` ceiling:
+
+### Added
+
+- **`ctx.http.{get,post,put,patch,delete}(..., timeout=N)` per-call kwarg.**
+  Federal cap 180s (`I-LONGRUN-HTTP-CAP-180S`). Anything larger raises
+  `ValueError("ctx.http timeout {N}s exceeds federal cap (180s)...")` —
+  use `ctx.background_task()` for longer ops.
+
+- **`ctx.background_task(coro, *, long_running=False, name="") -> str`**
+  — explicit opt-in for the kernel's auto-promote path. Coro runs detached
+  via `asyncio.create_task`; kernel auto-delivers its returned
+  `ActionResult` as a fresh bot message to the user's chat when done.
+  `long_running=True` raises the 180s cap to 1800s
+  (`LONG_RUNNING_TASK_S`). Returns task_id immediately.
+
+- **`ctx.deliver_chat_message(text, *, msg_type="response", refresh_panels=None)`**
+  — public API for extension-initiated bot turn injection. Posts to
+  auth-gw `/v1/internal/chat/inject`. Text truncated to 64KB with marker.
+  `msg_type` ∈ `{response, system, tool_result}`.
+
+### Federal invariants (new)
+
+- `I-LONGRUN-HTTP-CAP-180S` — per-call timeout federal cap
+- `I-LONGRUN-BG-CORO-RETURNS-ACTIONRESULT` — coro contract enforced
+  kernel-side via `_explicit_background_task_completion` isinstance
+  check; violation writes critical audit row + delivers fallback error.
+- `I-LONGRUN-BG-USER-SCOPED` — task bound to `(ext_id, user_id)` at
+  creation (existing `util/task_manager.py` invariant).
+- `I-LONGRUN-CHAT-INJECT-USER-SCOPED` — `X-Acting-User` header must
+  match `body.user_id` (auth-gw 403 on mismatch).
+- `I-LONGRUN-CHAT-INJECT-AUDIT-EVERY` — every inject writes an
+  `action_ledger` row through the `write_audit` chokepoint.
+
+### Spec
+
+`superpowers/specs/2026-05-13-longrun-v1-design.md`. Sessions 2 (Sharelock
+canary migration) and 3 (docs + observability) ship after 24h soak.
+
+### Migration
+
+None required — all additions are additive opt-in. Existing extensions
+work unchanged.
+
+## 4.2.11 — 2026-05-13
+
+**Fix: `ui.Link(text=...)` no longer breaks panel render**
+
+`ui.Link` now accepts the visible text via either `label=` (canonical) or
+`text=` (alias matching the HTML/JSX `<a>text</a>` mental model). Before
+v4.2.11, passing `text=` raised `TypeError: Link() got an unexpected
+keyword argument 'text'` at panel-render time, which killed the right
+panel for any extension that used the natural-looking kwarg.
+
+```python
+# All three are now equivalent
+ui.Link("Read docs", href="https://docs.imperal.io")           # positional
+ui.Link(label="Read docs", href="https://docs.imperal.io")     # canonical kwarg
+ui.Link(text="Read docs",  href="https://docs.imperal.io")     # alias kwarg
+```
+
+Calling `ui.Link()` with neither `label` nor `text` raises a clear
+`TypeError("ui.Link requires a 'label' (or 'text' alias)")` instead of
+silently rendering an empty anchor. `label` wins if both are passed.
+
+No migration required — existing `label=` callers are unchanged.
+
 ## 4.2.10 — 2026-05-13
 
 **Feat: `@chat.function` default `chain_callable=True` for ALL action_types (was write/destructive only)**

{imperal_sdk-4.2.10 → imperal_sdk-4.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imperal-sdk
-Version: 4.2.10
+Version: 4.2.12
 Summary: SDK for building Imperal Cloud extensions
 Author: Valentin Scerbacov, Imperal, Inc.
 License-Expression: AGPL-3.0-or-later

{imperal_sdk-4.2.10 → imperal_sdk-4.2.12}/src/imperal_sdk/__init__.py

@@ -39,7 +39,7 @@ from imperal_sdk.secrets import (
     SecretValueTooLarge, SecretDeclarationConflict,
 )
 
-__version__ = "4.2.10"
+__version__ = "4.2.12"
 
 __all__ = [
     # Core

{imperal_sdk-4.2.10 → imperal_sdk-4.2.12}/src/imperal_sdk/context.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
+import httpx
+
 from imperal_sdk.types.identity import UserContext, TenantContext
 
 if TYPE_CHECKING:
@@ -290,6 +292,106 @@ class Context:
         if cb:
             await cb(percent, message)
 
+    async def background_task(
+        self,
+        coro,
+        *,
+        long_running: bool = False,
+        name: str = "",
+    ) -> str:
+        """Spawn a coroutine in the background; return task_id immediately.
+
+        The kernel detaches ``coro`` via ``asyncio.create_task`` and tracks
+        it as an explicit-opt-in background task (federal task lifecycle in
+        ``util/task_manager.py``). When ``coro`` completes, the kernel
+        auto-delivers its returned ``ActionResult`` as a fresh bot message
+        in the user's chat via the existing ``_deliver_to_chat`` pipeline.
+
+        Args:
+            coro: A coroutine returning ``ActionResult``. Required.
+            long_running: ``False`` (default) → 180s federal cap.
+                          ``True`` → 1800s cap (``LONG_RUNNING_TASK_S``).
+            name: Human-readable name for UI/audit (default ``"background"``).
+
+        Returns:
+            task_id (str) — federal Redis key ``imperal:task:{task_id}``.
+
+        Raises:
+            RuntimeError: if ``ctx`` lacks kernel-injected spawn hook
+                (e.g. dev mode or non-extension dispatch context).
+
+        Federal: ``I-LONGRUN-BG-CORO-RETURNS-ACTIONRESULT`` — ``coro`` MUST
+        return ``ActionResult``; non-ActionResult return triggers a critical
+        audit row and delivers a fallback error to chat.
+        """
+        spawn = getattr(self, "_background_task_spawn", None)
+        if spawn is None:
+            raise RuntimeError(
+                "ctx.background_task not available in this context — the "
+                "Context was constructed without a kernel-injected spawn "
+                "hook. This is typically a test harness or dev-mode issue."
+            )
+        return await spawn(coro, long_running=long_running, name=name or "background")
+
+    async def deliver_chat_message(
+        self,
+        text: str,
+        *,
+        msg_type: str = "response",
+        refresh_panels: list[str] | None = None,
+    ) -> None:
+        """Inject a bot message into user's chat at any time.
+
+        Mirrors the existing kernel auto-promote chat-injection path
+        (``pipeline/task_delivery.py:_deliver_to_chat``) but is callable
+        explicitly from extension code. Use cases:
+          - Background task multi-stage announcements before final result
+          - Webhook acknowledgements ("Spotify connected!")
+          - Any one-off bot message that skeleton-alert polling can't model
+
+        Args:
+            text: Bot message body (Markdown). Truncated to 64KB if larger.
+            msg_type: ``"response"`` (default — bot turn),
+                      ``"system"`` (italicized notice),
+                      ``"tool_result"`` (formatted as tool execution).
+            refresh_panels: optional list of panel_ids to re-render after.
+
+        Federal: ``I-LONGRUN-CHAT-INJECT-USER-SCOPED`` — inject scoped to
+        ``(ext_id, user_id)``; cross-user inject returns 403.
+        ``I-LONGRUN-CHAT-INJECT-AUDIT-EVERY`` — every inject writes an
+        audit row in ``action_ledger``.
+        """
+        MAX_BYTES = 64 * 1024
+        if len(text.encode("utf-8")) > MAX_BYTES:
+            text = text.encode("utf-8")[:MAX_BYTES].decode("utf-8", errors="ignore") + "...(truncated)"
+
+        ext_id = getattr(self, "_extension_id", None)
+        user_id = getattr(self, "_user_id", None) or getattr(self.user, "imperal_id", None)
+        gateway_url = getattr(self, "_gateway_url", None)
+        service_token = getattr(self, "_service_token", None)
+        if not all([ext_id, user_id, gateway_url, service_token]):
+            raise RuntimeError(
+                "ctx.deliver_chat_message requires kernel-injected (ext_id, "
+                "user_id, gateway_url, service_token). Not available in this "
+                "context (likely a test harness or dev-mode dispatch)."
+            )
+
+        url = f"{gateway_url.rstrip('/')}/v1/internal/chat/inject"
+        body = {
+            "ext_id": ext_id,
+            "user_id": user_id,
+            "text": text,
+            "msg_type": msg_type,
+        }
+        if refresh_panels:
+            body["refresh_panels"] = refresh_panels
+        headers = {
+            "X-Service-Token": service_token,
+            "X-Acting-User": user_id,
+        }
+        async with httpx.AsyncClient(timeout=10.0) as c:
+            await c.post(url, json=body, headers=headers)
+
     async def log(self, message: str, level: str = "info") -> None:
         """Structured log visible in extension dashboard."""
         import logging

imperal_sdk-4.2.12/src/imperal_sdk/http/client.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2026 Imperal, Inc., Valentin Scerbacov, and contributors
+# Licensed under the AGPL-3.0 License. See LICENSE file for details.
+from __future__ import annotations
+import httpx
+
+from imperal_sdk.types.models import HTTPResponse
+
+
+def _wrap(resp: httpx.Response) -> HTTPResponse:
+    """Convert httpx.Response to typed HTTPResponse."""
+    content_type = resp.headers.get("content-type", "")
+    if "json" in content_type:
+        try:
+            body = resp.json()
+        except Exception:
+            body = resp.text
+    elif resp.content:
+        try:
+            body = resp.text
+        except Exception:
+            body = resp.content
+    else:
+        body = ""
+    return HTTPResponse(status_code=resp.status_code, body=body, headers=dict(resp.headers))
+
+
+class HTTPClient:
+    """Federal HTTP client.
+
+    Per-call ``timeout=`` kwarg overrides the instance default. Federal
+    cap is 180 seconds (``I-LONGRUN-HTTP-CAP-180S``) — anything longer
+    must use :func:`ctx.background_task` instead.
+    """
+
+    def __init__(
+        self,
+        timeout: float = 30,
+        max_redirects: int = 5,
+        max_timeout: float = 180,
+    ):
+        self._timeout = timeout
+        self._max_timeout = max_timeout
+        self._max_redirects = max_redirects
+
+    def _resolve_timeout(self, override: float | None) -> float:
+        if override is None:
+            return self._timeout
+        if override <= 0:
+            raise ValueError(f"ctx.http timeout must be > 0; got {override}")
+        if override > self._max_timeout:
+            raise ValueError(
+                f"ctx.http timeout {override}s exceeds federal cap "
+                f"({self._max_timeout}s). For >180s use ctx.background_task() "
+                f"— see concepts/long-running-operations."
+            )
+        return override
+
+    async def get(self, url: str, *, timeout: float | None = None, **kwargs) -> HTTPResponse:
+        t = self._resolve_timeout(timeout)
+        async with httpx.AsyncClient(timeout=t, follow_redirects=True,
+                                     max_redirects=self._max_redirects) as c:
+            return _wrap(await c.get(url, **kwargs))
+
+    async def post(self, url: str, *, timeout: float | None = None, **kwargs) -> HTTPResponse:
+        t = self._resolve_timeout(timeout)
+        async with httpx.AsyncClient(timeout=t, follow_redirects=True,
+                                     max_redirects=self._max_redirects) as c:
+            return _wrap(await c.post(url, **kwargs))
+
+    async def put(self, url: str, *, timeout: float | None = None, **kwargs) -> HTTPResponse:
+        t = self._resolve_timeout(timeout)
+        async with httpx.AsyncClient(timeout=t, follow_redirects=True,
+                                     max_redirects=self._max_redirects) as c:
+            return _wrap(await c.put(url, **kwargs))
+
+    async def patch(self, url: str, *, timeout: float | None = None, **kwargs) -> HTTPResponse:
+        t = self._resolve_timeout(timeout)
+        async with httpx.AsyncClient(timeout=t, follow_redirects=True,
+                                     max_redirects=self._max_redirects) as c:
+            return _wrap(await c.patch(url, **kwargs))
+
+    async def delete(self, url: str, *, timeout: float | None = None, **kwargs) -> HTTPResponse:
+        t = self._resolve_timeout(timeout)
+        async with httpx.AsyncClient(timeout=t, follow_redirects=True,
+                                     max_redirects=self._max_redirects) as c:
+            return _wrap(await c.delete(url, **kwargs))

{imperal_sdk-4.2.10 → imperal_sdk-4.2.12}/src/imperal_sdk/ui/interactive.py

@@ -73,9 +73,23 @@ def Tooltip(content: str, children: UINode | None = None) -> UINode:
     return UINode(type="Tooltip", props=props)
 
 
-def Link(label: str, href: str = "", on_click: UIAction | None = None) -> UINode:
-    """Hyperlink — navigates via href or fires on_click action."""
-    props: dict[str, Any] = {"label": label}
+def Link(
+    label: str = "",
+    href: str = "",
+    on_click: UIAction | None = None,
+    *,
+    text: str = "",
+) -> UINode:
+    """Hyperlink — navigates via href or fires on_click action.
+
+    The visible text can be passed as either ``label`` (canonical) or
+    ``text`` (alias matching the HTML/JSX `<a>text</a>` mental model).
+    Exactly one must be provided; ``label`` wins if both are set.
+    """
+    resolved = label or text
+    if not resolved:
+        raise TypeError("ui.Link requires a 'label' (or 'text' alias)")
+    props: dict[str, Any] = {"label": resolved}
     if href: props["href"] = href
     if on_click: props["on_click"] = on_click
     return UINode(type="Link", props=props)

imperal_sdk-4.2.12/tests/test_context_background_task.py

@@ -0,0 +1,76 @@
+# tests/test_context_background_task.py
+"""Component B — ctx.background_task() public API surface tests.
+
+Verifies the SDK contract:
+- Returns a task_id (str) immediately.
+- Spawns coroutine via injected kernel hook.
+- Raises RuntimeError if no kernel hook present (e.g. dev mode).
+"""
+from __future__ import annotations
+import pytest
+
+from imperal_sdk import ActionResult
+from imperal_sdk.context import Context
+from imperal_sdk.types.identity import UserContext
+
+
+def _make_ctx() -> Context:
+    return Context(user=UserContext(
+        imperal_id="imp_u_test", email="test@test.com", tenant_id="t", role="user",
+    ))
+
+
+@pytest.mark.asyncio
+async def test_background_task_returns_task_id_str():
+    captured: dict = {}
+
+    async def _spawn_hook(coro, *, long_running, name):
+        captured["coro_present"] = coro is not None
+        captured["long_running"] = long_running
+        captured["name"] = name
+        coro.close()
+        return "task_xyz123"
+
+    ctx = _make_ctx()
+    ctx._background_task_spawn = _spawn_hook  # type: ignore[attr-defined]
+
+    async def _work():
+        return ActionResult.success(data={"ok": True})
+
+    tid = await ctx.background_task(_work(), long_running=True, name="my-task")
+    assert tid == "task_xyz123"
+    assert captured["long_running"] is True
+    assert captured["name"] == "my-task"
+    assert captured["coro_present"] is True
+
+
+@pytest.mark.asyncio
+async def test_background_task_raises_without_kernel_hook():
+    ctx = _make_ctx()
+
+    async def _work():
+        return ActionResult.success(data={"ok": True})
+
+    coro = _work()
+    with pytest.raises(RuntimeError, match="ctx.background_task not available"):
+        await ctx.background_task(coro)
+    coro.close()
+
+
+@pytest.mark.asyncio
+async def test_background_task_default_long_running_false():
+    captured: dict = {}
+
+    async def _spawn_hook(coro, *, long_running, name):
+        captured["long_running"] = long_running
+        coro.close()
+        return "task_y"
+
+    ctx = _make_ctx()
+    ctx._background_task_spawn = _spawn_hook  # type: ignore[attr-defined]
+
+    async def _work():
+        return ActionResult.success(data={"ok": True})
+
+    await ctx.background_task(_work())
+    assert captured["long_running"] is False

imperal_sdk-4.2.12/tests/test_context_deliver_chat_message.py

@@ -0,0 +1,96 @@
+# tests/test_context_deliver_chat_message.py
+"""Component C — ctx.deliver_chat_message() public API surface tests.
+
+Verifies the SDK contract:
+- POSTs to auth-gw /v1/internal/chat/inject with correct payload + headers.
+- Truncates text > 64KB with appended marker.
+- Respects msg_type literal values.
+- Forwards optional refresh_panels list.
+"""
+from __future__ import annotations
+import pytest
+import httpx
+
+from imperal_sdk.context import Context
+from imperal_sdk.types.identity import UserContext
+
+
+def _make_ctx(*, ext_id="my-ext", user_id="imp_u_abc",
+              gw="http://auth-gw:8085", svc="tok_xxx") -> Context:
+    ctx = Context(user=UserContext(
+        imperal_id=user_id, email="u@t.com", tenant_id="t", role="user",
+    ))
+    ctx._extension_id = ext_id
+    ctx._user_id = user_id            # type: ignore[attr-defined]
+    ctx._gateway_url = gw
+    ctx._service_token = svc
+    return ctx
+
+
+@pytest.mark.asyncio
+async def test_deliver_chat_message_posts_to_auth_gw(monkeypatch):
+    captured: dict = {}
+
+    class _MockAsyncClient:
+        def __init__(self, *, timeout, **kw):
+            captured["timeout"] = timeout
+        async def __aenter__(self): return self
+        async def __aexit__(self, *a): pass
+        async def post(self, url, json=None, headers=None):
+            captured["url"] = url
+            captured["json"] = json
+            captured["headers"] = headers
+            return httpx.Response(200, json={"ok": True})
+
+    monkeypatch.setattr("imperal_sdk.context.httpx.AsyncClient", _MockAsyncClient)
+    ctx = _make_ctx()
+
+    await ctx.deliver_chat_message("Hello!")
+    assert captured["url"].endswith("/v1/internal/chat/inject")
+    assert captured["json"]["text"] == "Hello!"
+    assert captured["json"]["msg_type"] == "response"
+    assert captured["json"]["ext_id"] == "my-ext"
+    assert captured["json"]["user_id"] == "imp_u_abc"
+    assert captured["headers"]["X-Service-Token"] == "tok_xxx"
+    assert captured["headers"]["X-Acting-User"] == "imp_u_abc"
+
+
+@pytest.mark.asyncio
+async def test_deliver_chat_message_truncates_oversized_text(monkeypatch):
+    captured: dict = {}
+
+    class _MockAsyncClient:
+        def __init__(self, *, timeout, **kw): pass
+        async def __aenter__(self): return self
+        async def __aexit__(self, *a): pass
+        async def post(self, url, json=None, headers=None):
+            captured["text"] = json["text"]
+            return httpx.Response(200, json={"ok": True})
+
+    monkeypatch.setattr("imperal_sdk.context.httpx.AsyncClient", _MockAsyncClient)
+    ctx = _make_ctx()
+
+    big = "x" * 70000
+    await ctx.deliver_chat_message(big)
+    assert len(captured["text"]) <= 64 * 1024 + len("...(truncated)")
+    assert captured["text"].endswith("...(truncated)")
+
+
+@pytest.mark.asyncio
+async def test_deliver_chat_message_with_refresh_panels(monkeypatch):
+    captured: dict = {}
+
+    class _MockAsyncClient:
+        def __init__(self, *, timeout, **kw): pass
+        async def __aenter__(self): return self
+        async def __aexit__(self, *a): pass
+        async def post(self, url, json=None, headers=None):
+            captured["json"] = json
+            return httpx.Response(200, json={"ok": True})
+
+    monkeypatch.setattr("imperal_sdk.context.httpx.AsyncClient", _MockAsyncClient)
+    ctx = _make_ctx()
+
+    await ctx.deliver_chat_message("Done!", msg_type="tool_result", refresh_panels=["editor"])
+    assert captured["json"]["msg_type"] == "tool_result"
+    assert captured["json"]["refresh_panels"] == ["editor"]

imperal_sdk-4.2.12/tests/test_http_timeout_override.py

@@ -0,0 +1,59 @@
+# tests/test_http_timeout_override.py
+import pytest
+import httpx
+from imperal_sdk.http.client import HTTPClient
+
+
+@pytest.mark.asyncio
+async def test_post_accepts_per_call_timeout_override(monkeypatch):
+    """Component A: timeout= kwarg overrides instance default."""
+    captured: dict = {}
+
+    class _MockAsyncClient:
+        def __init__(self, *, timeout, follow_redirects, max_redirects):
+            captured["timeout"] = timeout
+        async def __aenter__(self): return self
+        async def __aexit__(self, *a): pass
+        async def post(self, url, **kw):
+            return httpx.Response(200, json={"ok": True})
+
+    monkeypatch.setattr("imperal_sdk.http.client.httpx.AsyncClient", _MockAsyncClient)
+    c = HTTPClient(timeout=30)
+    await c.post("https://example.com", timeout=120)
+    assert captured["timeout"] == 120
+
+
+@pytest.mark.asyncio
+async def test_post_default_when_no_override(monkeypatch):
+    """No timeout= kwarg → uses instance default."""
+    captured: dict = {}
+
+    class _MockAsyncClient:
+        def __init__(self, *, timeout, follow_redirects, max_redirects):
+            captured["timeout"] = timeout
+        async def __aenter__(self): return self
+        async def __aexit__(self, *a): pass
+        async def post(self, url, **kw):
+            return httpx.Response(200, json={"ok": True})
+
+    monkeypatch.setattr("imperal_sdk.http.client.httpx.AsyncClient", _MockAsyncClient)
+    c = HTTPClient(timeout=30)
+    await c.post("https://example.com")
+    assert captured["timeout"] == 30
+
+
+@pytest.mark.asyncio
+async def test_post_rejects_over_180s_cap():
+    """Component A: federal cap 180s — anything more raises ValueError."""
+    c = HTTPClient(timeout=30)
+    with pytest.raises(ValueError, match="exceeds federal cap"):
+        await c.post("https://example.com", timeout=300)
+
+
+@pytest.mark.asyncio
+async def test_post_rejects_zero_or_negative_timeout():
+    c = HTTPClient(timeout=30)
+    with pytest.raises(ValueError, match="must be > 0"):
+        await c.post("https://example.com", timeout=0)
+    with pytest.raises(ValueError, match="must be > 0"):
+        await c.post("https://example.com", timeout=-5)

imperal_sdk-4.2.10/src/imperal_sdk/http/client.py

@@ -1,51 +0,0 @@
-# Copyright (c) 2026 Imperal, Inc., Valentin Scerbacov, and contributors
-# Licensed under the AGPL-3.0 License. See LICENSE file for details.
-from __future__ import annotations
-import httpx
-
-from imperal_sdk.types.models import HTTPResponse
-
-
-def _wrap(resp: httpx.Response) -> HTTPResponse:
-    """Convert httpx.Response to typed HTTPResponse."""
-    content_type = resp.headers.get("content-type", "")
-    if "json" in content_type:
-        try:
-            body = resp.json()
-        except Exception:
-            body = resp.text
-    elif resp.content:
-        # Return text for text/* or small responses; bytes otherwise
-        try:
-            body = resp.text
-        except Exception:
-            body = resp.content
-    else:
-        body = ""
-    return HTTPResponse(status_code=resp.status_code, body=body, headers=dict(resp.headers))
-
-
-class HTTPClient:
-    def __init__(self, timeout: int = 30, max_redirects: int = 5):
-        self._timeout = timeout
-        self._max_redirects = max_redirects
-
-    async def get(self, url: str, **kwargs) -> HTTPResponse:
-        async with httpx.AsyncClient(timeout=self._timeout, follow_redirects=True, max_redirects=self._max_redirects) as client:
-            return _wrap(await client.get(url, **kwargs))
-
-    async def post(self, url: str, **kwargs) -> HTTPResponse:
-        async with httpx.AsyncClient(timeout=self._timeout, follow_redirects=True, max_redirects=self._max_redirects) as client:
-            return _wrap(await client.post(url, **kwargs))
-
-    async def put(self, url: str, **kwargs) -> HTTPResponse:
-        async with httpx.AsyncClient(timeout=self._timeout, follow_redirects=True, max_redirects=self._max_redirects) as client:
-            return _wrap(await client.put(url, **kwargs))
-
-    async def patch(self, url: str, **kwargs) -> HTTPResponse:
-        async with httpx.AsyncClient(timeout=self._timeout, follow_redirects=True, max_redirects=self._max_redirects) as client:
-            return _wrap(await client.patch(url, **kwargs))
-
-    async def delete(self, url: str, **kwargs) -> HTTPResponse:
-        async with httpx.AsyncClient(timeout=self._timeout, follow_redirects=True, max_redirects=self._max_redirects) as client:
-            return _wrap(await client.delete(url, **kwargs))