solari-sdk 0.1.0__tar.gz

solari_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brandazine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

solari_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: solari-sdk
+Version: 0.1.0
+Summary: Python client for the SOLARI API — creator and brand intelligence across Instagram and TikTok.
+License-Expression: MIT
+Project-URL: Homepage, https://solari.sh
+Project-URL: Documentation, https://solari.sh/api
+Keywords: solari,brandazine,instagram,tiktok,creator,influencer,brand,sdk,api-client
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# solari-sdk
+
+Python client for the [SOLARI API](https://solari.sh/api) — creator and brand intelligence across Instagram and TikTok. Standard library only; Python 3.9+.
+
+```
+pip install solari-sdk
+```
+
+## Quickstart
+
+```python
+from solari_sdk import Solari
+
+solari = Solari()  # reads SOLARI_TOKEN; or Solari(token="...")
+
+hits = solari.tools.catalog.instagram.account.search(query="nike", limit=3)
+brand = solari.call("solari_insight_instagram_brand_overview", username="nike")
+tools = solari.list_tools()
+```
+
+Get a token with `solari auth token` on a machine that is signed in to the [solari CLI](https://solari.sh/docs), or use a token you already hold from an MCP connector.
+
+## API
+
+- `Solari(token=None, base_url="https://solari.sh", timeout=150, user_agent=None, transport=None)`
+- `list_tools()` — every tool the signed-in account can call, with its JSON input schema.
+- `get_tool(name)` — one tool.
+- `call(name, arguments=None, **kwargs)` — run a tool and get its JSON payload back.
+- `tools.<family>.<platform>.<group>.<name>(**kwargs)` — the same call spelled as a path; segments join with `_` under the `solari_` prefix.
+- `me()` — the identity behind the token.
+
+Errors raise `SolariError` with `status`, `code`, `message`, `tool`, `retry_after_seconds`, and a `retryable` property (429, 502, 503, 504).
+
+## Development
+
+```
+python3 -m unittest discover -s tests -v
+```

solari_sdk-0.1.0/README.md

@@ -0,0 +1,38 @@
+# solari-sdk
+
+Python client for the [SOLARI API](https://solari.sh/api) — creator and brand intelligence across Instagram and TikTok. Standard library only; Python 3.9+.
+
+```
+pip install solari-sdk
+```
+
+## Quickstart
+
+```python
+from solari_sdk import Solari
+
+solari = Solari()  # reads SOLARI_TOKEN; or Solari(token="...")
+
+hits = solari.tools.catalog.instagram.account.search(query="nike", limit=3)
+brand = solari.call("solari_insight_instagram_brand_overview", username="nike")
+tools = solari.list_tools()
+```
+
+Get a token with `solari auth token` on a machine that is signed in to the [solari CLI](https://solari.sh/docs), or use a token you already hold from an MCP connector.
+
+## API
+
+- `Solari(token=None, base_url="https://solari.sh", timeout=150, user_agent=None, transport=None)`
+- `list_tools()` — every tool the signed-in account can call, with its JSON input schema.
+- `get_tool(name)` — one tool.
+- `call(name, arguments=None, **kwargs)` — run a tool and get its JSON payload back.
+- `tools.<family>.<platform>.<group>.<name>(**kwargs)` — the same call spelled as a path; segments join with `_` under the `solari_` prefix.
+- `me()` — the identity behind the token.
+
+Errors raise `SolariError` with `status`, `code`, `message`, `tool`, `retry_after_seconds`, and a `retryable` property (429, 502, 503, 504).
+
+## Development
+
+```
+python3 -m unittest discover -s tests -v
+```

solari_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "solari-sdk"
+version = "0.1.0"
+description = "Python client for the SOLARI API — creator and brand intelligence across Instagram and TikTok."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+dependencies = []
+keywords = ["solari", "brandazine", "instagram", "tiktok", "creator", "influencer", "brand", "sdk", "api-client"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://solari.sh"
+Documentation = "https://solari.sh/api"
+
+[tool.setuptools.packages.find]
+include = ["solari_sdk*"]
+
+[tool.setuptools.package-data]
+solari_sdk = ["py.typed"]

solari_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

solari_sdk-0.1.0/solari_sdk/__init__.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import socket
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Callable, Mapping, Optional
+
+__all__ = ["Solari", "SolariError", "ToolPath", "DEFAULT_BASE_URL", "API_PREFIX", "SDK_VERSION", "TOKEN_ENV"]
+
+DEFAULT_BASE_URL = "https://solari.sh"
+API_PREFIX = "/mcp/api/v1"
+SDK_VERSION = "0.1.0"
+TOKEN_ENV = "SOLARI_TOKEN"
+DEFAULT_TIMEOUT_SECONDS = 150.0
+
+Transport = Callable[[str, str, Mapping[str, str], Optional[bytes], float], "TransportResponse"]
+
+logger = logging.getLogger("solari_sdk")
+
+
+class TransportResponse:
+    __slots__ = ("status", "headers", "body")
+
+    def __init__(self, status: int, headers: Mapping[str, str], body: bytes) -> None:
+        self.status = status
+        self.headers = {key.lower(): value for key, value in headers.items()}
+        self.body = body
+
+
+class SolariError(Exception):
+    def __init__(
+        self,
+        status: int,
+        code: str,
+        message: str,
+        tool: Optional[str] = None,
+        retry_after_seconds: Optional[int] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.message = message
+        self.tool = tool
+        self.retry_after_seconds = retry_after_seconds
+
+    @property
+    def retryable(self) -> bool:
+        return self.status in (429, 502, 503, 504)
+
+    def __repr__(self) -> str:
+        return f"SolariError(status={self.status}, code={self.code!r}, message={self.message!r}, tool={self.tool!r})"
+
+
+def normalize_base_url(raw: str) -> str:
+    trimmed = raw.strip().rstrip("/")
+    if not trimmed.lower().startswith(("http://", "https://")):
+        trimmed = f"https://{trimmed}"
+    parsed = urllib.parse.urlsplit(trimmed)
+    path = parsed.path.rstrip("/")
+    if path.endswith(API_PREFIX):
+        path = path[: -len(API_PREFIX)]
+    return f"{parsed.scheme}://{parsed.netloc}{path}"
+
+
+def tool_name(segments: list[str]) -> str:
+    parts = [segment.strip() for segment in segments if segment.strip()]
+    if not parts:
+        raise SolariError(0, "invalid_tool_path", "a tool path needs at least one segment")
+    joined = "_".join(parts)
+    if joined == "solari" or joined.startswith("solari_"):
+        return joined
+    return "solari_" + joined
+
+
+def _urllib_transport(method: str, url: str, headers: Mapping[str, str], body: Optional[bytes], timeout: float) -> TransportResponse:
+    request = urllib.request.Request(url, data=body, method=method, headers=dict(headers))
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return TransportResponse(response.status, dict(response.headers.items()), response.read())
+    except urllib.error.HTTPError as error:
+        return TransportResponse(error.code, dict(error.headers.items()), error.read())
+
+
+def _parse_error(response: TransportResponse) -> tuple[str, str, Optional[str]]:
+    fallback = (f"http_{response.status}", f"SOLARI API returned HTTP {response.status}", None)
+    text = response.body.decode("utf-8", errors="replace") if response.body else ""
+    if not text:
+        return fallback
+    try:
+        parsed = json.loads(text)
+    except ValueError:
+        return (fallback[0], text[:300], None)
+    if isinstance(parsed, dict):
+        error = parsed.get("error")
+        if isinstance(error, dict):
+            code = error.get("code") if isinstance(error.get("code"), str) else fallback[0]
+            message = error.get("message") if isinstance(error.get("message"), str) else fallback[1]
+            tool = error.get("tool") if isinstance(error.get("tool"), str) else None
+            return (code, message, tool)
+        description = parsed.get("error_description")
+        if isinstance(description, str):
+            code = error if isinstance(error, str) else fallback[0]
+            return (code, description, None)
+    return fallback
+
+
+class ToolPath:
+    __slots__ = ("_client", "_segments")
+
+    def __init__(self, client: "Solari", segments: list[str]) -> None:
+        self._client = client
+        self._segments = segments
+
+    def __getattr__(self, segment: str) -> "ToolPath":
+        if segment.startswith("_"):
+            raise AttributeError(segment)
+        return ToolPath(self._client, [*self._segments, segment])
+
+    def __call__(self, arguments: Optional[Mapping[str, Any]] = None, **kwargs: Any) -> Any:
+        merged: dict[str, Any] = dict(arguments or {})
+        merged.update(kwargs)
+        return self._client.call(tool_name(self._segments), merged)
+
+    @property
+    def tool_name(self) -> str:
+        return tool_name(self._segments)
+
+
+class Solari:
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT_SECONDS,
+        user_agent: Optional[str] = None,
+        transport: Optional[Transport] = None,
+    ) -> None:
+        resolved = (token or os.environ.get(TOKEN_ENV, "")).strip()
+        if not resolved:
+            raise SolariError(
+                0,
+                "missing_token",
+                f'no access token: pass token= or set {TOKEN_ENV} (mint one with "solari auth token")',
+            )
+        self._token = resolved
+        self.base_url = normalize_base_url(base_url)
+        self.timeout = timeout
+        self.user_agent = user_agent or f"solari-sdk-python/{SDK_VERSION}"
+        self._transport = transport or _urllib_transport
+        self.tools = ToolPath(self, [])
+
+    def list_tools(self) -> list[dict[str, Any]]:
+        body = self._request("GET", f"{API_PREFIX}/tools")
+        tools = body.get("tools") if isinstance(body, dict) else None
+        return list(tools) if isinstance(tools, list) else []
+
+    def get_tool(self, name: str) -> dict[str, Any]:
+        body = self._request("GET", f"{API_PREFIX}/tools/{urllib.parse.quote(name, safe='')}")
+        return body if isinstance(body, dict) else {}
+
+    def call(self, name: str, arguments: Optional[Mapping[str, Any]] = None, **kwargs: Any) -> Any:
+        merged: dict[str, Any] = dict(arguments or {})
+        merged.update(kwargs)
+        return self._request("POST", f"{API_PREFIX}/tools/{urllib.parse.quote(name, safe='')}", merged)
+
+    def me(self) -> dict[str, Any]:
+        body = self._request("GET", f"{API_PREFIX}/me")
+        return body if isinstance(body, dict) else {}
+
+    def _request(self, method: str, path: str, body: Optional[Mapping[str, Any]] = None) -> Any:
+        headers = {
+            "Authorization": f"Bearer {self._token}",
+            "Accept": "application/json",
+            "User-Agent": self.user_agent,
+        }
+        payload: Optional[bytes] = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            payload = json.dumps(dict(body)).encode("utf-8")
+        url = f"{self.base_url}{path}"
+        logger.debug("event=solari_request method=%s path=%s", method, path)
+        try:
+            response = self._transport(method, url, headers, payload, self.timeout)
+        except urllib.error.URLError as error:
+            reason = getattr(error, "reason", error)
+            timed_out = isinstance(reason, TimeoutError) or "timed out" in str(reason).lower()
+            raise SolariError(
+                0,
+                "timeout" if timed_out else "network_error",
+                f"SOLARI API did not answer within {int(self.timeout)}s" if timed_out else f"could not reach SOLARI API: {reason}",
+            ) from error
+        except (TimeoutError, socket.timeout) as error:
+            raise SolariError(0, "timeout", f"SOLARI API did not answer within {int(self.timeout)}s") from error
+        logger.debug("event=solari_response method=%s path=%s status=%s", method, path, response.status)
+        if response.status < 200 or response.status >= 300:
+            code, message, tool = _parse_error(response)
+            retry_after: Optional[int] = None
+            raw_retry = response.headers.get("retry-after")
+            if raw_retry and raw_retry.isdigit():
+                retry_after = int(raw_retry)
+            raise SolariError(response.status, code, message, tool, retry_after)
+        if not response.body:
+            return None
+        try:
+            return json.loads(response.body.decode("utf-8"))
+        except ValueError as error:
+            raise SolariError(response.status, "invalid_response", "SOLARI API returned non-JSON") from error

solari_sdk-0.1.0/solari_sdk.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: solari-sdk
+Version: 0.1.0
+Summary: Python client for the SOLARI API — creator and brand intelligence across Instagram and TikTok.
+License-Expression: MIT
+Project-URL: Homepage, https://solari.sh
+Project-URL: Documentation, https://solari.sh/api
+Keywords: solari,brandazine,instagram,tiktok,creator,influencer,brand,sdk,api-client
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# solari-sdk
+
+Python client for the [SOLARI API](https://solari.sh/api) — creator and brand intelligence across Instagram and TikTok. Standard library only; Python 3.9+.
+
+```
+pip install solari-sdk
+```
+
+## Quickstart
+
+```python
+from solari_sdk import Solari
+
+solari = Solari()  # reads SOLARI_TOKEN; or Solari(token="...")
+
+hits = solari.tools.catalog.instagram.account.search(query="nike", limit=3)
+brand = solari.call("solari_insight_instagram_brand_overview", username="nike")
+tools = solari.list_tools()
+```
+
+Get a token with `solari auth token` on a machine that is signed in to the [solari CLI](https://solari.sh/docs), or use a token you already hold from an MCP connector.
+
+## API
+
+- `Solari(token=None, base_url="https://solari.sh", timeout=150, user_agent=None, transport=None)`
+- `list_tools()` — every tool the signed-in account can call, with its JSON input schema.
+- `get_tool(name)` — one tool.
+- `call(name, arguments=None, **kwargs)` — run a tool and get its JSON payload back.
+- `tools.<family>.<platform>.<group>.<name>(**kwargs)` — the same call spelled as a path; segments join with `_` under the `solari_` prefix.
+- `me()` — the identity behind the token.
+
+Errors raise `SolariError` with `status`, `code`, `message`, `tool`, `retry_after_seconds`, and a `retryable` property (429, 502, 503, 504).
+
+## Development
+
+```
+python3 -m unittest discover -s tests -v
+```

solari_sdk-0.1.0/solari_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+solari_sdk/__init__.py
+solari_sdk/py.typed
+solari_sdk.egg-info/PKG-INFO
+solari_sdk.egg-info/SOURCES.txt
+solari_sdk.egg-info/dependency_links.txt
+solari_sdk.egg-info/top_level.txt
+tests/test_client.py

solari_sdk-0.1.0/solari_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

solari_sdk-0.1.0/solari_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+solari_sdk

solari_sdk-0.1.0/tests/test_client.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import json
+import os
+import unittest
+import urllib.error
+from typing import Any, Mapping, Optional
+
+from solari_sdk import TOKEN_ENV, Solari, SolariError, TransportResponse, normalize_base_url, tool_name
+
+
+class Recorder:
+    def __init__(self, responder):
+        self.calls: list[dict[str, Any]] = []
+        self._responder = responder
+
+    def __call__(self, method: str, url: str, headers: Mapping[str, str], body: Optional[bytes], timeout: float) -> TransportResponse:
+        call = {"method": method, "url": url, "headers": dict(headers), "body": body, "timeout": timeout}
+        self.calls.append(call)
+        return self._responder(call)
+
+
+def json_response(payload: Any, status: int = 200, headers: Optional[dict[str, str]] = None) -> TransportResponse:
+    return TransportResponse(status, {"content-type": "application/json", **(headers or {})}, json.dumps(payload).encode("utf-8"))
+
+
+class ConstructionTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self._saved = os.environ.pop(TOKEN_ENV, None)
+
+    def tearDown(self) -> None:
+        if self._saved is None:
+            os.environ.pop(TOKEN_ENV, None)
+        else:
+            os.environ[TOKEN_ENV] = self._saved
+
+    def test_requires_a_token_from_argument_or_environment(self) -> None:
+        with self.assertRaises(SolariError) as raised:
+            Solari()
+        self.assertEqual(raised.exception.code, "missing_token")
+        os.environ[TOKEN_ENV] = "env-token"
+        self.assertEqual(Solari().base_url, "https://solari.sh")
+
+    def test_normalizes_the_base_url(self) -> None:
+        self.assertEqual(normalize_base_url("https://solari.sh/"), "https://solari.sh")
+        self.assertEqual(normalize_base_url("solari.sh"), "https://solari.sh")
+        self.assertEqual(normalize_base_url("https://solari.sh/mcp/api/v1"), "https://solari.sh")
+        self.assertEqual(normalize_base_url("http://localhost:8787/"), "http://localhost:8787")
+
+    def test_builds_tool_names_from_segments(self) -> None:
+        self.assertEqual(tool_name(["catalog", "instagram", "account", "search"]), "solari_catalog_instagram_account_search")
+        self.assertEqual(tool_name(["solari_insight_instagram_brand_overview"]), "solari_insight_instagram_brand_overview")
+        with self.assertRaises(SolariError):
+            tool_name([])
+
+
+class RequestTests(unittest.TestCase):
+    def test_lists_tools_with_bearer_and_user_agent(self) -> None:
+        transport = Recorder(lambda call: json_response({"tools": [{"name": "solari_catalog_instagram_account_search"}]}))
+        client = Solari(token="tok", transport=transport)
+
+        tools = client.list_tools()
+
+        self.assertEqual([tool["name"] for tool in tools], ["solari_catalog_instagram_account_search"])
+        call = transport.calls[0]
+        self.assertEqual(call["url"], "https://solari.sh/mcp/api/v1/tools")
+        self.assertEqual(call["headers"]["Authorization"], "Bearer tok")
+        self.assertIn("solari-sdk-python/", call["headers"]["User-Agent"])
+        self.assertIsNone(call["body"])
+
+    def test_calls_a_tool_with_a_json_body(self) -> None:
+        transport = Recorder(lambda call: json_response({"found": True, "items": [{"username": "nike"}]}))
+        client = Solari(token="tok", base_url="https://example.test/", transport=transport)
+
+        result = client.call("solari_catalog_instagram_account_search", {"query": "nike"}, limit=3)
+
+        self.assertTrue(result["found"])
+        call = transport.calls[0]
+        self.assertEqual(call["method"], "POST")
+        self.assertEqual(call["url"], "https://example.test/mcp/api/v1/tools/solari_catalog_instagram_account_search")
+        self.assertEqual(call["headers"]["Content-Type"], "application/json")
+        self.assertEqual(json.loads(call["body"]), {"query": "nike", "limit": 3})
+
+    def test_tools_proxy_turns_attribute_path_into_a_call(self) -> None:
+        transport = Recorder(lambda call: json_response({"items": []}))
+        client = Solari(token="tok", transport=transport)
+
+        client.tools.catalog.instagram.account.search(query="nike", limit=3)
+        client.tools.insight.instagram.brand.overview()
+
+        names = [call["url"].split("/tools/")[1] for call in transport.calls]
+        self.assertEqual(names, ["solari_catalog_instagram_account_search", "solari_insight_instagram_brand_overview"])
+        self.assertEqual(json.loads(transport.calls[1]["body"]), {})
+        self.assertEqual(client.tools.fetch.tiktok.account.tool_name, "solari_fetch_tiktok_account")
+
+    def test_get_tool_and_me(self) -> None:
+        def responder(call: dict[str, Any]) -> TransportResponse:
+            if call["url"].endswith("/me"):
+                return json_response({"sub": "abc", "email": "a@b.c"})
+            return json_response({"name": "solari_fetch_instagram_account"})
+
+        transport = Recorder(responder)
+        client = Solari(token="tok", transport=transport)
+
+        self.assertEqual(client.get_tool("solari_fetch_instagram_account")["name"], "solari_fetch_instagram_account")
+        self.assertEqual(client.me()["sub"], "abc")
+        self.assertEqual(transport.calls[0]["url"], "https://solari.sh/mcp/api/v1/tools/solari_fetch_instagram_account")
+
+
+class ErrorTests(unittest.TestCase):
+    def test_surfaces_the_api_error_envelope(self) -> None:
+        transport = Recorder(
+            lambda call: json_response(
+                {"error": {"code": "rate_limited", "message": "rate limited, retry shortly", "tool": "solari_x"}},
+                status=429,
+                headers={"retry-after": "7"},
+            )
+        )
+        client = Solari(token="tok", transport=transport)
+
+        with self.assertRaises(SolariError) as raised:
+            client.call("solari_x")
+
+        error = raised.exception
+        self.assertEqual(error.status, 429)
+        self.assertEqual(error.code, "rate_limited")
+        self.assertEqual(error.tool, "solari_x")
+        self.assertEqual(error.retry_after_seconds, 7)
+        self.assertTrue(error.retryable)
+
+    def test_maps_oauth_layer_and_plain_failures(self) -> None:
+        oauth = Recorder(lambda call: json_response({"error": "invalid_token", "error_description": "Invalid access token"}, status=401))
+        with self.assertRaises(SolariError) as raised:
+            Solari(token="tok", transport=oauth).list_tools()
+        self.assertEqual((raised.exception.status, raised.exception.code), (401, "invalid_token"))
+
+        plain = Recorder(lambda call: TransportResponse(500, {}, b"boom"))
+        with self.assertRaises(SolariError) as raised_plain:
+            Solari(token="tok", transport=plain).list_tools()
+        self.assertEqual((raised_plain.exception.status, raised_plain.exception.code, raised_plain.exception.message), (500, "http_500", "boom"))
+
+    def test_wraps_network_failures(self) -> None:
+        def failing(method, url, headers, body, timeout):
+            raise urllib.error.URLError("connection refused")
+
+        with self.assertRaises(SolariError) as raised:
+            Solari(token="tok", transport=failing).list_tools()
+        self.assertEqual(raised.exception.code, "network_error")
+
+
+if __name__ == "__main__":
+    unittest.main()