visionai-sdk-python 2.2.0.dev1__tar.gz → 2.2.0.dev2__tar.gz

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/.github/workflows/ci.yml

@@ -14,13 +14,8 @@ permissions:
 
 jobs:
   check:
-    name: Lint, test, and build (Python ${{ matrix.python-version }})
+    name: Lint, test, and build
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        # The oldest supported interpreter and the newest one a consumer runs on.
-        python-version: ["3.11", "3.14"]
     steps:
       - uses: actions/checkout@v4
 
@@ -32,7 +27,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version-file: pyproject.toml
 
       - name: Install locked dependencies
         run: uv sync --locked --all-extras

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visionai-sdk-python
-Version: 2.2.0.dev1
+Version: 2.2.0.dev2
 Summary: VisionAI SDK for Python
 Author-email: Tony Yang <tonyyang@linkervision.com>
 Requires-Python: >=3.11
@@ -146,7 +146,10 @@ cred = ClientCredentials(
 )
 client = Client(auth_url="...", vlm_url="...", credential=cred)   # vlm.chat() uses it
 
-token = cred.get_token().token          # for requests the SDK does not make itself
+token = cred.get_token().token          # for a WebSocket upgrade or another library
+
+# Any other HTTP call with the same token; a 401 gets one fresh token and one retry
+nodes = client.request("GET", "https://vs.example.com/mgmt/nodes").json()
 ```
 
 Platform mints at most 50 tokens per client per month, so the credential protects the

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/README.md

@@ -128,7 +128,10 @@ cred = ClientCredentials(
 )
 client = Client(auth_url="...", vlm_url="...", credential=cred)   # vlm.chat() uses it
 
-token = cred.get_token().token          # for requests the SDK does not make itself
+token = cred.get_token().token          # for a WebSocket upgrade or another library
+
+# Any other HTTP call with the same token; a 401 gets one fresh token and one retry
+nodes = client.request("GET", "https://vs.example.com/mgmt/nodes").json()
 ```
 
 Platform mints at most 50 tokens per client per month, so the credential protects the

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python/_base.py

@@ -85,11 +85,29 @@ class _BaseClient:
         self._credentials: dict | None = None
         self._credentials_type: Literal["login", "client"] | None = None
 
+    @property
+    def credential(self) -> "ClientCredentials | AsyncClientCredentials | None":
+        """The credential this client was built with, for callers that need the
+        raw token themselves (a WebSocket upgrade, another HTTP library)."""
+        return self._credential
+
     @staticmethod
     def _build_url(base_url: str, path: str) -> str:
         """Join a base URL and a path, normalizing slashes."""
         return f"{base_url.rstrip('/')}/{path.lstrip('/')}"
 
+    def _absolute(self, url: str) -> str:
+        """``url`` as given when absolute, else a path under ``auth_url``."""
+        return url if "://" in url else self._build_url(self.auth_url, url)
+
+    def _with_auth(self, kwargs: dict, token: str) -> dict:
+        """``kwargs`` for httpx with the bearer header; the client's token wins."""
+        headers = {
+            **dict(kwargs.get("headers") or {}),
+            **self._build_auth_header(token),
+        }
+        return {**kwargs, "headers": headers}
+
     def _vlm_base(self) -> str:
         if self.vlm_url is None:
             raise ValueError("vlm_url is required for VLM calls; pass it to the client")

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python/async_client.py

@@ -19,7 +19,10 @@ class AsyncClient(_BaseClient):
         max_connections: int = 100,
         max_keepalive_connections: int = 20,
         credential: AsyncClientCredentials | None = None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> None:
+        """See ``_BaseClient``; ``http_client`` is an httpx.AsyncClient to send through
+        (tests, shared pools); the client closes only the one it created."""
         super().__init__(
             auth_url=auth_url,
             vlm_url=vlm_url,
@@ -30,7 +33,7 @@ class AsyncClient(_BaseClient):
             max_keepalive_connections=max_keepalive_connections,
             credential=credential,
         )
-        self._client = httpx.AsyncClient(
+        self._client = http_client or httpx.AsyncClient(
             verify=self.verify_ssl,
             timeout=self.timeout,
             limits=httpx.Limits(
@@ -38,6 +41,7 @@ class AsyncClient(_BaseClient):
                 max_keepalive_connections=self.max_keepalive_connections,
             ),
         )
+        self._owns_http = http_client is None
         # Register the different function resource
         self.auth = AsyncAuthResource(self)
         self.vlm = AsyncVLMResource(self)
@@ -51,9 +55,46 @@ class AsyncClient(_BaseClient):
             raise self._map_transport_error(e) from e
         return self._handle_response(response)
 
+    async def request(self, method: str, url: str, **kwargs) -> httpx.Response:
+        """Send any request with this client's bearer token.
+
+        ``url`` is absolute, or a path under ``auth_url``; ``kwargs`` go to httpx.
+        A 401 buys one fresh token (from ``credential`` or the stored login) and
+        one retry, so a token revoked server-side costs one extra request.
+
+        Raises:
+            AuthenticationError: No token, or the fresh one was refused too.
+            RateLimitedError, NetworkError, ServerError, ClientError: As the
+                resource methods.
+        """
+        url = self._absolute(url)
+        await self._ensure_token()
+        token = self._access_token
+        try:
+            return await self._request(method, url, **self._with_auth(kwargs, token))
+        except AuthenticationError:
+            if not await self._renew_rejected(token):
+                raise
+        return await self._request(
+            method, url, **self._with_auth(kwargs, self._access_token)
+        )
+
+    async def _renew_rejected(self, token: str) -> bool:
+        """A 401 for ``token``: get a different one, once; False when none would help."""
+        if self._credential is not None:
+            if not self._credential.invalidate(token):
+                return False
+            self._access_token = (await self._credential.get_token()).token
+            return True
+        if self._credentials is None or self._access_token != token:
+            return False
+        await self._refresh_token()
+        return self._access_token != token
+
     async def close(self) -> None:
-        """Close the HTTP client and release connections."""
-        await self._client.aclose()
+        """Close the HTTP client this client created and release its connections."""
+        if self._owns_http:
+            await self._client.aclose()
 
     async def __aenter__(self) -> "AsyncClient":
         """Async context manager entry."""

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python/client.py

@@ -19,7 +19,10 @@ class Client(_BaseClient):
         max_connections: int = 100,
         max_keepalive_connections: int = 20,
         credential: ClientCredentials | None = None,
+        http_client: httpx.Client | None = None,
     ) -> None:
+        """See ``_BaseClient``; ``http_client`` is an httpx.Client to send through
+        (tests, shared pools); the client closes only the one it created."""
         super().__init__(
             auth_url=auth_url,
             vlm_url=vlm_url,
@@ -30,7 +33,7 @@ class Client(_BaseClient):
             max_keepalive_connections=max_keepalive_connections,
             credential=credential,
         )
-        self._client = httpx.Client(
+        self._client = http_client or httpx.Client(
             verify=self.verify_ssl,
             timeout=self.timeout,
             limits=httpx.Limits(
@@ -38,6 +41,7 @@ class Client(_BaseClient):
                 max_keepalive_connections=self.max_keepalive_connections,
             ),
         )
+        self._owns_http = http_client is None
         # Register the different function resource
         self.auth = AuthResource(self)
         self.vlm = VLMResource(self)
@@ -51,9 +55,44 @@ class Client(_BaseClient):
             raise self._map_transport_error(e) from e
         return self._handle_response(response)
 
+    def request(self, method: str, url: str, **kwargs) -> httpx.Response:
+        """Send any request with this client's bearer token.
+
+        ``url`` is absolute, or a path under ``auth_url``; ``kwargs`` go to httpx.
+        A 401 buys one fresh token (from ``credential`` or the stored login) and
+        one retry, so a token revoked server-side costs one extra request.
+
+        Raises:
+            AuthenticationError: No token, or the fresh one was refused too.
+            RateLimitedError, NetworkError, ServerError, ClientError: As the
+                resource methods.
+        """
+        url = self._absolute(url)
+        self._ensure_token()
+        token = self._access_token
+        try:
+            return self._request(method, url, **self._with_auth(kwargs, token))
+        except AuthenticationError:
+            if not self._renew_rejected(token):
+                raise
+        return self._request(method, url, **self._with_auth(kwargs, self._access_token))
+
+    def _renew_rejected(self, token: str) -> bool:
+        """A 401 for ``token``: get a different one, once; False when none would help."""
+        if self._credential is not None:
+            if not self._credential.invalidate(token):
+                return False
+            self._access_token = self._credential.get_token().token
+            return True
+        if self._credentials is None or self._access_token != token:
+            return False
+        self._refresh_token()
+        return self._access_token != token
+
     def close(self) -> None:
-        """Close the HTTP client and release connections."""
-        self._client.close()
+        """Close the HTTP client this client created and release its connections."""
+        if self._owns_http:
+            self._client.close()
 
     def __enter__(self) -> "Client":
         """Context manager entry."""

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python/vlm/async_resource.py

@@ -28,8 +28,8 @@ class AsyncVLMResource(VLMMixin):
     ) -> ResponseNormalModel | ResponseErrorModel:
         """Submit an inference request to the VLM service.
 
-        Uses the internally stored access token obtained from login() or get_access_token().
-        If the token is expiring soon, it will be automatically refreshed.
+        Sent with the client's token (``credential``, ``login()`` or ``get_access_token()``);
+        a 401 gets one fresh token and one retry.
 
         Args:
             payload: Inference parameters as a NIMRequestModel instance or a dict
@@ -45,17 +45,13 @@ class AsyncVLMResource(VLMMixin):
             NetworkError: If the request times out or a network error occurs.
             VisionaiSDKError: If the request fails for any other reason.
         """
-        # Ensure token is valid
-        await self._sdk_client._ensure_token()
-
         # Prepare request (from Mixin)
         body = self._prepare_chat_request(payload)
 
-        # I/O operation (async)
-        response = await self._sdk_client._request(
+        # I/O operation (async); the client adds the token and retries once on 401
+        response = await self._sdk_client.request(
             "POST",
             self._sdk_client._build_url(self._sdk_client._vlm_base(), VLMEndpoint.CHAT),
-            headers=self._sdk_client._build_auth_header(self._sdk_client._access_token),
             json=body,
         )
 
@@ -67,8 +63,8 @@ class AsyncVLMResource(VLMMixin):
     ) -> ResponseNormalModel | ResponseErrorModel:
         """Poll the result of a previously submitted inference request.
 
-        Uses the internally stored access token obtained from login() or get_access_token().
-        If the token is expiring soon, it will be automatically refreshed.
+        Sent with the client's token (``credential``, ``login()`` or ``get_access_token()``);
+        a 401 gets one fresh token and one retry.
 
         Args:
             result_id: Chat result ID returned from a prior chat() call.
@@ -82,16 +78,12 @@ class AsyncVLMResource(VLMMixin):
             NetworkError: If the request times out or a network error occurs.
             VisionaiSDKError: If the request fails for any other reason.
         """
-        # Ensure token is valid
-        await self._sdk_client._ensure_token()
-
-        # I/O operation (async)
-        response = await self._sdk_client._request(
+        # I/O operation (async); the client adds the token and retries once on 401
+        response = await self._sdk_client.request(
             "GET",
             self._sdk_client._build_url(
                 self._sdk_client._vlm_base(), f"{VLMEndpoint.CHAT}/{result_id}"
             ),
-            headers=self._sdk_client._build_auth_header(self._sdk_client._access_token),
         )
 
         # Parse response (from Mixin)

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python/vlm/resource.py

@@ -28,8 +28,8 @@ class VLMResource(VLMMixin):
     ) -> ResponseNormalModel | ResponseErrorModel:
         """Submit an inference request to the VLM service.
 
-        Uses the internally stored access token obtained from login() or get_access_token().
-        If the token is expiring soon, it will be automatically refreshed.
+        Sent with the client's token (``credential``, ``login()`` or ``get_access_token()``);
+        a 401 gets one fresh token and one retry.
 
         Args:
             payload: Inference parameters as a NIMRequestModel instance or a dict
@@ -45,17 +45,13 @@ class VLMResource(VLMMixin):
             NetworkError: If the request times out or a network error occurs.
             VisionaiSDKError: If the request fails for any other reason.
         """
-        # Ensure token is valid
-        self._sdk_client._ensure_token()
-
         # Prepare request (from Mixin)
         body = self._prepare_chat_request(payload)
 
-        # I/O operation (sync)
-        response = self._sdk_client._request(
+        # I/O operation (sync); the client adds the token and retries once on 401
+        response = self._sdk_client.request(
             "POST",
             self._sdk_client._build_url(self._sdk_client._vlm_base(), VLMEndpoint.CHAT),
-            headers=self._sdk_client._build_auth_header(self._sdk_client._access_token),
             json=body,
         )
 
@@ -65,8 +61,8 @@ class VLMResource(VLMMixin):
     def get_chat(self, result_id: str) -> ResponseNormalModel | ResponseErrorModel:
         """Poll the result of a previously submitted inference request.
 
-        Uses the internally stored access token obtained from login() or get_access_token().
-        If the token is expiring soon, it will be automatically refreshed.
+        Sent with the client's token (``credential``, ``login()`` or ``get_access_token()``);
+        a 401 gets one fresh token and one retry.
 
         Args:
             result_id: Chat result ID returned from a prior chat() call.
@@ -80,16 +76,12 @@ class VLMResource(VLMMixin):
             NetworkError: If the request times out or a network error occurs.
             VisionaiSDKError: If the request fails for any other reason.
         """
-        # Ensure token is valid
-        self._sdk_client._ensure_token()
-
-        # I/O operation (sync)
-        response = self._sdk_client._request(
+        # I/O operation (sync); the client adds the token and retries once on 401
+        response = self._sdk_client.request(
             "GET",
             self._sdk_client._build_url(
                 self._sdk_client._vlm_base(), f"{VLMEndpoint.CHAT}/{result_id}"
             ),
-            headers=self._sdk_client._build_auth_header(self._sdk_client._access_token),
         )
 
         # Parse response (from Mixin)

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visionai-sdk-python
-Version: 2.2.0.dev1
+Version: 2.2.0.dev2
 Summary: VisionAI SDK for Python
 Author-email: Tony Yang <tonyyang@linkervision.com>
 Requires-Python: >=3.11
@@ -146,7 +146,10 @@ cred = ClientCredentials(
 )
 client = Client(auth_url="...", vlm_url="...", credential=cred)   # vlm.chat() uses it
 
-token = cred.get_token().token          # for requests the SDK does not make itself
+token = cred.get_token().token          # for a WebSocket upgrade or another library
+
+# Any other HTTP call with the same token; a 401 gets one fresh token and one retry
+nodes = client.request("GET", "https://vs.example.com/mgmt/nodes").json()
 ```
 
 Platform mints at most 50 tokens per client per month, so the credential protects the

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python.egg-info/SOURCES.txt

@@ -43,4 +43,5 @@ tests/test_async_client.py
 tests/test_client.py
 tests/test_credentials.py
 tests/test_instrumentation.py
+tests/test_request.py
 tests/test_vlm_preprocess.py

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python.egg-info/scm_file_list.json

@@ -37,6 +37,7 @@
     "tests/test_client.py",
     "tests/test_credentials.py",
     "tests/test_instrumentation.py",
+    "tests/test_request.py",
     "tests/test_vlm_preprocess.py",
     "uv.lock"
   ]

{visionai_sdk_python-2.2.0.dev1 → visionai_sdk_python-2.2.0.dev2}/src/visionai_sdk_python.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "2.2.0.dev1",
+  "tag": "2.2.0.dev2",
   "distance": 0,
-  "node": "gb0c172d368ada597a6ac62fde2d1f71ba0faed72",
+  "node": "gac5a00feaebf548247cbea098aac2ae47e15c87a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-20"

visionai_sdk_python-2.2.0.dev2/tests/test_request.py

@@ -0,0 +1,218 @@
+"""``client.request()``: any URL with the client's token, one fresh token on 401."""
+
+import httpx
+import pytest
+
+from tests.constants import (
+    AUTH_URL,
+    NORMAL_COMPLETED_RESPONSE,
+    TOKEN_PAYLOAD,
+    VALID_NIM_PAYLOAD,
+    VLM_URL,
+)
+from visionai_sdk_python import (
+    AsyncClient,
+    AsyncClientCredentials,
+    Client,
+    ClientCredentials,
+)
+from visionai_sdk_python.exceptions import AuthenticationError
+from visionai_sdk_python.vlm.models import ResponseNormalModel
+
+NODES = "https://vs.example.com/mgmt/nodes"
+
+
+class FakeWorld:
+    """Platform (mint, login) and token-checking services behind one handler."""
+
+    def __init__(self) -> None:
+        self.minted = 0
+        self.logins = 0
+        self.rejected: set[str] = set()
+        self.calls: list[httpx.Request] = []
+
+    def handler(self, request: httpx.Request) -> httpx.Response:
+        path = request.url.path
+        if path == "/api/users/client-token":
+            self.minted += 1
+            token = f"tok-{self.minted}"
+            return httpx.Response(200, json={**TOKEN_PAYLOAD, "access_token": token})
+        if path == "/api/users/jwt":
+            self.logins += 1
+            token = f"login-{self.logins}"
+            return httpx.Response(200, json={**TOKEN_PAYLOAD, "access_token": token})
+        self.calls.append(request)
+        token = request.headers.get("authorization", "").removeprefix("Bearer ")
+        if not token or token in self.rejected:
+            return httpx.Response(401, json={"detail": "invalid token"})
+        if path == "/api/chat":
+            return httpx.Response(200, json=NORMAL_COMPLETED_RESPONSE)
+        return httpx.Response(200, json={"path": path})
+
+    def tokens_sent(self) -> list[str]:
+        return [
+            r.headers.get("authorization", "").removeprefix("Bearer ")
+            for r in self.calls
+        ]
+
+
+@pytest.fixture
+def world() -> FakeWorld:
+    return FakeWorld()
+
+
+@pytest.fixture
+def transport(world) -> httpx.MockTransport:
+    return httpx.MockTransport(world.handler)
+
+
+@pytest.fixture
+def client(transport) -> AsyncClient:
+    cred = AsyncClientCredentials(
+        AUTH_URL, "cid", "secret", http=httpx.AsyncClient(transport=transport)
+    )
+    return AsyncClient(
+        AUTH_URL,
+        VLM_URL,
+        credential=cred,
+        http_client=httpx.AsyncClient(transport=transport),
+    )
+
+
+@pytest.fixture
+def sync_client(transport) -> Client:
+    cred = ClientCredentials(
+        AUTH_URL, "cid", "secret", http=httpx.Client(transport=transport)
+    )
+    return Client(
+        AUTH_URL,
+        VLM_URL,
+        credential=cred,
+        http_client=httpx.Client(transport=transport),
+    )
+
+
+async def test_an_injected_http_client_is_used_and_not_closed(transport):
+    http = httpx.AsyncClient(transport=transport)
+    async with AsyncClient(AUTH_URL, http_client=http) as client:
+        assert client._client is http
+    assert not http.is_closed
+
+    owned = AsyncClient(AUTH_URL)
+    await owned.close()
+    assert owned._client.is_closed
+
+
+def test_the_credential_is_reachable_for_callers_that_need_the_raw_token(client):
+    assert isinstance(client.credential, AsyncClientCredentials)
+    assert AsyncClient(AUTH_URL).credential is None
+
+
+async def test_request_sends_the_token_to_any_url(world, client):
+    response = await client.request("GET", NODES)
+
+    assert response.status_code == 200
+    assert world.tokens_sent() == ["tok-1"]
+    assert str(world.calls[0].url) == NODES
+
+
+async def test_request_joins_a_path_onto_auth_url(world, client):
+    await client.request("GET", "/api/anything")
+
+    assert str(world.calls[0].url) == f"{AUTH_URL}/api/anything"
+
+
+async def test_request_keeps_caller_headers_but_uses_the_clients_token(world, client):
+    await client.request(
+        "GET",
+        NODES,
+        headers={"X-Request-Source": "agent", "Authorization": "Bearer nope"},
+    )
+
+    (call,) = world.calls
+    assert call.headers["x-request-source"] == "agent"
+    assert call.headers["authorization"] == "Bearer tok-1"
+
+
+async def test_request_retries_once_with_a_fresh_token_after_a_401(world, client):
+    world.rejected = {"tok-1"}
+
+    response = await client.request("GET", NODES)
+
+    assert response.status_code == 200
+    assert world.tokens_sent() == ["tok-1", "tok-2"]
+    assert world.minted == 2
+
+
+async def test_request_does_not_mint_a_third_token_when_the_replacement_is_rejected(
+    world, client
+):
+    world.rejected = {"tok-1", "tok-2"}
+
+    for _ in range(3):
+        with pytest.raises(AuthenticationError):
+            await client.request("GET", NODES)
+
+    assert world.minted == 2
+    assert world.tokens_sent() == ["tok-1", "tok-2", "tok-2", "tok-2"]
+
+
+async def test_request_after_login_logs_in_again_once_on_401(world, transport):
+    client = AsyncClient(
+        AUTH_URL, VLM_URL, http_client=httpx.AsyncClient(transport=transport)
+    )
+    await client.auth.login("user@example.com", "password")
+    world.rejected = {"login-1"}
+
+    response = await client.request("GET", NODES)
+
+    assert response.status_code == 200
+    assert world.logins == 2
+    assert world.tokens_sent() == ["login-1", "login-2"]
+
+
+async def test_request_with_an_injected_token_and_no_credentials_raises_on_401(
+    world, transport
+):
+    # Dataverse's path: a token it minted itself, nothing to refresh with.
+    client = AsyncClient(
+        AUTH_URL, VLM_URL, http_client=httpx.AsyncClient(transport=transport)
+    )
+    client._store_token("fixed", expires_in=3600)
+    world.rejected = {"fixed"}
+
+    with pytest.raises(AuthenticationError):
+        await client.request("GET", NODES)
+
+    assert world.tokens_sent() == ["fixed"]
+    assert world.minted == 0
+
+
+async def test_chat_gets_one_fresh_token_on_401(world, client):
+    world.rejected = {"tok-1"}
+
+    result = await client.vlm.chat(VALID_NIM_PAYLOAD)
+
+    assert isinstance(result, ResponseNormalModel)
+    assert result.status == "completed"
+    assert world.tokens_sent() == ["tok-1", "tok-2"]
+
+
+def test_sync_request_sends_the_token_and_retries_once(world, sync_client):
+    world.rejected = {"tok-1"}
+
+    response = sync_client.request("GET", NODES)
+
+    assert response.status_code == 200
+    assert world.tokens_sent() == ["tok-1", "tok-2"]
+
+
+def test_sync_request_keeps_a_rejected_replacement(world, sync_client):
+    world.rejected = {"tok-1", "tok-2"}
+
+    with pytest.raises(AuthenticationError):
+        sync_client.request("GET", NODES)
+    with pytest.raises(AuthenticationError):
+        sync_client.vlm.chat(VALID_NIM_PAYLOAD)
+
+    assert world.minted == 2