Merge remote-tracking branch 'origin/release/v0.5.29'

Author: SushantGautam

.env.example

@@ -96,6 +96,9 @@ WORKER_SLOT_COUNT=8
 SEED_DEMO_AUDITS=true
 
 # --- Chat (Open WebUI) ---------------------------------------------------------
+# Required. Open WebUI's secret; it encrypts stored provider keys. Generate once with
+# `openssl rand -hex 32` and keep it: changing it makes stored keys unreadable.
+WEBUI_SECRET_KEY=
 # Single-origin model: Open WebUI (the subpath fork) serves its whole app at
 # /chat/ on Studio's own origin, and Studio's wrapper page (model-picker bar +
 # iframe) lives at /ai/. Caddy is the only published port and does the

chat/api.py

@@ -45,6 +45,25 @@ class ChatAPIError(RuntimeError):
     """Open WebUI refused or could not be reached."""
 
 
+def service_token() -> str | None:
+    """A token for Studio's service account (admin), from the trusted-header sign-in.
+
+    Open WebUI takes the role from the trusted headers on each sign-in, so the
+    account is admin here by design: the runner calls models and agents as admin.
+    None when the chat is unreachable; callers treat that as "no key".
+    """
+    identity = {
+        chat.EMAIL_HEADER: chat.SERVICE_EMAIL,
+        chat.NAME_HEADER: chat.SERVICE_NAME,
+        chat.ROLE_HEADER: "admin",
+    }
+    try:
+        return (ChatAPI(identity).sign_in() or {}).get("token") or None
+    except Exception:
+        logger.info("Service sign-in to Open WebUI failed", exc_info=True)
+        return None
+
+
 class ChatAPI:
     """An Open WebUI session for one Studio user.
 

chat/config.py

@@ -95,6 +95,11 @@ def is_disabled(value: str | None) -> bool:
 EMAIL_HEADER = "X-Studio-Email"
 NAME_HEADER = "X-Studio-Name"
 ROLE_HEADER = "X-Studio-Role"
+
+#: Studio's own Open WebUI account: the runner signs in as it (admin, via the
+#: trusted headers) to call agents and models on anyone's behalf. Not a secret.
+SERVICE_EMAIL = os.environ.get("SIMPLEAUDIT_CHAT_SERVICE_EMAIL", "studio-audit@studio.local")
+SERVICE_NAME = "Studio audit"
 #: Every header the proxy injects — it must strip all of them off the incoming
 #: request before adding its own, or a client could forge them.
 TRUSTED_HEADERS = (EMAIL_HEADER, NAME_HEADER, ROLE_HEADER)

chat/proxy.py

@@ -712,12 +712,17 @@ def _locate_owui_interpreter(home: Path) -> str:
 
 
 def _secret_key(home: Path) -> str:
-    """Open WebUI's signing key — generated once, persisted.
+    """Open WebUI's signing key: the shared ``WEBUI_SECRET_KEY`` if set, else one generated once and persisted.
 
-    A direct uvicorn launch has no `serve` to persist the key, and a fresh
-    random key on every start would sign every session out; the file plays
-    the role ``.webui_secret_key`` serves for `open-webui serve`.
+    A shared key (set in `.env` for `manage.py dev`, or exported for `spin`) lets
+    several installs read the same stored provider keys. Without it, a direct
+    uvicorn launch has no `serve` to persist the key, and a fresh random key on
+    every start would sign every session out; the file plays the role
+    ``.webui_secret_key`` serves for `open-webui serve`.
     """
+    shared = os.environ.get("WEBUI_SECRET_KEY", "").strip()
+    if shared:
+        return shared
     key_file = home / "webui_secret_key"
     try:
         if key_file.exists():

chat/tests/test_proxy.py

@@ -404,3 +404,19 @@ def test_stale_wheel_triggers_rebuild(self):
             managed = Path(tmp)
             proxy._wheel_marker(managed).write_text("https://example.com/old.whl")
             self.assertFalse(proxy._managed_venv_matches_wheel(managed))
+
+
+class SecretKeyTests(SimpleTestCase):
+    def test_a_shared_env_key_wins_and_writes_no_file(self):
+        with tempfile.TemporaryDirectory() as tmp, patch.dict(os.environ, {"WEBUI_SECRET_KEY": "shared-key"}):
+            home = Path(tmp)
+            self.assertEqual(proxy._secret_key(home), "shared-key")
+            self.assertFalse((home / "webui_secret_key").exists())
+
+    def test_without_env_the_key_is_generated_once_and_reused(self):
+        with tempfile.TemporaryDirectory() as tmp, patch.dict(os.environ, {}, clear=False):
+            os.environ.pop("WEBUI_SECRET_KEY", None)
+            home = Path(tmp)
+            first = proxy._secret_key(home)
+            self.assertEqual(proxy._secret_key(home), first)
+            self.assertTrue((home / "webui_secret_key").exists())

docker-compose.yml

@@ -96,6 +96,8 @@ services:
       dockerfile: deploy/compose/Dockerfile
     env_file: .env
     environment:
+      # The agent connection's key is signed in against Open WebUI's internal address.
+      SIMPLEAUDIT_CHAT_UPSTREAM: http://open-webui:8080/chat
       POSTGRES_HOST: postgres
       HATCHET_SERVER_URL: http://hatchet-server:8888
       HATCHET_GRPC_URL: hatchet-server:7077
@@ -194,6 +196,9 @@ services:
       WEBUI_AUTH_TRUSTED_NAME_HEADER: X-Studio-Name
       WEBUI_AUTH_TRUSTED_ROLE_HEADER: X-Studio-Role
       ENABLE_SIGNUP: "false"
+      # Required. Open WebUI encrypts stored provider keys with this secret; if it
+      # changes (for example, a generated one lost on recreate) those keys stop working.
+      WEBUI_SECRET_KEY: ${WEBUI_SECRET_KEY:?set WEBUI_SECRET_KEY in .env (e.g. openssl rand -hex 32)}
       # Retrieval defaults Studio always wants (hybrid search, cached queries, KB exec).
       ENABLE_RAG_HYBRID_SEARCH: ${ENABLE_RAG_HYBRID_SEARCH:-true}
       ENABLE_QUERIES_CACHE: ${ENABLE_QUERIES_CACHE:-true}
@@ -208,14 +213,14 @@ services:
       # HOST/PORT and launches uvicorn itself.
       HOST: "0.0.0.0"
       PORT: ${SIMPLEAUDIT_CHAT_UPSTREAM_PORT:-8080}
-      # Optional: export Open WebUI's spans to Studio's OTLP listener. Off by
-      # default — set SIMPLEAUDIT_CHAT_OTLP=true to enable. Open WebUI passes
+      # Export Open WebUI's spans to Studio's OTLP listener. On by default —
+      # set SIMPLEAUDIT_CHAT_OTLP=false to opt out. Open WebUI passes
       # OTEL_EXPORTER_OTLP_ENDPOINT to its HTTP exporter as-is, so this must be
       # the full Studio ingestion URL. Exports
       # unauthenticated by default (matches an enabled "none" credential); for a
       # basic/bearer credential set OTEL_BASIC_AUTH_USERNAME / OTEL_BASIC_AUTH_PASSWORD.
-      ENABLE_OTEL: ${SIMPLEAUDIT_CHAT_OTLP:-false}
-      ENABLE_OTEL_TRACES: ${SIMPLEAUDIT_CHAT_OTLP:-false}
+      ENABLE_OTEL: ${SIMPLEAUDIT_CHAT_OTLP:-true}
+      ENABLE_OTEL_TRACES: ${SIMPLEAUDIT_CHAT_OTLP:-true}
       OTEL_OTLP_SPAN_EXPORTER: "http"
       OTEL_EXPORTER_OTLP_ENDPOINT: ${SIMPLEAUDIT_CHAT_OTLP_ENDPOINT:-http://web:8000/otlp/v1/traces}
       OTEL_SERVICE_NAME: ${SIMPLEAUDIT_CHAT_OTLP_SERVICE_NAME:-open-webui}

docs/chat.md

@@ -233,6 +233,7 @@ unset: the iframe loads the same-origin `/chat/`.
 | `ENABLE_QUERIES_CACHE` | `true`                 | cache retrieval queries; on by default |
 | `ENABLE_KB_EXEC` | `true`                       | filesystem-style knowledge exec for agentic RAG; on by default |
 | `ENABLE_VERSION_UPDATE_CHECK` | `false`                | Open WebUI's "new version available" banner; off by default because Studio pins the build. Set `true` to show it |
+| `WEBUI_SECRET_KEY` | required, no default | Open WebUI's secret; encrypts stored provider keys. Keep it stable: a new value makes stored keys unreadable |
 
 ## Exporting Open WebUI's spans to Studio (OTLP)
 

model_registry/services.py

@@ -32,12 +32,25 @@ def is_internal_agent_connection(connection) -> bool:
 
 
 def connection_api_key(conn) -> str:
-    """The connection's API key: the stored key first, else the env var it names."""
+    """The connection's API key: the stored key, else the env var it names.
+
+    A connection to Studio's own Open WebUI has neither: it uses the service
+    account's admin token, signed in fresh through the trusted headers.
+    """
     direct = (conn.api_key_direct or "").strip()
     if direct:
         return direct
     ref = (conn.secret_reference or "").strip()
-    return os.environ.get(ref, "") if ref else ""
+    if ref:
+        return os.environ.get(ref, "")
+    from chat import config as chat
+
+    base = (conn.base_url or "").strip().rstrip("/")
+    if chat.ENABLED and base.startswith(chat.UPSTREAM.rstrip("/")):
+        from chat.api import service_token
+
+        return service_token() or ""
+    return ""
 
 
 def models_url(conn) -> str: