thrindex 0.2.1__tar.gz

thrindex-0.2.1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: thrindex
+Version: 0.2.1
+Summary: The memory OS for AI agents — persistent memory, semantic search and LLM extraction.
+Author-email: Thrindex <hello@thrindex.com>
+License: Apache-2.0
+Project-URL: Homepage, https://thrindex.com
+Project-URL: Documentation, https://docs.thrindex.com
+Project-URL: Repository, https://github.com/thrindex/thrindex.git
+Keywords: ai,agents,memory,llm,openai,anthropic,langchain,semantic-search,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: pydantic>=2.10.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.20.0; extra == "anthropic"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2.0; extra == "langchain"
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.10.0; extra == "llamaindex"
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.20.0; extra == "all"
+Requires-Dist: langchain-core>=0.2.0; extra == "all"
+Requires-Dist: llama-index-core>=0.10.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: ruff>=0.9.0; extra == "dev"
+Requires-Dist: mypy>=1.13.0; extra == "dev"
+Requires-Dist: pytest>=8.3.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: anyio[trio]>=4.0.0; extra == "dev"

thrindex-0.2.1/pyproject.toml

@@ -0,0 +1,79 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "thrindex"
+version = "0.2.1"
+description = "The memory OS for AI agents — persistent memory, semantic search and LLM extraction."
+readme = "README.md"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.10"
+authors = [{ name = "Thrindex", email = "hello@thrindex.com" }]
+keywords = ["ai", "agents", "memory", "llm", "openai", "anthropic", "langchain", "semantic-search", "rag"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "httpx>=0.28.0",
+    "pydantic>=2.10.0",
+]
+
+[project.urls]
+Homepage = "https://thrindex.com"
+Documentation = "https://docs.thrindex.com"
+Repository = "https://github.com/thrindex/thrindex.git"
+
+[project.optional-dependencies]
+openai = [
+    "openai>=1.0.0",
+]
+anthropic = [
+    "anthropic>=0.20.0",
+]
+langchain = [
+    "langchain-core>=0.2.0",
+]
+llamaindex = [
+    "llama-index-core>=0.10.0",
+]
+all = [
+    "openai>=1.0.0",
+    "anthropic>=0.20.0",
+    "langchain-core>=0.2.0",
+    "llama-index-core>=0.10.0",
+]
+dev = [
+    "ruff>=0.9.0",
+    "mypy>=1.13.0",
+    "pytest>=8.3.0",
+    "pytest-asyncio>=0.24.0",
+    "anyio[trio]>=4.0.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["thrindex*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+ignore = []
+
+[tool.mypy]
+strict = true
+python_version = "3.10"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

thrindex-0.2.1/setup.cfg

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

thrindex-0.2.1/tests/test_async_client.py

@@ -0,0 +1,317 @@
+"""Unit tests for the async thrindex SDK client.
+
+Mirrors the sync client tests (test_client.py) but exercises AsyncClient.
+Uses httpx.MockTransport via pytest-asyncio — no real network calls made.
+"""
+
+from __future__ import annotations
+
+import json
+from collections import deque
+from typing import Any
+
+import httpx
+import pytest
+
+import thrindex
+from thrindex.async_client import AsyncThrindex
+from thrindex.client import AuthError, NotFoundError, RateLimitError, ThrindexError
+from thrindex.models import ListResponse, MemoryDetail
+
+
+def _transport(*responses: httpx.Response) -> httpx.MockTransport:
+    queue: deque[httpx.Response] = deque(responses)
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if queue:
+            return queue.popleft()
+        raise httpx.RequestError("no more mock responses")
+
+    return httpx.MockTransport(handler)
+
+
+def _json(body: Any, status: int = 200) -> httpx.Response:
+    return httpx.Response(
+        status_code=status,
+        headers={"Content-Type": "application/json"},
+        content=json.dumps(body).encode(),
+    )
+
+
+_RECORD = {
+    "id": "mem-1",
+    "org_id": "org-1",
+    "agent_id": "agent-1",
+    "user_id": "user-1",
+    "level": 0,
+    "status": "active",
+    "importance": 0.7,
+    "confidence": 0.9,
+    "source": "agent",
+    "created_at": "2026-01-01T00:00:00Z",
+    "updated_at": "2026-01-01T00:00:00Z",
+}
+
+# ── add() ──────────────────────────────────────────────────────────────────────
+
+
+async def test_async_add_success() -> None:
+    transport = _transport(_json({"id": "mem-123", "status": "queued"}, 202))
+    async with AsyncThrindex("mk_live_test", base_url="http://localhost", transport=transport) as client:
+        memory_id = await client.add("User likes cats", agent_id="agent-1", user_id="user-1")
+    assert memory_id == "mem-123"
+
+
+async def test_async_add_three_lines() -> None:
+    transport = _transport(_json({"id": "abc", "status": "queued"}, 202))
+    async with AsyncThrindex("mk_live_test", base_url="http://localhost", transport=transport) as client:
+        memory_id = await client.add("fact", agent_id="a", user_id="u")
+    assert isinstance(memory_id, str)
+
+
+async def test_async_add_retries_on_5xx() -> None:
+    transport = _transport(
+        httpx.Response(500, content=b"error"),
+        httpx.Response(503, content=b"unavailable"),
+        _json({"id": "mem-ok", "status": "queued"}, 202),
+    )
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=transport, max_retries=3
+    ) as client:
+        memory_id = await client.add("fact", agent_id="a", user_id="u")
+    assert memory_id == "mem-ok"
+
+
+async def test_async_add_raises_after_max_retries() -> None:
+    transport = _transport(
+        httpx.Response(500, content=b"err"),
+        httpx.Response(500, content=b"err"),
+        httpx.Response(500, content=b"err"),
+        httpx.Response(500, content=b"err"),
+    )
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=transport, max_retries=2
+    ) as client:
+        with pytest.raises(ThrindexError):
+            await client.add("fact", agent_id="a", user_id="u")
+
+
+async def test_async_add_raises_on_401() -> None:
+    body = {"error": {"code": "unauthorized", "message": "invalid api key"}}
+    async with AsyncThrindex(
+        "mk_live_bad_key", base_url="http://localhost", transport=_transport(_json(body, 401))
+    ) as client:
+        with pytest.raises(AuthError):
+            await client.add("fact", agent_id="a", user_id="u")
+
+
+async def test_async_add_respects_retry_after_on_429() -> None:
+    transport = _transport(
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"rate limited"),
+        _json({"id": "mem-ok", "status": "queued"}, 202),
+    )
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=transport, max_retries=2
+    ) as client:
+        memory_id = await client.add("fact", agent_id="a", user_id="u")
+    assert memory_id == "mem-ok"
+
+
+async def test_async_add_raises_rate_limit_after_exhausted_retries() -> None:
+    transport = _transport(
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"limited"),
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"limited"),
+    )
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=transport, max_retries=1
+    ) as client:
+        with pytest.raises(RateLimitError) as exc_info:
+            await client.add("fact", agent_id="a", user_id="u")
+    assert exc_info.value.status_code == 429
+
+
+# ── search() ──────────────────────────────────────────────────────────────────
+
+
+async def test_async_search_success() -> None:
+    body = {
+        "results": [
+            {
+                "id": "mem-1",
+                "content": "User likes cats",
+                "agent_id": "agent-1",
+                "user_id": "user-1",
+                "level": 0,
+                "status": "active",
+                "importance": 0.8,
+                "confidence": 1.0,
+                "score": 0.9,
+                "created_at": "2026-01-01T00:00:00Z",
+            }
+        ],
+        "latency_ms": 12,
+        "cache_hit": True,
+    }
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=_transport(_json(body))
+    ) as client:
+        results = await client.search("cat preferences", agent_id="agent-1", user_id="user-1")
+    assert len(results) == 1
+    assert results[0].id == "mem-1"
+    assert results[0].score == pytest.approx(0.9)
+
+
+async def test_async_search_empty() -> None:
+    body = {"results": [], "latency_ms": 5, "cache_hit": False}
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=_transport(_json(body))
+    ) as client:
+        results = await client.search("query", agent_id="a", user_id="u")
+    assert results == []
+
+
+# ── list() ────────────────────────────────────────────────────────────────────
+
+
+async def test_async_list_success() -> None:
+    body = {"results": [_RECORD], "next_cursor": "tok-xyz"}
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=_transport(_json(body))
+    ) as client:
+        resp = await client.list(agent_id="agent-1", user_id="user-1")
+    assert isinstance(resp, ListResponse)
+    assert resp.results[0].id == "mem-1"
+    assert resp.next_cursor == "tok-xyz"
+
+
+async def test_async_list_empty() -> None:
+    body = {"results": [], "next_cursor": None}
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=_transport(_json(body))
+    ) as client:
+        resp = await client.list()
+    assert resp.results == []
+    assert resp.next_cursor is None
+
+
+# ── batch_add() ───────────────────────────────────────────────────────────────
+
+
+async def test_async_batch_add() -> None:
+    from collections import deque as _deque
+
+    transport = _transport(
+        _json({"id": "id-1", "status": "queued"}, 202),
+        _json({"id": "id-2", "status": "queued"}, 202),
+        _json({"id": "id-3", "status": "queued"}, 202),
+    )
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=transport
+    ) as client:
+        ids = await client.batch_add(
+            [{"content": "a"}, {"content": "b"}, {"content": "c"}],
+            agent_id="agent-1",
+            user_id="user-1",
+        )
+    assert ids == ["id-1", "id-2", "id-3"]
+
+
+# ── get() ─────────────────────────────────────────────────────────────────────
+
+
+async def test_async_get_returns_memory_detail() -> None:
+    body = {**_RECORD, "content": "User prefers dark mode"}
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=_transport(_json(body))
+    ) as client:
+        detail = await client.get("mem-1")
+    assert isinstance(detail, MemoryDetail)
+    assert detail.content == "User prefers dark mode"
+
+
+async def test_async_get_raises_not_found() -> None:
+    body = {"error": {"code": "not_found", "message": "memory not found"}}
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=_transport(_json(body, 404))
+    ) as client:
+        with pytest.raises(NotFoundError):
+            await client.get("nonexistent")
+
+
+# ── delete() ──────────────────────────────────────────────────────────────────
+
+
+async def test_async_delete_soft() -> None:
+    async with AsyncThrindex(
+        "mk_live_test",
+        base_url="http://localhost",
+        transport=_transport(httpx.Response(204)),
+    ) as client:
+        await client.delete("mem-1")  # must not raise
+
+
+async def test_async_delete_hard() -> None:
+    async with AsyncThrindex(
+        "mk_live_test",
+        base_url="http://localhost",
+        transport=_transport(httpx.Response(204)),
+    ) as client:
+        await client.delete("mem-1", hard=True)
+
+
+async def test_async_delete_not_found() -> None:
+    body = {"error": {"code": "not_found", "message": "memory not found"}}
+    async with AsyncThrindex(
+        "mk_live_test",
+        base_url="http://localhost",
+        transport=_transport(_json(body, 404)),
+    ) as client:
+        with pytest.raises(NotFoundError):
+            await client.delete("nonexistent")
+
+
+async def test_async_delete_raises_rate_limit_after_exhausted_retries() -> None:
+    transport = _transport(
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"limited"),
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"limited"),
+    )
+    async with AsyncThrindex(
+        "mk_live_test", base_url="http://localhost", transport=transport, max_retries=1
+    ) as client:
+        with pytest.raises(RateLimitError) as exc_info:
+            await client.delete("mem-1")
+    assert exc_info.value.status_code == 429
+
+
+async def test_async_add_401_message_forwarded() -> None:
+    body = {"error": {"code": "forbidden", "message": "missing scope: memory:write"}}
+    async with AsyncThrindex(
+        "mk_live_readonly_key",
+        base_url="http://localhost",
+        transport=_transport(_json(body, 401)),
+    ) as client:
+        with pytest.raises(AuthError) as exc_info:
+            await client.add("fact", agent_id="a", user_id="u")
+    assert "missing scope" in str(exc_info.value)
+
+
+# ── context manager ───────────────────────────────────────────────────────────
+
+
+async def test_async_context_manager() -> None:
+    transport = _transport(_json({"id": "x", "status": "queued"}, 202))
+    async with AsyncThrindex("mk_live_test", base_url="http://localhost", transport=transport) as c:
+        mid = await c.add("test", agent_id="a", user_id="u")
+    assert mid == "x"
+
+
+# ── validation ────────────────────────────────────────────────────────────────
+
+
+def test_async_empty_api_key_raises() -> None:
+    with pytest.raises(ValueError, match="api_key"):
+        AsyncThrindex("")
+
+
+def test_async_client_exported_from_top_level() -> None:
+    assert thrindex.AsyncThrindex is AsyncThrindex

thrindex-0.2.1/tests/test_client.py

@@ -0,0 +1,226 @@
+"""Unit tests for the thrindex SDK client.
+
+Uses httpx.MockTransport so no real network calls are made.
+Tests: happy path, retry logic, 429 handling, 401/404 errors, batch_add.
+"""
+
+from __future__ import annotations
+
+import json
+from collections import deque
+from typing import Any
+
+import httpx
+import pytest
+
+import thrindex
+from thrindex.client import Thrindex, RateLimitError, ThrindexError, AuthError, NotFoundError
+
+
+def _transport(*responses: httpx.Response) -> httpx.MockTransport:
+    """Return a MockTransport that replays the given response sequence."""
+    queue: deque[httpx.Response] = deque(responses)
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if queue:
+            return queue.popleft()
+        raise httpx.RequestError("no more responses")  # test misconfiguration
+
+    return httpx.MockTransport(handler)
+
+
+def _json_response(body: Any, status: int = 200) -> httpx.Response:
+    return httpx.Response(
+        status_code=status,
+        headers={"Content-Type": "application/json"},
+        content=json.dumps(body).encode(),
+    )
+
+
+# ── add() ──────────────────────────────────────────────────────────────────────
+
+def test_add_success() -> None:
+    transport = _transport(_json_response({"id": "mem-123", "status": "queued"}, 202))
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport)
+    memory_id = client.add("User likes cats", agent_id="agent-1", user_id="user-1")
+    assert memory_id == "mem-123"
+
+
+def test_add_three_lines() -> None:
+    """Acceptance criterion: SDK works in three lines."""
+    transport = _transport(_json_response({"id": "abc", "status": "queued"}, 202))
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport)
+    memory_id = client.add("fact", agent_id="a", user_id="u")
+    assert isinstance(memory_id, str)
+
+
+def test_add_retries_on_5xx() -> None:
+    transport = _transport(
+        httpx.Response(500, content=b"error"),
+        httpx.Response(503, content=b"unavailable"),
+        _json_response({"id": "mem-ok", "status": "queued"}, 202),
+    )
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport, max_retries=3)
+    memory_id = client.add("fact", agent_id="a", user_id="u")
+    assert memory_id == "mem-ok"
+
+
+def test_add_raises_after_max_retries() -> None:
+    transport = _transport(
+        httpx.Response(500, content=b"err"),
+        httpx.Response(500, content=b"err"),
+        httpx.Response(500, content=b"err"),
+        httpx.Response(500, content=b"err"),
+    )
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport, max_retries=2)
+    with pytest.raises(ThrindexError):
+        client.add("fact", agent_id="a", user_id="u")
+
+
+def test_add_raises_on_401() -> None:
+    body = {"error": {"code": "unauthorized", "message": "invalid api key"}}
+    transport = _transport(_json_response(body, 401))
+    client = Thrindex("mk_live_bad_key", base_url="http://localhost", transport=transport)
+    with pytest.raises(AuthError):
+        client.add("fact", agent_id="a", user_id="u")
+
+
+def test_add_respects_retry_after_on_429() -> None:
+    transport = _transport(
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"rate limited"),
+        _json_response({"id": "mem-ok", "status": "queued"}, 202),
+    )
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport, max_retries=2)
+    memory_id = client.add("fact", agent_id="a", user_id="u")
+    assert memory_id == "mem-ok"
+
+
+def test_add_raises_rate_limit_after_exhausted_retries() -> None:
+    transport = _transport(
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"limited"),
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"limited"),
+    )
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport, max_retries=1)
+    with pytest.raises(RateLimitError) as exc_info:
+        client.add("fact", agent_id="a", user_id="u")
+    assert exc_info.value.status_code == 429
+
+
+# ── search() ──────────────────────────────────────────────────────────────────
+
+def test_search_success() -> None:
+    body = {
+        "results": [
+            {
+                "id": "mem-1",
+                "content": "User likes cats",
+                "agent_id": "agent-1",
+                "user_id": "user-1",
+                "level": 0,
+                "status": "active",
+                "importance": 0.8,
+                "confidence": 1.0,
+                "score": 0.9,
+                "created_at": "2026-01-01T00:00:00Z",
+            }
+        ],
+        "latency_ms": 12,
+        "cache_hit": True,
+    }
+    transport = _transport(_json_response(body))
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport)
+    results = client.search("cat preferences", agent_id="agent-1", user_id="user-1")
+    assert len(results) == 1
+    assert results[0].id == "mem-1"
+    assert results[0].score == pytest.approx(0.9)
+
+
+def test_search_three_lines() -> None:
+    """Acceptance criterion: search works in three lines."""
+    body = {"results": [], "latency_ms": 5, "cache_hit": False}
+    transport = _transport(_json_response(body))
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport)
+    results = client.search("query", agent_id="a", user_id="u")
+    assert isinstance(results, list)
+
+
+# ── batch_add() ───────────────────────────────────────────────────────────────
+
+def test_batch_add() -> None:
+    transport = _transport(
+        _json_response({"id": "id-1", "status": "queued"}, 202),
+        _json_response({"id": "id-2", "status": "queued"}, 202),
+        _json_response({"id": "id-3", "status": "queued"}, 202),
+    )
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport)
+    ids = client.batch_add(
+        [{"content": "a"}, {"content": "b"}, {"content": "c"}],
+        agent_id="agent-1",
+        user_id="user-1",
+    )
+    assert ids == ["id-1", "id-2", "id-3"]
+
+
+# ── delete() ──────────────────────────────────────────────────────────────────
+
+def test_delete_soft() -> None:
+    transport = _transport(httpx.Response(204))
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport)
+    client.delete("mem-1")  # should not raise
+
+
+def test_delete_hard() -> None:
+    transport = _transport(httpx.Response(204))
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport)
+    client.delete("mem-1", hard=True)
+
+
+def test_delete_not_found() -> None:
+    body = {"error": {"code": "not_found", "message": "memory not found"}}
+    transport = _transport(_json_response(body, 404))
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport)
+    with pytest.raises(NotFoundError):
+        client.delete("nonexistent")
+
+
+def test_delete_raises_rate_limit_after_exhausted_retries() -> None:
+    transport = _transport(
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"limited"),
+        httpx.Response(429, headers={"Retry-After": "0"}, content=b"limited"),
+    )
+    client = Thrindex("mk_live_test", base_url="http://localhost", transport=transport, max_retries=1)
+    with pytest.raises(RateLimitError) as exc_info:
+        client.delete("mem-1")
+    assert exc_info.value.status_code == 429
+
+
+def test_add_401_message_forwarded() -> None:
+    body = {"error": {"code": "forbidden", "message": "missing scope: memory:write"}}
+    transport = _transport(_json_response(body, 401))
+    client = Thrindex("mk_live_readonly_key", base_url="http://localhost", transport=transport)
+    with pytest.raises(AuthError) as exc_info:
+        client.add("fact", agent_id="a", user_id="u")
+    assert "missing scope" in str(exc_info.value)
+
+
+# ── context manager ───────────────────────────────────────────────────────────
+
+def test_context_manager() -> None:
+    transport = _transport(_json_response({"id": "x", "status": "queued"}, 202))
+    with Thrindex("mk_live_test", base_url="http://localhost", transport=transport) as c:
+        mid = c.add("test", agent_id="a", user_id="u")
+    assert mid == "x"
+
+
+# ── validation ────────────────────────────────────────────────────────────────
+
+def test_empty_api_key_raises() -> None:
+    with pytest.raises(ValueError, match="api_key"):
+        Thrindex("")
+
+
+def test_imports() -> None:
+    """Public surface: Client and error types importable from top-level."""
+    assert thrindex.Thrindex is Thrindex
+    assert thrindex.ThrindexError is ThrindexError
+    assert thrindex.RateLimitError is RateLimitError