meshapi 0.1.6__tar.gz → 0.1.8__tar.gz

{meshapi-0.1.6 → meshapi-0.1.8}/CLAUDE.md

@@ -20,13 +20,12 @@ python/
 │       ├── chat.py        # /v1/chat/completions
 │       ├── responses.py   # /v1/responses
 │       ├── embeddings.py  # /v1/embeddings
-│       ├── compare.py     # /v1/compare
-│       ├── files.py       # /v1/files (batch file objects)
-│       ├── rag.py         # /v1/files RAG endpoints (upload, embed, search)
+│       ├── compare.py     # /v1/chat/compare
+│       ├── rag.py         # /v1/files RAG endpoints (upload, list, get status, embed, search)
 │       ├── batches.py     # /v1/batches
 │       ├── models.py      # /v1/models
 │       ├── templates.py   # /v1/templates
-│       └── images.py      # /v1/images/generations
+│       └── images.py      # /v1/images/generations, /v1/images/edits
 ├── tests/
 │   ├── unit/              # Fast, no-network tests
 │   ├── contract/          # Pydantic model parsing against local fixtures
@@ -160,9 +159,10 @@ pytest test_rag.py::test_rag_upload_embed_search -v
 | `test_feature_matrix.py` | Cross-model feature matrix |
 | `test_rag.py` | RAG upload → embed → list → search |
 | `test_realtime.py` | WebSocket connect/close, session lifecycle |
-| `test_audio.py` | TTS synthesize, voice listing |
+| `test_audio.py` | TTS synthesize, voice listing, audio_translate |
 | `test_video.py` | Video list, generate → retrieve |
 | `test_compare.py` | Non-streaming compare, streaming compare |
+| `test_moderations.py` | Moderation classify: text and multimodal input |
 
 ---
 

{meshapi-0.1.6 → meshapi-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi
-Version: 0.1.6
+Version: 0.1.8
 Summary: Official Python SDK for the MeshAPI AI model gateway
 Project-URL: Homepage, https://meshapi.ai
 Project-URL: Documentation, https://developers.meshapi.ai
@@ -82,6 +82,9 @@ Get a key at [meshapi.ai](https://meshapi.ai). Data-plane keys are prefixed `rsk
 | **Multi-model compare** | Fire one prompt at N models in parallel and stream their replies side by side. |
 | **Audio** | Text-to-speech, speech-to-text, transcription translation, and voice listing. |
 | **Video** | Submit and poll async video generation tasks. |
+| **Moderations** | Classify text/image content for policy violations via `moderations.create`. |
+| **Web search** | Live web search with native + Tavily engines via `web.search`. |
+| **Router select** | Ask the Auto Router which model it would pick, without running inference. |
 | **RAG** | Upload files, embed them, and run vector search — all through the same client. |
 | **Batches** | Async bulk inference jobs at discounted rates with inline request submission. |
 | **Prompt templates** | Server-stored prompts with `{{variable}}` slots. Update prompts without redeploying. |
@@ -185,6 +188,10 @@ reply = client.responses.create(
         max_output_tokens=512,
     )
 )
+
+# List background response jobs, or fetch one by id
+jobs = client.responses.list(limit=20)
+job = client.responses.get("resp_abc123")
 ```
 
 ## Embeddings
@@ -301,6 +308,25 @@ result = client.images.generate(
 print(result.data[0].url)
 ```
 
+### Editing an image
+
+`image` (and optional `mask` / `reference_images`) take a base64 or
+`data:` URL — remote http(s) URLs are rejected by this endpoint.
+
+```python
+from meshapi import ImageEditParams
+
+edited = client.images.edit(
+    ImageEditParams(
+        model="openai/gpt-image-1",
+        image="data:image/png;base64,<...>",
+        prompt="Replace the background with a beach at sunset",
+        operation="edit",  # or inpaint / outpaint / mix / reframe / upscale / remove_background
+    )
+)
+print(edited.data[0].url or edited.data[0].b64_json[:32])
+```
+
 ## Compare (multi-model fanout)
 
 ```python
@@ -432,9 +458,61 @@ async with AsyncMeshAPI(base_url="...", token="rsk_...") as client:
 ## Models
 
 ```python
+from meshapi import ModelSearchParams
+
 all_models = client.models.list()
 free = client.models.free()
 paid = client.models.paid()
+
+# Paginated catalog search (DB-only, no model cost)
+page = client.models.search(ModelSearchParams(q="gpt", free=False, sort="name", limit=10))
+print(page.total, page.brands)
+
+# Fetch one model's detail
+gpt4o = client.models.get("openai/gpt-4o")
+```
+
+## Moderations
+
+```python
+from meshapi import ModerationParams
+
+result = client.moderations.create(ModerationParams(input="text to classify"))
+if result.results[0].flagged:
+    print("flagged:", result.results[0].categories)
+
+# Batch several inputs in one call
+client.moderations.create(ModerationParams(input=["first text", "second text"]))
+```
+
+## Web search
+
+Gated server-side by `WEB_SEARCH_ENABLED`. Native-first with Tavily fallback;
+inspect `response.provider` to see which engine served the request.
+
+```python
+from meshapi import WebSearchParams
+
+res = client.web.search(
+    WebSearchParams(query="latest news on Mars rovers", max_results=5, include_answer=True)
+)
+print(res.provider, res.answer)
+for hit in res.results:
+    print(hit.title, hit.url)
+```
+
+## Router select
+
+Gated server-side by `AUTO_ROUTER_ENABLED`. Returns the model the Auto Router
+*would* pick — without running inference — so you can run it on your own path.
+
+```python
+from meshapi import RouterSelectParams, ChatMessage
+
+sel = client.router.select(
+    RouterSelectParams(messages=[ChatMessage(role="user", content="Prove that 2+2=4.")])
+)
+print(sel.model, sel.auto_router.fallback_used)
 ```
 
 ## Prompt templates

{meshapi-0.1.6 → meshapi-0.1.8}/README.md

@@ -45,6 +45,9 @@ Get a key at [meshapi.ai](https://meshapi.ai). Data-plane keys are prefixed `rsk
 | **Multi-model compare** | Fire one prompt at N models in parallel and stream their replies side by side. |
 | **Audio** | Text-to-speech, speech-to-text, transcription translation, and voice listing. |
 | **Video** | Submit and poll async video generation tasks. |
+| **Moderations** | Classify text/image content for policy violations via `moderations.create`. |
+| **Web search** | Live web search with native + Tavily engines via `web.search`. |
+| **Router select** | Ask the Auto Router which model it would pick, without running inference. |
 | **RAG** | Upload files, embed them, and run vector search — all through the same client. |
 | **Batches** | Async bulk inference jobs at discounted rates with inline request submission. |
 | **Prompt templates** | Server-stored prompts with `{{variable}}` slots. Update prompts without redeploying. |
@@ -148,6 +151,10 @@ reply = client.responses.create(
         max_output_tokens=512,
     )
 )
+
+# List background response jobs, or fetch one by id
+jobs = client.responses.list(limit=20)
+job = client.responses.get("resp_abc123")
 ```
 
 ## Embeddings
@@ -264,6 +271,25 @@ result = client.images.generate(
 print(result.data[0].url)
 ```
 
+### Editing an image
+
+`image` (and optional `mask` / `reference_images`) take a base64 or
+`data:` URL — remote http(s) URLs are rejected by this endpoint.
+
+```python
+from meshapi import ImageEditParams
+
+edited = client.images.edit(
+    ImageEditParams(
+        model="openai/gpt-image-1",
+        image="data:image/png;base64,<...>",
+        prompt="Replace the background with a beach at sunset",
+        operation="edit",  # or inpaint / outpaint / mix / reframe / upscale / remove_background
+    )
+)
+print(edited.data[0].url or edited.data[0].b64_json[:32])
+```
+
 ## Compare (multi-model fanout)
 
 ```python
@@ -395,9 +421,61 @@ async with AsyncMeshAPI(base_url="...", token="rsk_...") as client:
 ## Models
 
 ```python
+from meshapi import ModelSearchParams
+
 all_models = client.models.list()
 free = client.models.free()
 paid = client.models.paid()
+
+# Paginated catalog search (DB-only, no model cost)
+page = client.models.search(ModelSearchParams(q="gpt", free=False, sort="name", limit=10))
+print(page.total, page.brands)
+
+# Fetch one model's detail
+gpt4o = client.models.get("openai/gpt-4o")
+```
+
+## Moderations
+
+```python
+from meshapi import ModerationParams
+
+result = client.moderations.create(ModerationParams(input="text to classify"))
+if result.results[0].flagged:
+    print("flagged:", result.results[0].categories)
+
+# Batch several inputs in one call
+client.moderations.create(ModerationParams(input=["first text", "second text"]))
+```
+
+## Web search
+
+Gated server-side by `WEB_SEARCH_ENABLED`. Native-first with Tavily fallback;
+inspect `response.provider` to see which engine served the request.
+
+```python
+from meshapi import WebSearchParams
+
+res = client.web.search(
+    WebSearchParams(query="latest news on Mars rovers", max_results=5, include_answer=True)
+)
+print(res.provider, res.answer)
+for hit in res.results:
+    print(hit.title, hit.url)
+```
+
+## Router select
+
+Gated server-side by `AUTO_ROUTER_ENABLED`. Returns the model the Auto Router
+*would* pick — without running inference — so you can run it on your own path.
+
+```python
+from meshapi import RouterSelectParams, ChatMessage
+
+sel = client.router.select(
+    RouterSelectParams(messages=[ChatMessage(role="user", content="Prove that 2+2=4.")])
+)
+print(sel.model, sel.auto_router.fallback_used)
 ```
 
 ## Prompt templates

meshapi-0.1.8/livetests/.env.livetest.example

@@ -0,0 +1,31 @@
+# MeshAPI Python SDK — live-test configuration.
+# Copy to `python/.env.livetest` (read automatically by the harness) and fill in.
+
+# ── Required ───────────────────────────────────────────────────────────────
+MESHAPI_BASE_URL=https://api-dev.meshapi.ai
+MESHAPI_TOKEN=rsk_your_key_here
+
+# ── Core models (have sensible defaults) ─────────────────────────────────────
+MESHAPI_MODEL=openai/gpt-4o-mini
+MESHAPI_SECOND_MODEL=anthropic/claude-haiku-4.5
+MESHAPI_EMBEDDINGS_MODEL=openai/text-embedding-3-small
+MESHAPI_REALTIME_MODEL=openai/gpt-realtime-mini
+
+# ── Optional-feature models/inputs ───────────────────────────────────────────
+# When these are UNSET the corresponding tests skip silently (a green run then
+# proves little). Set them all and MESHAPI_STRICT_LIVETESTS=1 for the
+# pre-hackathon gate so every feature test actually runs.
+MESHAPI_IMAGE_GEN_MODEL=openai/gpt-image-1
+MESHAPI_IMAGE_URL=https://upload.wikimedia.org/wikipedia/commons/3/3a/Cat03.jpg
+MESHAPI_INPUT_AUDIO_B64=            # base64 of a short wav/mp3 clip
+MESHAPI_INPUT_AUDIO_FORMAT=wav
+MESHAPI_AUDIO_OUT_MODEL=openai/gpt-4o-mini-audio-preview
+MESHAPI_VIDEO_GEN_MODEL=byteplus/seedance-1-5-pro-251215
+# Image editing is opt-in (costly, niche) — not part of the strict gate.
+# MESHAPI_IMAGE_EDIT_MODEL=openai/gpt-image-1
+# MESHAPI_IMAGE_EDIT_INPUT=            # optional base64/data-URL source image
+
+# ── Pre-hackathon gate ───────────────────────────────────────────────────────
+# When set, the suite fails fast unless every optional-feature var above is set,
+# so skip-by-default tests can't hide behind a green run.
+# MESHAPI_STRICT_LIVETESTS=1

{meshapi-0.1.6 → meshapi-0.1.8}/livetests/conftest.py

@@ -30,6 +30,43 @@ from config import BASE_URL, TOKEN, MODEL, get_env  # noqa: E402
 from meshapi import MeshAPI  # noqa: E402
 
 
+# ---------------------------------------------------------------------------
+# Strict-mode preflight (pre-hackathon gate)
+# ---------------------------------------------------------------------------
+#
+# Several feature tests skip-by-default when an env var is unset (image gen,
+# vision, audio in/out, video). A skipped test reads as "passed" — so a green
+# run can mean almost nothing ran. Set MESHAPI_STRICT_LIVETESTS=1 in the
+# pre-hackathon gate: the run fails fast unless every optional-feature env var
+# is present, forcing those tests to actually execute. See .env.livetest.example.
+
+# Env vars whose absence turns a real feature test into a silent skip.
+STRICT_REQUIRED_ENV = [
+    "MESHAPI_IMAGE_GEN_MODEL",
+    "MESHAPI_IMAGE_URL",
+    "MESHAPI_INPUT_AUDIO_B64",
+    "MESHAPI_AUDIO_OUT_MODEL",
+    "MESHAPI_VIDEO_GEN_MODEL",
+]
+
+
+def _strict_mode() -> bool:
+    return (os.getenv("MESHAPI_STRICT_LIVETESTS") or "").lower() in ("1", "true", "yes")
+
+
+def pytest_configure(config: "pytest.Config") -> None:
+    if not _strict_mode():
+        return
+    missing = [name for name in STRICT_REQUIRED_ENV if not get_env(name)]
+    if missing:
+        pytest.exit(
+            "MESHAPI_STRICT_LIVETESTS is set but these env vars are unset, so their "
+            "feature tests would silently skip:\n  - " + "\n  - ".join(missing) + "\n"
+            "Set them (see .env.livetest.example) or unset MESHAPI_STRICT_LIVETESTS.",
+            returncode=1,
+        )
+
+
 # ---------------------------------------------------------------------------
 # Session-scoped shared client fixture
 # ---------------------------------------------------------------------------

{meshapi-0.1.6 → meshapi-0.1.8}/livetests/test_audio.py

@@ -19,6 +19,9 @@ def test_audio_synthesize(client: MeshAPI) -> None:
 
 
 def test_audio_stt_from_tts(client: MeshAPI) -> None:
+    # NB: not forcing response_format — the TTS model (sarvam) rejects an
+    # explicit "wav" with a 422, and its default codec already transcribes
+    # end-to-end, so the round-trip is valid as-is.
     audio_bytes = client.audio.synthesize(
         SpeechParams(input="Hello from MeshAPI audio test.", model=TTS_MODEL)
     )

meshapi-0.1.8/livetests/test_compare.py

@@ -0,0 +1,73 @@
+"""Live tests: Model Compare API."""
+
+from __future__ import annotations
+
+import pytest
+from meshapi import MeshAPI, CompareParams, ChatMessage, ModelOverride
+
+
+def test_compare_nonstreaming(client: MeshAPI, model: str, second_model: str) -> None:
+    result = client.compare.create(
+        CompareParams(
+            models=[model, second_model],
+            messages=[ChatMessage(role="user", content="What is 2+2? Reply in one word.")],
+            skip_comparison=True,
+            max_tokens=20,
+        )
+    )
+    assert result.comparison_id, "expected comparison_id"
+    assert len(result.results) == 2, f"expected 2 results, got {len(result.results)}"
+    found_models = {r.model for r in result.results}
+    assert model in found_models, f"expected {model} in results"
+    assert second_model in found_models, f"expected {second_model} in results"
+    for r in result.results:
+        assert r.content or r.error, f"result for {r.model} has neither content nor error"
+
+
+def test_compare_streaming(client: MeshAPI, model: str, second_model: str) -> None:
+    events = list(
+        client.compare.stream(
+            CompareParams(
+                models=[model, second_model],
+                messages=[ChatMessage(role="user", content="Tell me a joke.")],
+                skip_comparison=True,
+                max_tokens=50,
+            )
+        )
+    )
+    assert len(events) > 0, "expected at least one streaming event"
+
+
+def test_compare_with_synthesis(client: MeshAPI, model: str, second_model: str) -> None:
+    """Exercise the synthesis path (skip_comparison=False) — previously never tested."""
+    result = client.compare.create(
+        CompareParams(
+            models=[model, second_model],
+            messages=[ChatMessage(role="user", content="In one sentence, what is TCP?")],
+            comparison_instructions="Briefly state which answer is clearer.",
+            skip_comparison=False,
+            max_tokens=60,
+        )
+    )
+    assert result.comparison_id
+    assert len(result.results) == 2
+    # When at least one per-model answer succeeded and the comparison model did
+    # not fall back, a synthesized comparison must be present with usage.
+    if any(r.content for r in result.results) and not result.comparison_fallback_used:
+        assert result.comparison, "expected a synthesized comparison when skip_comparison=False"
+        assert result.comparison_model, "expected comparison_model to be reported"
+        assert result.comparison_usage is not None, "expected comparison_usage to be populated"
+
+
+def test_compare_model_overrides(client: MeshAPI, model: str, second_model: str) -> None:
+    """Per-model overrides (temperature/max_tokens) — previously untested."""
+    result = client.compare.create(
+        CompareParams(
+            models=[model, second_model],
+            messages=[ChatMessage(role="user", content="Say hi in one word.")],
+            model_overrides=[ModelOverride(model=model, temperature=0.0, max_tokens=10)],
+            skip_comparison=True,
+            max_tokens=20,
+        )
+    )
+    assert len(result.results) == 2, "overrides must not drop any model from the fan-out"

meshapi-0.1.8/livetests/test_images_edit.py

@@ -0,0 +1,51 @@
+"""Live tests: image editing — POST /v1/images/edits.
+
+Requires an edit-capable model. Set MESHAPI_IMAGE_EDIT_MODEL (and optionally
+MESHAPI_IMAGE_EDIT_INPUT, a base64/data-URL source image) to run; otherwise
+skipped. Image editing costs real inference, so this is opt-in.
+"""
+
+from __future__ import annotations
+
+import pytest
+from config import get_env
+from meshapi import ImageEditParams, MeshAPI, MeshAPIError
+
+# 1x1 transparent PNG, used when MESHAPI_IMAGE_EDIT_INPUT is not provided.
+_PIXEL_PNG = (
+    "data:image/png;base64,"
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
+)
+
+
+def test_image_edit_basic(client: MeshAPI) -> None:
+    model = get_env("MESHAPI_IMAGE_EDIT_MODEL")
+    if not model:
+        pytest.skip("set MESHAPI_IMAGE_EDIT_MODEL to run the image-edit live test")
+    source = get_env("MESHAPI_IMAGE_EDIT_INPUT") or _PIXEL_PNG
+
+    try:
+        resp = client.images.edit(
+            ImageEditParams(
+                model=model,
+                image=source,
+                prompt="Make the background a solid blue.",
+                operation="edit",
+            )
+        )
+    except MeshAPIError as exc:
+        if exc.status == 400 and exc.error_code == "invalid_request":
+            # Upstream (provider) content/safety rejection of the synthetic test
+            # image — the request reached the provider, so the SDK path is
+            # validated. Skip rather than fail.
+            pytest.skip(f"provider rejected the test image: {exc}")
+        if exc.status in (400, 501) and exc.error_code in (
+            "model_capability_not_supported",
+            "not_implemented",
+        ):
+            pytest.skip(f"model does not support image edits: {exc.error_code}")
+        raise
+
+    assert resp.data, "expected at least one edited image"
+    first = resp.data[0]
+    assert first.url or first.b64_json, "edited image should have a url or b64_json"

{meshapi-0.1.6 → meshapi-0.1.8}/livetests/test_models.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from meshapi import MeshAPI
+from meshapi import MeshAPI, ModelSearchParams
 
 
 def test_models_list(client: MeshAPI) -> None:
@@ -36,3 +36,30 @@ def test_models_list_filter_free(client: MeshAPI) -> None:
 def test_models_list_filter_paid(client: MeshAPI) -> None:
     filtered = client.models.list(free=False)
     assert all(not m.is_free for m in filtered), "list(free=False) returned free models"
+
+
+def test_models_search_paginated(client: MeshAPI) -> None:
+    page = client.models.search(ModelSearchParams(limit=5))
+    assert page.total >= 0, "expected a non-negative total"
+    assert page.limit == 5, "page should echo the requested limit"
+    assert len(page.items) <= 5, "page must not exceed the limit"
+    assert isinstance(page.brands, list), "expected a brands facet list"
+    for m in page.items:
+        assert m.id and m.name
+
+
+def test_models_search_query_filter(client: MeshAPI) -> None:
+    page = client.models.search(ModelSearchParams(q="gpt", limit=10))
+    # Fuzzy match over id/name/brand — every returned model should relate to the query.
+    for m in page.items:
+        haystack = f"{m.id} {m.name}".lower()
+        assert "gpt" in haystack, f"unexpected model {m.id!r} for q='gpt'"
+
+
+def test_models_get_by_id(client: MeshAPI) -> None:
+    listed = client.models.list()
+    assert listed, "need at least one model to fetch by id"
+    target = listed[0].id
+    model = client.models.get(target)
+    assert model.id == target, f"get({target!r}) returned {model.id!r}"
+    assert model.name

meshapi-0.1.8/livetests/test_moderations.py

@@ -0,0 +1,48 @@
+"""Live tests: moderations — POST /v1/moderations."""
+
+from __future__ import annotations
+
+import pytest
+from meshapi import MeshAPI, MeshAPIError, ModerationParams
+
+
+def test_moderation_flags_harmful_text(client: MeshAPI) -> None:
+    try:
+        resp = client.moderations.create(
+            ModerationParams(input="I want to hurt and kill someone right now.")
+        )
+    except MeshAPIError as exc:
+        if exc.status in (403, 404, 501, 503):
+            pytest.skip(f"moderations unavailable on this deployment: {exc.error_code}")
+        raise
+
+    assert resp.results, "expected at least one moderation result"
+    result = resp.results[0]
+    assert result.flagged is True, "expected harmful text to be flagged"
+    assert result.categories, "expected category booleans"
+    assert result.category_scores, "expected category scores"
+
+
+def test_moderation_passes_benign_text(client: MeshAPI) -> None:
+    try:
+        resp = client.moderations.create(ModerationParams(input="I love sunny days at the park."))
+    except MeshAPIError as exc:
+        if exc.status in (403, 404, 501, 503):
+            pytest.skip(f"moderations unavailable on this deployment: {exc.error_code}")
+        raise
+
+    assert resp.results
+    assert resp.results[0].flagged is False, "expected benign text not to be flagged"
+
+
+def test_moderation_batch_input(client: MeshAPI) -> None:
+    try:
+        resp = client.moderations.create(
+            ModerationParams(input=["hello friend", "have a nice day"])
+        )
+    except MeshAPIError as exc:
+        if exc.status in (403, 404, 501, 503):
+            pytest.skip(f"moderations unavailable on this deployment: {exc.error_code}")
+        raise
+
+    assert len(resp.results) == 2, "expected one result per input"

meshapi-0.1.8/livetests/test_responses.py

@@ -0,0 +1,27 @@
+"""Live tests: responses list/get — GET /v1/responses, GET /v1/responses/{id}.
+
+(POST /v1/responses create/stream is covered in test_inference_resources.py.)
+"""
+
+from __future__ import annotations
+
+import pytest
+from meshapi import MeshAPI, MeshAPIError
+
+
+def test_responses_list_shape(client: MeshAPI) -> None:
+    page = client.responses.list(limit=5)
+    # OpenAI list envelope; data may be empty if the account has no background jobs.
+    if page.object is not None:
+        assert page.object == "list"
+    assert isinstance(page.data, list)
+    assert len(page.data) <= 5
+    for item in page.data:
+        assert item.id, "each job must have an id"
+
+
+def test_responses_get_unknown_id_404(client: MeshAPI) -> None:
+    """get() on a non-existent id should raise a structured 404 (exercises the path)."""
+    with pytest.raises(MeshAPIError) as excinfo:
+        client.responses.get("resp_does_not_exist_000000000000")
+    assert excinfo.value.status in (400, 404), f"unexpected status {excinfo.value.status}"

meshapi-0.1.8/livetests/test_router_select.py

@@ -0,0 +1,45 @@
+"""Live tests: router select — POST /v1/router/select.
+
+Gated server-side by AUTO_ROUTER_ENABLED. When disabled the endpoint returns
+403/404, in which case these tests skip (deployment config), not fail.
+"""
+
+from __future__ import annotations
+
+import pytest
+from meshapi import ChatMessage, MeshAPI, MeshAPIError, RouterSelectParams
+
+
+def _select(client: MeshAPI, params: RouterSelectParams):
+    try:
+        return client.router.select(params)
+    except MeshAPIError as exc:
+        if exc.status in (403, 404, 501):
+            pytest.skip(f"auto router disabled on this deployment (AUTO_ROUTER_ENABLED): {exc.error_code}")
+        raise
+
+
+def test_router_select_returns_a_model(client: MeshAPI) -> None:
+    resp = _select(
+        client,
+        RouterSelectParams(
+            messages=[ChatMessage(role="user", content="Write a Python function to reverse a string.")]
+        ),
+    )
+    assert resp.model, "router must always return a model (fail-soft)"
+    assert resp.auto_router is not None
+
+
+def test_router_select_honors_exclusions(client: MeshAPI) -> None:
+    excluded = "openai/gpt-4o-mini"
+    resp = _select(
+        client,
+        RouterSelectParams(
+            messages=[ChatMessage(role="user", content="Explain the theory of relativity simply.")],
+            exclude_models=[excluded],
+        ),
+    )
+    assert resp.model, "router must return a model even with exclusions"
+    # Unless it fell back to the configured default, the excluded model must not be picked.
+    if not resp.auto_router.fallback_used:
+        assert resp.model != excluded, "excluded model should not be selected"