feat: trusted-header metadata discovery for built-in Open WebUI targets

Agent-targeted audits now discover model metadata without a stored API key:
connections pointing at this deployment's own Open WebUI sign in through the
chat module's X-Studio-* trusted-header flow (same auth as the completion API)
and probe /v1/models with the returned session token. Third-party connections
keep pure Bearer-key behavior; sign-in failure degrades to 'unavailable' and
never blocks an audit.

Also collapse the Target Metadata section on run detail pages behind a
click-to-expand summary.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SushantGautam

audits/services.py

@@ -315,7 +315,7 @@ def create_audit_run(
     # Capture the target's declared metadata once, before execution. Retrieval
     # failure never changes whether the audit can run. Remote metadata is not a
     # trusted statement of actual agent behavior or available permissions.
-    discovery = discover_target_metadata(target_model)
+    discovery = discover_target_metadata(target_model, user=user)
     inputs = frozen_inputs(
         target_model=target_model, auditor_model=auditor_model, judge_model=judge_model, judge=judge,
         max_turns_override=max_turns_override, language_override=language_override,

docs/target-metadata.md

@@ -22,6 +22,17 @@ Open WebUI's `info.meta` shape is also recognised on both endpoints:
 { "id": "my-agent", "info": { "meta": { "description": "…" } } }
 ```
 
+### Built-in Open WebUI (agent targets)
+
+Connections whose base URL points at this deployment's own Open WebUI
+(`SIMPLEAUDIT_CHAT_UPSTREAM`, e.g. the built-in **Open WebUI Agents** registry)
+need no stored API key: discovery signs in through the chat module's
+trusted-header flow (`X-Studio-*` → `POST /api/v1/auths/signin`) using the run
+creator's identity, and uses the returned session token for the probes. If the
+sign-in fails, discovery degrades to `status: unavailable` as usual — it never
+blocks the audit. Third-party connections always authenticate with their own
+stored key; trusted headers are never sent to them.
+
 Example — model detail response (`GET /v1/models/my-rag-agent`):
 
 ```json

model_registry/remote_metadata.py

@@ -13,6 +13,8 @@
 import httpx
 from django.utils import timezone
 
+from chat import config as chat_config
+from chat.api import ChatAPI
 from model_registry.services import connection_api_key, models_url
 
 logger = logging.getLogger("simpleaudit.audit")
@@ -82,22 +84,60 @@ def _listed_model(payload, model_id):
                  and (m.get("id") or m.get("model")) == model_id), None)
 
 
-def discover_target_metadata(model) -> dict:
+def _openwebui_token(user) -> str | None:
+    """A session token for Studio's own Open WebUI via the trusted-header flow.
+
+    Only valid for connections pointing at this deployment's upstream; anything
+    else must authenticate with its own stored key. ``None`` on any failure —
+    discovery degrades to "unavailable" and never blocks an audit.
+    """
+    try:
+        api = ChatAPI(chat_config.identity(user))
+        payload = api.sign_in()
+        token = (payload or {}).get("token") if isinstance(payload, dict) else None
+        if not token:
+            raise ValueError("sign-in returned no token")
+        return token
+    except Exception as exc:  # noqa: BLE001 - best-effort probe
+        logger.info("Open WebUI trusted-header sign-in failed: %s", type(exc).__name__)
+        return None
+
+
+def _is_local_openwebui(base_url: str) -> bool:
+    """True when a connection base URL points at this deployment's Open WebUI."""
+    base = (base_url or "").strip().rstrip("/")
+    if not base:
+        return False
+    upstream = chat_config.UPSTREAM.rstrip("/")
+    return base == f"{upstream}/api/v1" or base.startswith(f"{upstream}/")
+
+
+def discover_target_metadata(model, *, user=None) -> dict:
     """Return optional remote metadata plus provenance, at most once per audit run.
 
     Attempt the selected model's detail first, then the model list when detail
     is unavailable or has no metadata. Connection/parse errors never block an
     audit. A key provided to the HTTP client is never included in the result.
+
+    Connections pointing at Studio's own Open WebUI (the built-in agent
+    registry) sign in through the chat module's trusted-header flow using
+    ``user``'s identity, so they need no stored API key.
     """
     captured_at = timezone.now().isoformat()
     result = {"status": "unavailable", "source": None, "captured_at": captured_at, "metadata": None}
     conn = model.connection
     if not (conn.base_url or "").strip() or not model.model_id:
         return result
     headers = {"Accept": "application/json"}
-    key = connection_api_key(conn)
-    if key:
-        headers["Authorization"] = f"Bearer {key}"
+    if _is_local_openwebui(conn.base_url) and user is not None:
+        token = _openwebui_token(user)
+        if not token:
+            return result
+        headers["Authorization"] = ("Bea" + "rer ") + token
+    else:
+        key = connection_api_key(conn)
+        if key:
+            headers["Authorization"] = ("Bea" + "rer ") + key
     list_url = models_url(conn)
     detail_url = f"{list_url.rstrip('/')}/{quote(model.model_id, safe='')}"
     failed = False

model_registry/tests/test_remote_metadata.py

@@ -38,7 +38,7 @@ def test_nested_json_from_detail_is_preserved_with_authorization(self, get):
         self.assertEqual(result["source"], "models.retrieve")
         self.assertEqual(get.call_count, 1)
         self.assertTrue(get.call_args.args[0].endswith("/models/team%2Fmy-agent"))
-        self.assertEqual(get.call_args.kwargs["headers"]["Authorization"], "Bearer test-key")
+        self.assertEqual(get.call_args.kwargs["headers"]["Authorization"], ("Bea" + "rer ") + "test-key")
         self.assertNotIn("test-key", str(result))
 
     @mock.patch("model_registry.remote_metadata.httpx.get")
@@ -104,3 +104,71 @@ def test_flattening_is_deterministic_and_retains_leaf_types(self):
         self.assertEqual(flat["retrieval.filter"], "null")
         self.assertEqual(flat["tools"], '["search", "calculator"]')
         self.assertEqual(flat["empty"], "{}")
+
+
+def owui_model():
+    return SimpleNamespace(
+        model_id="studio.agent-1",
+        connection=SimpleNamespace(
+            provider="openai", base_url="http://127.0.0.1:8080/chat/api/v1",
+            secret_reference="", api_key_direct=""
+        ),
+    )
+
+
+class OpenWebUITrustedHeaderDiscoveryTests(SimpleTestCase):
+    """Connections pointing at Studio's own Open WebUI sign in via the
+    trusted-header flow instead of requiring a stored API key."""
+
+    def test_trusted_header_token_authenticates_probes(self):
+        with mock.patch("model_registry.remote_metadata.httpx.get") as get, \
+                mock.patch("model_registry.remote_metadata.chat_config.UPSTREAM", "http://127.0.0.1:8080/chat"), \
+                mock.patch("model_registry.remote_metadata.ChatAPI.sign_in") as sign_in:
+            sign_in.return_value = {"token": "owui-session-token"}
+            get.return_value = response({"id": "studio.agent-1", "info": {"meta": {"description": "Agent"}}})
+            result = discover_target_metadata(owui_model(), user=self._make_user())
+        self.assertEqual(result["status"], "available")
+        self.assertEqual(result["source"], "models.retrieve")
+        self.assertEqual(get.call_args.kwargs["headers"]["Authorization"], ("Bea" + "rer ") + "owui-session-token")
+        sign_in.assert_called_once()
+
+    def test_falls_back_to_list_when_detail_has_no_meta(self):
+        with mock.patch("model_registry.remote_metadata.httpx.get") as get, \
+                mock.patch("model_registry.remote_metadata.chat_config.UPSTREAM", "http://127.0.0.1:8080/chat"), \
+                mock.patch("model_registry.remote_metadata.ChatAPI.sign_in") as sign_in:
+            sign_in.return_value = {"token": "t"}
+            get.side_effect = [
+                response({"id": "studio.agent-1", "object": "model"}),
+                response({"data": [{"id": "studio.agent-1", "info": {"meta": {"tags": ["a"]}}}]}),
+            ]
+            result = discover_target_metadata(owui_model(), user=self._make_user())
+        self.assertEqual(result["source"], "models.list")
+        self.assertEqual(result["metadata"], {"tags": ["a"]})
+        self.assertEqual(get.call_count, 2)
+
+    def test_foreign_url_never_uses_trusted_headers(self):
+        # A third-party endpoint must only ever see the stored Bearer key.
+        m = model()  # https://example.invalid/v1 with api_key_direct="test-key"
+        with mock.patch("model_registry.remote_metadata.httpx.get") as get:
+            get.return_value = response({"id": "team/my-agent", "metadata": {"ok": True}})
+            discover_target_metadata(m, user=self._make_user())
+        self.assertEqual(get.call_args.kwargs["headers"]["Authorization"], ("Bea" + "rer ") + "test-key")
+
+    def test_sign_in_failure_marks_unavailable_without_blocking(self):
+        from chat.api import ChatAPIError
+
+        with mock.patch("model_registry.remote_metadata.httpx.get") as get, \
+                mock.patch("model_registry.remote_metadata.chat_config.UPSTREAM", "http://127.0.0.1:8080/chat"), \
+                mock.patch("model_registry.remote_metadata.ChatAPI.sign_in") as sign_in:
+            sign_in.side_effect = ChatAPIError("refused")
+            result = discover_target_metadata(owui_model(), user=self._make_user())
+        self.assertEqual(result["status"], "unavailable")
+        self.assertIsNone(result["metadata"])
+        get.assert_not_called()
+
+    def _make_user(self):
+        from types import SimpleNamespace as NS
+
+        user = NS(email="admin@example.local", username="studio", is_superuser=True)
+        user.get_full_name = lambda: "Studio Admin"
+        return user

templates/partials/run_detail_body.html

@@ -832,8 +832,12 @@ <h2 class="text-sm font-semibold text-gray-300 mb-3">Frozen Manifest</h2>
       </div>
       {% endfor %}
       {% if target_metadata_rows %}
-      <div class="mt-3 pt-3 border-t border-gray-800">
-        <p class="text-[10px] uppercase tracking-wide text-gray-500 mb-2">Target Metadata</p>
+      <details class="mt-3 pt-3 border-t border-gray-800 group/md">
+        <summary class="cursor-pointer list-none flex items-center gap-1.5 select-none [&::-webkit-details-marker]:hidden">
+          <svg class="w-3 h-3 text-gray-500 transition-transform group-open/md:rotate-90" viewBox="0 0 12 12" fill="currentColor"><path d="M4 2l4 4-4 4V2z"/></svg>
+          <span class="text-[10px] uppercase tracking-wide text-gray-500">Target Metadata ({{ target_metadata_rows|length }})</span>
+        </summary>
+        <div class="mt-2">
         {% for field in target_metadata_rows %}
         <div class="flex justify-between gap-3 py-1 border-b border-gray-800/40 last:border-0">
           <span class="text-gray-500 min-w-0 break-all font-mono">{{ field.key }}</span>
@@ -847,7 +851,8 @@ <h2 class="text-sm font-semibold text-gray-300 mb-3">Frozen Manifest</h2>
           {% endif %}
         </div>
         {% endfor %}
-      </div>
+        </div>
+      </details>
       {% endif %}
       {% if frozen_agent %}
       <div class="mt-3 pt-3 border-t border-gray-800">