undo 43e9732

feat(ui): make admin settings dynamic based on backend response

routstr/algorithm.py

@@ -282,12 +282,8 @@ def create_model_mappings(
         provider_counts[provider_name] = provider_counts.get(provider_name, 0) + 1
 
     logger.debug(
-        "Created model mappings",
-        extra={
-            "unique_model_count": len(unique_models),
-            "total_alias_count": len(model_instances),
-            "provider_distribution": provider_counts,
-        },
+        f"Updated model mappings with ({len(unique_models)} unique models and {len(model_instances)} aliases)",
+        extra={"provider_distribution": provider_counts},
     )
 
     return model_instances, provider_map, unique_models

routstr/discovery.py

@@ -62,7 +62,9 @@ async def query_nostr_relay_for_providers(
 
                     if data[0] == "EVENT" and data[1] == sub_id:
                         event = data[2]
-                        logger.debug(f"Found provider announcement: {event['id']}")
+                        logger.debug(
+                            f"Found provider announcement: {event['id'][:6]}...{event['id'][-6:]}"
+                        )
                         events.append(event)
                     elif data[0] == "EOSE" and data[1] == sub_id:
                         logger.debug("Received EOSE message")

routstr/nip91.py

@@ -215,7 +215,7 @@ async def query_nip91_events(
                             continue
                     events_out.append(ev_dict)
                     logger.debug(
-                        f"Found existing NIP-91 event: {ev_dict.get('id', '')}"
+                        f"Found listing event: {ev_dict.get('id', '')[:6]}...{ev_dict.get('id', '')[-6:]}"
                     )
                 if drained:
                     last_event_ts = time.time()

routstr/payment/models.py

@@ -1,8 +1,6 @@
 import asyncio
 import json
 import random
-from pathlib import Path
-from urllib.request import urlopen
 
 import httpx
 from fastapi import APIRouter, Depends
@@ -89,53 +87,38 @@ def _has_valid_pricing(model: dict) -> bool:
     return True
 
 
-def fetch_openrouter_models(source_filter: str | None = None) -> list[dict]:
-    """Fetches model information from OpenRouter API."""
-    base_url = "https://openrouter.ai/api/v1"
-
-    try:
-        with urlopen(f"{base_url}/models") as response:
-            data = json.loads(response.read().decode("utf-8"))
-
-            models_data: list[dict] = []
-            for model in data.get("data", []):
-                model_id = model.get("id", "")
-
-                if source_filter:
-                    source_prefix = f"{source_filter}/"
-                    if not model_id.startswith(source_prefix):
-                        continue
-
-                    model = dict(model)
-                    model["id"] = model_id[len(source_prefix) :]
-                    model_id = model["id"]
-
-                if "(free)" in model.get("name", ""):
-                    continue
-
-                if not _has_valid_pricing(model):
-                    continue
-
-                models_data.append(model)
-
-            return models_data
-    except Exception as e:
-        logger.error(f"Error fetching models from OpenRouter API: {e}")
-        return []
-
-
 async def async_fetch_openrouter_models(source_filter: str | None = None) -> list[dict]:
     """Asynchronously fetch model information from OpenRouter API."""
     base_url = "https://openrouter.ai/api/v1"
 
     try:
         async with httpx.AsyncClient() as client:
-            response = await client.get(f"{base_url}/models", timeout=30)
-            response.raise_for_status()
-            data = response.json()
+            models_response, embeddings_response = await asyncio.gather(
+                client.get(f"{base_url}/models", timeout=30),
+                client.get(f"{base_url}/embeddings/models", timeout=30),
+                return_exceptions=True,
+            )
+
+            def process_models_response(
+                response: httpx.Response | BaseException,
+            ) -> list[dict]:
+                if not isinstance(response, BaseException):
+                    response.raise_for_status()
+                    data = response.json()
+                    return [
+                        model
+                        for model in data.get("data", [])
+                        if ":free" not in model.get("id", "").lower()
+                    ]
+                return []
 
             models_data: list[dict] = []
-            for model in data.get("data", []):
+            models_data.extend(process_models_response(models_response))
+            models_data.extend(process_models_response(embeddings_response))
+
+            # Apply source filter and exclusions
+            filtered_models = []
+            for model in models_data:
                 model_id = model.get("id", "")
 
                 if source_filter:
@@ -153,9 +136,9 @@ async def async_fetch_openrouter_models(source_filter: str | None = None) -> lis
                 if not _has_valid_pricing(model):
                     continue
 
-                models_data.append(model)
+                filtered_models.append(model)
 
-            return models_data
+            return filtered_models
     except Exception as e:
         logger.error(f"Error (async) fetching models from OpenRouter API: {e}")
         return []
@@ -169,69 +152,6 @@ def is_openrouter_upstream() -> bool:
     return base.lower() == "https://openrouter.ai/api/v1"
 
 
-def load_models() -> list[Model]:
-    """Load model definitions from a JSON file or auto-generate from OpenRouter API.
-
-    The file path can be specified via the ``MODELS_PATH`` environment variable.
-    If a user-provided models.json exists, it will be used. Otherwise, models are
-    automatically fetched from OpenRouter API in memory. If the example file exists
-    and no user file is provided, it will be used as a fallback.
-    """
-
-    try:
-        models_path = Path(settings.models_path)
-    except Exception:
-        models_path = Path("models.json")
-
-    # Check if user has actively provided a models.json file
-    if models_path.exists():
-        logger.info(f"Loading models from user-provided file: {models_path}")
-        try:
-            with models_path.open("r") as f:
-                data = json.load(f)
-            return [Model(**model) for model in data.get("models", [])]  # type: ignore
-        except Exception as e:
-            logger.error(f"Error loading models from {models_path}: {e}")
-            # Fall through to auto-generation
-
-    # Only auto-generate from OpenRouter when upstream is OpenRouter
-    if not is_openrouter_upstream():
-        logger.info(
-            "Skipping auto-generation from OpenRouter because upstream_base_url is not https://openrouter.ai/api/v1"
-        )
-        return []
-
-    logger.info("Auto-generating models from OpenRouter API")
-    try:
-        source_filter = settings.source or None
-    except Exception:
-        source_filter = None
-    source_filter = source_filter if source_filter and source_filter.strip() else None
-
-    models_data = fetch_openrouter_models(source_filter=source_filter)
-    if not models_data:
-        logger.error("Failed to fetch models from OpenRouter API")
-        return []
-
-    logger.info(f"Successfully fetched {len(models_data)} models from OpenRouter API")
-
-    valid_models = []
-    for model_data in models_data:
-        try:
-            model = Model(**model_data)  # type: ignore
-            valid_models.append(model)
-        except Exception as e:
-            model_id = model_data.get("id", "unknown")
-            logger.warning(f"Skipping model {model_id} - validation failed: {e}")
-
-    if len(valid_models) != len(models_data):
-        logger.warning(
-            f"Filtered out {len(models_data) - len(valid_models)} models with incomplete data"
-        )
-
-    return valid_models
-
-
 def _row_to_model(
     row: ModelRow, apply_provider_fee: bool = False, provider_fee: float = 1.01
 ) -> Model:
@@ -460,57 +380,6 @@ def _update_model_sats_pricing(model: Model, sats_to_usd: float) -> Model:
         return model
 
 
-async def ensure_models_bootstrapped() -> None:
-    async with create_session() as s:
-        existing = (await s.exec(select(ModelRow.id).limit(1))).all()  # type: ignore
-        if existing:
-            return
-
-        try:
-            models_path = Path(settings.models_path)
-        except Exception:
-            models_path = Path("models.json")
-
-        models_to_insert: list[dict] = []
-        if models_path.exists():
-            try:
-                with models_path.open("r") as f:
-                    data = json.load(f)
-                models_to_insert = data.get("models", [])
-                logger.info(
-                    f"Bootstrapping {len(models_to_insert)} models from {models_path}"
-                )
-            except Exception as e:
-                logger.error(f"Error loading models from {models_path}: {e}")
-
-        if not models_to_insert and is_openrouter_upstream():
-            logger.info("Bootstrapping models from OpenRouter API")
-            source_filter = None
-            try:
-                src = settings.source or None
-                source_filter = src if src and src.strip() else None
-            except Exception:
-                pass
-            models_to_insert = fetch_openrouter_models(source_filter=source_filter)
-        elif not models_to_insert:
-            logger.info(
-                "No models.json found and upstream is not OpenRouter; skipping bootstrap"
-            )
-
-        for m in models_to_insert:
-            try:
-                model = Model(**m)  # type: ignore
-            except Exception:
-                # Some OpenRouter models include extra fields; only map required ones
-                continue
-            exists = await s.get(ModelRow, model.id)
-            if exists:
-                continue
-            payload = _model_to_row_payload(model)
-            s.add(ModelRow(**payload))  # type: ignore
-        await s.commit()
-
-
 async def _update_sats_pricing_once() -> None:
     """Update sats pricing once for all provider models (in-memory only)."""
     from ..proxy import get_upstreams
@@ -672,76 +541,6 @@ def _pricing_matches(
     return True
 
 
-async def refresh_models_periodically() -> None:
-    """Background task: periodically fetch OpenRouter models and insert new ones.
-
-    - Respects optional SOURCE filter from settings
-    - Does not overwrite existing rows
-    - Sleeps according to settings.models_refresh_interval_seconds; disabled when 0
-    """
-    interval = getattr(settings, "models_refresh_interval_seconds", 0)
-    if not interval or interval <= 0:
-        return
-
-    # Only refresh from OpenRouter when upstream is OpenRouter
-    if not is_openrouter_upstream():
-        logger.info("Skipping models refresh: upstream_base_url is not OpenRouter")
-        return
-
-    while True:
-        try:
-            try:
-                if not settings.enable_models_refresh:
-                    return
-            except Exception:
-                pass
-            try:
-                src = settings.source or None
-                source_filter = src if src and src.strip() else None
-            except Exception:
-                source_filter = None
-
-            models = fetch_openrouter_models(source_filter=source_filter)
-            if not models:
-                await asyncio.sleep(interval)
-                continue
-
-            async with create_session() as s:
-                result = await s.exec(select(ModelRow.id))  # type: ignore
-                existing_ids = {
-                    row[0] if isinstance(row, tuple) else row for row in result.all()
-                }
-                inserted = 0
-                for m in models:
-                    try:
-                        model = Model(**m)  # type: ignore
-                    except Exception:
-                        continue
-                    if model.id in existing_ids:
-                        continue
-                    payload = _model_to_row_payload(model)
-                    try:
-                        s.add(ModelRow(**payload))  # type: ignore
-                    except Exception:
-                        pass
-                    inserted += 1
-                if inserted:
-                    await s.commit()
-                    logger.info(f"Inserted {inserted} new models from OpenRouter")
-        except asyncio.CancelledError:
-            break
-        except Exception as e:
-            logger.error(
-                "Error during models refresh",
-                extra={"error": str(e), "error_type": type(e).__name__},
-            )
-        try:
-            jitter = max(0.0, float(interval) * 0.1)
-            await asyncio.sleep(interval + random.uniform(0, jitter))
-        except asyncio.CancelledError:
-            break
-
-
 @models_router.get("/v1/models")
 @models_router.get("/models", include_in_schema=False)
 async def models(session: AsyncSession = Depends(get_session)) -> dict:

routstr/proxy.py

@@ -65,7 +65,7 @@ def get_upstreams() -> list[BaseUpstreamProvider]:
 
 def get_model_instance(model_id: str) -> Model | None:
     """Get Model instance by ID from global cache."""
-    return _model_instances.get(model_id)
+    return _model_instances.get(model_id.lower())
 
 
 def get_provider_for_model(model_id: str) -> BaseUpstreamProvider | None:

routstr/upstream/base.py

@@ -734,51 +734,53 @@ class BaseUpstreamProvider:
                     await client.aclose()
                 return mapped_error
 
-            if path.endswith("chat/completions"):
-                client_wants_streaming = False
-                if request_body:
-                    try:
-                        request_data = json.loads(request_body)
-                        client_wants_streaming = request_data.get("stream", False)
-                        logger.debug(
-                            "Chat completion request analysis",
-                            extra={
-                                "client_wants_streaming": client_wants_streaming,
-                                "model": request_data.get("model", "unknown"),
-                                "key_hash": key.hashed_key[:8] + "...",
-                            },
-                        )
-                    except json.JSONDecodeError:
-                        logger.warning(
-                            "Failed to parse request body JSON for streaming detection"
-                        )
+            if path.endswith("chat/completions") or path.endswith("embeddings"):
+                if path.endswith("chat/completions"):
+                    client_wants_streaming = False
+                    if request_body:
+                        try:
+                            request_data = json.loads(request_body)
+                            client_wants_streaming = request_data.get("stream", False)
+                            logger.debug(
+                                "Chat completion request analysis",
+                                extra={
+                                    "client_wants_streaming": client_wants_streaming,
+                                    "model": request_data.get("model", "unknown"),
+                                    "key_hash": key.hashed_key[:8] + "...",
+                                },
+                            )
+                        except json.JSONDecodeError:
+                            logger.warning(
+                                "Failed to parse request body JSON for streaming detection"
+                            )
 
-                content_type = response.headers.get("content-type", "")
-                upstream_is_streaming = "text/event-stream" in content_type
-                is_streaming = client_wants_streaming and upstream_is_streaming
+                    content_type = response.headers.get("content-type", "")
+                    upstream_is_streaming = "text/event-stream" in content_type
+                    is_streaming = client_wants_streaming and upstream_is_streaming
 
-                logger.debug(
-                    "Response type analysis",
-                    extra={
-                        "is_streaming": is_streaming,
-                        "client_wants_streaming": client_wants_streaming,
-                        "upstream_is_streaming": upstream_is_streaming,
-                        "content_type": content_type,
-                        "key_hash": key.hashed_key[:8] + "...",
-                    },
-                )
-
-                if is_streaming and response.status_code == 200:
-                    result = await self.handle_streaming_chat_completion(
-                        response, key, max_cost_for_model
+                    logger.debug(
+                        "Response type analysis",
+                        extra={
+                            "is_streaming": is_streaming,
+                            "client_wants_streaming": client_wants_streaming,
+                            "upstream_is_streaming": upstream_is_streaming,
+                            "content_type": content_type,
+                            "key_hash": key.hashed_key[:8] + "...",
+                        },
                     )
-                    background_tasks = BackgroundTasks()
-                    background_tasks.add_task(response.aclose)
-                    background_tasks.add_task(client.aclose)
-                    result.background = background_tasks
-                    return result
 
-                elif response.status_code == 200:
+                    if is_streaming and response.status_code == 200:
+                        result = await self.handle_streaming_chat_completion(
+                            response, key, max_cost_for_model
+                        )
+                        background_tasks = BackgroundTasks()
+                        background_tasks.add_task(response.aclose)
+                        background_tasks.add_task(client.aclose)
+                        result.background = background_tasks
+                        return result
+
+                # Handle both non-streaming chat completions and embeddings
+                if response.status_code == 200:
                     try:
                         return await self.handle_non_streaming_chat_completion(
                             response, key, session, max_cost_for_model
@@ -1519,9 +1521,9 @@ class BaseUpstreamProvider:
                     error_response.headers["X-Cashu"] = refund_token
                     return error_response
 
-                if path.endswith("chat/completions"):
+                if path.endswith("chat/completions") or path.endswith("embeddings"):
                     logger.debug(
-                        "Processing chat completion response",
+                        "Processing completion/embeddings response",
                         extra={"path": path, "amount": amount, "unit": unit},
                     )
 
@@ -1770,15 +1772,32 @@ class BaseUpstreamProvider:
     async def _fetch_openrouter_models(self) -> list[dict]:
         """Fetch models from OpenRouter API."""
         url = "https://openrouter.ai/api/v1/models"
+        embeddings_url = "https://openrouter.ai/api/v1/embeddings/models"
+
         async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.get(url)
-            response.raise_for_status()
-            models = response.json()
-            return [
-                model
-                for model in models.get("data", [])
-                if ":free" not in model.get("id", "").lower()
-            ]
+            models_response, embeddings_response = await asyncio.gather(
+                client.get(url), client.get(embeddings_url), return_exceptions=True
+            )
+
+            all_models = []
+
+            def process_models_response(
+                response: httpx.Response | BaseException,
+            ) -> list[dict]:
+                if not isinstance(response, BaseException):
+                    response.raise_for_status()
+                    data = response.json()
+                    return [
+                        model
+                        for model in data.get("data", [])
+                        if ":free" not in model.get("id", "").lower()
+                    ]
+                return []
+
+            all_models.extend(process_models_response(models_response))
+            all_models.extend(process_models_response(embeddings_response))
+
+            return all_models
 
     async def _fetch_provider_models(self) -> dict:
         """Fetch models from provider's API."""

routstr/upstream/openrouter.py

@@ -50,7 +50,13 @@ class OpenRouterUpstreamProvider(BaseUpstreamProvider):
     async def fetch_models(self) -> list[Model]:
         """Fetch all OpenRouter models."""
         models_data = await async_fetch_openrouter_models()
-        return [Model(**model) for model in models_data]  # type: ignore
+        models = [Model(**model) for model in models_data]  # type: ignore
+        # manual alias for openai/text-embedding-ada-002 due to openrouter api bug
+        for model in models:
+            if model.id == "openai/text-embedding-ada-002":
+                model.alias_ids = ["text-embedding-ada-002-v2"]
+                break
+        return models
 
     async def get_balance(self) -> float | None:
         """Get the current account balance from OpenRouter.

tests/integration/test_embeddings.py

@@ -0,0 +1,97 @@
+import json
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from httpx import AsyncClient
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_proxy_embeddings_endpoint(authenticated_client: AsyncClient) -> None:
+    """Test the embeddings endpoint proxy functionality"""
+
+    test_payload = {
+        "model": "text-embedding-ada-002",
+        "input": "The quick brown fox",
+    }
+
+    mock_response_data = {
+        "object": "list",
+        "data": [
+            {"object": "embedding", "embedding": [0.0023, -0.0012, 0.0045], "index": 0}
+        ],
+        "model": "text-embedding-ada-002",
+        "usage": {"prompt_tokens": 5, "total_tokens": 5},
+    }
+
+    with patch("httpx.AsyncClient.send") as mock_send:
+        # Create a proper async generator for iter_bytes
+        async def mock_iter_bytes(*args: Any, **kwargs: Any) -> Any:
+            yield json.dumps(mock_response_data).encode()
+
+        mock_response = AsyncMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-type": "application/json"}
+        mock_response.text = json.dumps(mock_response_data)
+        # Use MagicMock for synchronous .json() method
+        mock_response.json = MagicMock(return_value=mock_response_data)
+        mock_response.iter_bytes = mock_iter_bytes
+        mock_response.aiter_bytes = mock_iter_bytes
+        mock_send.return_value = mock_response
+
+        # Make POST request to embeddings endpoint
+        response = await authenticated_client.post("/v1/embeddings", json=test_payload)
+
+        assert response.status_code == 200
+        response_data = response.json()
+        assert response_data["object"] == "list"
+        assert len(response_data["data"]) == 1
+        assert response_data["data"][0]["object"] == "embedding"
+
+        # Verify request was forwarded
+        mock_send.assert_called_once()
+        forwarded_request = mock_send.call_args[0][0]
+        # Verify the path ends with embeddings
+        # Note: forwarded path might be full URL
+        assert str(forwarded_request.url).endswith("embeddings")
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_model_case_insensitivity(authenticated_client: AsyncClient) -> None:
+    """Test that model lookups are case insensitive"""
+
+    # We'll use a mixed-case model ID that should match the lowercase one in the system
+    # We assume 'gpt-3.5-turbo' is available in the mock env/database
+
+    test_payload = {
+        "model": "GPT-3.5-TURBO",
+        "messages": [{"role": "user", "content": "Hello"}],
+    }
+
+    with patch("httpx.AsyncClient.send") as mock_send:
+        mock_response_data = {
+            "id": "chatcmpl-123",
+            "object": "chat.completion",
+            "choices": [{"message": {"content": "Hi"}}],
+            "usage": {"total_tokens": 10},
+        }
+
+        async def mock_iter_bytes(*args: Any, **kwargs: Any) -> Any:
+            yield json.dumps(mock_response_data).encode()
+
+        mock_response = AsyncMock()
+        mock_response.status_code = 200
+        mock_response.headers = {"content-type": "application/json"}
+        mock_response.text = json.dumps(mock_response_data)
+        mock_response.json = MagicMock(return_value=mock_response_data)
+        mock_response.iter_bytes = mock_iter_bytes
+        mock_response.aiter_bytes = mock_iter_bytes
+        mock_send.return_value = mock_response
+
+        response = await authenticated_client.post(
+            "/v1/chat/completions", json=test_payload
+        )
+
+        assert response.status_code == 200

ui/components/settings/admin-settings.tsx

@@ -18,6 +18,7 @@ import { Textarea } from '@/components/ui/textarea';
 import { Alert, AlertDescription } from '@/components/ui/alert';
 import { AlertCircle, Save, RefreshCw, Eye, EyeOff } from 'lucide-react';
 import { toast } from 'sonner';
+import { Switch } from '@/components/ui/switch';
 
 interface SettingsData {
   name?: string;
@@ -28,9 +29,32 @@ interface SettingsData {
   http_url?: string;
   onion_url?: string;
   cashu_mints?: string[];
+  relays?: string[];
   [key: string]: unknown;
 }
 
+const HANDLED_KEYS = [
+  'name',
+  'description',
+  'http_url',
+  'onion_url',
+  'npub',
+  'nsec',
+  'cashu_mints',
+  'relays',
+  'admin_password',
+  'id',
+  'updated_at',
+];
+
+const IGNORED_KEYS = [
+  'upstream_base_url',
+  'upstream_api_key',
+  'upstream_provider_fee',
+  'exchange_fee',
+  'models_path',
+];
+
 interface PasswordData {
   current_password: string;
   new_password: string;
@@ -44,6 +68,7 @@ export function AdminSettings() {
   const [error, setError] = useState<string>('');
   const [showSecrets, setShowSecrets] = useState(false);
   const [newMint, setNewMint] = useState('');
+  const [newRelay, setNewRelay] = useState('');
   const [passwordData, setPasswordData] = useState<PasswordData>({
     current_password: '',
     new_password: '',
@@ -129,7 +154,7 @@ export function AdminSettings() {
     }
   };
 
-  const handleInputChange = (field: string, value: string | boolean) => {
+  const handleInputChange = (field: string, value: unknown) => {
     setSettings((prev) => ({
       ...prev,
       [field]: value,
@@ -153,6 +178,23 @@ export function AdminSettings() {
     }));
   };
 
+  const addRelay = () => {
+    if (newRelay.trim()) {
+      setSettings((prev) => ({
+        ...prev,
+        relays: [...(prev.relays || []), newRelay.trim()],
+      }));
+      setNewRelay('');
+    }
+  };
+
+  const removeRelay = (index: number) => {
+    setSettings((prev) => ({
+      ...prev,
+      relays: prev.relays?.filter((_, i) => i !== index) || [],
+    }));
+  };
+
   const renderSecretField = (
     field: string,
     label: string,
@@ -162,7 +204,7 @@ export function AdminSettings() {
     const displayValue = showSecrets ? value : value ? '••••••••' : '';
 
     return (
-      <div className='space-y-2'>
+      <div key={field} className='space-y-2'>
         <Label htmlFor={field}>{label}</Label>
         <div className='flex gap-2'>
           <Input
@@ -190,6 +232,89 @@ export function AdminSettings() {
     );
   };
 
+  const renderDynamicField = (key: string, value: unknown) => {
+    const label = key
+      .split('_')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+
+    if (typeof value === 'boolean') {
+      return (
+        <div
+          key={key}
+          className='flex items-center justify-between space-y-0 py-4'
+        >
+          <Label htmlFor={key}>{label}</Label>
+          <Switch
+            id={key}
+            checked={value}
+            onCheckedChange={(checked) => handleInputChange(key, checked)}
+          />
+        </div>
+      );
+    }
+
+    if (typeof value === 'number') {
+      return (
+        <div key={key} className='space-y-2'>
+          <Label htmlFor={key}>{label}</Label>
+          <Input
+            id={key}
+            type='number'
+            value={value}
+            onChange={(e) => {
+              const val = e.target.value === '' ? 0 : Number(e.target.value);
+              handleInputChange(key, val);
+            }}
+          />
+        </div>
+      );
+    }
+
+    if (Array.isArray(value)) {
+      const strValue = value.join(', ');
+      return (
+        <div key={key} className='space-y-2'>
+          <Label htmlFor={key}>{label}</Label>
+          <Textarea
+            id={key}
+            value={strValue}
+            onChange={(e) => {
+              const arr = e.target.value
+                .split(',')
+                .map((s) => s.trim())
+                .filter((s) => s !== '');
+              handleInputChange(key, arr);
+            }}
+            placeholder='Comma separated values'
+            rows={2}
+          />
+        </div>
+      );
+    }
+
+    const isSecret =
+      key.includes('key') ||
+      key.includes('password') ||
+      key.includes('secret') ||
+      key.includes('nsec');
+
+    if (isSecret) {
+      return renderSecretField(key, label);
+    }
+
+    return (
+      <div key={key} className='space-y-2'>
+        <Label htmlFor={key}>{label}</Label>
+        <Input
+          id={key}
+          value={(value as string) || ''}
+          onChange={(e) => handleInputChange(key, e.target.value)}
+        />
+      </div>
+    );
+  };
+
   if (loading) {
     return (
       <div className='flex items-center justify-center py-8'>
@@ -337,6 +462,73 @@ export function AdminSettings() {
           </CardContent>
         </Card>
 
+        {/* Relays */}
+        <Card>
+          <CardHeader>
+            <CardTitle>Nostr Relays</CardTitle>
+            <CardDescription>
+              Configure Nostr relays for communication
+            </CardDescription>
+          </CardHeader>
+          <CardContent className='space-y-4'>
+            <div className='space-y-2'>
+              <Label htmlFor='newRelay'>Add Relay URL</Label>
+              <div className='flex gap-2'>
+                <Input
+                  id='newRelay'
+                  value={newRelay}
+                  onChange={(e) => setNewRelay(e.target.value)}
+                  placeholder='wss://relay.example.com'
+                />
+                <Button onClick={addRelay} disabled={!newRelay.trim()}>
+                  Add Relay
+                </Button>
+              </div>
+            </div>
+
+            {settings.relays && settings.relays.length > 0 && (
+              <div className='space-y-2'>
+                <Label>Configured Relays</Label>
+                <div className='space-y-2'>
+                  {settings.relays.map((relay, index) => (
+                    <div
+                      key={index}
+                      className='flex items-center gap-2 rounded border p-2'
+                    >
+                      <span className='flex-1 text-sm'>{relay}</span>
+                      <Button
+                        variant='outline'
+                        size='sm'
+                        onClick={() => removeRelay(index)}
+                      >
+                        Remove
+                      </Button>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+          </CardContent>
+        </Card>
+
+        {/* Other Settings */}
+        <Card>
+          <CardHeader>
+            <CardTitle>Advanced Settings</CardTitle>
+            <CardDescription>
+              Configure additional node settings
+            </CardDescription>
+          </CardHeader>
+          <CardContent className='space-y-4'>
+            {Object.keys(settings)
+              .filter(
+                (key) =>
+                  !HANDLED_KEYS.includes(key) && !IGNORED_KEYS.includes(key)
+              )
+              .map((key) => renderDynamicField(key, settings[key]))}
+          </CardContent>
+        </Card>
+
         <Card className='mt-6'>
           <CardFooter className='flex justify-between'>
             <Button