simpleaudit-studio 0.4.2__tar.gz → 0.5.0__tar.gz

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simpleaudit-studio
-Version: 0.4.2
+Version: 0.5.0
 Summary: Production AI model audit platform — one-liner demo mode via uvx
 License: MIT
 License-File: LICENSE

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/audits/comparison.py

@@ -156,13 +156,13 @@ def compare_runs(project, run_ids: list[int]) -> dict:
             text = getter(r)
             url = None
             if label == "Target model" and r.target_model_id:
-                url = f"/models/#conn-{r.target_model.connection_id}"
+                url = f"/connections/#conn-{r.target_model.connection_id}"
             elif label == "Auditor model" and r.auditor_model_id:
-                url = f"/models/#conn-{r.auditor_model.connection_id}"
+                url = f"/connections/#conn-{r.auditor_model.connection_id}"
             elif label == "Judge" and frozen_judge(r)["judge_id"]:
                 url = f"/judges/{frozen_judge(r)['judge_id']}/?v={frozen_judge(r)['version']}"
             elif label == "Judge model" and r.judge_model_id:
-                url = f"/models/#conn-{r.judge_model.connection_id}"
+                url = f"/connections/#conn-{r.judge_model.connection_id}"
             elif label == "Scenario set version" and r.scenario_set_version:
                 url = f"/scenarios/?set={r.scenario_set_version.scenario_set_id}"
             cells.append(_cell(text, url))

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/config/urls.py

@@ -16,7 +16,9 @@ from infra.seo import LandingView, llms_txt, robots_txt, sitemap_xml
 from infra.ui import (
     AdminView,
     CompareView,
+    ConnectionCheckView,
     ConnectionDeleteView,
+    ConnectionsView,
     DashboardView,
     DiscoverModelsView,
     ExperimentDetailView,
@@ -24,7 +26,6 @@ from infra.ui import (
     HealthView,
     JudgeScriptView,
     LoginView,
-    ModelsView,
     MonitorActionView,
     MonitorDetailView,
     MonitorsView,
@@ -176,9 +177,10 @@ urlpatterns = [
     path("scenarios/diff/<int:set_id>/", ScenarioDiffView.as_view(), name="scenario_diff"),
     path("scenarios/<int:set_id>/export/", ScenarioExportView.as_view(), name="scenario_export"),
     path("scenarios/<int:set_id>/import/", ScenarioImportView.as_view(), name="scenario_import"),
-    path("models/", ModelsView.as_view(), name="models"),
-    path("models/discover/", DiscoverModelsView.as_view(), name="models_discover"),
-    path("models/connection-delete/<int:conn_id>/", ConnectionDeleteView.as_view(), name="connection_delete"),
+    path("connections/", ConnectionsView.as_view(), name="connections"),
+    path("connections/discover/", DiscoverModelsView.as_view(), name="models_discover"),
+    path("connections/check/", ConnectionCheckView.as_view(), name="connection_check"),
+    path("connections/<int:conn_id>/delete/", ConnectionDeleteView.as_view(), name="connection_delete"),
     path("judges/", JudgesView.as_view(), name="judges"),
     path("judges/new/", JudgeDetailView.as_view(), name="judge_new"),
     path("judges/preview/", JudgePreviewView.as_view(), name="judge_preview"),

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/docs/architecture.md

@@ -73,7 +73,7 @@ data directory (`~/.simpleaudit-studio/embedded-pg`, override with
 | `/monitors/`, `/monitors/<id>/` | Monitors and drift charts |
 | `/runs/<id>/`, `/runs/<id>/results/<rid>/` | Run detail (live) and per-scenario result |
 | `/compare/?runs=a,b` | Side-by-side comparison of completed runs |
-| `/scenarios/`, `/models/` | Scenario library and model registry |
+| `/scenarios/`, `/connections/` | Scenario library; connections (servers + API keys) and the models registered on them |
 | `/judges/`, `/judges/<id>/` | Judges: start from a SimpleAudit judge or write own criteria, edit (new version), clone, version history, live prompt preview (`/judges/preview/`) |
 | `/workspaces/`, `/admin-settings/`, `/profile/`, `/health/` | Workspaces, super-admin settings, profile, system health |
 | `/healthz`, `/readyz` | Liveness and readiness probes |

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/docs/domain-model.md

@@ -216,7 +216,7 @@ Rules:
 A connection authenticates with either `api_key_direct` (stored on the
 connection) or `secret_reference`, the name of an environment variable read at
 execution time (e.g. `OPENAI_API_KEY`). The direct key wins when both are set.
-Keys are never rendered into pages: the models page and model discovery look the
+Keys are never rendered into pages: the Connections page and model discovery look the
 connection up server-side (`model_registry.services`).
 
 ### 4.4 `Judge` and `JudgeVersion` (`judges/`)

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/infra/context_processors.py

@@ -92,7 +92,7 @@ _NAV = (
     ("experiments", "Experiments", "⊞", ("/experiments/",), False),
     ("monitors", "Monitors", "↻", ("/monitors/",), False),
     ("scenarios", "Scenarios", "▤", ("/scenarios/",), False),
-    ("models", "Models", "⬡", ("/models/",), False),
+    ("connections", "Connections", "⬡", ("/connections/",), False),
     ("judges", "Judges", "⚖", ("/judges/",), False),
     ("compare", "Compare", "⇄", ("/compare/",), False),
     ("health", "Health", "⚕", ("/health/",), True),

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/infra/seo.py

@@ -175,7 +175,7 @@ def robots_txt(request):
         "Disallow: /health/",
         "Disallow: /runs/",
         "Disallow: /scenarios/",
-        "Disallow: /models/",
+        "Disallow: /connections/",
         "Disallow: /compare/",
         "Disallow: /auth/",
         "Disallow: /static/",

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/infra/tests/test_connection_delete.py

@@ -34,10 +34,10 @@ class ConnectionDeleteTest(TestCase):
         conn = ModelConnectionFactory(project=self.project, name="unused-conn")
         RegisteredModelFactory(connection=conn, project=self.project)
 
-        resp = self.client.post(f"/models/connection-delete/{conn.id}/")
+        resp = self.client.post(f"/connections/{conn.id}/delete/")
 
         assert resp.status_code == 302
-        assert resp.url == "/models/"
+        assert resp.url == "/connections/"
         assert not conn.__class__.objects.filter(pk=conn.id).exists()
 
     def test_delete_referenced_connection_is_blocked_with_message(self):
@@ -45,16 +45,16 @@ class ConnectionDeleteTest(TestCase):
         pinned_model = RegisteredModelFactory(connection=conn, project=self.project)
         AuditRunFactory(project=self.project, target_model=pinned_model)
 
-        resp = self.client.post(f"/models/connection-delete/{conn.id}/")
+        resp = self.client.post(f"/connections/{conn.id}/delete/")
 
         assert resp.status_code == 302
-        assert resp.url == "/models/"
+        assert resp.url == "/connections/"
         # Connection and its models must still exist.
         assert conn.__class__.objects.filter(pk=conn.id).exists()
         assert pinned_model.__class__.objects.filter(pk=pinned_model.id).exists()
         # The error banner is rendered on the next page load (base.html iterates
         # the messages framework), so follow the redirect and check the body.
-        get_resp = self.client.get("/models/")
+        get_resp = self.client.get("/connections/")
         body = get_resp.content.decode()
         assert "runs or monitors use it" in body
 
@@ -62,7 +62,7 @@ class ConnectionDeleteTest(TestCase):
         other_project = ProjectFactory()
         conn = ModelConnectionFactory(project=other_project, name="foreign-conn")
 
-        resp = self.client.post(f"/models/connection-delete/{conn.id}/")
+        resp = self.client.post(f"/connections/{conn.id}/delete/")
 
         assert resp.status_code == 302
         assert conn.__class__.objects.filter(pk=conn.id).exists()
@@ -89,7 +89,7 @@ class RegisteredModelDeleteTest(TestCase):
         conn = ModelConnectionFactory(project=self.project, name="conn-a")
         rm = RegisteredModelFactory(connection=conn, project=self.project)
 
-        resp = self.client.post("/models/", {"action": "delete_model", "rm_id": rm.id}, follow=True)
+        resp = self.client.post("/connections/", {"action": "delete_model", "rm_id": rm.id}, follow=True)
 
         assert resp.status_code == 200
         assert not RegisteredModel.objects.filter(pk=rm.id).exists()
@@ -101,7 +101,7 @@ class RegisteredModelDeleteTest(TestCase):
         rm = RegisteredModelFactory(connection=conn, project=self.project)
         AuditRunFactory(project=self.project, target_model=rm)
 
-        resp = self.client.post("/models/", {"action": "delete_model", "rm_id": rm.id}, follow=True)
+        resp = self.client.post("/connections/", {"action": "delete_model", "rm_id": rm.id}, follow=True)
 
         assert resp.status_code == 200
         # Model must still exist.
@@ -111,7 +111,7 @@ class RegisteredModelDeleteTest(TestCase):
 
 
 class DiscoverModelsKeyTests(TestCase):
-    """The Models page must never render API keys; discover resolves them server-side."""
+    """The Connections page must never render API keys; discover resolves them server-side."""
 
     def setUp(self):
         self.user = UserFactory()
@@ -127,7 +127,7 @@ class DiscoverModelsKeyTests(TestCase):
         )
 
     def test_models_page_does_not_contain_the_key(self):
-        page = self.client.get("/models/")
+        page = self.client.get("/connections/")
         self.assertEqual(page.status_code, 200)
         self.assertNotContains(page, "sk-super-secret-123")
         self.assertContains(page, f'data-discover="{self.conn.id}"')
@@ -138,11 +138,86 @@ class DiscoverModelsKeyTests(TestCase):
         fake = mock.MagicMock()
         fake.json.return_value = {"data": [{"id": "gpt-x"}]}
         with mock.patch("model_registry.services.httpx.get", return_value=fake) as get:
-            resp = self.client.post("/models/discover/", {"connection_id": self.conn.id})
+            resp = self.client.post("/connections/discover/", {"connection_id": self.conn.id})
         self.assertEqual(resp.json()["models"], ["gpt-x"])
         url, kwargs = get.call_args.args[0], get.call_args.kwargs
         self.assertEqual(kwargs["headers"]["Authorization"], "Bearer sk-super-secret-123")
         self.assertEqual(url, "https://api.example.invalid/v1/models")
 
         other = ModelConnection.objects.create(project=ProjectFactory(), name="Other", base_url="https://x.invalid/v1")
-        self.assertEqual(self.client.post("/models/discover/", {"connection_id": other.id}).status_code, 404)
+        self.assertEqual(self.client.post("/connections/discover/", {"connection_id": other.id}).status_code, 404)
+
+
+class ConnectionCheckTests(TestCase):
+    """The connection dialog's Check tries unsaved settings before saving."""
+
+    def setUp(self):
+        from unittest import mock
+
+        self.mock = mock
+        self.user = UserFactory()
+        self.user.set_password("pw")
+        self.user.save()
+        self.project = ProjectFactory()
+        self.membership = MembershipFactory(user=self.user, project=self.project, role="admin")
+        self.client = Client()
+        self.client.login(username=self.user.username, password="pw")
+
+    def _server(self, ids=("a", "b")):
+        fake = self.mock.MagicMock()
+        fake.json.return_value = {"data": [{"id": i} for i in ids]}
+        return self.mock.patch("model_registry.services.httpx.get", return_value=fake)
+
+    def test_typed_settings_are_tried(self):
+        with self._server(["m1", "m2"]) as get:
+            out = self.client.post("/connections/check/", {
+                "conn_provider": "openai", "conn_base_url": "https://new.invalid/v1",
+                "key_mode": "stored", "conn_api_key": "sk-typed",
+            }).json()
+        self.assertEqual(out, {"ok": True, "count": 2, "models": ["m1", "m2"]})
+        self.assertEqual(get.call_args.args[0], "https://new.invalid/v1/models")
+        self.assertEqual(get.call_args.kwargs["headers"]["Authorization"], "Bearer sk-typed")
+        self.assertFalse(ModelConnection.objects.exists())   # nothing saved
+
+    def test_editing_with_blank_key_uses_the_stored_one(self):
+        conn = ModelConnection.objects.create(project=self.project, name="C", base_url="https://c.invalid/v1",
+                                              api_key_direct="sk-stored")
+        with self._server() as get:
+            self.client.post("/connections/check/", {"conn_id": conn.id, "conn_base_url": conn.base_url,
+                                                     "key_mode": "stored", "conn_api_key": ""})
+        self.assertEqual(get.call_args.kwargs["headers"]["Authorization"], "Bearer sk-stored")
+
+    def test_another_workspaces_key_is_never_used(self):
+        other = ModelConnection.objects.create(project=ProjectFactory(), name="O", base_url="https://o.invalid/v1",
+                                               api_key_direct="sk-not-yours")
+        with self._server() as get:
+            self.client.post("/connections/check/", {"conn_id": other.id, "conn_base_url": other.base_url,
+                                                     "key_mode": "stored"})
+        self.assertNotIn("Authorization", get.call_args.kwargs["headers"])
+
+    def test_errors_are_reported(self):
+        import httpx
+
+        self.assertIn("base URL", self.client.post("/connections/check/", {"conn_base_url": ""}).json()["error"])
+        with self.mock.patch("model_registry.services.httpx.get", side_effect=httpx.ConnectError("refused")):
+            out = self.client.post("/connections/check/", {"conn_base_url": "https://down.invalid/v1"}).json()
+        self.assertFalse(out["ok"])
+        self.assertTrue(out["error"])
+
+    def test_a_web_page_is_explained(self):
+        fake = self.mock.MagicMock()
+        fake.json.side_effect = ValueError("Expecting value")
+        with self.mock.patch("model_registry.services.httpx.get", return_value=fake):
+            out = self.client.post("/connections/check/", {"conn_base_url": "https://site.invalid"}).json()
+        self.assertIn("usually ends in /v1", out["error"])
+
+    def test_viewers_cannot_check(self):
+        self.membership.role = "viewer"
+        self.membership.save()
+        self.assertEqual(self.client.post("/connections/check/", {"conn_base_url": "https://x.invalid/v1"}).status_code, 403)
+
+    def test_each_provider_listed_once(self):
+        ModelConnection.objects.create(project=self.project, name="G", provider="gemini", base_url="https://g.invalid")
+        providers = self.client.get("/connections/").context["providers"]
+        self.assertEqual(providers.count("openai"), 1)
+        self.assertIn("gemini", providers)   # a connection's own provider stays pickable

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/infra/tests/test_connection_sharing.py

@@ -111,8 +111,8 @@ class VisibilityHelperTests(TestCase):
         self.assertEqual(names, {"Owner WS", "Other WS"})
 
 
-class ModelsPageSharingTests(TestCase):
-    """The Models page shows shared connections read-only to consumers."""
+class ConnectionsPageSharingTests(TestCase):
+    """The Connections page shows shared connections read-only to consumers."""
 
     def setUp(self):
         self.owner_ws = ProjectFactory(name="Owner WS")
@@ -133,7 +133,7 @@ class ModelsPageSharingTests(TestCase):
         _login(self.client, user)
         self.client.session["active_project_id"] = ws.id
         self.client.session.save()
-        return self.client.get("/models/")
+        return self.client.get("/connections/")
 
     def test_consumer_sees_shared_connection_readonly(self):
         page = self._page_as(self.consumer_user, self.consumer_ws)
@@ -154,7 +154,7 @@ class ModelsPageSharingTests(TestCase):
         self.client.session["active_project_id"] = self.consumer_ws.id
         self.client.session.save()
         before = self.conn.description
-        resp = self.client.post("/models/", {
+        resp = self.client.post("/connections/", {
             "action": "edit_connection", "conn_id": self.conn.id,
             "conn_name": "Hacked", "conn_base_url": "https://evil.example/v1",
             "conn_enabled": "1", "key_mode": "none",
@@ -168,7 +168,7 @@ class ModelsPageSharingTests(TestCase):
         _login(self.client, self.consumer_user)
         self.client.session["active_project_id"] = self.consumer_ws.id
         self.client.session.save()
-        resp = self.client.post(f"/models/connection-delete/{self.conn.id}/")
+        resp = self.client.post(f"/connections/{self.conn.id}/delete/")
         self.assertEqual(resp.status_code, 302)
         self.assertTrue(ModelConnection.objects.filter(pk=self.conn.id).exists())
 
@@ -176,7 +176,7 @@ class ModelsPageSharingTests(TestCase):
         _login(self.client, self.owner_user)
         self.client.session["active_project_id"] = self.owner_ws.id
         self.client.session.save()
-        self.client.post("/models/", {
+        self.client.post("/connections/", {
             "action": "edit_connection", "conn_id": self.conn.id,
             "conn_name": "Public OpenAI", "conn_base_url": "https://api.openai.com/v1",
             "conn_enabled": "1", "key_mode": "none",

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/infra/tests/test_smoke_all_pages.py

@@ -80,7 +80,7 @@ class AllPagesSmokeTest(TestCase):
 
     def test_main_pages(self):
         self._ok("/scenarios/", "Scenario Library")
-        self._ok("/models/", "Models")
+        self._ok("/connections/", "Connections")
         self._ok("/workspaces/", "Workspaces")
         self._ok("/profile/", "Profile")
 

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/infra/tests/test_write_guard.py

@@ -33,7 +33,7 @@ class ViewerWriteTests(_Base):
         self.assertFalse(ScenarioSet.objects.filter(name="Sneaky").exists())
 
     def test_viewer_cannot_add_connection(self):
-        resp = self.client.post("/models/", {
+        resp = self.client.post("/connections/", {
             "action": "add_connection", "conn_name": "X", "conn_base_url": "https://api.example.com/v1",
         }, follow=True)
         self.assertContains(resp, "Admin or auditor role required")
@@ -48,10 +48,10 @@ class AuditorWriteTests(_Base):
         self.assertTrue(ScenarioSet.objects.filter(project=self.project, name="Allowed").exists())
 
     def test_connection_base_url_is_validated(self):
-        resp = self.client.post("/models/", {"action": "add_connection", "conn_name": "Bad", "conn_base_url": "not a url"}, follow=True)
+        resp = self.client.post("/connections/", {"action": "add_connection", "conn_name": "Bad", "conn_base_url": "not a url"}, follow=True)
         self.assertContains(resp, "Base URL must be an http(s) URL")
         self.assertFalse(ModelConnection.objects.filter(project=self.project).exists())
-        self.client.post("/models/", {"action": "add_connection", "conn_name": "Ok", "conn_base_url": "http://mock-model:8080/v1"})
+        self.client.post("/connections/", {"action": "add_connection", "conn_name": "Ok", "conn_base_url": "http://mock-model:8080/v1"})
         self.assertTrue(ModelConnection.objects.filter(project=self.project, name="Ok").exists())
 
 
@@ -80,7 +80,7 @@ class ModelsPageTests(_Base):
 
         conn = ModelConnectionFactory(project=self.project)
         RegisteredModel.objects.create(connection=conn, project=self.project, model_id="a", display_name="a")
-        resp = self.client.post("/models/", {"action": "add_models", "conn_id": conn.id, "model_id": ["a", "b", "c"]})
+        resp = self.client.post("/connections/", {"action": "add_models", "conn_id": conn.id, "model_id": ["a", "b", "c"]})
         self.assertEqual(resp.status_code, 302)   # redirect after save: refresh won't resubmit
         self.assertEqual(sorted(conn.models.values_list("model_id", flat=True)), ["a", "b", "c"])
         page = self.client.get(resp.url)
@@ -90,17 +90,17 @@ class ModelsPageTests(_Base):
         conn = ModelConnectionFactory(project=self.project, api_key_direct="sk-old", secret_reference="")
         data = {"action": "edit_connection", "conn_id": conn.id, "conn_name": conn.name,
                 "conn_base_url": "https://api.example.com/v1", "conn_enabled": "1"}
-        self.client.post("/models/", {**data, "key_mode": "stored", "conn_api_key": ""})
+        self.client.post("/connections/", {**data, "key_mode": "stored", "conn_api_key": ""})
         conn.refresh_from_db()
         self.assertEqual(conn.api_key_direct, "sk-old")   # blank keeps the stored key
-        resp = self.client.post("/models/", {**data, "key_mode": "env", "conn_secret_ref": ""}, follow=True)
+        resp = self.client.post("/connections/", {**data, "key_mode": "env", "conn_secret_ref": ""}, follow=True)
         self.assertContains(resp, "Enter the environment variable")
         conn.refresh_from_db()
         self.assertEqual(conn.api_key_direct, "sk-old")   # rejected: nothing changed
-        self.client.post("/models/", {**data, "key_mode": "env", "conn_secret_ref": "MY_KEY"})
+        self.client.post("/connections/", {**data, "key_mode": "env", "conn_secret_ref": "MY_KEY"})
         conn.refresh_from_db()
         self.assertEqual((conn.api_key_direct, conn.secret_reference), ("", "MY_KEY"))
-        self.client.post("/models/", {**data, "key_mode": "none"})
+        self.client.post("/connections/", {**data, "key_mode": "none"})
         conn.refresh_from_db()
         self.assertEqual((conn.api_key_direct, conn.secret_reference), ("", ""))
 
@@ -108,24 +108,24 @@ class ModelsPageTests(_Base):
         from infra.tests.factories import RegisteredModelFactory
 
         conn = ModelConnectionFactory(project=self.project)
-        self.client.post("/models/", {"action": "edit_connection", "conn_id": conn.id, "conn_name": conn.name,
+        self.client.post("/connections/", {"action": "edit_connection", "conn_id": conn.id, "conn_name": conn.name,
                                       "conn_base_url": "https://api.example.com/v1", "conn_enabled": "1",
                                       "key_mode": "none", "conn_description": "  Team account  "})
         rm = RegisteredModelFactory(connection=conn, project=self.project)
-        self.client.post("/models/", {"action": "edit_model", "rm_id": rm.id, "model_id_new": rm.model_id,
+        self.client.post("/connections/", {"action": "edit_model", "rm_id": rm.id, "model_id_new": rm.model_id,
                                       "model_display_name": "Fast", "model_description": "Cheap & quick"})
-        self.client.post("/models/", {"action": "add_models", "conn_id": conn.id, "model_id": ["solo"],
+        self.client.post("/connections/", {"action": "add_models", "conn_id": conn.id, "model_id": ["solo"],
                                       "model_description": "Single add"})
         conn.refresh_from_db()
         rm.refresh_from_db()
         self.assertEqual(conn.description, "Team account")
         self.assertEqual((rm.display_name, rm.description), ("Fast", "Cheap & quick"))
         self.assertEqual(conn.models.get(model_id="solo").description, "Single add")
-        page = self.client.get("/models/")
+        page = self.client.get("/connections/")
         self.assertContains(page, "Team account")
         self.assertContains(page, "Cheap & quick")
         # Bulk adds don't copy one description onto every model.
-        self.client.post("/models/", {"action": "add_models", "conn_id": conn.id, "model_id": ["x", "y"],
+        self.client.post("/connections/", {"action": "add_models", "conn_id": conn.id, "model_id": ["x", "y"],
                                       "model_description": "ignored"})
         self.assertFalse(conn.models.filter(model_id__in=["x", "y"]).exclude(description="").exists())
 
@@ -135,7 +135,7 @@ class ModelsPageTests(_Base):
         conn = ModelConnectionFactory(project=self.project)
         used = RegisteredModelFactory(connection=conn, project=self.project)
         AuditRunFactory(project=self.project, target_model=used)
-        page = self.client.get("/models/").content.decode()
+        page = self.client.get("/connections/").content.decode()
         self.assertIn("1 run", page)
         self.assertNotIn(f'value="{used.id}">\n                <button title="Remove model"', page)
         self.assertIn("kept for reproducibility", page)

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/infra/ui.py

@@ -14,6 +14,7 @@ from django.contrib.auth.mixins import LoginRequiredMixin
 from django.db.models import Count, F, Max, ProtectedError, Q, RestrictedError
 from django.http import Http404, HttpResponse, HttpResponseForbidden, JsonResponse
 from django.shortcuts import get_object_or_404, redirect, render
+from django.urls import reverse
 from django.utils import timezone
 from django.views.generic import DetailView, TemplateView, View
 
@@ -1674,10 +1675,10 @@ class ScenarioImportView(ProjectMixin, View):
 DESCRIPTION_MAX = 1000
 
 
-class ModelsView(ProjectMixin, TemplateView):
-    """Model registry: connections (server + key) and the models each one serves."""
+class ConnectionsView(ProjectMixin, TemplateView):
+    """Connections (a server and its API key) and the models registered on each."""
 
-    template_name = "models.html"
+    template_name = "connections.html"
 
     def get_context_data(self, **kw):
         from model_registry.models import ModelConnection
@@ -1730,6 +1731,9 @@ class ModelsView(ProjectMixin, TemplateView):
             conn_data=conn_data,
             model_total=sum(len(c.model_list) for c in connections),
             provider_presets=PROVIDER_PRESETS,
+            # Each provider once: presets share some (OpenAI and "Custom" are
+            # both openai), and a connection's own provider must stay pickable.
+            providers=list(dict.fromkeys([p[2] for p in PROVIDER_PRESETS] + [c.provider for c in connections if c.provider])),
             share_targets=share_targets,
             visibility_choices=[(v, label) for v, label in ModelConnection.Visibility.choices],
         )
@@ -1748,7 +1752,7 @@ class ModelsView(ProjectMixin, TemplateView):
 
         def fail(msg):
             messages.error(request, msg)
-            return redirect(f"/models/{anchor}")
+            return redirect(reverse("connections") + anchor)
 
         if action in ("add_connection", "edit_connection"):
             name = post.get("conn_name", "").strip()
@@ -1842,7 +1846,7 @@ class ModelsView(ProjectMixin, TemplateView):
                 except (ProtectedError, RestrictedError):
                     # Runs pin models (RESTRICT FKs); deleting would break their records.
                     return fail(f"Can't delete “{rm.display_name}”: runs or monitors use it. Kept for reproducibility.")
-        return redirect(f"/models/{anchor}")
+        return redirect(reverse("connections") + anchor)
 
 
 class ConnectionDeleteView(ProjectMixin, View):
@@ -1866,7 +1870,7 @@ class ConnectionDeleteView(ProjectMixin, View):
                     request,
                     "Cannot delete: this connection's models are referenced by audit runs or monitors.",
                 )
-        return redirect("/models/")
+        return redirect("connections")
 
 
 def _base_url_error(raw: str) -> str | None:
@@ -1884,6 +1888,40 @@ def _base_url_error(raw: str) -> str | None:
     return None
 
 
+class ConnectionCheckView(ProjectMixin, View):
+    """Try the connection dialog's values before saving: list the server's
+    models with that base URL, provider and key. Editing with the key left
+    blank uses the connection's stored key."""
+
+    def post(self, request):
+        from model_registry.models import ModelConnection
+        from model_registry.services import (
+            can_edit_connection,
+            fetch_remote_model_ids,
+            http_error_detail,
+        )
+
+        blocked = _require_write_access(request)
+        if blocked:
+            return JsonResponse({"ok": False, "error": "You don't have permission to change connections."}, status=403)
+        post = request.POST
+        mode = post.get("key_mode", "stored")
+        conn = ModelConnection(provider=(post.get("conn_provider") or "openai").strip(),
+                               base_url=(post.get("conn_base_url") or "").strip())
+        if mode == "stored":
+            conn.api_key_direct = (post.get("conn_api_key") or "").strip()
+            saved = ModelConnection.objects.filter(pk=_int(post.get("conn_id"))).first()
+            if not conn.api_key_direct and saved is not None and can_edit_connection(request.user, saved):
+                conn.api_key_direct = saved.api_key_direct
+        elif mode == "env":
+            conn.secret_reference = (post.get("conn_secret_ref") or "").strip()
+        try:
+            ids = fetch_remote_model_ids(conn)
+        except Exception as e:  # noqa: BLE001 - any failure is the answer the user asked for
+            return JsonResponse({"ok": False, "error": http_error_detail(e)})
+        return JsonResponse({"ok": True, "count": len(ids), "models": ids[:6]})
+
+
 class DiscoverModelsView(ProjectMixin, View):
     """List the models a connection's server offers (GET {base_url}/models)."""
 

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/model_registry/services.py

@@ -37,8 +37,8 @@ def models_url(conn) -> str:
 def fetch_remote_model_ids(conn, *, timeout: float = 10) -> list[str]:
     """Model ids the connection's OpenAI-compatible ``/models`` endpoint lists, sorted.
 
-    Raises ``ValueError`` when the connection has no base URL and ``httpx.HTTPError``
-    on network or HTTP failures.
+    Raises ``ValueError`` when the connection has no base URL or the reply isn't
+    a JSON model list, and ``httpx.HTTPError`` on network or HTTP failures.
     """
     if not (conn.base_url or "").strip():
         raise ValueError("This connection has no base URL.")
@@ -48,7 +48,13 @@ def fetch_remote_model_ids(conn, *, timeout: float = 10) -> list[str]:
         headers["Authorization"] = f"Bearer {key}"
     resp = httpx.get(models_url(conn), headers=headers, timeout=timeout)
     resp.raise_for_status()
-    data = resp.json()
+    try:
+        data = resp.json()
+    except ValueError as exc:   # e.g. a web page: the URL isn't the API root
+        raise ValueError(
+            f"{models_url(conn)} didn't return a model list (the reply isn't JSON). "
+            "Check the base URL: it usually ends in /v1."
+        ) from exc
     items = data.get("data", []) if isinstance(data, dict) else data if isinstance(data, list) else []
     ids = {item if isinstance(item, str) else (item.get("id") or item.get("model") or "")
            for item in items if isinstance(item, (str, dict))}

{simpleaudit_studio-0.4.2 → simpleaudit_studio-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "simpleaudit-studio"
-version = "0.4.2"
+version = "0.5.0"
 description = "Production AI model audit platform — one-liner demo mode via uvx"
 readme = "README.md"
 requires-python = ">=3.11"