fix: add missing import for backend.server.v2.llm.routes

Was removed in earlier commit but still used in include_router.
Caused AttributeError on server startup.

autogpt_platform/backend/backend/api/conn_manager.py

@@ -122,6 +122,24 @@ class ConnectionManager:
 
         return len(connections)
 
+    async def broadcast_to_all(self, *, method: WSMethod, data: dict) -> int:
+        """Broadcast a message to all active websocket connections."""
+        message = WSMessage(
+            method=method,
+            data=data,
+        ).model_dump_json()
+
+        connections = tuple(self.active_connections)
+        if not connections:
+            return 0
+
+        await asyncio.gather(
+            *(connection.send_text(message) for connection in connections),
+            return_exceptions=True,
+        )
+
+        return len(connections)
+
     async def _subscribe(self, channel_key: str, websocket: WebSocket) -> str:
         if channel_key not in self.subscriptions:
             self.subscriptions[channel_key] = set()

autogpt_platform/backend/backend/api/features/admin/execution_analytics_routes.py

@@ -8,6 +8,7 @@ from fastapi import APIRouter, HTTPException, Security
 from pydantic import BaseModel, Field
 
 from backend.blocks.llm import LlmModel
+from backend.data import llm_registry
 from backend.data.analytics import (
     AccuracyTrendsResponse,
     get_accuracy_trends_and_alerts,
@@ -18,6 +19,7 @@ from backend.data.execution import (
     get_graph_executions,
     update_graph_execution_stats,
 )
+from backend.server.v2.llm import db as llm_db
 from backend.data.model import GraphExecutionStats
 from backend.executor.activity_status_generator import (
     DEFAULT_SYSTEM_PROMPT,
@@ -176,30 +178,55 @@ async def get_execution_analytics_config(
         # Return with provider prefix for clarity
         return f"{provider_name}: {model_name}"
 
-    # Include all LlmModel values (no more filtering by hardcoded list)
-    recommended_model = LlmModel.GPT4O_MINI.value
-    for model in LlmModel:
+    # Get all models from the registry (dynamic, not hardcoded enum)
+    # Get the recommended model from the database (configurable via admin UI)
+    recommended_model_slug = await llm_db.get_recommended_model_slug()
+
+    # Build the available models list
+    first_enabled_slug = None
+    for registry_model in llm_registry.iter_dynamic_models():
+        # Only include enabled models in the list
+        if not registry_model.is_enabled:
+            continue
+
+        # Track first enabled model as fallback
+        if first_enabled_slug is None:
+            first_enabled_slug = registry_model.slug
+
+        model = LlmModel(registry_model.slug)
         label = generate_model_label(model)
         # Add "(Recommended)" suffix to the recommended model
-        if model.value == recommended_model:
+        if registry_model.slug == recommended_model_slug:
             label += " (Recommended)"
 
         available_models.append(
             ModelInfo(
-                value=model.value,
+                value=registry_model.slug,
                 label=label,
-                provider=model.provider,
+                provider=registry_model.metadata.provider,
             )
         )
 
     # Sort models by provider and name for better UX
     available_models.sort(key=lambda x: (x.provider, x.label))
 
+    # Handle case where no models are available
+    if not available_models:
+        logger.warning(
+            "No enabled LLM models found in registry. "
+            "Ensure models are configured and enabled in the LLM Registry."
+        )
+        # Return empty list - frontend will handle empty state appropriately
+        # Self-hosters should run database migrations to seed default models
+
+    # Use the DB recommended model, or fallback to first enabled model
+    final_recommended = recommended_model_slug or first_enabled_slug or ""
+
     return ExecutionAnalyticsConfig(
         available_models=available_models,
         default_system_prompt=DEFAULT_SYSTEM_PROMPT,
         default_user_prompt=DEFAULT_USER_PROMPT,
-        recommended_model=recommended_model,
+        recommended_model=final_recommended,
     )
 
 

autogpt_platform/backend/backend/api/features/admin/llm_routes.py

@@ -0,0 +1,599 @@
+import logging
+
+import autogpt_libs.auth
+import fastapi
+
+from backend.api.features.builder import db as builder_db
+from backend.api.features.v1 import _get_cached_blocks
+from backend.blocks._base import BlockSchema
+from backend.data import llm_registry
+from backend.data.block_cost_config import refresh_llm_costs
+from backend.data.llm_registry import publish_registry_refresh_notification
+from backend.data.llm_registry.registry import _fetch_registry_from_db
+from backend.server.v2.llm import db as llm_db
+from backend.server.v2.llm import model as llm_model
+
+logger = logging.getLogger(__name__)
+
+router = fastapi.APIRouter(
+    tags=["llm", "admin"],
+    dependencies=[fastapi.Security(autogpt_libs.auth.requires_admin_user)],
+)
+
+
+async def _refresh_runtime_state() -> None:
+    """Refresh the LLM registry and clear all related caches to ensure real-time updates."""
+    logger.info("Refreshing LLM registry runtime state...")
+    try:
+        _fetch_registry_from_db.cache_clear()
+        logger.debug("Cleared Redis cache for LLM registry")
+
+        # Refresh registry from database
+        await llm_registry.refresh_llm_registry()
+        await refresh_llm_costs()
+
+        # Clear block schema caches so they're regenerated with updated model options
+        BlockSchema.clear_all_schema_caches()
+        logger.info("Cleared all block schema caches")
+
+        # Clear the /blocks endpoint cache so frontend gets updated schemas
+        try:
+            _get_cached_blocks.cache_clear()
+            logger.info("Cleared /blocks endpoint cache")
+        except Exception as e:
+            logger.warning("Failed to clear /blocks cache: %s", e)
+
+        # Clear the v2 builder caches
+        try:
+            builder_db._get_all_providers.cache_clear()
+            logger.info("Cleared v2 builder providers cache")
+            builder_db._build_cached_search_results.cache_clear()
+            logger.info("Cleared v2 builder search results cache")
+            builder_db._get_llm_models.cache_clear()
+            logger.info("Cleared v2 builder LLM models cache")
+        except Exception as e:
+            logger.debug("Could not clear v2 builder cache: %s", e)
+
+        # Fetch fresh data for notification (now contains updated data from DB)
+        models_data = await _fetch_registry_from_db()
+
+        await publish_registry_refresh_notification(models_data=models_data)
+        logger.info(
+            "Published registry refresh notification with %d models", len(models_data)
+        )
+    except Exception as exc:
+        logger.exception(
+            "LLM runtime state refresh failed; caches may be stale: %s", exc
+        )
+
+
+@router.get(
+    "/providers",
+    summary="List LLM providers",
+    response_model=llm_model.LlmProvidersResponse,
+)
+async def list_llm_providers(include_models: bool = True):
+    providers = await llm_db.list_providers(include_models=include_models)
+    return llm_model.LlmProvidersResponse(providers=providers)
+
+
+@router.post(
+    "/providers",
+    summary="Create LLM provider",
+    response_model=llm_model.LlmProvider,
+)
+async def create_llm_provider(request: llm_model.UpsertLlmProviderRequest):
+    provider = await llm_db.upsert_provider(request=request)
+    await _refresh_runtime_state()
+    return provider
+
+
+@router.patch(
+    "/providers/{provider_id}",
+    summary="Update LLM provider",
+    response_model=llm_model.LlmProvider,
+)
+async def update_llm_provider(
+    provider_id: str,
+    request: llm_model.UpsertLlmProviderRequest,
+):
+    provider = await llm_db.upsert_provider(request=request, provider_id=provider_id)
+    await _refresh_runtime_state()
+    return provider
+
+
+@router.delete(
+    "/providers/{provider_id}",
+    summary="Delete LLM provider",
+    response_model=dict,
+)
+async def delete_llm_provider(provider_id: str):
+    """
+    Delete an LLM provider.
+
+    A provider can only be deleted if it has no associated models.
+    Delete all models from the provider first before deleting the provider.
+    """
+    try:
+        await llm_db.delete_provider(provider_id)
+        await _refresh_runtime_state()
+        logger.info("Deleted LLM provider '%s'", provider_id)
+        return {"success": True, "message": "Provider deleted successfully"}
+    except ValueError as e:
+        logger.warning("Failed to delete provider '%s': %s", provider_id, e)
+        raise fastapi.HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.exception("Failed to delete provider '%s': %s", provider_id, e)
+        raise fastapi.HTTPException(status_code=500, detail=str(e))
+
+
+@router.get(
+    "/models",
+    summary="List LLM models",
+    response_model=llm_model.LlmModelsResponse,
+)
+async def list_llm_models(
+    provider_id: str | None = fastapi.Query(default=None),
+    page: int = fastapi.Query(default=1, ge=1, description="Page number (1-indexed)"),
+    page_size: int = fastapi.Query(
+        default=50, ge=1, le=100, description="Number of models per page"
+    ),
+):
+    return await llm_db.list_models(
+        provider_id=provider_id, page=page, page_size=page_size
+    )
+
+
+@router.post(
+    "/models",
+    summary="Create LLM model",
+    response_model=llm_model.LlmModel,
+)
+async def create_llm_model(request: llm_model.CreateLlmModelRequest):
+    model = await llm_db.create_model(request=request)
+    await _refresh_runtime_state()
+    return model
+
+
+@router.patch(
+    "/models/{model_id}",
+    summary="Update LLM model",
+    response_model=llm_model.LlmModel,
+)
+async def update_llm_model(
+    model_id: str,
+    request: llm_model.UpdateLlmModelRequest,
+):
+    model = await llm_db.update_model(model_id=model_id, request=request)
+    await _refresh_runtime_state()
+    return model
+
+
+@router.patch(
+    "/models/{model_id}/toggle",
+    summary="Toggle LLM model availability",
+    response_model=llm_model.ToggleLlmModelResponse,
+)
+async def toggle_llm_model(
+    model_id: str,
+    request: llm_model.ToggleLlmModelRequest,
+):
+    """
+    Toggle a model's enabled status, optionally migrating workflows when disabling.
+
+    If disabling a model and `migrate_to_slug` is provided, all workflows using
+    this model will be migrated to the specified replacement model before disabling.
+    A migration record is created which can be reverted later using the revert endpoint.
+
+    Optional fields:
+    - `migration_reason`: Reason for the migration (e.g., "Provider outage")
+    - `custom_credit_cost`: Custom pricing override for billing during migration
+    """
+    try:
+        result = await llm_db.toggle_model(
+            model_id=model_id,
+            is_enabled=request.is_enabled,
+            migrate_to_slug=request.migrate_to_slug,
+            migration_reason=request.migration_reason,
+            custom_credit_cost=request.custom_credit_cost,
+        )
+        await _refresh_runtime_state()
+        if result.nodes_migrated > 0:
+            logger.info(
+                "Toggled model '%s' to %s and migrated %d nodes to '%s' (migration_id=%s)",
+                result.model.slug,
+                "enabled" if request.is_enabled else "disabled",
+                result.nodes_migrated,
+                result.migrated_to_slug,
+                result.migration_id,
+            )
+        return result
+    except ValueError as exc:
+        logger.warning("Model toggle validation failed: %s", exc)
+        raise fastapi.HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.exception("Failed to toggle LLM model %s: %s", model_id, exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to toggle model availability",
+        ) from exc
+
+
+@router.get(
+    "/models/{model_id}/usage",
+    summary="Get model usage count",
+    response_model=llm_model.LlmModelUsageResponse,
+)
+async def get_llm_model_usage(model_id: str):
+    """Get the number of workflow nodes using this model."""
+    try:
+        return await llm_db.get_model_usage(model_id=model_id)
+    except ValueError as exc:
+        raise fastapi.HTTPException(status_code=404, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.exception("Failed to get model usage %s: %s", model_id, exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to get model usage",
+        ) from exc
+
+
+@router.delete(
+    "/models/{model_id}",
+    summary="Delete LLM model and migrate workflows",
+    response_model=llm_model.DeleteLlmModelResponse,
+)
+async def delete_llm_model(
+    model_id: str,
+    replacement_model_slug: str | None = fastapi.Query(
+        default=None,
+        description="Slug of the model to migrate existing workflows to (required only if workflows use this model)",
+    ),
+):
+    """
+    Delete a model and optionally migrate workflows using it to a replacement model.
+
+    If no workflows are using this model, it can be deleted without providing a
+    replacement. If workflows exist, replacement_model_slug is required.
+
+    This endpoint:
+    1. Counts how many workflow nodes use the model being deleted
+    2. If nodes exist, validates the replacement model and migrates them
+    3. Deletes the model record
+    4. Refreshes all caches and notifies executors
+
+    Example: DELETE /api/llm/admin/models/{id}?replacement_model_slug=gpt-4o
+    Example (no usage): DELETE /api/llm/admin/models/{id}
+    """
+    try:
+        result = await llm_db.delete_model(
+            model_id=model_id, replacement_model_slug=replacement_model_slug
+        )
+        await _refresh_runtime_state()
+        logger.info(
+            "Deleted model '%s' and migrated %d nodes to '%s'",
+            result.deleted_model_slug,
+            result.nodes_migrated,
+            result.replacement_model_slug,
+        )
+        return result
+    except ValueError as exc:
+        # Validation errors (model not found, replacement invalid, etc.)
+        logger.warning("Model deletion validation failed: %s", exc)
+        raise fastapi.HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.exception("Failed to delete LLM model %s: %s", model_id, exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to delete model and migrate workflows",
+        ) from exc
+
+
+# ============================================================================
+# Migration Management Endpoints
+# ============================================================================
+
+
+@router.get(
+    "/migrations",
+    summary="List model migrations",
+    response_model=llm_model.LlmMigrationsResponse,
+)
+async def list_llm_migrations(
+    include_reverted: bool = fastapi.Query(
+        default=False, description="Include reverted migrations in the list"
+    ),
+):
+    """
+    List all model migrations.
+
+    Migrations are created when disabling a model with the migrate_to_slug option.
+    They can be reverted to restore the original model configuration.
+    """
+    try:
+        migrations = await llm_db.list_migrations(include_reverted=include_reverted)
+        return llm_model.LlmMigrationsResponse(migrations=migrations)
+    except Exception as exc:
+        logger.exception("Failed to list migrations: %s", exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to list migrations",
+        ) from exc
+
+
+@router.get(
+    "/migrations/{migration_id}",
+    summary="Get migration details",
+    response_model=llm_model.LlmModelMigration,
+)
+async def get_llm_migration(migration_id: str):
+    """Get details of a specific migration."""
+    try:
+        migration = await llm_db.get_migration(migration_id)
+        if not migration:
+            raise fastapi.HTTPException(
+                status_code=404, detail=f"Migration '{migration_id}' not found"
+            )
+        return migration
+    except fastapi.HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("Failed to get migration %s: %s", migration_id, exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to get migration",
+        ) from exc
+
+
+@router.post(
+    "/migrations/{migration_id}/revert",
+    summary="Revert a model migration",
+    response_model=llm_model.RevertMigrationResponse,
+)
+async def revert_llm_migration(
+    migration_id: str,
+    request: llm_model.RevertMigrationRequest | None = None,
+):
+    """
+    Revert a model migration, restoring affected workflows to their original model.
+
+    This only reverts the specific nodes that were part of the migration.
+    The source model must exist for the revert to succeed.
+
+    Options:
+    - `re_enable_source_model`: Whether to re-enable the source model if disabled (default: True)
+
+    Response includes:
+    - `nodes_reverted`: Number of nodes successfully reverted
+    - `nodes_already_changed`: Number of nodes that were modified since migration (not reverted)
+    - `source_model_re_enabled`: Whether the source model was re-enabled
+
+    Requirements:
+    - Migration must not already be reverted
+    - Source model must exist
+    """
+    try:
+        re_enable = request.re_enable_source_model if request else True
+        result = await llm_db.revert_migration(
+            migration_id,
+            re_enable_source_model=re_enable,
+        )
+        await _refresh_runtime_state()
+        logger.info(
+            "Reverted migration '%s': %d nodes restored from '%s' to '%s' "
+            "(%d already changed, source re-enabled=%s)",
+            migration_id,
+            result.nodes_reverted,
+            result.target_model_slug,
+            result.source_model_slug,
+            result.nodes_already_changed,
+            result.source_model_re_enabled,
+        )
+        return result
+    except ValueError as exc:
+        logger.warning("Migration revert validation failed: %s", exc)
+        raise fastapi.HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.exception("Failed to revert migration %s: %s", migration_id, exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to revert migration",
+        ) from exc
+
+
+# ============================================================================
+# Creator Management Endpoints
+# ============================================================================
+
+
+@router.get(
+    "/creators",
+    summary="List model creators",
+    response_model=llm_model.LlmCreatorsResponse,
+)
+async def list_llm_creators():
+    """
+    List all model creators.
+
+    Creators are organizations that create/train models (e.g., OpenAI, Meta, Anthropic).
+    This is distinct from providers who host/serve the models (e.g., OpenRouter).
+    """
+    try:
+        creators = await llm_db.list_creators()
+        return llm_model.LlmCreatorsResponse(creators=creators)
+    except Exception as exc:
+        logger.exception("Failed to list creators: %s", exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to list creators",
+        ) from exc
+
+
+@router.get(
+    "/creators/{creator_id}",
+    summary="Get creator details",
+    response_model=llm_model.LlmModelCreator,
+)
+async def get_llm_creator(creator_id: str):
+    """Get details of a specific model creator."""
+    try:
+        creator = await llm_db.get_creator(creator_id)
+        if not creator:
+            raise fastapi.HTTPException(
+                status_code=404, detail=f"Creator '{creator_id}' not found"
+            )
+        return creator
+    except fastapi.HTTPException:
+        raise
+    except Exception as exc:
+        logger.exception("Failed to get creator %s: %s", creator_id, exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to get creator",
+        ) from exc
+
+
+@router.post(
+    "/creators",
+    summary="Create model creator",
+    response_model=llm_model.LlmModelCreator,
+)
+async def create_llm_creator(request: llm_model.UpsertLlmCreatorRequest):
+    """
+    Create a new model creator.
+
+    A creator represents an organization that creates/trains AI models,
+    such as OpenAI, Anthropic, Meta, or Google.
+    """
+    try:
+        creator = await llm_db.upsert_creator(request=request)
+        await _refresh_runtime_state()
+        logger.info("Created model creator '%s' (%s)", creator.display_name, creator.id)
+        return creator
+    except Exception as exc:
+        logger.exception("Failed to create creator: %s", exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to create creator",
+        ) from exc
+
+
+@router.patch(
+    "/creators/{creator_id}",
+    summary="Update model creator",
+    response_model=llm_model.LlmModelCreator,
+)
+async def update_llm_creator(
+    creator_id: str,
+    request: llm_model.UpsertLlmCreatorRequest,
+):
+    """Update an existing model creator."""
+    try:
+        creator = await llm_db.upsert_creator(request=request, creator_id=creator_id)
+        await _refresh_runtime_state()
+        logger.info("Updated model creator '%s' (%s)", creator.display_name, creator_id)
+        return creator
+    except Exception as exc:
+        logger.exception("Failed to update creator %s: %s", creator_id, exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to update creator",
+        ) from exc
+
+
+@router.delete(
+    "/creators/{creator_id}",
+    summary="Delete model creator",
+    response_model=dict,
+)
+async def delete_llm_creator(creator_id: str):
+    """
+    Delete a model creator.
+
+    This will remove the creator association from all models that reference it
+    (sets creatorId to NULL), but will not delete the models themselves.
+    """
+    try:
+        await llm_db.delete_creator(creator_id)
+        await _refresh_runtime_state()
+        logger.info("Deleted model creator '%s'", creator_id)
+        return {"success": True, "message": f"Creator '{creator_id}' deleted"}
+    except ValueError as exc:
+        logger.warning("Creator deletion validation failed: %s", exc)
+        raise fastapi.HTTPException(status_code=404, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.exception("Failed to delete creator %s: %s", creator_id, exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to delete creator",
+        ) from exc
+
+
+# ============================================================================
+# Recommended Model Endpoints
+# ============================================================================
+
+
+@router.get(
+    "/recommended-model",
+    summary="Get recommended model",
+    response_model=llm_model.RecommendedModelResponse,
+)
+async def get_recommended_model():
+    """
+    Get the currently recommended LLM model.
+
+    The recommended model is shown to users as the default/suggested option
+    in model selection dropdowns.
+    """
+    try:
+        model = await llm_db.get_recommended_model()
+        return llm_model.RecommendedModelResponse(
+            model=model,
+            slug=model.slug if model else None,
+        )
+    except Exception as exc:
+        logger.exception("Failed to get recommended model: %s", exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to get recommended model",
+        ) from exc
+
+
+@router.post(
+    "/recommended-model",
+    summary="Set recommended model",
+    response_model=llm_model.SetRecommendedModelResponse,
+)
+async def set_recommended_model(request: llm_model.SetRecommendedModelRequest):
+    """
+    Set a model as the recommended model.
+
+    This clears the recommended flag from any other model and sets it on
+    the specified model. The model must be enabled to be set as recommended.
+
+    The recommended model is displayed to users as the default/suggested
+    option in model selection dropdowns throughout the platform.
+    """
+    try:
+        model, previous_slug = await llm_db.set_recommended_model(request.model_id)
+        await _refresh_runtime_state()
+        logger.info(
+            "Set recommended model to '%s' (previous: %s)",
+            model.slug,
+            previous_slug or "none",
+        )
+        return llm_model.SetRecommendedModelResponse(
+            model=model,
+            previous_recommended_slug=previous_slug,
+            message=f"Model '{model.display_name}' is now the recommended model",
+        )
+    except ValueError as exc:
+        logger.warning("Set recommended model validation failed: %s", exc)
+        raise fastapi.HTTPException(status_code=400, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.exception("Failed to set recommended model: %s", exc)
+        raise fastapi.HTTPException(
+            status_code=500,
+            detail="Failed to set recommended model",
+        ) from exc

autogpt_platform/backend/backend/api/features/admin/llm_routes_test.py

@@ -0,0 +1,491 @@
+import json
+from unittest.mock import AsyncMock
+
+import fastapi
+import fastapi.testclient
+import pytest
+import pytest_mock
+from autogpt_libs.auth.jwt_utils import get_jwt_payload
+from pytest_snapshot.plugin import Snapshot
+
+import backend.api.features.admin.llm_routes as llm_routes
+from backend.server.v2.llm import model as llm_model
+from backend.util.models import Pagination
+
+app = fastapi.FastAPI()
+app.include_router(llm_routes.router, prefix="/admin/llm")
+
+client = fastapi.testclient.TestClient(app)
+
+
+@pytest.fixture(autouse=True)
+def setup_app_admin_auth(mock_jwt_admin):
+    """Setup admin auth overrides for all tests in this module"""
+    app.dependency_overrides[get_jwt_payload] = mock_jwt_admin["get_jwt_payload"]
+    yield
+    app.dependency_overrides.clear()
+
+
+def test_list_llm_providers_success(
+    mocker: pytest_mock.MockFixture,
+    configured_snapshot: Snapshot,
+) -> None:
+    """Test successful listing of LLM providers"""
+    # Mock the database function
+    mock_providers = [
+        {
+            "id": "provider-1",
+            "name": "openai",
+            "display_name": "OpenAI",
+            "description": "OpenAI LLM provider",
+            "supports_tools": True,
+            "supports_json_output": True,
+            "supports_reasoning": False,
+            "supports_parallel_tool": True,
+            "metadata": {},
+            "models": [],
+        },
+        {
+            "id": "provider-2",
+            "name": "anthropic",
+            "display_name": "Anthropic",
+            "description": "Anthropic LLM provider",
+            "supports_tools": True,
+            "supports_json_output": True,
+            "supports_reasoning": False,
+            "supports_parallel_tool": True,
+            "metadata": {},
+            "models": [],
+        },
+    ]
+
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.list_providers",
+        new=AsyncMock(return_value=mock_providers),
+    )
+
+    response = client.get("/admin/llm/providers")
+
+    assert response.status_code == 200
+    response_data = response.json()
+    assert len(response_data["providers"]) == 2
+    assert response_data["providers"][0]["name"] == "openai"
+
+    # Snapshot test the response (must be string)
+    configured_snapshot.assert_match(
+        json.dumps(response_data, indent=2, sort_keys=True),
+        "list_llm_providers_success.json",
+    )
+
+
+def test_list_llm_models_success(
+    mocker: pytest_mock.MockFixture,
+    configured_snapshot: Snapshot,
+) -> None:
+    """Test successful listing of LLM models with pagination"""
+    # Mock the database function - now returns LlmModelsResponse
+    mock_model = llm_model.LlmModel(
+        id="model-1",
+        slug="gpt-4o",
+        display_name="GPT-4o",
+        description="GPT-4 Optimized",
+        provider_id="provider-1",
+        context_window=128000,
+        max_output_tokens=16384,
+        is_enabled=True,
+        capabilities={},
+        metadata={},
+        costs=[
+            llm_model.LlmModelCost(
+                id="cost-1",
+                credit_cost=10,
+                credential_provider="openai",
+                metadata={},
+            )
+        ],
+    )
+
+    mock_response = llm_model.LlmModelsResponse(
+        models=[mock_model],
+        pagination=Pagination(
+            total_items=1,
+            total_pages=1,
+            current_page=1,
+            page_size=50,
+        ),
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.list_models",
+        new=AsyncMock(return_value=mock_response),
+    )
+
+    response = client.get("/admin/llm/models")
+
+    assert response.status_code == 200
+    response_data = response.json()
+    assert len(response_data["models"]) == 1
+    assert response_data["models"][0]["slug"] == "gpt-4o"
+    assert response_data["pagination"]["total_items"] == 1
+    assert response_data["pagination"]["page_size"] == 50
+
+    # Snapshot test the response (must be string)
+    configured_snapshot.assert_match(
+        json.dumps(response_data, indent=2, sort_keys=True),
+        "list_llm_models_success.json",
+    )
+
+
+def test_create_llm_provider_success(
+    mocker: pytest_mock.MockFixture,
+    configured_snapshot: Snapshot,
+) -> None:
+    """Test successful creation of LLM provider"""
+    mock_provider = {
+        "id": "new-provider-id",
+        "name": "groq",
+        "display_name": "Groq",
+        "description": "Groq LLM provider",
+        "supports_tools": True,
+        "supports_json_output": True,
+        "supports_reasoning": False,
+        "supports_parallel_tool": False,
+        "metadata": {},
+    }
+
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.upsert_provider",
+        new=AsyncMock(return_value=mock_provider),
+    )
+
+    mock_refresh = mocker.patch(
+        "backend.api.features.admin.llm_routes._refresh_runtime_state",
+        new=AsyncMock(),
+    )
+
+    request_data = {
+        "name": "groq",
+        "display_name": "Groq",
+        "description": "Groq LLM provider",
+        "supports_tools": True,
+        "supports_json_output": True,
+        "supports_reasoning": False,
+        "supports_parallel_tool": False,
+        "metadata": {},
+    }
+
+    response = client.post("/admin/llm/providers", json=request_data)
+
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data["name"] == "groq"
+    assert response_data["display_name"] == "Groq"
+
+    # Verify refresh was called
+    mock_refresh.assert_called_once()
+
+    # Snapshot test the response (must be string)
+    configured_snapshot.assert_match(
+        json.dumps(response_data, indent=2, sort_keys=True),
+        "create_llm_provider_success.json",
+    )
+
+
+def test_create_llm_model_success(
+    mocker: pytest_mock.MockFixture,
+    configured_snapshot: Snapshot,
+) -> None:
+    """Test successful creation of LLM model"""
+    mock_model = {
+        "id": "new-model-id",
+        "slug": "gpt-4.1-mini",
+        "display_name": "GPT-4.1 Mini",
+        "description": "Latest GPT-4.1 Mini model",
+        "provider_id": "provider-1",
+        "context_window": 128000,
+        "max_output_tokens": 16384,
+        "is_enabled": True,
+        "capabilities": {},
+        "metadata": {},
+        "costs": [
+            {
+                "id": "cost-id",
+                "credit_cost": 5,
+                "credential_provider": "openai",
+                "metadata": {},
+            }
+        ],
+    }
+
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.create_model",
+        new=AsyncMock(return_value=mock_model),
+    )
+
+    mock_refresh = mocker.patch(
+        "backend.api.features.admin.llm_routes._refresh_runtime_state",
+        new=AsyncMock(),
+    )
+
+    request_data = {
+        "slug": "gpt-4.1-mini",
+        "display_name": "GPT-4.1 Mini",
+        "description": "Latest GPT-4.1 Mini model",
+        "provider_id": "provider-1",
+        "context_window": 128000,
+        "max_output_tokens": 16384,
+        "is_enabled": True,
+        "capabilities": {},
+        "metadata": {},
+        "costs": [
+            {
+                "credit_cost": 5,
+                "credential_provider": "openai",
+                "metadata": {},
+            }
+        ],
+    }
+
+    response = client.post("/admin/llm/models", json=request_data)
+
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data["slug"] == "gpt-4.1-mini"
+    assert response_data["is_enabled"] is True
+
+    # Verify refresh was called
+    mock_refresh.assert_called_once()
+
+    # Snapshot test the response (must be string)
+    configured_snapshot.assert_match(
+        json.dumps(response_data, indent=2, sort_keys=True),
+        "create_llm_model_success.json",
+    )
+
+
+def test_update_llm_model_success(
+    mocker: pytest_mock.MockFixture,
+    configured_snapshot: Snapshot,
+) -> None:
+    """Test successful update of LLM model"""
+    mock_model = {
+        "id": "model-1",
+        "slug": "gpt-4o",
+        "display_name": "GPT-4o Updated",
+        "description": "Updated description",
+        "provider_id": "provider-1",
+        "context_window": 256000,
+        "max_output_tokens": 32768,
+        "is_enabled": True,
+        "capabilities": {},
+        "metadata": {},
+        "costs": [
+            {
+                "id": "cost-1",
+                "credit_cost": 15,
+                "credential_provider": "openai",
+                "metadata": {},
+            }
+        ],
+    }
+
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.update_model",
+        new=AsyncMock(return_value=mock_model),
+    )
+
+    mock_refresh = mocker.patch(
+        "backend.api.features.admin.llm_routes._refresh_runtime_state",
+        new=AsyncMock(),
+    )
+
+    request_data = {
+        "display_name": "GPT-4o Updated",
+        "description": "Updated description",
+        "context_window": 256000,
+        "max_output_tokens": 32768,
+    }
+
+    response = client.patch("/admin/llm/models/model-1", json=request_data)
+
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data["display_name"] == "GPT-4o Updated"
+    assert response_data["context_window"] == 256000
+
+    # Verify refresh was called
+    mock_refresh.assert_called_once()
+
+    # Snapshot test the response (must be string)
+    configured_snapshot.assert_match(
+        json.dumps(response_data, indent=2, sort_keys=True),
+        "update_llm_model_success.json",
+    )
+
+
+def test_toggle_llm_model_success(
+    mocker: pytest_mock.MockFixture,
+    configured_snapshot: Snapshot,
+) -> None:
+    """Test successful toggling of LLM model enabled status"""
+    # Create a proper mock model object
+    mock_model = llm_model.LlmModel(
+        id="model-1",
+        slug="gpt-4o",
+        display_name="GPT-4o",
+        description="GPT-4 Optimized",
+        provider_id="provider-1",
+        context_window=128000,
+        max_output_tokens=16384,
+        is_enabled=False,
+        capabilities={},
+        metadata={},
+        costs=[],
+    )
+
+    # Create a proper ToggleLlmModelResponse
+    mock_response = llm_model.ToggleLlmModelResponse(
+        model=mock_model,
+        nodes_migrated=0,
+        migrated_to_slug=None,
+        migration_id=None,
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.toggle_model",
+        new=AsyncMock(return_value=mock_response),
+    )
+
+    mock_refresh = mocker.patch(
+        "backend.api.features.admin.llm_routes._refresh_runtime_state",
+        new=AsyncMock(),
+    )
+
+    request_data = {"is_enabled": False}
+
+    response = client.patch("/admin/llm/models/model-1/toggle", json=request_data)
+
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data["model"]["is_enabled"] is False
+
+    # Verify refresh was called
+    mock_refresh.assert_called_once()
+
+    # Snapshot test the response (must be string)
+    configured_snapshot.assert_match(
+        json.dumps(response_data, indent=2, sort_keys=True),
+        "toggle_llm_model_success.json",
+    )
+
+
+def test_delete_llm_model_success(
+    mocker: pytest_mock.MockFixture,
+    configured_snapshot: Snapshot,
+) -> None:
+    """Test successful deletion of LLM model with migration"""
+    # Create a proper DeleteLlmModelResponse
+    mock_response = llm_model.DeleteLlmModelResponse(
+        deleted_model_slug="gpt-3.5-turbo",
+        deleted_model_display_name="GPT-3.5 Turbo",
+        replacement_model_slug="gpt-4o-mini",
+        nodes_migrated=42,
+        message="Successfully deleted model 'GPT-3.5 Turbo' (gpt-3.5-turbo) "
+        "and migrated 42 workflow node(s) to 'gpt-4o-mini'.",
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.delete_model",
+        new=AsyncMock(return_value=mock_response),
+    )
+
+    mock_refresh = mocker.patch(
+        "backend.api.features.admin.llm_routes._refresh_runtime_state",
+        new=AsyncMock(),
+    )
+
+    response = client.delete(
+        "/admin/llm/models/model-1?replacement_model_slug=gpt-4o-mini"
+    )
+
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data["deleted_model_slug"] == "gpt-3.5-turbo"
+    assert response_data["nodes_migrated"] == 42
+    assert response_data["replacement_model_slug"] == "gpt-4o-mini"
+
+    # Verify refresh was called
+    mock_refresh.assert_called_once()
+
+    # Snapshot test the response (must be string)
+    configured_snapshot.assert_match(
+        json.dumps(response_data, indent=2, sort_keys=True),
+        "delete_llm_model_success.json",
+    )
+
+
+def test_delete_llm_model_validation_error(
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """Test deletion fails with proper error when validation fails"""
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.delete_model",
+        new=AsyncMock(side_effect=ValueError("Replacement model 'invalid' not found")),
+    )
+
+    response = client.delete("/admin/llm/models/model-1?replacement_model_slug=invalid")
+
+    assert response.status_code == 400
+    assert "Replacement model 'invalid' not found" in response.json()["detail"]
+
+
+def test_delete_llm_model_no_replacement_with_usage(
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """Test deletion fails when nodes exist but no replacement is provided"""
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.delete_model",
+        new=AsyncMock(
+            side_effect=ValueError(
+                "Cannot delete model 'test-model': 5 workflow node(s) are using it. "
+                "Please provide a replacement_model_slug to migrate them."
+            )
+        ),
+    )
+
+    response = client.delete("/admin/llm/models/model-1")
+
+    assert response.status_code == 400
+    assert "workflow node(s) are using it" in response.json()["detail"]
+
+
+def test_delete_llm_model_no_replacement_no_usage(
+    mocker: pytest_mock.MockFixture,
+) -> None:
+    """Test deletion succeeds when no nodes use the model and no replacement is provided"""
+    mock_response = llm_model.DeleteLlmModelResponse(
+        deleted_model_slug="unused-model",
+        deleted_model_display_name="Unused Model",
+        replacement_model_slug=None,
+        nodes_migrated=0,
+        message="Successfully deleted model 'Unused Model' (unused-model). No workflows were using this model.",
+    )
+
+    mocker.patch(
+        "backend.api.features.admin.llm_routes.llm_db.delete_model",
+        new=AsyncMock(return_value=mock_response),
+    )
+
+    mock_refresh = mocker.patch(
+        "backend.api.features.admin.llm_routes._refresh_runtime_state",
+        new=AsyncMock(),
+    )
+
+    response = client.delete("/admin/llm/models/model-1")
+
+    assert response.status_code == 200
+    response_data = response.json()
+    assert response_data["deleted_model_slug"] == "unused-model"
+    assert response_data["nodes_migrated"] == 0
+    assert response_data["replacement_model_slug"] is None
+    mock_refresh.assert_called_once()

autogpt_platform/backend/backend/api/features/builder/db.py

@@ -1,6 +1,7 @@
 import logging
 from dataclasses import dataclass
 from difflib import SequenceMatcher
+from functools import lru_cache
 from typing import Any, Sequence, get_args, get_origin
 
 import prisma
@@ -21,6 +22,7 @@ from backend.blocks._base import (
     BlockType,
 )
 from backend.blocks.llm import LlmModel
+from backend.data.llm_registry import get_all_model_slugs_for_validation
 from backend.integrations.providers import ProviderName
 from backend.util.cache import cached
 from backend.util.models import Pagination
@@ -37,7 +39,20 @@ from .model import (
 )
 
 logger = logging.getLogger(__name__)
-llm_models = [name.name.lower().replace("_", " ") for name in LlmModel]
+
+
+@lru_cache(maxsize=1)
+def _get_llm_models() -> tuple[str, ...]:
+    """Get LLM model names for search matching from the registry.
+
+    Cached to avoid rebuilding on every search call.
+    Cache is cleared when registry is refreshed via _refresh_runtime_state.
+    Returns tuple for hashability (required by lru_cache).
+    """
+    return tuple(
+        slug.lower().replace("-", " ") for slug in get_all_model_slugs_for_validation()
+    )
+
 
 MAX_LIBRARY_AGENT_RESULTS = 100
 MAX_MARKETPLACE_AGENT_RESULTS = 100
@@ -656,8 +671,10 @@ def _contains_type(annotation: Any, target: type) -> bool:
 def _matches_llm_model(schema_cls: type[BlockSchema], query: str) -> bool:
     for field in schema_cls.model_fields.values():
         if _contains_type(field.annotation, LlmModel):
-            # Check if query matches any value in llm_models
-            if any(query in name for name in llm_models):
+            # Normalize query same as model slugs (lowercase, hyphens to spaces)
+            normalized_model_query = query.lower().replace("-", " ")
+            # Check if query matches any value in llm_models from registry
+            if any(normalized_model_query in name for name in _get_llm_models()):
                 return True
     return False
 

autogpt_platform/backend/backend/api/features/store/routes.py

@@ -311,6 +311,7 @@ async def get_creators(
 @router.get(
     "/creators/{username}",
     summary="Get creator details",
+    operation_id="getV2GetCreatorDetails",
     tags=["store", "public"],
 )
 async def get_creator(username: str) -> store_model.CreatorDetails:

autogpt_platform/backend/backend/api/rest_api.py

@@ -18,6 +18,7 @@ from prisma.errors import PrismaError
 
 import backend.api.features.admin.credit_admin_routes
 import backend.api.features.admin.execution_analytics_routes
+import backend.api.features.admin.llm_routes
 import backend.api.features.admin.store_admin_routes
 import backend.api.features.builder
 import backend.api.features.builder.routes
@@ -39,13 +40,15 @@ import backend.data.db
 import backend.data.graph
 import backend.data.user
 import backend.integrations.webhooks.utils
+import backend.server.v2.llm.routes
 import backend.util.service
 import backend.util.settings
 from backend.api.features.library.exceptions import (
     FolderAlreadyExistsError,
     FolderValidationError,
 )
-from backend.blocks.llm import DEFAULT_LLM_MODEL
+from backend.data import llm_registry
+from backend.data.block_cost_config import refresh_llm_costs
 from backend.data.model import Credentials
 from backend.integrations.providers import ProviderName
 from backend.monitoring.instrumentation import instrument_fastapi
@@ -117,11 +120,30 @@ async def lifespan_context(app: fastapi.FastAPI):
 
     AutoRegistry.patch_integrations()
 
+    # Refresh LLM registry before initializing blocks so blocks can use registry data
+    try:
+        await llm_registry.refresh_llm_registry()
+        await refresh_llm_costs()
+    except Exception as e:
+        logger.warning(f"Failed to refresh LLM registry/costs at startup: {e}")
+
+    # Clear block schema caches so they're regenerated with updated discriminator_mapping
+    from backend.blocks._base import BlockSchema
+
+    BlockSchema.clear_all_schema_caches()
+
     await backend.data.block.initialize_blocks()
 
     await backend.data.user.migrate_and_encrypt_user_integrations()
     await backend.data.graph.fix_llm_provider_credentials()
-    await backend.data.graph.migrate_llm_models(DEFAULT_LLM_MODEL)
+    # migrate_llm_models uses registry default model
+    from backend.blocks.llm import LlmModel
+
+    default_model_slug = llm_registry.get_default_model_slug()
+    if default_model_slug:
+        await backend.data.graph.migrate_llm_models(LlmModel(default_model_slug))
+    else:
+        logger.warning("Skipping LLM model migration: no default model available")
     await backend.integrations.webhooks.utils.migrate_legacy_triggered_graphs()
 
     with launch_darkly_context():
@@ -316,6 +338,16 @@ app.include_router(
     tags=["v2", "executions", "review"],
     prefix="/api/review",
 )
+app.include_router(
+    backend.api.features.admin.llm_routes.router,
+    tags=["v2"],
+    prefix="/api/llm/admin",
+)
+app.include_router(
+    backend.server.v2.llm.routes.router,
+    tags=["v2"],
+    prefix="/api/llm",
+)
 app.include_router(
     backend.api.features.library.routes.router, tags=["v2"], prefix="/api/library"
 )

autogpt_platform/backend/backend/api/ws_api.py

@@ -79,7 +79,42 @@ async def event_broadcaster(manager: ConnectionManager):
                     payload=notification.payload,
                 )
 
-        await asyncio.gather(execution_worker(), notification_worker())
+        async def registry_refresh_worker():
+            """Listen for LLM registry refresh notifications and broadcast to all clients."""
+            from backend.data.llm_registry import REGISTRY_REFRESH_CHANNEL
+            from backend.data.redis_client import connect_async
+
+            redis = await connect_async()
+            pubsub = redis.pubsub()
+            try:
+                await pubsub.subscribe(REGISTRY_REFRESH_CHANNEL)
+                logger.info(
+                    "Subscribed to LLM registry refresh notifications for WebSocket broadcast"
+                )
+
+                async for message in pubsub.listen():
+                    if (
+                        message["type"] == "message"
+                        and message["channel"] == REGISTRY_REFRESH_CHANNEL
+                    ):
+                        logger.info(
+                            "Broadcasting LLM registry refresh to all WebSocket clients"
+                        )
+                        await manager.broadcast_to_all(
+                            method=WSMethod.NOTIFICATION,
+                            data={
+                                "type": "LLM_REGISTRY_REFRESH",
+                                "event": "registry_updated",
+                            },
+                        )
+            finally:
+                await pubsub.close()
+
+        await asyncio.gather(
+            execution_worker(),
+            notification_worker(),
+            registry_refresh_worker(),
+        )
     finally:
         # Ensure PubSub connections are closed on any exit to prevent leaks
         await execution_bus.close()

autogpt_platform/backend/backend/blocks/_base.py

@@ -134,7 +134,26 @@ class BlockInfo(BaseModel):
 
 
 class BlockSchema(BaseModel):
-    cached_jsonschema: ClassVar[dict[str, Any]]
+    cached_jsonschema: ClassVar[dict[str, Any] | None] = None
+
+    @classmethod
+    def clear_schema_cache(cls) -> None:
+        """Clear the cached JSON schema for this class."""
+        # Use None instead of {} because {} is truthy and would prevent regeneration
+        cls.cached_jsonschema = None  # type: ignore
+
+    @staticmethod
+    def clear_all_schema_caches() -> None:
+        """Clear cached JSON schemas for all BlockSchema subclasses."""
+
+        def clear_recursive(cls: type) -> None:
+            """Recursively clear cache for class and all subclasses."""
+            if hasattr(cls, "clear_schema_cache"):
+                cls.clear_schema_cache()
+            for subclass in cls.__subclasses__():
+                clear_recursive(subclass)
+
+        clear_recursive(BlockSchema)
 
     @classmethod
     def jsonschema(cls) -> dict[str, Any]:
@@ -225,7 +244,8 @@ class BlockSchema(BaseModel):
         super().__pydantic_init_subclass__(**kwargs)
 
         # Reset cached JSON schema to prevent inheriting it from parent class
-        cls.cached_jsonschema = {}
+        # Use None instead of {} because {} is truthy and would prevent regeneration
+        cls.cached_jsonschema = None
 
         credentials_fields = cls.get_credentials_fields()
 

autogpt_platform/backend/backend/blocks/ai_condition.py

@@ -7,7 +7,6 @@ from backend.blocks._base import (
     BlockSchemaOutput,
 )
 from backend.blocks.llm import (
-    DEFAULT_LLM_MODEL,
     TEST_CREDENTIALS,
     TEST_CREDENTIALS_INPUT,
     AIBlockBase,
@@ -16,6 +15,7 @@ from backend.blocks.llm import (
     LlmModel,
     LLMResponse,
     llm_call,
+    llm_model_schema_extra,
 )
 from backend.data.model import APIKeyCredentials, NodeExecutionStats, SchemaField
 
@@ -50,9 +50,10 @@ class AIConditionBlock(AIBlockBase):
         )
         model: LlmModel = SchemaField(
             title="LLM Model",
-            default=DEFAULT_LLM_MODEL,
+            default_factory=LlmModel.default,
             description="The language model to use for evaluating the condition.",
             advanced=False,
+            json_schema_extra=llm_model_schema_extra(),
         )
         credentials: AICredentials = AICredentialsField()
 
@@ -82,7 +83,7 @@ class AIConditionBlock(AIBlockBase):
                 "condition": "the input is an email address",
                 "yes_value": "Valid email",
                 "no_value": "Not an email",
-                "model": DEFAULT_LLM_MODEL,
+                "model": LlmModel.default(),
                 "credentials": TEST_CREDENTIALS_INPUT,
             },
             test_credentials=TEST_CREDENTIALS,

autogpt_platform/backend/backend/blocks/smart_decision_maker.py

@@ -226,9 +226,10 @@ class SmartDecisionMakerBlock(Block):
         )
         model: llm.LlmModel = SchemaField(
             title="LLM Model",
-            default=llm.DEFAULT_LLM_MODEL,
+            default_factory=llm.LlmModel.default,
             description="The language model to use for answering the prompt.",
             advanced=False,
+            json_schema_extra=llm.llm_model_schema_extra(),
         )
         credentials: llm.AICredentials = llm.AICredentialsField()
         multiple_tool_calls: bool = SchemaField(

autogpt_platform/backend/backend/blocks/stagehand/blocks.py

@@ -10,13 +10,13 @@ import stagehand.main
 from stagehand import Stagehand
 
 from backend.blocks.llm import (
-    MODEL_METADATA,
     AICredentials,
     AICredentialsField,
     LlmModel,
     ModelMetadata,
 )
 from backend.blocks.stagehand._config import stagehand as stagehand_provider
+from backend.data import llm_registry
 from backend.sdk import (
     APIKeyCredentials,
     Block,
@@ -92,7 +92,7 @@ class StagehandRecommendedLlmModel(str, Enum):
         Returns the provider name for the model in the required format for Stagehand:
         provider/model_name
         """
-        model_metadata = MODEL_METADATA[LlmModel(self.value)]
+        model_metadata = self.metadata
         model_name = self.value
 
         if len(model_name.split("/")) == 1 and not self.value.startswith(
@@ -103,24 +103,28 @@ class StagehandRecommendedLlmModel(str, Enum):
             ), "Logic failed and open_router provider attempted to be prepended to model name! in stagehand/_config.py"
             model_name = f"{model_metadata.provider}/{model_name}"
 
-        logger.error(f"Model name: {model_name}")
+        logger.debug(f"Model name: {model_name}")
         return model_name
 
     @property
     def provider(self) -> str:
-        return MODEL_METADATA[LlmModel(self.value)].provider
+        return self.metadata.provider
 
     @property
     def metadata(self) -> ModelMetadata:
-        return MODEL_METADATA[LlmModel(self.value)]
+        metadata = llm_registry.get_llm_model_metadata(self.value)
+        if metadata:
+            return metadata
+        # Fallback to LlmModel enum if registry lookup fails
+        return LlmModel(self.value).metadata
 
     @property
     def context_window(self) -> int:
-        return MODEL_METADATA[LlmModel(self.value)].context_window
+        return self.metadata.context_window
 
     @property
     def max_output_tokens(self) -> int | None:
-        return MODEL_METADATA[LlmModel(self.value)].max_output_tokens
+        return self.metadata.max_output_tokens
 
 
 class StagehandObserveBlock(Block):

autogpt_platform/backend/backend/data/block.py

@@ -19,6 +19,30 @@ CompletedBlockOutput = dict[str, list[Any]]  # Completed stream, collected as a
 
 
 async def initialize_blocks() -> None:
+    # Refresh LLM registry before initializing blocks so blocks can use registry data
+    # This ensures the registry cache is populated even in executor context
+    try:
+        from backend.data import llm_registry
+        from backend.data.block_cost_config import refresh_llm_costs
+
+        # Only refresh if we have DB access (check if Prisma is connected)
+        from backend.data.db import is_connected
+
+        if is_connected():
+            await llm_registry.refresh_llm_registry()
+            await refresh_llm_costs()
+            logger.info("LLM registry refreshed during block initialization")
+        else:
+            logger.warning(
+                "Prisma not connected, skipping LLM registry refresh during block initialization"
+            )
+    except Exception as exc:
+        logger.warning(
+            "Failed to refresh LLM registry during block initialization: %s", exc
+        )
+
+    # First, sync all provider costs to blocks
+    # Imported here to avoid circular import
     from backend.blocks import get_blocks
     from backend.sdk.cost_integration import sync_all_provider_costs
     from backend.util.retry import func_retry

autogpt_platform/backend/backend/data/block_cost_config.py

@@ -1,5 +1,8 @@
+import logging
 from typing import Type
 
+import prisma.models
+
 from backend.blocks._base import Block, BlockCost, BlockCostType
 from backend.blocks.ai_image_customizer import AIImageCustomizerBlock, GeminiImageModel
 from backend.blocks.ai_image_generator_block import AIImageGeneratorBlock, ImageGenModel
@@ -24,13 +27,11 @@ from backend.blocks.ideogram import IdeogramModelBlock
 from backend.blocks.jina.embeddings import JinaEmbeddingBlock
 from backend.blocks.jina.search import ExtractWebsiteContentBlock, SearchTheWebBlock
 from backend.blocks.llm import (
-    MODEL_METADATA,
     AIConversationBlock,
     AIListGeneratorBlock,
     AIStructuredResponseGeneratorBlock,
     AITextGeneratorBlock,
     AITextSummarizerBlock,
-    LlmModel,
 )
 from backend.blocks.replicate.flux_advanced import ReplicateFluxAdvancedModelBlock
 from backend.blocks.replicate.replicate_block import ReplicateModelBlock
@@ -38,6 +39,7 @@ from backend.blocks.smart_decision_maker import SmartDecisionMakerBlock
 from backend.blocks.talking_head import CreateTalkingAvatarVideoBlock
 from backend.blocks.text_to_speech_block import UnrealTextToSpeechBlock
 from backend.blocks.video.narration import VideoNarrationBlock
+from backend.data import llm_registry
 from backend.integrations.credentials_store import (
     aiml_api_credentials,
     anthropic_credentials,
@@ -57,211 +59,119 @@ from backend.integrations.credentials_store import (
     v0_credentials,
 )
 
-# =============== Configure the cost for each LLM Model call =============== #
+logger = logging.getLogger(__name__)
 
-MODEL_COST: dict[LlmModel, int] = {
-    LlmModel.O3: 4,
-    LlmModel.O3_MINI: 2,
-    LlmModel.O1: 16,
-    LlmModel.O1_MINI: 4,
-    # GPT-5 models
-    LlmModel.GPT5_2: 6,
-    LlmModel.GPT5_1: 5,
-    LlmModel.GPT5: 2,
-    LlmModel.GPT5_MINI: 1,
-    LlmModel.GPT5_NANO: 1,
-    LlmModel.GPT5_CHAT: 5,
-    LlmModel.GPT41: 2,
-    LlmModel.GPT41_MINI: 1,
-    LlmModel.GPT4O_MINI: 1,
-    LlmModel.GPT4O: 3,
-    LlmModel.GPT4_TURBO: 10,
-    LlmModel.GPT3_5_TURBO: 1,
-    LlmModel.CLAUDE_4_1_OPUS: 21,
-    LlmModel.CLAUDE_4_OPUS: 21,
-    LlmModel.CLAUDE_4_SONNET: 5,
-    LlmModel.CLAUDE_4_6_OPUS: 14,
-    LlmModel.CLAUDE_4_6_SONNET: 9,
-    LlmModel.CLAUDE_4_5_HAIKU: 4,
-    LlmModel.CLAUDE_4_5_OPUS: 14,
-    LlmModel.CLAUDE_4_5_SONNET: 9,
-    LlmModel.CLAUDE_3_HAIKU: 1,
-    LlmModel.AIML_API_QWEN2_5_72B: 1,
-    LlmModel.AIML_API_LLAMA3_1_70B: 1,
-    LlmModel.AIML_API_LLAMA3_3_70B: 1,
-    LlmModel.AIML_API_META_LLAMA_3_1_70B: 1,
-    LlmModel.AIML_API_LLAMA_3_2_3B: 1,
-    LlmModel.LLAMA3_3_70B: 1,
-    LlmModel.LLAMA3_1_8B: 1,
-    LlmModel.OLLAMA_LLAMA3_3: 1,
-    LlmModel.OLLAMA_LLAMA3_2: 1,
-    LlmModel.OLLAMA_LLAMA3_8B: 1,
-    LlmModel.OLLAMA_LLAMA3_405B: 1,
-    LlmModel.OLLAMA_DOLPHIN: 1,
-    LlmModel.OPENAI_GPT_OSS_120B: 1,
-    LlmModel.OPENAI_GPT_OSS_20B: 1,
-    LlmModel.GEMINI_2_5_PRO: 4,
-    LlmModel.GEMINI_3_PRO_PREVIEW: 5,
-    LlmModel.GEMINI_2_5_FLASH: 1,
-    LlmModel.GEMINI_2_0_FLASH: 1,
-    LlmModel.GEMINI_2_5_FLASH_LITE_PREVIEW: 1,
-    LlmModel.GEMINI_2_0_FLASH_LITE: 1,
-    LlmModel.MISTRAL_NEMO: 1,
-    LlmModel.COHERE_COMMAND_R_08_2024: 1,
-    LlmModel.COHERE_COMMAND_R_PLUS_08_2024: 3,
-    LlmModel.DEEPSEEK_CHAT: 2,
-    LlmModel.DEEPSEEK_R1_0528: 1,
-    LlmModel.PERPLEXITY_SONAR: 1,
-    LlmModel.PERPLEXITY_SONAR_PRO: 5,
-    LlmModel.PERPLEXITY_SONAR_DEEP_RESEARCH: 10,
-    LlmModel.NOUSRESEARCH_HERMES_3_LLAMA_3_1_405B: 1,
-    LlmModel.NOUSRESEARCH_HERMES_3_LLAMA_3_1_70B: 1,
-    LlmModel.AMAZON_NOVA_LITE_V1: 1,
-    LlmModel.AMAZON_NOVA_MICRO_V1: 1,
-    LlmModel.AMAZON_NOVA_PRO_V1: 1,
-    LlmModel.MICROSOFT_WIZARDLM_2_8X22B: 1,
-    LlmModel.GRYPHE_MYTHOMAX_L2_13B: 1,
-    LlmModel.META_LLAMA_4_SCOUT: 1,
-    LlmModel.META_LLAMA_4_MAVERICK: 1,
-    LlmModel.LLAMA_API_LLAMA_4_SCOUT: 1,
-    LlmModel.LLAMA_API_LLAMA4_MAVERICK: 1,
-    LlmModel.LLAMA_API_LLAMA3_3_8B: 1,
-    LlmModel.LLAMA_API_LLAMA3_3_70B: 1,
-    LlmModel.GROK_4: 9,
-    LlmModel.GROK_4_FAST: 1,
-    LlmModel.GROK_4_1_FAST: 1,
-    LlmModel.GROK_CODE_FAST_1: 1,
-    LlmModel.KIMI_K2: 1,
-    LlmModel.QWEN3_235B_A22B_THINKING: 1,
-    LlmModel.QWEN3_CODER: 9,
-    # v0 by Vercel models
-    LlmModel.V0_1_5_MD: 1,
-    LlmModel.V0_1_5_LG: 2,
-    LlmModel.V0_1_0_MD: 1,
+PROVIDER_CREDENTIALS = {
+    "openai": openai_credentials,
+    "anthropic": anthropic_credentials,
+    "groq": groq_credentials,
+    "open_router": open_router_credentials,
+    "llama_api": llama_api_credentials,
+    "aiml_api": aiml_api_credentials,
+    "v0": v0_credentials,
 }
 
-for model in LlmModel:
-    if model not in MODEL_COST:
-        raise ValueError(f"Missing MODEL_COST for model: {model}")
+# =============== Configure the cost for each LLM Model call =============== #
+# All LLM costs now come from the database via llm_registry
+
+LLM_COST: list[BlockCost] = []
 
 
-LLM_COST = (
-    # Anthropic Models
-    [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
+async def _build_llm_costs_from_registry() -> list[BlockCost]:
+    """
+    Build BlockCost list from all models in the LLM registry.
+
+    This function checks for active model migrations with customCreditCost overrides.
+    When a model has been migrated with a custom price, that price is used instead
+    of the target model's default cost.
+    """
+    # Query active migrations with custom pricing overrides.
+    # Note: LlmModelMigration is system-level data (no userId field) and this function
+    # is only called during app startup and admin operations, so no user ID filter needed.
+    migration_overrides: dict[str, int] = {}
+    try:
+        active_migrations = await prisma.models.LlmModelMigration.prisma().find_many(
+            where={
+                "isReverted": False,
+                "customCreditCost": {"not": None},
+            }
+        )
+        # Key by targetModelSlug since that's the model nodes are now using
+        # after migration. The custom cost applies to the target model.
+        migration_overrides = {
+            migration.targetModelSlug: migration.customCreditCost
+            for migration in active_migrations
+            if migration.customCreditCost is not None
+        }
+        if migration_overrides:
+            logger.info(
+                "Found %d active model migrations with custom pricing overrides",
+                len(migration_overrides),
+            )
+    except Exception as exc:
+        logger.warning(
+            "Failed to query model migration overrides: %s. Proceeding with default costs.",
+            exc,
+            exc_info=True,
+        )
+
+    costs: list[BlockCost] = []
+    for model in llm_registry.iter_dynamic_models():
+        for cost in model.costs:
+            credentials = PROVIDER_CREDENTIALS.get(cost.credential_provider)
+            if not credentials:
+                logger.warning(
+                    "Skipping cost entry for %s due to unknown credentials provider %s",
+                    model.slug,
+                    cost.credential_provider,
+                )
+                continue
+
+            # Check if this model has a custom cost override from migration
+            cost_amount = migration_overrides.get(model.slug, cost.credit_cost)
+
+            if model.slug in migration_overrides:
+                logger.debug(
+                    "Applying custom cost override for model %s: %d credits (default: %d)",
+                    model.slug,
+                    cost_amount,
+                    cost.credit_cost,
+                )
+
+            cost_filter = {
+                "model": model.slug,
                 "credentials": {
-                    "id": anthropic_credentials.id,
-                    "provider": anthropic_credentials.provider,
-                    "type": anthropic_credentials.type,
+                    "id": credentials.id,
+                    "provider": credentials.provider,
+                    "type": credentials.type,
                 },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "anthropic"
-    ]
-    # OpenAI Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {
-                    "id": openai_credentials.id,
-                    "provider": openai_credentials.provider,
-                    "type": openai_credentials.type,
-                },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "openai"
-    ]
-    # Groq Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {"id": groq_credentials.id},
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "groq"
-    ]
-    # Open Router Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {
-                    "id": open_router_credentials.id,
-                    "provider": open_router_credentials.provider,
-                    "type": open_router_credentials.type,
-                },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "open_router"
-    ]
-    # Llama API Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {
-                    "id": llama_api_credentials.id,
-                    "provider": llama_api_credentials.provider,
-                    "type": llama_api_credentials.type,
-                },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "llama_api"
-    ]
-    # v0 by Vercel Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {
-                    "id": v0_credentials.id,
-                    "provider": v0_credentials.provider,
-                    "type": v0_credentials.type,
-                },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "v0"
-    ]
-    # AI/ML Api Models
-    + [
-        BlockCost(
-            cost_type=BlockCostType.RUN,
-            cost_filter={
-                "model": model,
-                "credentials": {
-                    "id": aiml_api_credentials.id,
-                    "provider": aiml_api_credentials.provider,
-                    "type": aiml_api_credentials.type,
-                },
-            },
-            cost_amount=cost,
-        )
-        for model, cost in MODEL_COST.items()
-        if MODEL_METADATA[model].provider == "aiml_api"
-    ]
-)
+            }
+            costs.append(
+                BlockCost(
+                    cost_type=BlockCostType.RUN,
+                    cost_filter=cost_filter,
+                    cost_amount=cost_amount,
+                )
+            )
+    return costs
+
+
+async def refresh_llm_costs() -> None:
+    """
+    Refresh LLM costs from the registry. All costs now come from the database.
+
+    This function also checks for active model migrations with custom pricing overrides
+    and applies them to ensure accurate billing.
+    """
+    # Build new costs first, then swap atomically to avoid race condition
+    # where concurrent readers see an empty list during the await
+    new_costs = await _build_llm_costs_from_registry()
+    LLM_COST.clear()
+    LLM_COST.extend(new_costs)
+
+
+# Initial load will happen after registry is refreshed at startup
+# Don't call refresh_llm_costs() here - it will be called after registry refresh
 
 # =============== This is the exhaustive list of cost for each Block =============== #
 

autogpt_platform/backend/backend/data/graph.py

@@ -28,6 +28,7 @@ from backend.blocks._base import Block, BlockType, EmptySchema
 from backend.blocks.agent import AgentExecutorBlock
 from backend.blocks.io import AgentInputBlock, AgentOutputBlock
 from backend.blocks.llm import LlmModel
+from backend.data import llm_registry
 from backend.integrations.providers import ProviderName
 from backend.util import type as type_utils
 from backend.util.exceptions import GraphNotAccessibleError, GraphNotInLibraryError
@@ -1663,8 +1664,14 @@ async def migrate_llm_models(migrate_to: LlmModel):
             if field.annotation == LlmModel:
                 llm_model_fields[block.id] = field_name
 
-    # Convert enum values to a list of strings for the SQL query
-    enum_values = [v.value for v in LlmModel]
+    # Get all model slugs from the registry (dynamic, not hardcoded enum)
+    enum_values = list(llm_registry.get_all_model_slugs_for_validation())
+
+    # Skip migration if registry is empty (fresh deployment before seeding)
+    if not enum_values:
+        logger.warning("LLM registry is empty, skipping model migration")
+        return
+
     escaped_enum_values = repr(tuple(enum_values))  # hack but works
 
     # Update each block

autogpt_platform/backend/backend/data/llm_registry/__init__.py

@@ -0,0 +1,72 @@
+"""
+LLM Registry module for managing LLM models, providers, and costs dynamically.
+
+This module provides a database-driven registry system for LLM models,
+replacing hardcoded model configurations with a flexible admin-managed system.
+"""
+
+from backend.data.llm_registry.model import ModelMetadata
+
+# Re-export for backwards compatibility
+from backend.data.llm_registry.notifications import (
+    REGISTRY_REFRESH_CHANNEL,
+    publish_registry_refresh_notification,
+    subscribe_to_registry_refresh,
+)
+from backend.data.llm_registry.registry import (
+    RegistryModel,
+    RegistryModelCost,
+    RegistryModelCreator,
+    get_all_model_slugs_for_validation,
+    get_default_model_slug,
+    get_dynamic_model_slugs,
+    get_fallback_model_for_disabled,
+    get_llm_discriminator_mapping,
+    get_llm_model_cost,
+    get_llm_model_metadata,
+    get_llm_model_schema_options,
+    get_model_info,
+    is_model_enabled,
+    iter_dynamic_models,
+    refresh_llm_registry,
+    register_static_costs,
+    register_static_metadata,
+)
+from backend.data.llm_registry.schema_utils import (
+    is_llm_model_field,
+    refresh_llm_discriminator_mapping,
+    refresh_llm_model_options,
+    update_schema_with_llm_registry,
+)
+
+__all__ = [
+    # Types
+    "ModelMetadata",
+    "RegistryModel",
+    "RegistryModelCost",
+    "RegistryModelCreator",
+    # Registry functions
+    "get_all_model_slugs_for_validation",
+    "get_default_model_slug",
+    "get_dynamic_model_slugs",
+    "get_fallback_model_for_disabled",
+    "get_llm_discriminator_mapping",
+    "get_llm_model_cost",
+    "get_llm_model_metadata",
+    "get_llm_model_schema_options",
+    "get_model_info",
+    "is_model_enabled",
+    "iter_dynamic_models",
+    "refresh_llm_registry",
+    "register_static_costs",
+    "register_static_metadata",
+    # Notifications
+    "REGISTRY_REFRESH_CHANNEL",
+    "publish_registry_refresh_notification",
+    "subscribe_to_registry_refresh",
+    # Schema utilities
+    "is_llm_model_field",
+    "refresh_llm_discriminator_mapping",
+    "refresh_llm_model_options",
+    "update_schema_with_llm_registry",
+]

autogpt_platform/backend/backend/data/llm_registry/integration_test.py

@@ -0,0 +1,145 @@
+"""Integration tests for LLM registry notification system."""
+
+import asyncio
+import json
+import time
+
+import pytest
+from unittest.mock import AsyncMock, patch
+
+from backend.data.llm_registry import notifications
+from backend.executor import llm_registry_init
+
+
+@pytest.mark.asyncio
+async def test_notification_with_data_payload():
+    """Verify notification can carry model data."""
+    models_data = [
+        {
+            "slug": "gpt-4o",
+            "displayName": "GPT-4o",
+            "contextWindow": 128000,
+        }
+    ]
+
+    # Mock Redis
+    with patch("backend.data.llm_registry.notifications.connect_async") as mock_redis:
+        mock_client = AsyncMock()
+        mock_redis.return_value = mock_client
+
+        # Publish notification
+        await notifications.publish_registry_refresh_notification(models_data)
+
+        # Verify Redis publish was called with JSON payload
+        assert mock_client.publish.call_count == 1
+        channel, payload = mock_client.publish.call_args[0]
+
+        assert channel == "llm_registry:refresh"
+
+        # Parse and verify payload
+        parsed = json.loads(payload)
+        assert parsed["action"] == "refresh"
+        assert parsed["data"] == models_data
+
+
+@pytest.mark.asyncio
+async def test_notification_backwards_compatibility():
+    """Verify notifications work without data payload (backwards compatibility)."""
+    with patch("backend.data.llm_registry.notifications.connect_async") as mock_redis:
+        mock_client = AsyncMock()
+        mock_redis.return_value = mock_client
+
+        # Publish without data
+        await notifications.publish_registry_refresh_notification(models_data=None)
+
+        # Verify simple string payload
+        assert mock_client.publish.call_count == 1
+        _, payload = mock_client.publish.call_args[0]
+        assert payload == "refresh"
+
+
+@pytest.mark.asyncio
+async def test_subscribe_extracts_data_from_notification():
+    """Verify subscriber can extract data from notification payload."""
+    received_data = None
+
+    async def mock_callback(data):
+        nonlocal received_data
+        received_data = data
+
+    models_data = [{"slug": "gpt-4o", "displayName": "GPT-4o"}]
+
+    # Simulate receiving a notification message
+    message = {
+        "type": "message",
+        "channel": b"llm_registry:refresh",
+        "data": json.dumps({"action": "refresh", "data": models_data}).encode("utf-8"),
+    }
+
+    # Mock Redis pubsub
+    with patch("backend.data.llm_registry.notifications.connect_async") as mock_redis:
+        mock_client = AsyncMock()
+        mock_pubsub = AsyncMock()
+        mock_redis.return_value = mock_client
+        mock_client.pubsub.return_value = mock_pubsub
+
+        # Return the message once, then None to stop the loop
+        mock_pubsub.get_message.side_effect = [message, None]
+
+        # Start subscription in a task and cancel after first message
+        async def run_subscription():
+            await notifications.subscribe_to_registry_refresh(mock_callback)
+
+        task = asyncio.create_task(run_subscription())
+        await asyncio.sleep(0.1)  # Let it process the message
+        task.cancel()
+
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+
+        # Verify callback was called with extracted data
+        assert received_data == models_data
+
+
+@pytest.mark.asyncio
+async def test_jitter_adds_delay():
+    """Verify jitter is applied before refresh."""
+    with patch("backend.data.llm_registry.registry.refresh_llm_registry"), patch(
+        "backend.data.block_cost_config.refresh_llm_costs"
+    ), patch("backend.blocks._base.BlockSchema.clear_all_schema_caches"), patch(
+        "backend.data.db.is_connected", return_value=True
+    ):
+
+        start = time.time()
+        await llm_registry_init.refresh_registry_on_notification(models_data=[])
+        elapsed = time.time() - start
+
+        # Should have at least some delay (0-2 seconds)
+        # We can't test the exact delay due to jitter randomness,
+        # but we can verify it took some time
+        assert elapsed >= 0
+        assert elapsed <= 3  # Allow some overhead
+
+
+@pytest.mark.asyncio
+async def test_refresh_uses_provided_data():
+    """Verify refresh uses provided data instead of fetching."""
+    models_data = [{"slug": "test", "displayName": "Test"}]
+
+    with patch(
+        "backend.data.llm_registry.registry.refresh_llm_registry"
+    ) as mock_refresh, patch("backend.data.block_cost_config.refresh_llm_costs"), patch(
+        "backend.blocks._base.BlockSchema.clear_all_schema_caches"
+    ), patch(
+        "backend.data.db.is_connected", return_value=True
+    ):
+
+        await llm_registry_init.refresh_registry_on_notification(
+            models_data=models_data
+        )
+
+        # Verify refresh was called with the data
+        assert mock_refresh.call_count == 1
+        assert mock_refresh.call_args[1]["models_data"] == models_data

autogpt_platform/backend/backend/data/llm_registry/model.py

@@ -0,0 +1,25 @@
+"""Type definitions for LLM model metadata."""
+
+from typing import Literal, NamedTuple
+
+
+class ModelMetadata(NamedTuple):
+    """Metadata for an LLM model.
+
+    Attributes:
+        provider: The provider identifier (e.g., "openai", "anthropic")
+        context_window: Maximum context window size in tokens
+        max_output_tokens: Maximum output tokens (None if unlimited)
+        display_name: Human-readable name for the model
+        provider_name: Human-readable provider name (e.g., "OpenAI", "Anthropic")
+        creator_name: Name of the organization that created the model
+        price_tier: Relative cost tier (1=cheapest, 2=medium, 3=expensive)
+    """
+
+    provider: str
+    context_window: int
+    max_output_tokens: int | None
+    display_name: str
+    provider_name: str
+    creator_name: str
+    price_tier: Literal[1, 2, 3]

autogpt_platform/backend/backend/data/llm_registry/notifications.py

@@ -0,0 +1,128 @@
+"""
+Redis pub/sub notifications for LLM registry updates.
+
+When models are added/updated/removed via the admin UI, this module
+publishes notifications to Redis that all executor services subscribe to,
+ensuring they refresh their registry cache in real-time.
+"""
+
+import asyncio
+import json
+import logging
+from typing import Any
+
+from backend.data.redis_client import connect_async
+
+logger = logging.getLogger(__name__)
+
+# Redis channel name for LLM registry refresh notifications
+REGISTRY_REFRESH_CHANNEL = "llm_registry:refresh"
+
+
+async def publish_registry_refresh_notification(
+    models_data: list[dict[str, Any]] | None = None
+) -> None:
+    """
+    Publish a notification to Redis that the LLM registry has been updated.
+
+    Args:
+        models_data: Optional full registry data to include in notification
+    """
+    try:
+        redis = await connect_async()
+
+        # Prepare payload
+        if models_data is not None:
+            payload = json.dumps({"action": "refresh", "data": models_data})
+        else:
+            payload = "refresh"  # Backwards compatible
+
+        await redis.publish(REGISTRY_REFRESH_CHANNEL, payload)
+
+        if models_data:
+            logger.info(
+                "Published LLM registry refresh notification with %d models",
+                len(models_data),
+            )
+        else:
+            logger.info("Published LLM registry refresh notification")
+
+    except Exception as exc:
+        logger.warning(
+            "Failed to publish LLM registry refresh notification: %s",
+            exc,
+            exc_info=True,
+        )
+
+
+async def subscribe_to_registry_refresh(
+    on_refresh: Any,  # Async callable that takes optional models_data
+) -> None:
+    """
+    Subscribe to Redis notifications for LLM registry updates.
+
+    Args:
+        on_refresh: Async callable(models_data: list[dict] | None) -> None
+    """
+    try:
+        redis = await connect_async()
+        pubsub = redis.pubsub()
+        await pubsub.subscribe(REGISTRY_REFRESH_CHANNEL)
+        logger.info(
+            "Subscribed to LLM registry refresh notifications on channel: %s",
+            REGISTRY_REFRESH_CHANNEL,
+        )
+
+        # Process messages in a loop
+        while True:
+            try:
+                message = await pubsub.get_message(
+                    ignore_subscribe_messages=True, timeout=1.0
+                )
+                if (
+                    message
+                    and message["type"] == "message"
+                    and message["channel"] == REGISTRY_REFRESH_CHANNEL
+                ):
+                    logger.info("Received LLM registry refresh notification")
+
+                    # Extract models_data if present
+                    models_data = None
+                    try:
+                        payload = message["data"]
+                        if isinstance(payload, bytes):
+                            payload = payload.decode("utf-8")
+
+                        # Try to parse as JSON
+                        if payload != "refresh":
+                            parsed = json.loads(payload)
+                            models_data = parsed.get("data")
+                            logger.debug(
+                                "Notification includes %d models",
+                                len(models_data) if models_data else 0,
+                            )
+                    except (json.JSONDecodeError, AttributeError):
+                        # Backwards compatible: simple "refresh" string
+                        pass
+
+                    try:
+                        await on_refresh(models_data)
+                    except Exception as exc:
+                        logger.error(
+                            "Error refreshing LLM registry from notification: %s",
+                            exc,
+                            exc_info=True,
+                        )
+            except Exception as exc:
+                logger.warning(
+                    "Error processing registry refresh message: %s", exc, exc_info=True
+                )
+                # Continue listening even if one message fails
+                await asyncio.sleep(1)
+    except Exception as exc:
+        logger.error(
+            "Failed to subscribe to LLM registry refresh notifications: %s",
+            exc,
+            exc_info=True,
+        )
+        raise

autogpt_platform/backend/backend/data/llm_registry/registry.py

@@ -0,0 +1,463 @@
+"""Core LLM registry implementation for managing models dynamically."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Iterable
+
+import prisma.models
+
+from backend.data.llm_registry.model import ModelMetadata
+from backend.util.cache import cached
+
+logger = logging.getLogger(__name__)
+
+
+def _json_to_dict(value: Any) -> dict[str, Any]:
+    """Convert Prisma Json type to dict, with fallback to empty dict."""
+    if value is None:
+        return {}
+    if isinstance(value, dict):
+        return value
+    # Prisma Json type should always be a dict at runtime
+    return dict(value) if value else {}
+
+
+@dataclass(frozen=True)
+class RegistryModelCost:
+    """Cost configuration for an LLM model."""
+
+    credit_cost: int
+    credential_provider: str
+    credential_id: str | None
+    credential_type: str | None
+    currency: str | None
+    metadata: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class RegistryModelCreator:
+    """Creator information for an LLM model."""
+
+    id: str
+    name: str
+    display_name: str
+    description: str | None
+    website_url: str | None
+    logo_url: str | None
+
+
+@dataclass(frozen=True)
+class RegistryModel:
+    """Represents a model in the LLM registry."""
+
+    slug: str
+    display_name: str
+    description: str | None
+    metadata: ModelMetadata
+    capabilities: dict[str, Any]
+    extra_metadata: dict[str, Any]
+    provider_display_name: str
+    is_enabled: bool
+    is_recommended: bool = False
+    costs: tuple[RegistryModelCost, ...] = field(default_factory=tuple)
+    creator: RegistryModelCreator | None = None
+
+
+_static_metadata: dict[str, ModelMetadata] = {}
+_static_costs: dict[str, int] = {}
+_dynamic_models: dict[str, RegistryModel] = {}
+_schema_options: list[dict[str, str]] = []
+_discriminator_mapping: dict[str, str] = {}
+_lock = asyncio.Lock()
+
+
+def register_static_metadata(metadata: dict[Any, ModelMetadata]) -> None:
+    """Register static metadata for legacy models (deprecated)."""
+    _static_metadata.update({str(key): value for key, value in metadata.items()})
+    _refresh_cached_schema()
+
+
+def register_static_costs(costs: dict[Any, int]) -> None:
+    """Register static costs for legacy models (deprecated)."""
+    _static_costs.update({str(key): value for key, value in costs.items()})
+
+
+def _build_schema_options() -> list[dict[str, str]]:
+    """Build schema options for model selection dropdown. Only includes enabled models."""
+    options: list[dict[str, str]] = []
+    # Only include enabled models in the dropdown options
+    for model in sorted(_dynamic_models.values(), key=lambda m: m.display_name.lower()):
+        if model.is_enabled:
+            options.append(
+                {
+                    "label": model.display_name,
+                    "value": model.slug,
+                    "group": model.metadata.provider,
+                    "description": model.description or "",
+                }
+            )
+
+    for slug, metadata in _static_metadata.items():
+        if slug in _dynamic_models:
+            continue
+        options.append(
+            {
+                "label": slug,
+                "value": slug,
+                "group": metadata.provider,
+                "description": "",
+            }
+        )
+    return options
+
+
+@cached(maxsize=1, ttl_seconds=300, shared_cache=True, refresh_ttl_on_get=True)
+async def _fetch_registry_from_db() -> list[dict[str, Any]]:
+    """
+    Fetch all LLM models from database with related data.
+
+    Cached in Redis with 300s TTL. Thundering herd protection ensures
+    only one executor queries DB even if 1000 receive notification simultaneously.
+    """
+    records = await prisma.models.LlmModel.prisma().find_many(
+        include={
+            "Provider": True,
+            "Costs": True,
+            "Creator": True,
+        }
+    )
+    logger.debug("Fetched %d LLM model records from database", len(records))
+
+    # Serialize to plain dicts for caching
+    return [
+        {
+            "id": record.id,
+            "slug": record.slug,
+            "displayName": record.displayName,
+            "description": record.description,
+            "providerId": record.providerId,
+            "creatorId": record.creatorId,
+            "contextWindow": record.contextWindow,
+            "maxOutputTokens": record.maxOutputTokens,
+            "priceTier": getattr(record, "priceTier", 1) or 1,
+            "isEnabled": record.isEnabled,
+            "isRecommended": record.isRecommended,
+            "capabilities": record.capabilities,
+            "metadata": record.metadata,
+            "Provider": (
+                {
+                    "name": (
+                        record.Provider.name if record.Provider else record.providerId
+                    ),
+                    "displayName": (
+                        record.Provider.displayName
+                        if record.Provider
+                        else record.providerId
+                    ),
+                }
+                if record.Provider
+                else None
+            ),
+            "Costs": [
+                {
+                    "creditCost": cost.creditCost,
+                    "credentialProvider": cost.credentialProvider,
+                    "credentialId": cost.credentialId,
+                    "credentialType": cost.credentialType,
+                    "currency": cost.currency,
+                    "metadata": cost.metadata,
+                }
+                for cost in (record.Costs or [])
+            ],
+            "Creator": (
+                {
+                    "id": record.Creator.id,
+                    "name": record.Creator.name,
+                    "displayName": record.Creator.displayName,
+                    "description": record.Creator.description,
+                    "websiteUrl": record.Creator.websiteUrl,
+                    "logoUrl": record.Creator.logoUrl,
+                }
+                if record.Creator
+                else None
+            ),
+        }
+        for record in records
+    ]
+
+
+async def refresh_llm_registry(models_data: list[dict[str, Any]] | None = None) -> None:
+    """
+    Refresh the LLM registry from the database or provided data.
+
+    Args:
+        models_data: Optional pre-fetched model data from notification payload
+    """
+    async with _lock:
+        try:
+            if models_data is None:
+                # Fetch from cache (thundering herd protected)
+                models_data = await _fetch_registry_from_db()
+
+            logger.debug("Processing %d LLM model records", len(models_data))
+        except Exception as exc:
+            logger.error(
+                "Failed to refresh LLM registry from DB: %s", exc, exc_info=True
+            )
+            return
+
+        dynamic: dict[str, RegistryModel] = {}
+        for record_dict in models_data:
+            provider = record_dict.get("Provider")
+            creator_data = record_dict.get("Creator")
+
+            provider_name = provider["name"] if provider else record_dict["providerId"]
+            provider_display_name = (
+                provider["displayName"] if provider else record_dict["providerId"]
+            )
+            # Creator name: prefer Creator.name, fallback to provider display name
+            creator_name = (
+                creator_data["name"] if creator_data else provider_display_name
+            )
+            # Price tier: default to 1 (cheapest) if not set
+            price_tier = record_dict.get("priceTier", 1) or 1
+            # Clamp to valid range 1-3
+            price_tier = max(1, min(3, price_tier))
+
+            metadata = ModelMetadata(
+                provider=provider_name,
+                context_window=record_dict["contextWindow"],
+                max_output_tokens=record_dict["maxOutputTokens"],
+                display_name=record_dict["displayName"],
+                provider_name=provider_display_name,
+                creator_name=creator_name,
+                price_tier=price_tier,  # type: ignore[arg-type]
+            )
+            costs = tuple(
+                RegistryModelCost(
+                    credit_cost=cost["creditCost"],
+                    credential_provider=cost["credentialProvider"],
+                    credential_id=cost.get("credentialId"),
+                    credential_type=cost.get("credentialType"),
+                    currency=cost.get("currency"),
+                    metadata=_json_to_dict(cost.get("metadata")),
+                )
+                for cost in record_dict.get("Costs", [])
+            )
+
+            # Map creator if present
+            creator = None
+            if creator_data:
+                creator = RegistryModelCreator(
+                    id=creator_data["id"],
+                    name=creator_data["name"],
+                    display_name=creator_data["displayName"],
+                    description=creator_data.get("description"),
+                    website_url=creator_data.get("websiteUrl"),
+                    logo_url=creator_data.get("logoUrl"),
+                )
+
+            dynamic[record_dict["slug"]] = RegistryModel(
+                slug=record_dict["slug"],
+                display_name=record_dict["displayName"],
+                description=record_dict.get("description"),
+                metadata=metadata,
+                capabilities=_json_to_dict(record_dict.get("capabilities")),
+                extra_metadata=_json_to_dict(record_dict.get("metadata")),
+                provider_display_name=provider_display_name,
+                is_enabled=record_dict["isEnabled"],
+                is_recommended=record_dict["isRecommended"],
+                costs=costs,
+                creator=creator,
+            )
+
+        # Atomic swap - build new structures then replace references
+        # This ensures readers never see partially updated state
+        global _dynamic_models
+        _dynamic_models = dynamic
+        _refresh_cached_schema()
+        logger.info(
+            "LLM registry refreshed with %s dynamic models (enabled: %s, disabled: %s)",
+            len(dynamic),
+            sum(1 for m in dynamic.values() if m.is_enabled),
+            sum(1 for m in dynamic.values() if not m.is_enabled),
+        )
+
+
+def _refresh_cached_schema() -> None:
+    """Refresh cached schema options and discriminator mapping."""
+    global _schema_options, _discriminator_mapping
+
+    # Build new structures
+    new_options = _build_schema_options()
+    new_mapping = {
+        slug: entry.metadata.provider for slug, entry in _dynamic_models.items()
+    }
+    for slug, metadata in _static_metadata.items():
+        new_mapping.setdefault(slug, metadata.provider)
+
+    # Atomic swap - replace references to ensure readers see consistent state
+    _schema_options = new_options
+    _discriminator_mapping = new_mapping
+
+
+def get_llm_model_metadata(slug: str) -> ModelMetadata | None:
+    """Get model metadata by slug. Checks dynamic models first, then static metadata."""
+    if slug in _dynamic_models:
+        return _dynamic_models[slug].metadata
+    return _static_metadata.get(slug)
+
+
+def get_llm_model_cost(slug: str) -> tuple[RegistryModelCost, ...]:
+    """Get model cost configuration by slug."""
+    if slug in _dynamic_models:
+        return _dynamic_models[slug].costs
+    cost_value = _static_costs.get(slug)
+    if cost_value is None:
+        return tuple()
+    return (
+        RegistryModelCost(
+            credit_cost=cost_value,
+            credential_provider="static",
+            credential_id=None,
+            credential_type=None,
+            currency=None,
+            metadata={},
+        ),
+    )
+
+
+def get_llm_model_schema_options() -> list[dict[str, str]]:
+    """
+    Get schema options for LLM model selection dropdown.
+
+    Returns a copy of cached schema options that are refreshed when the registry is
+    updated via refresh_llm_registry() (called on startup and via Redis pub/sub).
+    """
+    # Return a copy to prevent external mutation
+    return list(_schema_options)
+
+
+def get_llm_discriminator_mapping() -> dict[str, str]:
+    """
+    Get discriminator mapping for LLM models.
+
+    Returns a copy of cached discriminator mapping that is refreshed when the registry
+    is updated via refresh_llm_registry() (called on startup and via Redis pub/sub).
+    """
+    # Return a copy to prevent external mutation
+    return dict(_discriminator_mapping)
+
+
+def get_dynamic_model_slugs() -> set[str]:
+    """Get all dynamic model slugs from the registry."""
+    return set(_dynamic_models.keys())
+
+
+def get_all_model_slugs_for_validation() -> set[str]:
+    """
+    Get ALL model slugs (both enabled and disabled) for validation purposes.
+
+    This is used for JSON schema enum validation - we need to accept any known
+    model value (even disabled ones) so that existing graphs don't fail validation.
+    The actual fallback/enforcement happens at runtime in llm_call().
+    """
+    all_slugs = set(_dynamic_models.keys())
+    all_slugs.update(_static_metadata.keys())
+    return all_slugs
+
+
+def iter_dynamic_models() -> Iterable[RegistryModel]:
+    """Iterate over all dynamic models in the registry."""
+    return tuple(_dynamic_models.values())
+
+
+def get_fallback_model_for_disabled(disabled_model_slug: str) -> RegistryModel | None:
+    """
+    Find a fallback model when the requested model is disabled.
+
+    Looks for an enabled model from the same provider. Prefers models with
+    similar names or capabilities if possible.
+
+    Args:
+        disabled_model_slug: The slug of the disabled model
+
+    Returns:
+        An enabled RegistryModel from the same provider, or None if no fallback found
+    """
+    disabled_model = _dynamic_models.get(disabled_model_slug)
+    if not disabled_model:
+        return None
+
+    provider = disabled_model.metadata.provider
+
+    # Find all enabled models from the same provider
+    candidates = [
+        model
+        for model in _dynamic_models.values()
+        if model.is_enabled and model.metadata.provider == provider
+    ]
+
+    if not candidates:
+        return None
+
+    # Sort by: prefer models with similar context window, then by name
+    candidates.sort(
+        key=lambda m: (
+            abs(m.metadata.context_window - disabled_model.metadata.context_window),
+            m.display_name.lower(),
+        )
+    )
+
+    return candidates[0]
+
+
+def is_model_enabled(model_slug: str) -> bool:
+    """Check if a model is enabled in the registry."""
+    model = _dynamic_models.get(model_slug)
+    if not model:
+        # Model not in registry - assume it's a static/legacy model and allow it
+        return True
+    return model.is_enabled
+
+
+def get_model_info(model_slug: str) -> RegistryModel | None:
+    """Get model info from the registry."""
+    return _dynamic_models.get(model_slug)
+
+
+def get_default_model_slug() -> str | None:
+    """
+    Get the default model slug to use for block defaults.
+
+    Returns the recommended model if set (configured via admin UI),
+    otherwise returns the first enabled model alphabetically.
+    Returns None if no models are available or enabled.
+    """
+    # Return the recommended model if one is set and enabled
+    for model in _dynamic_models.values():
+        if model.is_recommended and model.is_enabled:
+            return model.slug
+
+    # No recommended model set - find first enabled model alphabetically
+    for model in sorted(_dynamic_models.values(), key=lambda m: m.display_name.lower()):
+        if model.is_enabled:
+            logger.warning(
+                "No recommended model set, using '%s' as default",
+                model.slug,
+            )
+            return model.slug
+
+    # No enabled models available
+    if _dynamic_models:
+        logger.error(
+            "No enabled models found in registry (%d models registered but all disabled)",
+            len(_dynamic_models),
+        )
+    else:
+        logger.error("No models registered in LLM registry")
+
+    return None

autogpt_platform/backend/backend/data/llm_registry/registry_test.py

@@ -0,0 +1,143 @@
+"""Unit tests for LLM registry caching and thundering herd protection."""
+
+import asyncio
+
+import pytest
+from unittest.mock import AsyncMock, patch
+
+from backend.data.llm_registry import registry
+
+
+@pytest.mark.asyncio
+async def test_fetch_registry_from_db_caching():
+    """Verify @cached prevents duplicate DB calls."""
+    with patch("backend.data.llm_registry.registry.prisma.models.LlmModel") as mock:
+        mock.prisma().find_many = AsyncMock(return_value=[])
+
+        # Clear cache first
+        registry._fetch_registry_from_db.cache_clear()
+
+        # Call twice
+        await registry._fetch_registry_from_db()
+        await registry._fetch_registry_from_db()
+
+        # Verify only called once (cached)
+        assert mock.prisma().find_many.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_thundering_herd_protection():
+    """Verify only 1 DB call with 100 concurrent requests."""
+    call_count = 0
+
+    async def mock_db_fetch(*args, **kwargs):
+        nonlocal call_count
+        call_count += 1
+        await asyncio.sleep(0.1)  # Simulate slow DB
+        return []
+
+    with patch("backend.data.llm_registry.registry.prisma.models.LlmModel") as mock:
+        mock.prisma().find_many = mock_db_fetch
+
+        # Clear cache first
+        registry._fetch_registry_from_db.cache_clear()
+
+        # Launch 100 concurrent fetches
+        tasks = [registry._fetch_registry_from_db() for _ in range(100)]
+        await asyncio.gather(*tasks)
+
+        # Verify only 1 DB call due to thundering herd protection
+        assert call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_refresh_accepts_models_data():
+    """Verify refresh_llm_registry can accept pre-fetched data."""
+    models_data = [
+        {
+            "id": "test-id",
+            "slug": "gpt-4o",
+            "displayName": "GPT-4o",
+            "description": "Test model",
+            "providerId": "openai",
+            "creatorId": None,
+            "contextWindow": 128000,
+            "maxOutputTokens": 4096,
+            "priceTier": 2,
+            "isEnabled": True,
+            "isRecommended": False,
+            "capabilities": {},
+            "metadata": {},
+            "Provider": {
+                "name": "openai",
+                "displayName": "OpenAI",
+            },
+            "Costs": [],
+            "Creator": None,
+        }
+    ]
+
+    with patch("backend.data.llm_registry.registry.prisma.models.LlmModel") as mock:
+        # Should NOT call DB if data provided
+        await registry.refresh_llm_registry(models_data=models_data)
+        mock.prisma().find_many.assert_not_called()
+
+        # Verify model was added to registry
+        assert "gpt-4o" in registry._dynamic_models
+        assert registry._dynamic_models["gpt-4o"].display_name == "GPT-4o"
+
+
+@pytest.mark.asyncio
+async def test_refresh_falls_back_to_cache():
+    """Verify refresh_llm_registry fetches from cache when no data provided."""
+    with patch(
+        "backend.data.llm_registry.registry._fetch_registry_from_db"
+    ) as mock_fetch:
+        mock_fetch.return_value = []
+
+        # Call without data - should fetch from cache
+        await registry.refresh_llm_registry(models_data=None)
+
+        # Verify cache fetch was called
+        assert mock_fetch.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_cache_clear_forces_fresh_fetch():
+    """
+    Verify that cache_clear() forces a fresh DB fetch.
+
+    This is CRITICAL for admin updates - when an admin changes a model,
+    we must clear the cache before fetching to ensure fresh data is broadcast.
+    """
+    fetch_count = 0
+
+    async def mock_db_fetch(*args, **kwargs):
+        nonlocal fetch_count
+        fetch_count += 1
+        return [{"slug": f"model-{fetch_count}", "displayName": f"Model {fetch_count}"}]
+
+    with patch("backend.data.llm_registry.registry.prisma.models.LlmModel") as mock:
+        mock.prisma().find_many = mock_db_fetch
+
+        # Clear cache and fetch first time
+        registry._fetch_registry_from_db.cache_clear()
+        result1 = await registry._fetch_registry_from_db()
+        assert result1[0]["slug"] == "model-1"
+        assert fetch_count == 1
+
+        # Fetch second time (should use cache, no DB call)
+        result2 = await registry._fetch_registry_from_db()
+        assert result2[0]["slug"] == "model-1"  # Same cached data
+        assert fetch_count == 1  # No additional DB call
+
+        # Clear cache (simulating admin update)
+        registry._fetch_registry_from_db.cache_clear()
+
+        # Fetch third time (should hit DB for fresh data)
+        result3 = await registry._fetch_registry_from_db()
+        assert result3[0]["slug"] == "model-2"  # Fresh data!
+        assert fetch_count == 2  # New DB call
+
+        # Verify cache_clear() method exists and is callable
+        assert callable(registry._fetch_registry_from_db.cache_clear)

autogpt_platform/backend/backend/data/llm_registry/schema_utils.py

@@ -0,0 +1,130 @@
+"""
+Helper utilities for LLM registry integration with block schemas.
+
+This module handles the dynamic injection of discriminator mappings
+and model options from the LLM registry into block schemas.
+"""
+
+import logging
+from typing import Any
+
+from backend.data.llm_registry.registry import (
+    get_all_model_slugs_for_validation,
+    get_default_model_slug,
+    get_llm_discriminator_mapping,
+    get_llm_model_schema_options,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def is_llm_model_field(field_name: str, field_info: Any) -> bool:
+    """
+    Check if a field is an LLM model selection field.
+
+    Returns True if the field has 'options' in json_schema_extra
+    (set by llm_model_schema_extra() in blocks/llm.py).
+    """
+    if not hasattr(field_info, "json_schema_extra"):
+        return False
+
+    extra = field_info.json_schema_extra
+    if isinstance(extra, dict):
+        return "options" in extra
+
+    return False
+
+
+def refresh_llm_model_options(field_schema: dict[str, Any]) -> None:
+    """
+    Refresh LLM model options from the registry.
+
+    Updates 'options' (for frontend dropdown) to show only enabled models,
+    but keeps the 'enum' (for validation) inclusive of ALL known models.
+
+    This is important because:
+    - Options: What users see in the dropdown (enabled models only)
+    - Enum: What values pass validation (all known models, including disabled)
+
+    Existing graphs may have disabled models selected - they should pass validation
+    and the fallback logic in llm_call() will handle using an alternative model.
+    """
+    fresh_options = get_llm_model_schema_options()
+    if not fresh_options:
+        return
+
+    # Update options array (UI dropdown) - only enabled models
+    if "options" in field_schema:
+        field_schema["options"] = fresh_options
+
+    all_known_slugs = get_all_model_slugs_for_validation()
+    if all_known_slugs and "enum" in field_schema:
+        existing_enum = set(field_schema.get("enum", []))
+        combined_enum = existing_enum | all_known_slugs
+        field_schema["enum"] = sorted(combined_enum)
+
+    # Set the default value from the registry (gpt-4o if available, else first enabled)
+    # This ensures new blocks have a sensible default pre-selected
+    default_slug = get_default_model_slug()
+    if default_slug:
+        field_schema["default"] = default_slug
+
+
+def refresh_llm_discriminator_mapping(field_schema: dict[str, Any]) -> None:
+    """
+    Refresh discriminator_mapping for fields that use model-based discrimination.
+
+    The discriminator is already set when AICredentialsField() creates the field.
+    We only need to refresh the mapping when models are added/removed.
+    """
+    if field_schema.get("discriminator") != "model":
+        return
+
+    # Always refresh the mapping to get latest models
+    fresh_mapping = get_llm_discriminator_mapping()
+    if fresh_mapping is not None:
+        field_schema["discriminator_mapping"] = fresh_mapping
+
+
+def update_schema_with_llm_registry(
+    schema: dict[str, Any], model_class: type | None = None
+) -> None:
+    """
+    Update a JSON schema with current LLM registry data.
+
+    Refreshes:
+    1. Model options for LLM model selection fields (dropdown choices)
+    2. Discriminator mappings for credentials fields (model → provider)
+
+    Args:
+        schema: The JSON schema to update (mutated in-place)
+        model_class: The Pydantic model class (optional, for field introspection)
+    """
+    properties = schema.get("properties", {})
+
+    for field_name, field_schema in properties.items():
+        if not isinstance(field_schema, dict):
+            continue
+
+        # Refresh model options for LLM model fields
+        if model_class and hasattr(model_class, "model_fields"):
+            field_info = model_class.model_fields.get(field_name)
+            if field_info and is_llm_model_field(field_name, field_info):
+                try:
+                    refresh_llm_model_options(field_schema)
+                except Exception as exc:
+                    logger.warning(
+                        "Failed to refresh LLM options for field %s: %s",
+                        field_name,
+                        exc,
+                    )
+
+        # Refresh discriminator mapping for fields that use model discrimination
+        try:
+            refresh_llm_discriminator_mapping(field_schema)
+        except Exception as exc:
+            logger.warning(
+                "Failed to refresh discriminator mapping for field %s: %s",
+                field_name,
+                exc,
+            )

autogpt_platform/backend/backend/data/model.py

@@ -40,6 +40,7 @@ from pydantic_core import (
 )
 from typing_extensions import TypedDict
 
+from backend.data.llm_registry import update_schema_with_llm_registry
 from backend.integrations.providers import ProviderName
 from backend.util.json import loads as json_loads
 from backend.util.request import parse_url
@@ -570,7 +571,9 @@ class CredentialsMetaInput(BaseModel, Generic[CP, CT]):
             else:
                 schema["credentials_provider"] = allowed_providers
             schema["credentials_types"] = model_class.allowed_cred_types()
-        # Do not return anything, just mutate schema in place
+
+        # Ensure LLM discriminators are populated (delegates to shared helper)
+        update_schema_with_llm_registry(schema, model_class)
 
     model_config = ConfigDict(
         json_schema_extra=_add_json_schema_extra,  # type: ignore
@@ -732,16 +735,20 @@ def CredentialsField(
     This is enforced by the `BlockSchema` base class.
     """
 
-    field_schema_extra = {
-        k: v
-        for k, v in {
-            "credentials_scopes": list(required_scopes) or None,
-            "discriminator": discriminator,
-            "discriminator_mapping": discriminator_mapping,
-            "discriminator_values": discriminator_values,
-        }.items()
-        if v is not None
-    }
+    # Build field_schema_extra - always include discriminator and mapping if discriminator is set
+    field_schema_extra: dict[str, Any] = {}
+
+    # Always include discriminator if provided
+    if discriminator is not None:
+        field_schema_extra["discriminator"] = discriminator
+        # Always include discriminator_mapping when discriminator is set (even if empty initially)
+        field_schema_extra["discriminator_mapping"] = discriminator_mapping or {}
+
+    # Include other optional fields (only if not None)
+    if required_scopes:
+        field_schema_extra["credentials_scopes"] = list(required_scopes)
+    if discriminator_values:
+        field_schema_extra["discriminator_values"] = discriminator_values
 
     # Merge any json_schema_extra passed in kwargs
     if "json_schema_extra" in kwargs:

autogpt_platform/backend/backend/executor/llm_registry_init.py

@@ -0,0 +1,87 @@
+"""
+Helper functions for LLM registry initialization in executor context.
+
+These functions handle refreshing the LLM registry when the executor starts
+and subscribing to real-time updates via Redis pub/sub.
+"""
+
+import asyncio
+import logging
+import random
+
+from backend.blocks._base import BlockSchema
+from backend.data import db, llm_registry
+from backend.data.block import initialize_blocks
+from backend.data.block_cost_config import refresh_llm_costs
+from backend.data.llm_registry import subscribe_to_registry_refresh
+
+logger = logging.getLogger(__name__)
+
+
+async def initialize_registry_for_executor() -> None:
+    """
+    Initialize blocks and refresh LLM registry in the executor context.
+
+    This must run in the executor's event loop to have access to the database.
+    """
+    try:
+        # Connect to database if not already connected
+        if not db.is_connected():
+            await db.connect()
+            logger.info("[GraphExecutor] Connected to database for registry refresh")
+
+        # Initialize blocks (internally refreshes LLM registry and costs)
+        await initialize_blocks()
+        logger.info("[GraphExecutor] Blocks initialized")
+    except Exception as exc:
+        logger.warning(
+            "[GraphExecutor] Failed to refresh LLM registry on startup: %s",
+            exc,
+            exc_info=True,
+        )
+
+
+async def refresh_registry_on_notification(
+    models_data: list[dict] | None = None,
+) -> None:
+    """
+    Refresh LLM registry when notified via Redis pub/sub.
+
+    Args:
+        models_data: Optional pre-fetched model data from notification
+    """
+    # Add jitter to spread load across executors (0-2 seconds)
+    jitter = random.uniform(0, 2.0)
+    await asyncio.sleep(jitter)
+    logger.debug("[GraphExecutor] Starting registry refresh after %.2fs jitter", jitter)
+
+    try:
+        # Ensure DB is connected
+        if not db.is_connected():
+            await db.connect()
+
+        # Refresh registry (uses provided data or fetches from cache)
+        await llm_registry.refresh_llm_registry(models_data=models_data)
+        await refresh_llm_costs()
+
+        # Clear block schema caches so they regenerate with new model options
+        BlockSchema.clear_all_schema_caches()
+
+        if models_data:
+            logger.info(
+                "[GraphExecutor] LLM registry refreshed from notification data (%d models)",
+                len(models_data),
+            )
+        else:
+            logger.info("[GraphExecutor] LLM registry refreshed from cache")
+    except Exception as exc:
+        logger.error(
+            "[GraphExecutor] Failed to refresh LLM registry from notification: %s",
+            exc,
+            exc_info=True,
+        )
+
+
+async def subscribe_to_registry_updates() -> None:
+    """Subscribe to Redis pub/sub for LLM registry refresh notifications."""
+    await subscribe_to_registry_refresh(refresh_registry_on_notification)

autogpt_platform/backend/backend/executor/manager.py

@@ -45,6 +45,10 @@ from backend.data.notifications import (
     ZeroBalanceData,
 )
 from backend.data.rabbitmq import SyncRabbitMQ
+from backend.executor.llm_registry_init import (
+    initialize_registry_for_executor,
+    subscribe_to_registry_updates,
+)
 from backend.integrations.creds_manager import IntegrationCredentialsManager
 from backend.notifications.notifications import queue_notification
 from backend.util import json
@@ -750,6 +754,15 @@ class ExecutionProcessor:
         )
         self.node_execution_thread.start()
         self.node_evaluation_thread.start()
+
+        # Initialize LLM registry and subscribe to updates
+        asyncio.run_coroutine_threadsafe(
+            initialize_registry_for_executor(), self.node_execution_loop
+        )
+        asyncio.run_coroutine_threadsafe(
+            subscribe_to_registry_updates(), self.node_execution_loop
+        )
+
         logger.info(f"[GraphExecutor] {self.tid} started")
 
     @error_logged(swallow=False)

autogpt_platform/backend/backend/server/v2/llm/db.py

@@ -0,0 +1,938 @@
+from __future__ import annotations
+
+from typing import Any, Iterable, Sequence, cast
+
+import prisma
+import prisma.models
+
+from backend.data.db import transaction
+from backend.server.v2.llm import model as llm_model
+from backend.util.models import Pagination
+
+
+def _json_dict(value: Any | None) -> dict[str, Any]:
+    if not value:
+        return {}
+    if isinstance(value, dict):
+        return value
+    return {}
+
+
+def _map_cost(record: prisma.models.LlmModelCost) -> llm_model.LlmModelCost:
+    return llm_model.LlmModelCost(
+        id=record.id,
+        unit=record.unit,
+        credit_cost=record.creditCost,
+        credential_provider=record.credentialProvider,
+        credential_id=record.credentialId,
+        credential_type=record.credentialType,
+        currency=record.currency,
+        metadata=_json_dict(record.metadata),
+    )
+
+
+def _map_creator(
+    record: prisma.models.LlmModelCreator,
+) -> llm_model.LlmModelCreator:
+    return llm_model.LlmModelCreator(
+        id=record.id,
+        name=record.name,
+        display_name=record.displayName,
+        description=record.description,
+        website_url=record.websiteUrl,
+        logo_url=record.logoUrl,
+        metadata=_json_dict(record.metadata),
+    )
+
+
+def _map_model(record: prisma.models.LlmModel) -> llm_model.LlmModel:
+    costs = []
+    if record.Costs:
+        costs = [_map_cost(cost) for cost in record.Costs]
+
+    creator = None
+    if hasattr(record, "Creator") and record.Creator:
+        creator = _map_creator(record.Creator)
+
+    return llm_model.LlmModel(
+        id=record.id,
+        slug=record.slug,
+        display_name=record.displayName,
+        description=record.description,
+        provider_id=record.providerId,
+        creator_id=record.creatorId,
+        creator=creator,
+        context_window=record.contextWindow,
+        max_output_tokens=record.maxOutputTokens,
+        is_enabled=record.isEnabled,
+        is_recommended=record.isRecommended,
+        supports_tools=record.supportsTools,
+        supports_json_output=record.supportsJsonOutput,
+        supports_reasoning=record.supportsReasoning,
+        supports_parallel_tool=record.supportsParallelTool,
+        capabilities=_json_dict(record.capabilities),
+        metadata=_json_dict(record.metadata),
+        costs=costs,
+    )
+
+
+def _map_provider(record: prisma.models.LlmProvider) -> llm_model.LlmProvider:
+    models: list[llm_model.LlmModel] = []
+    if record.Models:
+        models = [_map_model(model) for model in record.Models]
+
+    return llm_model.LlmProvider(
+        id=record.id,
+        name=record.name,
+        display_name=record.displayName,
+        description=record.description,
+        default_credential_provider=record.defaultCredentialProvider,
+        default_credential_id=record.defaultCredentialId,
+        default_credential_type=record.defaultCredentialType,
+        metadata=_json_dict(record.metadata),
+        models=models,
+    )
+
+
+async def list_providers(
+    include_models: bool = True, enabled_only: bool = False
+) -> list[llm_model.LlmProvider]:
+    """
+    List all LLM providers.
+
+    Args:
+        include_models: Whether to include models for each provider
+        enabled_only: If True, only include enabled models (for public routes)
+    """
+    include: Any = None
+    if include_models:
+        model_where = {"isEnabled": True} if enabled_only else None
+        include = {
+            "Models": {
+                "include": {"Costs": True, "Creator": True},
+                "where": model_where,
+            }
+        }
+    records = await prisma.models.LlmProvider.prisma().find_many(include=include)
+    return [_map_provider(record) for record in records]
+
+
+async def upsert_provider(
+    request: llm_model.UpsertLlmProviderRequest,
+    provider_id: str | None = None,
+) -> llm_model.LlmProvider:
+    data: Any = {
+        "name": request.name,
+        "displayName": request.display_name,
+        "description": request.description,
+        "defaultCredentialProvider": request.default_credential_provider,
+        "defaultCredentialId": request.default_credential_id,
+        "defaultCredentialType": request.default_credential_type,
+        "supportsTools": request.supports_tools,
+        "supportsJsonOutput": request.supports_json_output,
+        "supportsReasoning": request.supports_reasoning,
+        "supportsParallelTool": request.supports_parallel_tool,
+        "metadata": prisma.Json(request.metadata or {}),
+    }
+    include: Any = {"Models": {"include": {"Costs": True, "Creator": True}}}
+    if provider_id:
+        record = await prisma.models.LlmProvider.prisma().update(
+            where={"id": provider_id},
+            data=data,
+            include=include,
+        )
+    else:
+        record = await prisma.models.LlmProvider.prisma().create(
+            data=data,
+            include=include,
+        )
+    if record is None:
+        raise ValueError("Failed to create/update provider")
+    return _map_provider(record)
+
+
+async def delete_provider(provider_id: str) -> bool:
+    """
+    Delete an LLM provider.
+
+    A provider can only be deleted if it has no associated models.
+    Due to onDelete: Restrict on LlmModel.Provider, the database will
+    block deletion if models exist.
+
+    Args:
+        provider_id: UUID of the provider to delete
+
+    Returns:
+        True if deleted successfully
+
+    Raises:
+        ValueError: If provider not found or has associated models
+    """
+    # Check if provider exists
+    provider = await prisma.models.LlmProvider.prisma().find_unique(
+        where={"id": provider_id},
+        include={"Models": True},
+    )
+    if not provider:
+        raise ValueError(f"Provider with id '{provider_id}' not found")
+
+    # Check if provider has any models
+    model_count = len(provider.Models) if provider.Models else 0
+    if model_count > 0:
+        raise ValueError(
+            f"Cannot delete provider '{provider.displayName}' because it has "
+            f"{model_count} model(s). Delete all models first."
+        )
+
+    # Safe to delete
+    await prisma.models.LlmProvider.prisma().delete(where={"id": provider_id})
+    return True
+
+
+async def list_models(
+    provider_id: str | None = None,
+    enabled_only: bool = False,
+    page: int = 1,
+    page_size: int = 50,
+) -> llm_model.LlmModelsResponse:
+    """
+    List LLM models with pagination.
+
+    Args:
+        provider_id: Optional filter by provider ID
+        enabled_only: If True, only return enabled models (for public routes)
+        page: Page number (1-indexed)
+        page_size: Number of models per page
+    """
+    # Validate pagination inputs to avoid runtime errors
+    if page_size < 1:
+        page_size = 50
+    if page < 1:
+        page = 1
+
+    where: Any = {}
+    if provider_id:
+        where["providerId"] = provider_id
+    if enabled_only:
+        where["isEnabled"] = True
+
+    # Get total count for pagination
+    total_items = await prisma.models.LlmModel.prisma().count(
+        where=where if where else None
+    )
+
+    # Calculate pagination
+    skip = (page - 1) * page_size
+    total_pages = (total_items + page_size - 1) // page_size if total_items > 0 else 0
+
+    records = await prisma.models.LlmModel.prisma().find_many(
+        where=where if where else None,
+        include={"Costs": True, "Creator": True},
+        skip=skip,
+        take=page_size,
+    )
+    models = [_map_model(record) for record in records]
+
+    return llm_model.LlmModelsResponse(
+        models=models,
+        pagination=Pagination(
+            total_items=total_items,
+            total_pages=total_pages,
+            current_page=page,
+            page_size=page_size,
+        ),
+    )
+
+
+def _cost_create_payload(
+    costs: Sequence[llm_model.LlmModelCostInput],
+) -> dict[str, Iterable[dict[str, Any]]]:
+
+    create_items = []
+    for cost in costs:
+        item: dict[str, Any] = {
+            "unit": cost.unit,
+            "creditCost": cost.credit_cost,
+            "credentialProvider": cost.credential_provider,
+        }
+        # Only include optional fields if they have values
+        if cost.credential_id:
+            item["credentialId"] = cost.credential_id
+        if cost.credential_type:
+            item["credentialType"] = cost.credential_type
+        if cost.currency:
+            item["currency"] = cost.currency
+        # Handle metadata - use Prisma Json type
+        if cost.metadata is not None and cost.metadata != {}:
+            item["metadata"] = prisma.Json(cost.metadata)
+        create_items.append(item)
+    return {"create": create_items}
+
+
+async def create_model(
+    request: llm_model.CreateLlmModelRequest,
+) -> llm_model.LlmModel:
+    data: Any = {
+        "slug": request.slug,
+        "displayName": request.display_name,
+        "description": request.description,
+        "Provider": {"connect": {"id": request.provider_id}},
+        "contextWindow": request.context_window,
+        "maxOutputTokens": request.max_output_tokens,
+        "isEnabled": request.is_enabled,
+        "capabilities": prisma.Json(request.capabilities or {}),
+        "metadata": prisma.Json(request.metadata or {}),
+        "Costs": _cost_create_payload(request.costs),
+    }
+    if request.creator_id:
+        data["Creator"] = {"connect": {"id": request.creator_id}}
+
+    record = await prisma.models.LlmModel.prisma().create(
+        data=data,
+        include={"Costs": True, "Creator": True, "Provider": True},
+    )
+    return _map_model(record)
+
+
+async def update_model(
+    model_id: str,
+    request: llm_model.UpdateLlmModelRequest,
+) -> llm_model.LlmModel:
+    # Build scalar field updates (non-relation fields)
+    scalar_data: Any = {}
+    if request.display_name is not None:
+        scalar_data["displayName"] = request.display_name
+    if request.description is not None:
+        scalar_data["description"] = request.description
+    if request.context_window is not None:
+        scalar_data["contextWindow"] = request.context_window
+    if request.max_output_tokens is not None:
+        scalar_data["maxOutputTokens"] = request.max_output_tokens
+    if request.is_enabled is not None:
+        scalar_data["isEnabled"] = request.is_enabled
+    if request.capabilities is not None:
+        scalar_data["capabilities"] = request.capabilities
+    if request.metadata is not None:
+        scalar_data["metadata"] = request.metadata
+    # Foreign keys can be updated directly as scalar fields
+    if request.provider_id is not None:
+        scalar_data["providerId"] = request.provider_id
+    if request.creator_id is not None:
+        # Empty string means remove the creator
+        scalar_data["creatorId"] = request.creator_id if request.creator_id else None
+
+    # If we have costs to update, we need to handle them separately
+    # because nested writes have different constraints
+    if request.costs is not None:
+        # Wrap cost replacement in a transaction for atomicity
+        async with transaction() as tx:
+            # First update scalar fields
+            if scalar_data:
+                await tx.llmmodel.update(
+                    where={"id": model_id},
+                    data=scalar_data,
+                )
+            # Then handle costs: delete existing and create new
+            await tx.llmmodelcost.delete_many(where={"llmModelId": model_id})
+            if request.costs:
+                cost_payload = _cost_create_payload(request.costs)
+                for cost_item in cost_payload["create"]:
+                    cost_item["llmModelId"] = model_id
+                    await tx.llmmodelcost.create(data=cast(Any, cost_item))
+        # Fetch the updated record (outside transaction)
+        record = await prisma.models.LlmModel.prisma().find_unique(
+            where={"id": model_id},
+            include={"Costs": True, "Creator": True},
+        )
+    else:
+        # No costs update - simple update
+        record = await prisma.models.LlmModel.prisma().update(
+            where={"id": model_id},
+            data=scalar_data,
+            include={"Costs": True, "Creator": True},
+        )
+
+    if not record:
+        raise ValueError(f"Model with id '{model_id}' not found")
+    return _map_model(record)
+
+
+async def toggle_model(
+    model_id: str,
+    is_enabled: bool,
+    migrate_to_slug: str | None = None,
+    migration_reason: str | None = None,
+    custom_credit_cost: int | None = None,
+) -> llm_model.ToggleLlmModelResponse:
+    """
+    Toggle a model's enabled status, optionally migrating workflows when disabling.
+
+    Args:
+        model_id: UUID of the model to toggle
+        is_enabled: New enabled status
+        migrate_to_slug: If disabling and this is provided, migrate all workflows
+                         using this model to the specified replacement model
+        migration_reason: Optional reason for the migration (e.g., "Provider outage")
+        custom_credit_cost: Optional custom pricing override for migrated workflows.
+                           When set, the billing system should use this cost instead
+                           of the target model's cost for affected nodes.
+
+    Returns:
+        ToggleLlmModelResponse with the updated model and optional migration stats
+    """
+    import json
+
+    # Get the model being toggled
+    model = await prisma.models.LlmModel.prisma().find_unique(
+        where={"id": model_id}, include={"Costs": True}
+    )
+    if not model:
+        raise ValueError(f"Model with id '{model_id}' not found")
+
+    nodes_migrated = 0
+    migration_id: str | None = None
+
+    # If disabling with migration, perform migration first
+    if not is_enabled and migrate_to_slug:
+        # Perform all operations atomically within a single transaction
+        # This ensures no nodes are missed between query and update
+        async with transaction() as tx:
+            # Validate replacement model exists and is enabled (inside transaction to prevent TOCTOU)
+            replacement = await tx.llmmodel.find_unique(where={"slug": migrate_to_slug})
+            if not replacement:
+                raise ValueError(f"Replacement model '{migrate_to_slug}' not found")
+            if not replacement.isEnabled:
+                raise ValueError(
+                    f"Replacement model '{migrate_to_slug}' is disabled. "
+                    f"Please enable it before using it as a replacement."
+                )
+            # Get the IDs of nodes that will be migrated (inside transaction for consistency)
+            node_ids_result = await tx.query_raw(
+                """
+                SELECT id
+                FROM "AgentNode"
+                WHERE "constantInput"::jsonb->>'model' = $1
+                FOR UPDATE
+                """,
+                model.slug,
+            )
+            migrated_node_ids = (
+                [row["id"] for row in node_ids_result] if node_ids_result else []
+            )
+            nodes_migrated = len(migrated_node_ids)
+
+            if nodes_migrated > 0:
+                # Update by IDs to ensure we only update the exact nodes we queried
+                # Use JSON array and jsonb_array_elements_text for safe parameterization
+                node_ids_json = json.dumps(migrated_node_ids)
+                await tx.execute_raw(
+                    """
+                    UPDATE "AgentNode"
+                    SET "constantInput" = JSONB_SET(
+                        "constantInput"::jsonb,
+                        '{model}',
+                        to_jsonb($1::text)
+                    )
+                    WHERE id::text IN (
+                        SELECT jsonb_array_elements_text($2::jsonb)
+                    )
+                    """,
+                    migrate_to_slug,
+                    node_ids_json,
+                )
+
+            record = await tx.llmmodel.update(
+                where={"id": model_id},
+                data={"isEnabled": is_enabled},
+                include={"Costs": True},
+            )
+
+            # Create migration record for revert capability
+            if nodes_migrated > 0:
+                migration_data: Any = {
+                    "sourceModelSlug": model.slug,
+                    "targetModelSlug": migrate_to_slug,
+                    "reason": migration_reason,
+                    "migratedNodeIds": json.dumps(migrated_node_ids),
+                    "nodeCount": nodes_migrated,
+                    "customCreditCost": custom_credit_cost,
+                }
+                migration_record = await tx.llmmodelmigration.create(
+                    data=migration_data
+                )
+                migration_id = migration_record.id
+    else:
+        # Simple toggle without migration
+        record = await prisma.models.LlmModel.prisma().update(
+            where={"id": model_id},
+            data={"isEnabled": is_enabled},
+            include={"Costs": True},
+        )
+
+    if record is None:
+        raise ValueError(f"Model with id '{model_id}' not found")
+    return llm_model.ToggleLlmModelResponse(
+        model=_map_model(record),
+        nodes_migrated=nodes_migrated,
+        migrated_to_slug=migrate_to_slug if nodes_migrated > 0 else None,
+        migration_id=migration_id,
+    )
+
+
+async def get_model_usage(model_id: str) -> llm_model.LlmModelUsageResponse:
+    """Get usage count for a model."""
+    import prisma as prisma_module
+
+    model = await prisma.models.LlmModel.prisma().find_unique(where={"id": model_id})
+    if not model:
+        raise ValueError(f"Model with id '{model_id}' not found")
+
+    count_result = await prisma_module.get_client().query_raw(
+        """
+        SELECT COUNT(*) as count
+        FROM "AgentNode"
+        WHERE "constantInput"::jsonb->>'model' = $1
+        """,
+        model.slug,
+    )
+    node_count = int(count_result[0]["count"]) if count_result else 0
+
+    return llm_model.LlmModelUsageResponse(model_slug=model.slug, node_count=node_count)
+
+
+async def delete_model(
+    model_id: str, replacement_model_slug: str | None = None
+) -> llm_model.DeleteLlmModelResponse:
+    """
+    Delete a model and optionally migrate all AgentNodes using it to a replacement model.
+
+    This performs an atomic operation within a database transaction:
+    1. Validates the model exists
+    2. Counts affected nodes
+    3. If nodes exist, validates replacement model and migrates them
+    4. Deletes the LlmModel record (CASCADE deletes costs)
+
+    Args:
+        model_id: UUID of the model to delete
+        replacement_model_slug: Slug of the model to migrate to (required only if nodes use this model)
+
+    Returns:
+        DeleteLlmModelResponse with migration stats
+
+    Raises:
+        ValueError: If model not found, nodes exist but no replacement provided,
+                    replacement not found, or replacement is disabled
+    """
+    # 1. Get the model being deleted (early validation - outside transaction)
+    model = await prisma.models.LlmModel.prisma().find_unique(
+        where={"id": model_id}, include={"Costs": True}
+    )
+    if not model:
+        raise ValueError(f"Model with id '{model_id}' not found")
+
+    deleted_slug = model.slug
+    deleted_display_name = model.displayName
+
+    # 2. Perform all mutation logic atomically within a transaction
+    # This prevents TOCTOU issues where nodes could be created between count and delete
+    async with transaction() as tx:
+        # Count affected nodes inside the transaction
+        count_result = await tx.query_raw(
+            """
+            SELECT COUNT(*) as count
+            FROM "AgentNode"
+            WHERE "constantInput"::jsonb->>'model' = $1
+            """,
+            deleted_slug,
+        )
+        nodes_to_migrate = int(count_result[0]["count"]) if count_result else 0
+
+        # Validate replacement model only if there are nodes to migrate
+        if nodes_to_migrate > 0:
+            if not replacement_model_slug:
+                raise ValueError(
+                    f"Cannot delete model '{deleted_slug}': {nodes_to_migrate} workflow node(s) "
+                    f"are using it. Please provide a replacement_model_slug to migrate them."
+                )
+            replacement = await tx.llmmodel.find_unique(
+                where={"slug": replacement_model_slug}
+            )
+            if not replacement:
+                raise ValueError(
+                    f"Replacement model '{replacement_model_slug}' not found"
+                )
+            if not replacement.isEnabled:
+                raise ValueError(
+                    f"Replacement model '{replacement_model_slug}' is disabled. "
+                    f"Please enable it before using it as a replacement."
+                )
+
+            # Migrate all AgentNode.constantInput->model to replacement
+            await tx.execute_raw(
+                """
+                UPDATE "AgentNode"
+                SET "constantInput" = JSONB_SET(
+                    "constantInput"::jsonb,
+                    '{model}',
+                    to_jsonb($1::text)
+                )
+                WHERE "constantInput"::jsonb->>'model' = $2
+                """,
+                replacement_model_slug,
+                deleted_slug,
+            )
+
+        # Delete the model (CASCADE will delete costs automatically)
+        await tx.llmmodel.delete(where={"id": model_id})
+
+    # Build appropriate message based on whether migration happened
+    if nodes_to_migrate > 0:
+        message = (
+            f"Successfully deleted model '{deleted_display_name}' ({deleted_slug}) "
+            f"and migrated {nodes_to_migrate} workflow node(s) to '{replacement_model_slug}'."
+        )
+    else:
+        message = (
+            f"Successfully deleted model '{deleted_display_name}' ({deleted_slug}). "
+            f"No workflows were using this model."
+        )
+
+    return llm_model.DeleteLlmModelResponse(
+        deleted_model_slug=deleted_slug,
+        deleted_model_display_name=deleted_display_name,
+        replacement_model_slug=replacement_model_slug,
+        nodes_migrated=nodes_to_migrate,
+        message=message,
+    )
+
+
+def _map_migration(
+    record: prisma.models.LlmModelMigration,
+) -> llm_model.LlmModelMigration:
+    return llm_model.LlmModelMigration(
+        id=record.id,
+        source_model_slug=record.sourceModelSlug,
+        target_model_slug=record.targetModelSlug,
+        reason=record.reason,
+        node_count=record.nodeCount,
+        custom_credit_cost=record.customCreditCost,
+        is_reverted=record.isReverted,
+        created_at=record.createdAt,
+        reverted_at=record.revertedAt,
+    )
+
+
+async def list_migrations(
+    include_reverted: bool = False,
+) -> list[llm_model.LlmModelMigration]:
+    """
+    List model migrations, optionally including reverted ones.
+
+    Args:
+        include_reverted: If True, include reverted migrations. Default is False.
+
+    Returns:
+        List of LlmModelMigration records
+    """
+    where: Any = None if include_reverted else {"isReverted": False}
+    records = await prisma.models.LlmModelMigration.prisma().find_many(
+        where=where,
+        order={"createdAt": "desc"},
+    )
+    return [_map_migration(record) for record in records]
+
+
+async def get_migration(migration_id: str) -> llm_model.LlmModelMigration | None:
+    """Get a specific migration by ID."""
+    record = await prisma.models.LlmModelMigration.prisma().find_unique(
+        where={"id": migration_id}
+    )
+    return _map_migration(record) if record else None
+
+
+async def revert_migration(
+    migration_id: str,
+    re_enable_source_model: bool = True,
+) -> llm_model.RevertMigrationResponse:
+    """
+    Revert a model migration, restoring affected nodes to their original model.
+
+    This only reverts the specific nodes that were migrated, not all nodes
+    currently using the target model.
+
+    Args:
+        migration_id: UUID of the migration to revert
+        re_enable_source_model: Whether to re-enable the source model if it's disabled
+
+    Returns:
+        RevertMigrationResponse with revert stats
+
+    Raises:
+        ValueError: If migration not found, already reverted, or source model not available
+    """
+    import json
+    from datetime import datetime, timezone
+
+    # Get the migration record
+    migration = await prisma.models.LlmModelMigration.prisma().find_unique(
+        where={"id": migration_id}
+    )
+    if not migration:
+        raise ValueError(f"Migration with id '{migration_id}' not found")
+
+    if migration.isReverted:
+        raise ValueError(
+            f"Migration '{migration_id}' has already been reverted "
+            f"on {migration.revertedAt.isoformat() if migration.revertedAt else 'unknown date'}"
+        )
+
+    # Check if source model exists
+    source_model = await prisma.models.LlmModel.prisma().find_unique(
+        where={"slug": migration.sourceModelSlug}
+    )
+    if not source_model:
+        raise ValueError(
+            f"Source model '{migration.sourceModelSlug}' no longer exists. "
+            f"Cannot revert migration."
+        )
+
+    # Get the migrated node IDs (Prisma auto-parses JSONB to list)
+    migrated_node_ids: list[str] = (
+        migration.migratedNodeIds
+        if isinstance(migration.migratedNodeIds, list)
+        else json.loads(migration.migratedNodeIds)  # type: ignore
+    )
+    if not migrated_node_ids:
+        raise ValueError("No nodes to revert in this migration")
+
+    # Track if we need to re-enable the source model
+    source_model_was_disabled = not source_model.isEnabled
+    should_re_enable = source_model_was_disabled and re_enable_source_model
+    source_model_re_enabled = False
+
+    # Perform revert atomically
+    async with transaction() as tx:
+        # Re-enable the source model if requested and it was disabled
+        if should_re_enable:
+            await tx.llmmodel.update(
+                where={"id": source_model.id},
+                data={"isEnabled": True},
+            )
+            source_model_re_enabled = True
+
+        # Update only the specific nodes that were migrated
+        # We need to check that they still have the target model (haven't been changed since)
+        # Use a single batch update for efficiency
+        # Use JSON array and jsonb_array_elements_text for safe parameterization
+        node_ids_json = json.dumps(migrated_node_ids)
+        result = await tx.execute_raw(
+            """
+            UPDATE "AgentNode"
+            SET "constantInput" = JSONB_SET(
+                "constantInput"::jsonb,
+                '{model}',
+                to_jsonb($1::text)
+            )
+            WHERE id::text IN (
+                SELECT jsonb_array_elements_text($2::jsonb)
+            )
+            AND "constantInput"::jsonb->>'model' = $3
+            """,
+            migration.sourceModelSlug,
+            node_ids_json,
+            migration.targetModelSlug,
+        )
+        nodes_reverted = result if result else 0
+
+        # Mark migration as reverted
+        await tx.llmmodelmigration.update(
+            where={"id": migration_id},
+            data={
+                "isReverted": True,
+                "revertedAt": datetime.now(timezone.utc),
+            },
+        )
+
+    # Calculate nodes that were already changed since migration
+    nodes_already_changed = len(migrated_node_ids) - nodes_reverted
+
+    # Build appropriate message
+    message_parts = [
+        f"Successfully reverted migration: {nodes_reverted} node(s) restored "
+        f"from '{migration.targetModelSlug}' to '{migration.sourceModelSlug}'."
+    ]
+    if nodes_already_changed > 0:
+        message_parts.append(
+            f" {nodes_already_changed} node(s) were already changed and not reverted."
+        )
+    if source_model_re_enabled:
+        message_parts.append(
+            f" Model '{migration.sourceModelSlug}' has been re-enabled."
+        )
+
+    return llm_model.RevertMigrationResponse(
+        migration_id=migration_id,
+        source_model_slug=migration.sourceModelSlug,
+        target_model_slug=migration.targetModelSlug,
+        nodes_reverted=nodes_reverted,
+        nodes_already_changed=nodes_already_changed,
+        source_model_re_enabled=source_model_re_enabled,
+        message="".join(message_parts),
+    )
+
+
+# ============================================================================
+# Creator CRUD operations
+# ============================================================================
+
+
+async def list_creators() -> list[llm_model.LlmModelCreator]:
+    """List all LLM model creators."""
+    records = await prisma.models.LlmModelCreator.prisma().find_many(
+        order={"displayName": "asc"}
+    )
+    return [_map_creator(record) for record in records]
+
+
+async def get_creator(creator_id: str) -> llm_model.LlmModelCreator | None:
+    """Get a specific creator by ID."""
+    record = await prisma.models.LlmModelCreator.prisma().find_unique(
+        where={"id": creator_id}
+    )
+    return _map_creator(record) if record else None
+
+
+async def upsert_creator(
+    request: llm_model.UpsertLlmCreatorRequest,
+    creator_id: str | None = None,
+) -> llm_model.LlmModelCreator:
+    """Create or update a model creator."""
+    data: Any = {
+        "name": request.name,
+        "displayName": request.display_name,
+        "description": request.description,
+        "websiteUrl": request.website_url,
+        "logoUrl": request.logo_url,
+        "metadata": prisma.Json(request.metadata or {}),
+    }
+    if creator_id:
+        record = await prisma.models.LlmModelCreator.prisma().update(
+            where={"id": creator_id},
+            data=data,
+        )
+    else:
+        record = await prisma.models.LlmModelCreator.prisma().create(data=data)
+    if record is None:
+        raise ValueError("Failed to create/update creator")
+    return _map_creator(record)
+
+
+async def delete_creator(creator_id: str) -> bool:
+    """
+    Delete a model creator.
+
+    This will set creatorId to NULL on all associated models (due to onDelete: SetNull).
+
+    Args:
+        creator_id: UUID of the creator to delete
+
+    Returns:
+        True if deleted successfully
+
+    Raises:
+        ValueError: If creator not found
+    """
+    creator = await prisma.models.LlmModelCreator.prisma().find_unique(
+        where={"id": creator_id}
+    )
+    if not creator:
+        raise ValueError(f"Creator with id '{creator_id}' not found")
+
+    await prisma.models.LlmModelCreator.prisma().delete(where={"id": creator_id})
+    return True
+
+
+async def get_recommended_model() -> llm_model.LlmModel | None:
+    """
+    Get the currently recommended LLM model.
+
+    Returns:
+        The recommended model, or None if no model is marked as recommended.
+    """
+    record = await prisma.models.LlmModel.prisma().find_first(
+        where={"isRecommended": True, "isEnabled": True},
+        include={"Costs": True, "Creator": True},
+    )
+    return _map_model(record) if record else None
+
+
+async def set_recommended_model(
+    model_id: str,
+) -> tuple[llm_model.LlmModel, str | None]:
+    """
+    Set a model as the recommended model.
+
+    This will clear the isRecommended flag from any other model and set it
+    on the specified model. The model must be enabled.
+
+    Args:
+        model_id: UUID of the model to set as recommended
+
+    Returns:
+        Tuple of (the updated model, previous recommended model slug or None)
+
+    Raises:
+        ValueError: If model not found or not enabled
+    """
+    # First, verify the model exists and is enabled
+    target_model = await prisma.models.LlmModel.prisma().find_unique(
+        where={"id": model_id}
+    )
+    if not target_model:
+        raise ValueError(f"Model with id '{model_id}' not found")
+    if not target_model.isEnabled:
+        raise ValueError(
+            f"Cannot set disabled model '{target_model.slug}' as recommended"
+        )
+
+    # Get the current recommended model (if any)
+    current_recommended = await prisma.models.LlmModel.prisma().find_first(
+        where={"isRecommended": True}
+    )
+    previous_slug = current_recommended.slug if current_recommended else None
+
+    # Use a transaction to ensure atomicity
+    async with transaction() as tx:
+        # Clear isRecommended from all models
+        await tx.llmmodel.update_many(
+            where={"isRecommended": True},
+            data={"isRecommended": False},
+        )
+        # Set the new recommended model
+        await tx.llmmodel.update(
+            where={"id": model_id},
+            data={"isRecommended": True},
+        )
+
+    # Fetch and return the updated model
+    updated_record = await prisma.models.LlmModel.prisma().find_unique(
+        where={"id": model_id},
+        include={"Costs": True, "Creator": True},
+    )
+    if not updated_record:
+        raise ValueError("Failed to fetch updated model")
+
+    return _map_model(updated_record), previous_slug
+
+
+async def get_recommended_model_slug() -> str | None:
+    """
+    Get the slug of the currently recommended LLM model.
+
+    Returns:
+        The slug of the recommended model, or None if no model is marked as recommended.
+    """
+    record = await prisma.models.LlmModel.prisma().find_first(
+        where={"isRecommended": True, "isEnabled": True},
+    )
+    return record.slug if record else None

autogpt_platform/backend/backend/server/v2/llm/model.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from typing import Any, Optional
+
+import prisma.enums
+import pydantic
+
+from backend.util.models import Pagination
+
+# Pattern for valid model slugs: alphanumeric start, then alphanumeric, dots, underscores, slashes, hyphens
+SLUG_PATTERN = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9._/-]*$")
+
+
+class LlmModelCost(pydantic.BaseModel):
+    id: str
+    unit: prisma.enums.LlmCostUnit = prisma.enums.LlmCostUnit.RUN
+    credit_cost: int = pydantic.Field(ge=0)
+    credential_provider: str
+    credential_id: Optional[str] = None
+    credential_type: Optional[str] = None
+    currency: Optional[str] = None
+    metadata: dict[str, Any] = pydantic.Field(default_factory=dict)
+
+
+class LlmModelCreator(pydantic.BaseModel):
+    """Represents the organization that created/trained the model (e.g., OpenAI, Meta)."""
+
+    id: str
+    name: str
+    display_name: str
+    description: Optional[str] = None
+    website_url: Optional[str] = None
+    logo_url: Optional[str] = None
+    metadata: dict[str, Any] = pydantic.Field(default_factory=dict)
+
+
+class LlmModel(pydantic.BaseModel):
+    id: str
+    slug: str
+    display_name: str
+    description: Optional[str] = None
+    provider_id: str
+    creator_id: Optional[str] = None
+    creator: Optional[LlmModelCreator] = None
+    context_window: int
+    max_output_tokens: Optional[int] = None
+    is_enabled: bool = True
+    is_recommended: bool = False
+    # Model-specific capabilities (moved from Provider)
+    supports_tools: bool = True
+    supports_json_output: bool = True
+    supports_reasoning: bool = False
+    supports_parallel_tool: bool = False
+    capabilities: dict[str, Any] = pydantic.Field(default_factory=dict)
+    metadata: dict[str, Any] = pydantic.Field(default_factory=dict)
+    costs: list[LlmModelCost] = pydantic.Field(default_factory=list)
+
+
+class LlmProvider(pydantic.BaseModel):
+    id: str
+    name: str
+    display_name: str
+    description: Optional[str] = None
+    default_credential_provider: Optional[str] = None
+    default_credential_id: Optional[str] = None
+    default_credential_type: Optional[str] = None
+    metadata: dict[str, Any] = pydantic.Field(default_factory=dict)
+    models: list[LlmModel] = pydantic.Field(default_factory=list)
+
+
+class LlmProvidersResponse(pydantic.BaseModel):
+    providers: list[LlmProvider]
+
+
+class LlmModelsResponse(pydantic.BaseModel):
+    models: list[LlmModel]
+    pagination: Optional[Pagination] = None
+
+
+class LlmCreatorsResponse(pydantic.BaseModel):
+    creators: list[LlmModelCreator]
+
+
+class UpsertLlmProviderRequest(pydantic.BaseModel):
+    name: str
+    display_name: str
+    description: Optional[str] = None
+    default_credential_provider: Optional[str] = None
+    default_credential_id: Optional[str] = None
+    default_credential_type: Optional[str] = "api_key"
+    supports_tools: bool = True
+    supports_json_output: bool = True
+    supports_reasoning: bool = False
+    supports_parallel_tool: bool = False
+    metadata: dict[str, Any] = pydantic.Field(default_factory=dict)
+
+
+class UpsertLlmCreatorRequest(pydantic.BaseModel):
+    name: str
+    display_name: str
+    description: Optional[str] = None
+    website_url: Optional[str] = None
+    logo_url: Optional[str] = None
+    metadata: dict[str, Any] = pydantic.Field(default_factory=dict)
+
+
+class LlmModelCostInput(pydantic.BaseModel):
+    unit: prisma.enums.LlmCostUnit = prisma.enums.LlmCostUnit.RUN
+    credit_cost: int = pydantic.Field(ge=0)
+    credential_provider: str
+    credential_id: Optional[str] = None
+    credential_type: Optional[str] = "api_key"
+    currency: Optional[str] = None
+    metadata: dict[str, Any] = pydantic.Field(default_factory=dict)
+
+
+class CreateLlmModelRequest(pydantic.BaseModel):
+    slug: str
+    display_name: str
+    description: Optional[str] = None
+    provider_id: str
+    creator_id: Optional[str] = None
+    context_window: int = pydantic.Field(gt=0)
+    max_output_tokens: Optional[int] = pydantic.Field(default=None, gt=0)
+    is_enabled: bool = True
+    capabilities: dict[str, Any] = pydantic.Field(default_factory=dict)
+    metadata: dict[str, Any] = pydantic.Field(default_factory=dict)
+    costs: list[LlmModelCostInput]
+
+    @pydantic.field_validator("slug")
+    @classmethod
+    def validate_slug(cls, v: str) -> str:
+        if not v or len(v) > 100:
+            raise ValueError("Slug must be 1-100 characters")
+        if not SLUG_PATTERN.match(v):
+            raise ValueError(
+                "Slug must start with alphanumeric and contain only "
+                "alphanumeric characters, dots, underscores, slashes, or hyphens"
+            )
+        return v
+
+
+class UpdateLlmModelRequest(pydantic.BaseModel):
+    display_name: Optional[str] = None
+    description: Optional[str] = None
+    context_window: Optional[int] = pydantic.Field(default=None, gt=0)
+    max_output_tokens: Optional[int] = pydantic.Field(default=None, gt=0)
+    is_enabled: Optional[bool] = None
+    capabilities: Optional[dict[str, Any]] = None
+    metadata: Optional[dict[str, Any]] = None
+    provider_id: Optional[str] = None
+    creator_id: Optional[str] = None
+    costs: Optional[list[LlmModelCostInput]] = None
+
+
+class ToggleLlmModelRequest(pydantic.BaseModel):
+    is_enabled: bool
+    migrate_to_slug: Optional[str] = None
+    migration_reason: Optional[str] = None  # e.g., "Provider outage"
+    # Custom pricing override for migrated workflows. When set, billing should use
+    # this cost instead of the target model's cost for affected nodes.
+    # See LlmModelMigration in schema.prisma for full documentation.
+    custom_credit_cost: Optional[int] = pydantic.Field(default=None, ge=0)
+
+
+class ToggleLlmModelResponse(pydantic.BaseModel):
+    model: LlmModel
+    nodes_migrated: int = 0
+    migrated_to_slug: Optional[str] = None
+    migration_id: Optional[str] = None  # ID of the migration record for revert
+
+
+class DeleteLlmModelResponse(pydantic.BaseModel):
+    deleted_model_slug: str
+    deleted_model_display_name: str
+    replacement_model_slug: Optional[str] = None
+    nodes_migrated: int
+    message: str
+
+
+class LlmModelUsageResponse(pydantic.BaseModel):
+    model_slug: str
+    node_count: int
+
+
+# Migration tracking models
+class LlmModelMigration(pydantic.BaseModel):
+    id: str
+    source_model_slug: str
+    target_model_slug: str
+    reason: Optional[str] = None
+    node_count: int
+    # Custom pricing override - billing should use this instead of target model's cost
+    custom_credit_cost: Optional[int] = pydantic.Field(default=None, ge=0)
+    is_reverted: bool = False
+    created_at: datetime
+    reverted_at: Optional[datetime] = None
+
+
+class LlmMigrationsResponse(pydantic.BaseModel):
+    migrations: list[LlmModelMigration]
+
+
+class RevertMigrationRequest(pydantic.BaseModel):
+    re_enable_source_model: bool = (
+        True  # Whether to re-enable the source model if disabled
+    )
+
+
+class RevertMigrationResponse(pydantic.BaseModel):
+    migration_id: str
+    source_model_slug: str
+    target_model_slug: str
+    nodes_reverted: int
+    nodes_already_changed: int = (
+        0  # Nodes that were modified since migration (not reverted)
+    )
+    source_model_re_enabled: bool = False  # Whether the source model was re-enabled
+    message: str
+
+
+class SetRecommendedModelRequest(pydantic.BaseModel):
+    model_id: str
+
+
+class SetRecommendedModelResponse(pydantic.BaseModel):
+    model: LlmModel
+    previous_recommended_slug: Optional[str] = None
+    message: str
+
+
+class RecommendedModelResponse(pydantic.BaseModel):
+    model: Optional[LlmModel] = None
+    slug: Optional[str] = None

autogpt_platform/backend/backend/server/v2/llm/routes.py

@@ -0,0 +1,29 @@
+import autogpt_libs.auth
+import fastapi
+
+from backend.server.v2.llm import db as llm_db
+from backend.server.v2.llm import model as llm_model
+
+router = fastapi.APIRouter(
+    prefix="/llm",
+    tags=["llm"],
+    dependencies=[fastapi.Security(autogpt_libs.auth.requires_user)],
+)
+
+
+@router.get("/models", response_model=llm_model.LlmModelsResponse)
+async def list_models(
+    page: int = fastapi.Query(default=1, ge=1, description="Page number (1-indexed)"),
+    page_size: int = fastapi.Query(
+        default=50, ge=1, le=100, description="Number of models per page"
+    ),
+):
+    """List all enabled LLM models available to users."""
+    return await llm_db.list_models(enabled_only=True, page=page, page_size=page_size)
+
+
+@router.get("/providers", response_model=llm_model.LlmProvidersResponse)
+async def list_providers():
+    """List all LLM providers with their enabled models."""
+    providers = await llm_db.list_providers(include_models=True, enabled_only=True)
+    return llm_model.LlmProvidersResponse(providers=providers)

autogpt_platform/backend/migrations/20251126113000_add_llm_registry/migration.sql

@@ -0,0 +1,81 @@
+-- CreateEnum
+CREATE TYPE "LlmCostUnit" AS ENUM ('RUN', 'TOKENS');
+
+-- CreateTable
+CREATE TABLE "LlmProvider" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "name" TEXT NOT NULL,
+    "displayName" TEXT NOT NULL,
+    "description" TEXT,
+    "defaultCredentialProvider" TEXT,
+    "defaultCredentialId" TEXT,
+    "defaultCredentialType" TEXT,
+    "supportsTools" BOOLEAN NOT NULL DEFAULT TRUE,
+    "supportsJsonOutput" BOOLEAN NOT NULL DEFAULT TRUE,
+    "supportsReasoning" BOOLEAN NOT NULL DEFAULT FALSE,
+    "supportsParallelTool" BOOLEAN NOT NULL DEFAULT FALSE,
+    "metadata" JSONB NOT NULL DEFAULT '{}'::jsonb,
+
+    CONSTRAINT "LlmProvider_pkey" PRIMARY KEY ("id"),
+    CONSTRAINT "LlmProvider_name_key" UNIQUE ("name")
+);
+
+-- CreateTable
+CREATE TABLE "LlmModel" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "slug" TEXT NOT NULL,
+    "displayName" TEXT NOT NULL,
+    "description" TEXT,
+    "providerId" TEXT NOT NULL,
+    "contextWindow" INTEGER NOT NULL,
+    "maxOutputTokens" INTEGER,
+    "isEnabled" BOOLEAN NOT NULL DEFAULT TRUE,
+    "capabilities" JSONB NOT NULL DEFAULT '{}'::jsonb,
+    "metadata" JSONB NOT NULL DEFAULT '{}'::jsonb,
+
+    CONSTRAINT "LlmModel_pkey" PRIMARY KEY ("id"),
+    CONSTRAINT "LlmModel_slug_key" UNIQUE ("slug")
+);
+
+-- CreateTable
+CREATE TABLE "LlmModelCost" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "unit" "LlmCostUnit" NOT NULL DEFAULT 'RUN',
+    "creditCost" INTEGER NOT NULL,
+    "credentialProvider" TEXT NOT NULL,
+    "credentialId" TEXT,
+    "credentialType" TEXT,
+    "currency" TEXT,
+    "metadata" JSONB NOT NULL DEFAULT '{}'::jsonb,
+    "llmModelId" TEXT NOT NULL,
+
+    CONSTRAINT "LlmModelCost_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "LlmModel_providerId_isEnabled_idx" ON "LlmModel"("providerId", "isEnabled");
+
+-- CreateIndex
+CREATE INDEX "LlmModel_slug_idx" ON "LlmModel"("slug");
+
+-- CreateIndex
+CREATE INDEX "LlmModelCost_llmModelId_idx" ON "LlmModelCost"("llmModelId");
+
+-- CreateIndex
+CREATE INDEX "LlmModelCost_credentialProvider_idx" ON "LlmModelCost"("credentialProvider");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "LlmModelCost_llmModelId_credentialProvider_unit_key" ON "LlmModelCost"("llmModelId", "credentialProvider", "unit");
+
+-- AddForeignKey
+ALTER TABLE "LlmModel" ADD CONSTRAINT "LlmModel_providerId_fkey" FOREIGN KEY ("providerId") REFERENCES "LlmProvider"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "LlmModelCost" ADD CONSTRAINT "LlmModelCost_llmModelId_fkey" FOREIGN KEY ("llmModelId") REFERENCES "LlmModel"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+

autogpt_platform/backend/migrations/20251126120000_seed_llm_registry/migration.sql

@@ -0,0 +1,226 @@
+-- Seed LLM Registry from existing hard-coded data
+-- This migration populates the LlmProvider, LlmModel, and LlmModelCost tables
+-- with data from the existing MODEL_METADATA and MODEL_COST dictionaries
+
+-- Insert Providers
+INSERT INTO "LlmProvider" ("id", "name", "displayName", "description", "defaultCredentialProvider", "defaultCredentialType", "supportsTools", "supportsJsonOutput", "supportsReasoning", "supportsParallelTool", "metadata")
+VALUES
+    (gen_random_uuid(), 'openai', 'OpenAI', 'OpenAI language models', 'openai', 'api_key', true, true, true, true, '{}'::jsonb),
+    (gen_random_uuid(), 'anthropic', 'Anthropic', 'Anthropic Claude models', 'anthropic', 'api_key', true, true, true, false, '{}'::jsonb),
+    (gen_random_uuid(), 'groq', 'Groq', 'Groq inference API', 'groq', 'api_key', false, true, false, false, '{}'::jsonb),
+    (gen_random_uuid(), 'open_router', 'OpenRouter', 'OpenRouter unified API', 'open_router', 'api_key', true, true, false, false, '{}'::jsonb),
+    (gen_random_uuid(), 'aiml_api', 'AI/ML API', 'AI/ML API models', 'aiml_api', 'api_key', false, true, false, false, '{}'::jsonb),
+    (gen_random_uuid(), 'ollama', 'Ollama', 'Ollama local models', 'ollama', 'api_key', false, true, false, false, '{}'::jsonb),
+    (gen_random_uuid(), 'llama_api', 'Llama API', 'Llama API models', 'llama_api', 'api_key', false, true, false, false, '{}'::jsonb),
+    (gen_random_uuid(), 'v0', 'v0', 'v0 by Vercel models', 'v0', 'api_key', true, true, false, false, '{}'::jsonb)
+ON CONFLICT ("name") DO NOTHING;
+
+-- Insert Models (using CTEs to reference provider IDs)
+WITH provider_ids AS (
+    SELECT "id", "name" FROM "LlmProvider"
+)
+INSERT INTO "LlmModel" ("id", "slug", "displayName", "description", "providerId", "contextWindow", "maxOutputTokens", "isEnabled", "capabilities", "metadata")
+SELECT
+    gen_random_uuid(),
+    model_slug,
+    model_display_name,
+    NULL,
+    p."id",
+    context_window,
+    max_output_tokens,
+    true,
+    '{}'::jsonb,
+    '{}'::jsonb
+FROM (VALUES
+    -- OpenAI models
+    ('o3', 'O3', 'openai', 200000, 100000),
+    ('o3-mini', 'O3 Mini', 'openai', 200000, 100000),
+    ('o1', 'O1', 'openai', 200000, 100000),
+    ('o1-mini', 'O1 Mini', 'openai', 128000, 65536),
+    ('gpt-5-2025-08-07', 'GPT 5', 'openai', 400000, 128000),
+    ('gpt-5.1-2025-11-13', 'GPT 5.1', 'openai', 400000, 128000),
+    ('gpt-5-mini-2025-08-07', 'GPT 5 Mini', 'openai', 400000, 128000),
+    ('gpt-5-nano-2025-08-07', 'GPT 5 Nano', 'openai', 400000, 128000),
+    ('gpt-5-chat-latest', 'GPT 5 Chat', 'openai', 400000, 16384),
+    ('gpt-4.1-2025-04-14', 'GPT 4.1', 'openai', 1000000, 32768),
+    ('gpt-4.1-mini-2025-04-14', 'GPT 4.1 Mini', 'openai', 1047576, 32768),
+    ('gpt-4o-mini', 'GPT 4o Mini', 'openai', 128000, 16384),
+    ('gpt-4o', 'GPT 4o', 'openai', 128000, 16384),
+    ('gpt-4-turbo', 'GPT 4 Turbo', 'openai', 128000, 4096),
+    ('gpt-3.5-turbo', 'GPT 3.5 Turbo', 'openai', 16385, 4096),
+    -- Anthropic models
+    ('claude-opus-4-1-20250805', 'Claude 4.1 Opus', 'anthropic', 200000, 32000),
+    ('claude-opus-4-20250514', 'Claude 4 Opus', 'anthropic', 200000, 32000),
+    ('claude-sonnet-4-20250514', 'Claude 4 Sonnet', 'anthropic', 200000, 64000),
+    ('claude-opus-4-5-20251101', 'Claude 4.5 Opus', 'anthropic', 200000, 64000),
+    ('claude-sonnet-4-5-20250929', 'Claude 4.5 Sonnet', 'anthropic', 200000, 64000),
+    ('claude-haiku-4-5-20251001', 'Claude 4.5 Haiku', 'anthropic', 200000, 64000),
+    ('claude-3-7-sonnet-20250219', 'Claude 3.7 Sonnet', 'anthropic', 200000, 64000),
+    ('claude-3-haiku-20240307', 'Claude 3 Haiku', 'anthropic', 200000, 4096),
+    -- AI/ML API models
+    ('Qwen/Qwen2.5-72B-Instruct-Turbo', 'Qwen 2.5 72B', 'aiml_api', 32000, 8000),
+    ('nvidia/llama-3.1-nemotron-70b-instruct', 'Llama 3.1 Nemotron 70B', 'aiml_api', 128000, 40000),
+    ('meta-llama/Llama-3.3-70B-Instruct-Turbo', 'Llama 3.3 70B', 'aiml_api', 128000, NULL),
+    ('meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo', 'Meta Llama 3.1 70B', 'aiml_api', 131000, 2000),
+    ('meta-llama/Llama-3.2-3B-Instruct-Turbo', 'Llama 3.2 3B', 'aiml_api', 128000, NULL),
+    -- Groq models
+    ('llama-3.3-70b-versatile', 'Llama 3.3 70B', 'groq', 128000, 32768),
+    ('llama-3.1-8b-instant', 'Llama 3.1 8B', 'groq', 128000, 8192),
+    -- Ollama models
+    ('llama3.3', 'Llama 3.3', 'ollama', 8192, NULL),
+    ('llama3.2', 'Llama 3.2', 'ollama', 8192, NULL),
+    ('llama3', 'Llama 3', 'ollama', 8192, NULL),
+    ('llama3.1:405b', 'Llama 3.1 405B', 'ollama', 8192, NULL),
+    ('dolphin-mistral:latest', 'Dolphin Mistral', 'ollama', 32768, NULL),
+    -- OpenRouter models
+    ('google/gemini-2.5-pro-preview-03-25', 'Gemini 2.5 Pro', 'open_router', 1050000, 8192),
+    ('google/gemini-3-pro-preview', 'Gemini 3 Pro Preview', 'open_router', 1048576, 65535),
+    ('google/gemini-2.5-flash', 'Gemini 2.5 Flash', 'open_router', 1048576, 65535),
+    ('google/gemini-2.0-flash-001', 'Gemini 2.0 Flash', 'open_router', 1048576, 8192),
+    ('google/gemini-2.5-flash-lite-preview-06-17', 'Gemini 2.5 Flash Lite Preview', 'open_router', 1048576, 65535),
+    ('google/gemini-2.0-flash-lite-001', 'Gemini 2.0 Flash Lite', 'open_router', 1048576, 8192),
+    ('mistralai/mistral-nemo', 'Mistral Nemo', 'open_router', 128000, 4096),
+    ('cohere/command-r-08-2024', 'Command R', 'open_router', 128000, 4096),
+    ('cohere/command-r-plus-08-2024', 'Command R Plus', 'open_router', 128000, 4096),
+    ('deepseek/deepseek-chat', 'DeepSeek Chat', 'open_router', 64000, 2048),
+    ('deepseek/deepseek-r1-0528', 'DeepSeek R1', 'open_router', 163840, 163840),
+    ('perplexity/sonar', 'Perplexity Sonar', 'open_router', 127000, 8000),
+    ('perplexity/sonar-pro', 'Perplexity Sonar Pro', 'open_router', 200000, 8000),
+    ('perplexity/sonar-deep-research', 'Perplexity Sonar Deep Research', 'open_router', 128000, 16000),
+    ('nousresearch/hermes-3-llama-3.1-405b', 'Hermes 3 Llama 3.1 405B', 'open_router', 131000, 4096),
+    ('nousresearch/hermes-3-llama-3.1-70b', 'Hermes 3 Llama 3.1 70B', 'open_router', 12288, 12288),
+    ('openai/gpt-oss-120b', 'GPT OSS 120B', 'open_router', 131072, 131072),
+    ('openai/gpt-oss-20b', 'GPT OSS 20B', 'open_router', 131072, 32768),
+    ('amazon/nova-lite-v1', 'Amazon Nova Lite', 'open_router', 300000, 5120),
+    ('amazon/nova-micro-v1', 'Amazon Nova Micro', 'open_router', 128000, 5120),
+    ('amazon/nova-pro-v1', 'Amazon Nova Pro', 'open_router', 300000, 5120),
+    ('microsoft/wizardlm-2-8x22b', 'WizardLM 2 8x22B', 'open_router', 65536, 4096),
+    ('gryphe/mythomax-l2-13b', 'MythoMax L2 13B', 'open_router', 4096, 4096),
+    ('meta-llama/llama-4-scout', 'Llama 4 Scout', 'open_router', 131072, 131072),
+    ('meta-llama/llama-4-maverick', 'Llama 4 Maverick', 'open_router', 1048576, 1000000),
+    ('x-ai/grok-4', 'Grok 4', 'open_router', 256000, 256000),
+    ('x-ai/grok-4-fast', 'Grok 4 Fast', 'open_router', 2000000, 30000),
+    ('x-ai/grok-4.1-fast', 'Grok 4.1 Fast', 'open_router', 2000000, 30000),
+    ('x-ai/grok-code-fast-1', 'Grok Code Fast 1', 'open_router', 256000, 10000),
+    ('moonshotai/kimi-k2', 'Kimi K2', 'open_router', 131000, 131000),
+    ('qwen/qwen3-235b-a22b-thinking-2507', 'Qwen 3 235B Thinking', 'open_router', 262144, 262144),
+    ('qwen/qwen3-coder', 'Qwen 3 Coder', 'open_router', 262144, 262144),
+    -- Llama API models
+    ('Llama-4-Scout-17B-16E-Instruct-FP8', 'Llama 4 Scout', 'llama_api', 128000, 4028),
+    ('Llama-4-Maverick-17B-128E-Instruct-FP8', 'Llama 4 Maverick', 'llama_api', 128000, 4028),
+    ('Llama-3.3-8B-Instruct', 'Llama 3.3 8B', 'llama_api', 128000, 4028),
+    ('Llama-3.3-70B-Instruct', 'Llama 3.3 70B', 'llama_api', 128000, 4028),
+    -- v0 models
+    ('v0-1.5-md', 'v0 1.5 MD', 'v0', 128000, 64000),
+    ('v0-1.5-lg', 'v0 1.5 LG', 'v0', 512000, 64000),
+    ('v0-1.0-md', 'v0 1.0 MD', 'v0', 128000, 64000)
+) AS models(model_slug, model_display_name, provider_name, context_window, max_output_tokens)
+JOIN provider_ids p ON p."name" = models.provider_name
+ON CONFLICT ("slug") DO NOTHING;
+
+-- Insert Costs (using CTEs to reference model IDs)
+WITH model_ids AS (
+    SELECT "id", "slug", "providerId" FROM "LlmModel"
+),
+provider_ids AS (
+    SELECT "id", "name" FROM "LlmProvider"
+)
+INSERT INTO "LlmModelCost" ("id", "unit", "creditCost", "credentialProvider", "credentialId", "credentialType", "currency", "metadata", "llmModelId")
+SELECT
+    gen_random_uuid(),
+    'RUN'::"LlmCostUnit",
+    cost,
+    p."name",
+    NULL,
+    'api_key',
+    NULL,
+    '{}'::jsonb,
+    m."id"
+FROM (VALUES
+    -- OpenAI costs
+    ('o3', 4),
+    ('o3-mini', 2),
+    ('o1', 16),
+    ('o1-mini', 4),
+    ('gpt-5-2025-08-07', 2),
+    ('gpt-5.1-2025-11-13', 5),
+    ('gpt-5-mini-2025-08-07', 1),
+    ('gpt-5-nano-2025-08-07', 1),
+    ('gpt-5-chat-latest', 5),
+    ('gpt-4.1-2025-04-14', 2),
+    ('gpt-4.1-mini-2025-04-14', 1),
+    ('gpt-4o-mini', 1),
+    ('gpt-4o', 3),
+    ('gpt-4-turbo', 10),
+    ('gpt-3.5-turbo', 1),
+    -- Anthropic costs
+    ('claude-opus-4-1-20250805', 21),
+    ('claude-opus-4-20250514', 21),
+    ('claude-sonnet-4-20250514', 5),
+    ('claude-haiku-4-5-20251001', 4),
+    ('claude-opus-4-5-20251101', 14),
+    ('claude-sonnet-4-5-20250929', 9),
+    ('claude-3-7-sonnet-20250219', 5),
+    ('claude-3-haiku-20240307', 1),
+    -- AI/ML API costs
+    ('Qwen/Qwen2.5-72B-Instruct-Turbo', 1),
+    ('nvidia/llama-3.1-nemotron-70b-instruct', 1),
+    ('meta-llama/Llama-3.3-70B-Instruct-Turbo', 1),
+    ('meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo', 1),
+    ('meta-llama/Llama-3.2-3B-Instruct-Turbo', 1),
+    -- Groq costs
+    ('llama-3.3-70b-versatile', 1),
+    ('llama-3.1-8b-instant', 1),
+    -- Ollama costs
+    ('llama3.3', 1),
+    ('llama3.2', 1),
+    ('llama3', 1),
+    ('llama3.1:405b', 1),
+    ('dolphin-mistral:latest', 1),
+    -- OpenRouter costs
+    ('google/gemini-2.5-pro-preview-03-25', 4),
+    ('google/gemini-3-pro-preview', 5),
+    ('mistralai/mistral-nemo', 1),
+    ('cohere/command-r-08-2024', 1),
+    ('cohere/command-r-plus-08-2024', 3),
+    ('deepseek/deepseek-chat', 2),
+    ('perplexity/sonar', 1),
+    ('perplexity/sonar-pro', 5),
+    ('perplexity/sonar-deep-research', 10),
+    ('nousresearch/hermes-3-llama-3.1-405b', 1),
+    ('nousresearch/hermes-3-llama-3.1-70b', 1),
+    ('amazon/nova-lite-v1', 1),
+    ('amazon/nova-micro-v1', 1),
+    ('amazon/nova-pro-v1', 1),
+    ('microsoft/wizardlm-2-8x22b', 1),
+    ('gryphe/mythomax-l2-13b', 1),
+    ('meta-llama/llama-4-scout', 1),
+    ('meta-llama/llama-4-maverick', 1),
+    ('x-ai/grok-4', 9),
+    ('x-ai/grok-4-fast', 1),
+    ('x-ai/grok-4.1-fast', 1),
+    ('x-ai/grok-code-fast-1', 1),
+    ('moonshotai/kimi-k2', 1),
+    ('qwen/qwen3-235b-a22b-thinking-2507', 1),
+    ('qwen/qwen3-coder', 9),
+    ('google/gemini-2.5-flash', 1),
+    ('google/gemini-2.0-flash-001', 1),
+    ('google/gemini-2.5-flash-lite-preview-06-17', 1),
+    ('google/gemini-2.0-flash-lite-001', 1),
+    ('deepseek/deepseek-r1-0528', 1),
+    ('openai/gpt-oss-120b', 1),
+    ('openai/gpt-oss-20b', 1),
+    -- Llama API costs
+    ('Llama-4-Scout-17B-16E-Instruct-FP8', 1),
+    ('Llama-4-Maverick-17B-128E-Instruct-FP8', 1),
+    ('Llama-3.3-8B-Instruct', 1),
+    ('Llama-3.3-70B-Instruct', 1),
+    -- v0 costs
+    ('v0-1.5-md', 1),
+    ('v0-1.5-lg', 2),
+    ('v0-1.0-md', 1)
+) AS costs(model_slug, cost)
+JOIN model_ids m ON m."slug" = costs.model_slug
+JOIN provider_ids p ON p."id" = m."providerId"
+ON CONFLICT ("llmModelId", "credentialProvider", "unit") DO NOTHING;
+

autogpt_platform/backend/migrations/20251218100000_add_llm_model_migration/migration.sql

@@ -0,0 +1,25 @@
+-- CreateTable
+CREATE TABLE "LlmModelMigration" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "sourceModelSlug" TEXT NOT NULL,
+    "targetModelSlug" TEXT NOT NULL,
+    "reason" TEXT,
+    "migratedNodeIds" JSONB NOT NULL DEFAULT '[]',
+    "nodeCount" INTEGER NOT NULL,
+    "customCreditCost" INTEGER,
+    "isReverted" BOOLEAN NOT NULL DEFAULT false,
+    "revertedAt" TIMESTAMP(3),
+
+    CONSTRAINT "LlmModelMigration_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "LlmModelMigration_sourceModelSlug_idx" ON "LlmModelMigration"("sourceModelSlug");
+
+-- CreateIndex
+CREATE INDEX "LlmModelMigration_targetModelSlug_idx" ON "LlmModelMigration"("targetModelSlug");
+
+-- CreateIndex
+CREATE INDEX "LlmModelMigration_isReverted_idx" ON "LlmModelMigration"("isReverted");

autogpt_platform/backend/migrations/20251224100000_add_llm_model_creator/migration.sql

@@ -0,0 +1,127 @@
+-- Add LlmModelCreator table
+-- Creator represents who made/trained the model (e.g., OpenAI, Meta)
+-- This is distinct from Provider who hosts/serves the model (e.g., OpenRouter)
+
+-- Create the LlmModelCreator table
+CREATE TABLE "LlmModelCreator" (
+    "id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "name" TEXT NOT NULL,
+    "displayName" TEXT NOT NULL,
+    "description" TEXT,
+    "websiteUrl" TEXT,
+    "logoUrl" TEXT,
+    "metadata" JSONB NOT NULL DEFAULT '{}',
+
+    CONSTRAINT "LlmModelCreator_pkey" PRIMARY KEY ("id")
+);
+
+-- Create unique index on name
+CREATE UNIQUE INDEX "LlmModelCreator_name_key" ON "LlmModelCreator"("name");
+
+-- Add creatorId column to LlmModel
+ALTER TABLE "LlmModel" ADD COLUMN "creatorId" TEXT;
+
+-- Add foreign key constraint
+ALTER TABLE "LlmModel" ADD CONSTRAINT "LlmModel_creatorId_fkey"
+    FOREIGN KEY ("creatorId") REFERENCES "LlmModelCreator"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- Create index on creatorId
+CREATE INDEX "LlmModel_creatorId_idx" ON "LlmModel"("creatorId");
+
+-- Seed creators based on known model creators
+INSERT INTO "LlmModelCreator" ("id", "updatedAt", "name", "displayName", "description", "websiteUrl", "metadata")
+VALUES
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'openai', 'OpenAI', 'Creator of GPT models', 'https://openai.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'anthropic', 'Anthropic', 'Creator of Claude models', 'https://anthropic.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'meta', 'Meta', 'Creator of Llama models', 'https://ai.meta.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'google', 'Google', 'Creator of Gemini models', 'https://deepmind.google', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'mistral', 'Mistral AI', 'Creator of Mistral models', 'https://mistral.ai', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'cohere', 'Cohere', 'Creator of Command models', 'https://cohere.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'deepseek', 'DeepSeek', 'Creator of DeepSeek models', 'https://deepseek.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'perplexity', 'Perplexity AI', 'Creator of Sonar models', 'https://perplexity.ai', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'qwen', 'Qwen (Alibaba)', 'Creator of Qwen models', 'https://qwenlm.github.io', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'xai', 'xAI', 'Creator of Grok models', 'https://x.ai', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'amazon', 'Amazon', 'Creator of Nova models', 'https://aws.amazon.com/bedrock', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'microsoft', 'Microsoft', 'Creator of WizardLM models', 'https://microsoft.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'moonshot', 'Moonshot AI', 'Creator of Kimi models', 'https://moonshot.cn', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'nvidia', 'NVIDIA', 'Creator of Nemotron models', 'https://nvidia.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'nous_research', 'Nous Research', 'Creator of Hermes models', 'https://nousresearch.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'vercel', 'Vercel', 'Creator of v0 models', 'https://vercel.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'cognitive_computations', 'Cognitive Computations', 'Creator of Dolphin models', 'https://erichartford.com', '{}'),
+    (gen_random_uuid(), CURRENT_TIMESTAMP, 'gryphe', 'Gryphe', 'Creator of MythoMax models', 'https://huggingface.co/Gryphe', '{}')
+ON CONFLICT ("name") DO NOTHING;
+
+-- Update existing models with their creators
+-- OpenAI models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'openai')
+WHERE "slug" LIKE 'gpt-%' OR "slug" LIKE 'o1%' OR "slug" LIKE 'o3%' OR "slug" LIKE 'openai/%';
+
+-- Anthropic models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'anthropic')
+WHERE "slug" LIKE 'claude-%';
+
+-- Meta/Llama models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'meta')
+WHERE "slug" LIKE 'llama%' OR "slug" LIKE 'Llama%' OR "slug" LIKE 'meta-llama/%' OR "slug" LIKE '%/llama-%';
+
+-- Google models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'google')
+WHERE "slug" LIKE 'google/%' OR "slug" LIKE 'gemini%';
+
+-- Mistral models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'mistral')
+WHERE "slug" LIKE 'mistral%' OR "slug" LIKE 'mistralai/%';
+
+-- Cohere models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'cohere')
+WHERE "slug" LIKE 'cohere/%' OR "slug" LIKE 'command-%';
+
+-- DeepSeek models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'deepseek')
+WHERE "slug" LIKE 'deepseek/%' OR "slug" LIKE 'deepseek-%';
+
+-- Perplexity models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'perplexity')
+WHERE "slug" LIKE 'perplexity/%' OR "slug" LIKE 'sonar%';
+
+-- Qwen models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'qwen')
+WHERE "slug" LIKE 'Qwen/%' OR "slug" LIKE 'qwen/%';
+
+-- xAI/Grok models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'xai')
+WHERE "slug" LIKE 'x-ai/%' OR "slug" LIKE 'grok%';
+
+-- Amazon models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'amazon')
+WHERE "slug" LIKE 'amazon/%' OR "slug" LIKE 'nova-%';
+
+-- Microsoft models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'microsoft')
+WHERE "slug" LIKE 'microsoft/%' OR "slug" LIKE 'wizardlm%';
+
+-- Moonshot models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'moonshot')
+WHERE "slug" LIKE 'moonshotai/%' OR "slug" LIKE 'kimi%';
+
+-- NVIDIA models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'nvidia')
+WHERE "slug" LIKE 'nvidia/%' OR "slug" LIKE '%nemotron%';
+
+-- Nous Research models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'nous_research')
+WHERE "slug" LIKE 'nousresearch/%' OR "slug" LIKE 'hermes%';
+
+-- Vercel/v0 models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'vercel')
+WHERE "slug" LIKE 'v0-%';
+
+-- Dolphin models (Cognitive Computations / Eric Hartford)
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'cognitive_computations')
+WHERE "slug" LIKE 'dolphin-%';
+
+-- Gryphe models
+UPDATE "LlmModel" SET "creatorId" = (SELECT "id" FROM "LlmModelCreator" WHERE "name" = 'gryphe')
+WHERE "slug" LIKE 'gryphe/%' OR "slug" LIKE 'mythomax%';

autogpt_platform/backend/migrations/20260105120000_add_agent_node_model_index/migration.sql

@@ -0,0 +1,4 @@
+-- CreateIndex
+-- Index for efficient LLM model lookups on AgentNode.constantInput->>'model'
+-- This improves performance of model migration queries in the LLM registry
+CREATE INDEX "AgentNode_constantInput_model_idx" ON "AgentNode" ((("constantInput"->>'model')));

autogpt_platform/backend/migrations/20260106150000_add_gpt52_model/migration.sql

@@ -0,0 +1,52 @@
+-- Add GPT-5.2 model and update O3 slug
+-- This migration adds the new GPT-5.2 model added in dev branch
+
+-- Update O3 slug to match dev branch format
+UPDATE "LlmModel"
+SET "slug" = 'o3-2025-04-16'
+WHERE "slug" = 'o3';
+
+-- Update cost reference for O3 if needed
+-- (costs are linked by model ID, so no update needed)
+
+-- Add GPT-5.2 model
+WITH provider_id AS (
+    SELECT "id" FROM "LlmProvider" WHERE "name" = 'openai'
+)
+INSERT INTO "LlmModel" ("id", "slug", "displayName", "description", "providerId", "contextWindow", "maxOutputTokens", "isEnabled", "capabilities", "metadata")
+SELECT
+    gen_random_uuid(),
+    'gpt-5.2-2025-12-11',
+    'GPT 5.2',
+    'OpenAI GPT-5.2 model',
+    p."id",
+    400000,
+    128000,
+    true,
+    '{}'::jsonb,
+    '{}'::jsonb
+FROM provider_id p
+ON CONFLICT ("slug") DO NOTHING;
+
+-- Add cost for GPT-5.2
+WITH model_id AS (
+    SELECT m."id", p."name" as provider_name
+    FROM "LlmModel" m
+    JOIN "LlmProvider" p ON p."id" = m."providerId"
+    WHERE m."slug" = 'gpt-5.2-2025-12-11'
+)
+INSERT INTO "LlmModelCost" ("id", "unit", "creditCost", "credentialProvider", "credentialId", "credentialType", "currency", "metadata", "llmModelId")
+SELECT
+    gen_random_uuid(),
+    'RUN'::"LlmCostUnit",
+    3,  -- Same cost tier as GPT-5.1
+    m.provider_name,
+    NULL,
+    'api_key',
+    NULL,
+    '{}'::jsonb,
+    m."id"
+FROM model_id m
+WHERE NOT EXISTS (
+    SELECT 1 FROM "LlmModelCost" c WHERE c."llmModelId" = m."id"
+);

autogpt_platform/backend/migrations/20260107100000_add_llm_recommended_model/migration.sql

@@ -0,0 +1,11 @@
+-- Add isRecommended field to LlmModel table
+-- This allows admins to mark a model as the recommended default
+
+ALTER TABLE "LlmModel" ADD COLUMN "isRecommended" BOOLEAN NOT NULL DEFAULT false;
+
+-- Set gpt-4o-mini as the default recommended model (if it exists)
+UPDATE "LlmModel" SET "isRecommended" = true WHERE "slug" = 'gpt-4o-mini' AND "isEnabled" = true;
+
+-- Create unique partial index to enforce only one recommended model at the database level
+-- This prevents multiple rows from having isRecommended = true
+CREATE UNIQUE INDEX "LlmModel_single_recommended_idx" ON "LlmModel" ("isRecommended") WHERE "isRecommended" = true;

autogpt_platform/backend/migrations/20260122000000_add_llm_price_tier/migration.sql

@@ -0,0 +1,61 @@
+-- Add new columns to LlmModel table for extended model metadata
+-- These columns support the LLM Picker UI enhancements
+
+-- Add priceTier column: 1=cheapest, 2=medium, 3=expensive
+ALTER TABLE "LlmModel" ADD COLUMN IF NOT EXISTS "priceTier" INTEGER NOT NULL DEFAULT 1;
+
+-- Add creatorId column for model creator relationship (if not exists)
+ALTER TABLE "LlmModel" ADD COLUMN IF NOT EXISTS "creatorId" TEXT;
+
+-- Add isRecommended column (if not exists)
+ALTER TABLE "LlmModel" ADD COLUMN IF NOT EXISTS "isRecommended" BOOLEAN NOT NULL DEFAULT FALSE;
+
+-- Add index on creatorId if not exists
+CREATE INDEX IF NOT EXISTS "LlmModel_creatorId_idx" ON "LlmModel"("creatorId");
+
+-- Add foreign key for creatorId if not exists
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'LlmModel_creatorId_fkey') THEN
+        -- Only add FK if LlmModelCreator table exists
+        IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'LlmModelCreator') THEN
+            ALTER TABLE "LlmModel" ADD CONSTRAINT "LlmModel_creatorId_fkey"
+            FOREIGN KEY ("creatorId") REFERENCES "LlmModelCreator"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+        END IF;
+    END IF;
+END $$;
+
+-- Update priceTier values for existing models based on original MODEL_METADATA
+-- Tier 1 = cheapest, Tier 2 = medium, Tier 3 = expensive
+
+-- OpenAI models
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" = 'o3';
+UPDATE "LlmModel" SET "priceTier" = 1 WHERE "slug" = 'o3-mini';
+UPDATE "LlmModel" SET "priceTier" = 3 WHERE "slug" = 'o1';
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" = 'o1-mini';
+UPDATE "LlmModel" SET "priceTier" = 3 WHERE "slug" = 'gpt-5.2';
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" = 'gpt-5.1';
+UPDATE "LlmModel" SET "priceTier" = 1 WHERE "slug" = 'gpt-5';
+UPDATE "LlmModel" SET "priceTier" = 1 WHERE "slug" = 'gpt-5-mini';
+UPDATE "LlmModel" SET "priceTier" = 1 WHERE "slug" = 'gpt-5-nano';
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" = 'gpt-5-chat-latest';
+UPDATE "LlmModel" SET "priceTier" = 1 WHERE "slug" LIKE 'gpt-4.1%';
+UPDATE "LlmModel" SET "priceTier" = 1 WHERE "slug" = 'gpt-4o-mini';
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" = 'gpt-4o';
+UPDATE "LlmModel" SET "priceTier" = 3 WHERE "slug" = 'gpt-4-turbo';
+UPDATE "LlmModel" SET "priceTier" = 1 WHERE "slug" = 'gpt-3.5-turbo';
+
+-- Anthropic models
+UPDATE "LlmModel" SET "priceTier" = 3 WHERE "slug" LIKE 'claude-opus%';
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" LIKE 'claude-sonnet%';
+UPDATE "LlmModel" SET "priceTier" = 3 WHERE "slug" LIKE 'claude%-4-5-sonnet%';
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" LIKE 'claude%-haiku%';
+UPDATE "LlmModel" SET "priceTier" = 1 WHERE "slug" = 'claude-3-haiku-20240307';
+
+-- OpenRouter models - Pro/expensive tiers
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" LIKE 'google/gemini%-pro%';
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" LIKE '%command-r-plus%';
+UPDATE "LlmModel" SET "priceTier" = 2 WHERE "slug" LIKE '%sonar-pro%';
+UPDATE "LlmModel" SET "priceTier" = 3 WHERE "slug" LIKE '%sonar-deep-research%';
+UPDATE "LlmModel" SET "priceTier" = 3 WHERE "slug" = 'x-ai/grok-4';
+UPDATE "LlmModel" SET "priceTier" = 3 WHERE "slug" LIKE '%qwen3-coder%';

autogpt_platform/backend/migrations/20260212000000_add_llm_migration_composite_index/migration.sql

@@ -0,0 +1,6 @@
+-- Add composite index on LlmModelMigration for optimized active migration queries
+-- This index improves performance when querying for non-reverted migrations by model slug
+-- Used by the billing system to apply customCreditCost overrides
+
+-- CreateIndex
+CREATE INDEX "LlmModelMigration_sourceModelSlug_isReverted_idx" ON "LlmModelMigration"("sourceModelSlug", "isReverted");

autogpt_platform/backend/migrations/20260212000001_sync_llm_models_with_dev/migration.sql

@@ -0,0 +1,65 @@
+-- Sync LLM models with latest dev branch changes
+-- This migration adds new models and removes deprecated ones
+
+-- Remove models that were deleted from dev
+DELETE FROM "LlmModelCost" WHERE "llmModelId" IN (
+    SELECT "id" FROM "LlmModel" WHERE "slug" IN ('o3', 'o3-mini', 'claude-3-7-sonnet-20250219')
+);
+
+DELETE FROM "LlmModel" WHERE "slug" IN ('o3', 'o3-mini', 'claude-3-7-sonnet-20250219');
+
+-- Add new models from dev
+WITH provider_ids AS (
+    SELECT "id", "name" FROM "LlmProvider"
+)
+INSERT INTO "LlmModel" ("id", "slug", "displayName", "description", "providerId", "contextWindow", "maxOutputTokens", "isEnabled", "capabilities", "metadata", "createdAt", "updatedAt")
+SELECT
+    gen_random_uuid(),
+    model_slug,
+    model_display_name,
+    NULL,
+    p."id",
+    context_window,
+    max_output_tokens,
+    true,
+    '{}'::jsonb,
+    '{}'::jsonb,
+    NOW(),
+    NOW()
+FROM (VALUES
+    -- New OpenAI model
+    ('gpt-5.2-2025-12-11', 'GPT 5.2', 'openai', 400000, 128000),
+    -- New Anthropic model
+    ('claude-opus-4-6', 'Claude 4.6 Opus', 'anthropic', 200000, 64000)
+) AS models(model_slug, model_display_name, provider_name, context_window, max_output_tokens)
+JOIN provider_ids p ON p."name" = models.provider_name
+ON CONFLICT ("slug") DO NOTHING;
+
+-- Add costs for new models
+WITH model_ids AS (
+    SELECT "id", "slug", "providerId" FROM "LlmModel"
+),
+provider_ids AS (
+    SELECT "id", "name" FROM "LlmProvider"
+)
+INSERT INTO "LlmModelCost" ("id", "unit", "creditCost", "credentialProvider", "credentialId", "credentialType", "currency", "metadata", "llmModelId", "createdAt", "updatedAt")
+SELECT
+    gen_random_uuid(),
+    'RUN'::"LlmCostUnit",
+    cost,
+    p."name",
+    NULL,
+    'api_key',
+    NULL,
+    '{}'::jsonb,
+    m."id",
+    NOW(),
+    NOW()
+FROM (VALUES
+    -- New model costs (estimate based on similar models)
+    ('gpt-5.2-2025-12-11', 5),  -- Similar to GPT 5.1
+    ('claude-opus-4-6', 21)     -- Similar to other Opus 4.x models
+) AS costs(model_slug, cost)
+JOIN model_ids m ON m."slug" = costs.model_slug
+JOIN provider_ids p ON p."id" = m."providerId"
+ON CONFLICT ("llmModelId", "credentialProvider", "unit") DO NOTHING;

autogpt_platform/backend/migrations/20260310_move_capabilities_to_model/migration.sql

@@ -0,0 +1,25 @@
+-- Move capability fields from LlmProvider to LlmModel
+-- Per reviewer feedback: capabilities should be per-model, not per-provider
+-- (e.g., Hugging Face hosts models with vastly different capabilities)
+
+-- Add capability columns to LlmModel
+ALTER TABLE platform."LlmModel" ADD COLUMN "supportsTools" BOOLEAN NOT NULL DEFAULT true;
+ALTER TABLE platform."LlmModel" ADD COLUMN "supportsJsonOutput" BOOLEAN NOT NULL DEFAULT true;
+ALTER TABLE platform."LlmModel" ADD COLUMN "supportsReasoning" BOOLEAN NOT NULL DEFAULT false;
+ALTER TABLE platform."LlmModel" ADD COLUMN "supportsParallelTool" BOOLEAN NOT NULL DEFAULT false;
+
+-- Copy capability values from provider to all its models
+UPDATE platform."LlmModel" m
+SET 
+  "supportsTools" = p."supportsTools",
+  "supportsJsonOutput" = p."supportsJsonOutput",
+  "supportsReasoning" = p."supportsReasoning",
+  "supportsParallelTool" = p."supportsParallelTool"
+FROM platform."LlmProvider" p
+WHERE m."providerId" = p.id;
+
+-- Remove capability columns from LlmProvider
+ALTER TABLE platform."LlmProvider" DROP COLUMN "supportsTools";
+ALTER TABLE platform."LlmProvider" DROP COLUMN "supportsJsonOutput";
+ALTER TABLE platform."LlmProvider" DROP COLUMN "supportsReasoning";
+ALTER TABLE platform."LlmProvider" DROP COLUMN "supportsParallelTool";

autogpt_platform/backend/schema.prisma

@@ -1195,6 +1195,159 @@ enum APIKeyStatus {
   SUSPENDED
 }
 
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+/////////////   LLM REGISTRY AND BILLING DATA   /////////////
+////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////
+
+// LlmCostUnit: Defines how LLM MODEL costs are calculated (per run or per token).
+// This is distinct from BlockCostType (in backend/data/block.py) which defines
+// how BLOCK EXECUTION costs are calculated (per run, per byte, or per second).
+// LlmCostUnit is for pricing individual LLM model API calls in the registry,
+// while BlockCostType is for billing platform block executions.
+enum LlmCostUnit {
+  RUN
+  TOKENS
+}
+
+model LlmModelCreator {
+  id        String   @id @default(uuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  name        String  @unique // e.g., "openai", "anthropic", "meta"
+  displayName String // e.g., "OpenAI", "Anthropic", "Meta"
+  description String?
+  websiteUrl  String? // Link to creator's website
+  logoUrl     String? // URL to creator's logo
+
+  metadata Json @default("{}")
+
+  Models LlmModel[]
+}
+
+model LlmProvider {
+  id        String   @id @default(uuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  name        String @unique
+  displayName String
+  description String?
+
+  defaultCredentialProvider String?
+  defaultCredentialId       String?
+  defaultCredentialType     String?
+
+  metadata Json @default("{}")
+
+  Models LlmModel[]
+}
+
+model LlmModel {
+  id        String   @id @default(uuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  slug        String @unique
+  displayName String
+  description String?
+
+  providerId String
+  Provider   LlmProvider @relation(fields: [providerId], references: [id], onDelete: Restrict)
+
+  // Creator is the organization that created/trained the model (e.g., OpenAI, Meta)
+  // This is distinct from the provider who hosts/serves the model (e.g., OpenRouter)
+  creatorId String?
+  Creator   LlmModelCreator? @relation(fields: [creatorId], references: [id], onDelete: SetNull)
+
+  contextWindow   Int
+  maxOutputTokens Int?
+  priceTier       Int     @default(1) // 1=cheapest, 2=medium, 3=expensive
+  isEnabled       Boolean @default(true)
+  isRecommended   Boolean @default(false)
+
+  // Model-specific capabilities (moved from Provider per Nick's feedback)
+  // These vary per model even within the same provider (e.g., Hugging Face)
+  supportsTools        Boolean @default(true)
+  supportsJsonOutput   Boolean @default(true)
+  supportsReasoning    Boolean @default(false)
+  supportsParallelTool Boolean @default(false)
+
+  capabilities Json @default("{}")
+  metadata     Json @default("{}")
+
+  Costs LlmModelCost[]
+
+  @@index([providerId, isEnabled])
+  @@index([creatorId])
+  // Note: slug already has @unique which creates an implicit index
+}
+
+model LlmModelCost {
+  id        String     @id @default(uuid())
+  createdAt DateTime   @default(now())
+  updatedAt DateTime   @updatedAt
+  unit      LlmCostUnit @default(RUN)
+
+  creditCost Int
+
+  credentialProvider String
+  credentialId       String?
+  credentialType     String?
+  currency           String?
+
+  metadata Json @default("{}")
+
+  llmModelId String
+  Model      LlmModel @relation(fields: [llmModelId], references: [id], onDelete: Cascade)
+
+  @@unique([llmModelId, credentialProvider, unit])
+  @@index([llmModelId])
+  @@index([credentialProvider])
+}
+
+// Tracks model migrations for revert capability
+// When a model is disabled with migration, we record which nodes were affected
+// so they can be reverted when the original model is back online
+model LlmModelMigration {
+  id        String   @id @default(uuid())
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  sourceModelSlug String // The original model that was disabled
+  targetModelSlug String // The model workflows were migrated to
+  reason          String? // Why the migration happened (e.g., "Provider outage")
+
+  // Track affected nodes as JSON array of node IDs
+  // Format: ["node-uuid-1", "node-uuid-2", ...]
+  migratedNodeIds Json @default("[]")
+  nodeCount       Int // Number of nodes migrated
+
+  // Custom pricing override for migrated workflows during the migration period.
+  // Use case: When migrating users from an expensive model (e.g., GPT-4) to a cheaper
+  // one (e.g., GPT-3.5), you may want to temporarily maintain the original pricing
+  // to avoid billing surprises, or offer a discount during the transition.
+  //
+  // IMPORTANT: This field is intended for integration with the billing system.
+  // When billing calculates costs for nodes affected by this migration, it should
+  // check if customCreditCost is set and use it instead of the target model's cost.
+  // If null, the target model's normal cost applies.
+  //
+  // TODO: Integrate with billing system to apply this override during cost calculation.
+  customCreditCost Int?
+
+  // Revert tracking
+  isReverted Boolean   @default(false)
+  revertedAt DateTime?
+
+  @@index([sourceModelSlug])
+  @@index([targetModelSlug])
+  @@index([isReverted])
+  @@index([sourceModelSlug, isReverted]) // Composite index for active migration queries
+}
+
 ////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////
 //////////////   OAUTH PROVIDER TABLES    //////////////////

autogpt_platform/backend/snapshots/create_llm_model_success.json

@@ -0,0 +1,27 @@
+{
+  "capabilities": {},
+  "context_window": 128000,
+  "costs": [
+    {
+      "credential_id": null,
+      "credential_provider": "openai",
+      "credential_type": null,
+      "credit_cost": 5,
+      "currency": null,
+      "id": "cost-id",
+      "metadata": {},
+      "unit": "RUN"
+    }
+  ],
+  "creator": null,
+  "creator_id": null,
+  "description": "Latest GPT-4.1 Mini model",
+  "display_name": "GPT-4.1 Mini",
+  "id": "new-model-id",
+  "is_enabled": true,
+  "is_recommended": false,
+  "max_output_tokens": 16384,
+  "metadata": {},
+  "provider_id": "provider-1",
+  "slug": "gpt-4.1-mini"
+}

autogpt_platform/backend/snapshots/create_llm_provider_success.json

@@ -0,0 +1,15 @@
+{
+  "default_credential_id": null,
+  "default_credential_provider": null,
+  "default_credential_type": null,
+  "description": "Groq LLM provider",
+  "display_name": "Groq",
+  "id": "new-provider-id",
+  "metadata": {},
+  "models": [],
+  "name": "groq",
+  "supports_json_output": true,
+  "supports_parallel_tool": false,
+  "supports_reasoning": false,
+  "supports_tools": true
+}

autogpt_platform/backend/snapshots/delete_llm_model_success.json

@@ -0,0 +1,7 @@
+{
+  "deleted_model_display_name": "GPT-3.5 Turbo",
+  "deleted_model_slug": "gpt-3.5-turbo",
+  "message": "Successfully deleted model 'GPT-3.5 Turbo' (gpt-3.5-turbo) and migrated 42 workflow node(s) to 'gpt-4o-mini'.",
+  "nodes_migrated": 42,
+  "replacement_model_slug": "gpt-4o-mini"
+}

autogpt_platform/backend/snapshots/list_llm_models_success.json

@@ -0,0 +1,37 @@
+{
+  "models": [
+    {
+      "capabilities": {},
+      "context_window": 128000,
+      "costs": [
+        {
+          "credential_id": null,
+          "credential_provider": "openai",
+          "credential_type": null,
+          "credit_cost": 10,
+          "currency": null,
+          "id": "cost-1",
+          "metadata": {},
+          "unit": "RUN"
+        }
+      ],
+      "creator": null,
+      "creator_id": null,
+      "description": "GPT-4 Optimized",
+      "display_name": "GPT-4o",
+      "id": "model-1",
+      "is_enabled": true,
+      "is_recommended": false,
+      "max_output_tokens": 16384,
+      "metadata": {},
+      "provider_id": "provider-1",
+      "slug": "gpt-4o"
+    }
+  ],
+  "pagination": {
+    "current_page": 1,
+    "page_size": 50,
+    "total_items": 1,
+    "total_pages": 1
+  }
+}

autogpt_platform/backend/snapshots/list_llm_providers_success.json

@@ -0,0 +1,34 @@
+{
+  "providers": [
+    {
+      "default_credential_id": null,
+      "default_credential_provider": null,
+      "default_credential_type": null,
+      "description": "OpenAI LLM provider",
+      "display_name": "OpenAI",
+      "id": "provider-1",
+      "metadata": {},
+      "models": [],
+      "name": "openai",
+      "supports_json_output": true,
+      "supports_parallel_tool": true,
+      "supports_reasoning": false,
+      "supports_tools": true
+    },
+    {
+      "default_credential_id": null,
+      "default_credential_provider": null,
+      "default_credential_type": null,
+      "description": "Anthropic LLM provider",
+      "display_name": "Anthropic",
+      "id": "provider-2",
+      "metadata": {},
+      "models": [],
+      "name": "anthropic",
+      "supports_json_output": true,
+      "supports_parallel_tool": true,
+      "supports_reasoning": false,
+      "supports_tools": true
+    }
+  ]
+}

autogpt_platform/backend/snapshots/toggle_llm_model_success.json

@@ -0,0 +1,21 @@
+{
+  "migrated_to_slug": null,
+  "migration_id": null,
+  "model": {
+    "capabilities": {},
+    "context_window": 128000,
+    "costs": [],
+    "creator": null,
+    "creator_id": null,
+    "description": "GPT-4 Optimized",
+    "display_name": "GPT-4o",
+    "id": "model-1",
+    "is_enabled": false,
+    "is_recommended": false,
+    "max_output_tokens": 16384,
+    "metadata": {},
+    "provider_id": "provider-1",
+    "slug": "gpt-4o"
+  },
+  "nodes_migrated": 0
+}

autogpt_platform/backend/snapshots/update_llm_model_success.json

@@ -0,0 +1,27 @@
+{
+  "capabilities": {},
+  "context_window": 256000,
+  "costs": [
+    {
+      "credential_id": null,
+      "credential_provider": "openai",
+      "credential_type": null,
+      "credit_cost": 15,
+      "currency": null,
+      "id": "cost-1",
+      "metadata": {},
+      "unit": "RUN"
+    }
+  ],
+  "creator": null,
+  "creator_id": null,
+  "description": "Updated description",
+  "display_name": "GPT-4o Updated",
+  "id": "model-1",
+  "is_enabled": true,
+  "is_recommended": false,
+  "max_output_tokens": 32768,
+  "metadata": {},
+  "provider_id": "provider-1",
+  "slug": "gpt-4o"
+}

autogpt_platform/frontend/src/app/(platform)/admin/layout.tsx

@@ -1,5 +1,8 @@
+"use client";
+
 import { Sidebar } from "@/components/__legacy__/Sidebar";
 import { Users, DollarSign, UserSearch, FileText } from "lucide-react";
+import { Cpu } from "@phosphor-icons/react";
 
 import { IconSliders } from "@/components/__legacy__/ui/icons";
 
@@ -26,6 +29,11 @@ const sidebarLinkGroups = [
         href: "/admin/execution-analytics",
         icon: <FileText className="h-6 w-6" />,
       },
+      {
+        text: "LLM Registry",
+        href: "/admin/llms",
+        icon: <Cpu size={24} />,
+      },
       {
         text: "Admin User Management",
         href: "/admin/settings",

autogpt_platform/frontend/src/app/(platform)/admin/llms/actions.ts

@@ -0,0 +1,493 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+
+// Generated API functions
+import {
+  getV2ListLlmProviders,
+  postV2CreateLlmProvider,
+  patchV2UpdateLlmProvider,
+  deleteV2DeleteLlmProvider,
+  getV2ListLlmModels,
+  postV2CreateLlmModel,
+  patchV2UpdateLlmModel,
+  patchV2ToggleLlmModelAvailability,
+  deleteV2DeleteLlmModelAndMigrateWorkflows,
+  getV2GetModelUsageCount,
+  getV2ListModelMigrations,
+  postV2RevertAModelMigration,
+  getV2ListModelCreators,
+  postV2CreateModelCreator,
+  patchV2UpdateModelCreator,
+  deleteV2DeleteModelCreator,
+  postV2SetRecommendedModel,
+} from "@/app/api/__generated__/endpoints/admin/admin";
+
+// Generated types
+import type { LlmProvidersResponse } from "@/app/api/__generated__/models/llmProvidersResponse";
+import type { LlmModelsResponse } from "@/app/api/__generated__/models/llmModelsResponse";
+import type { UpsertLlmProviderRequest } from "@/app/api/__generated__/models/upsertLlmProviderRequest";
+import type { CreateLlmModelRequest } from "@/app/api/__generated__/models/createLlmModelRequest";
+import type { UpdateLlmModelRequest } from "@/app/api/__generated__/models/updateLlmModelRequest";
+import type { ToggleLlmModelRequest } from "@/app/api/__generated__/models/toggleLlmModelRequest";
+import type { LlmMigrationsResponse } from "@/app/api/__generated__/models/llmMigrationsResponse";
+import type { LlmCreatorsResponse } from "@/app/api/__generated__/models/llmCreatorsResponse";
+import type { UpsertLlmCreatorRequest } from "@/app/api/__generated__/models/upsertLlmCreatorRequest";
+import type { LlmModelUsageResponse } from "@/app/api/__generated__/models/llmModelUsageResponse";
+import { LlmCostUnit } from "@/app/api/__generated__/models/llmCostUnit";
+
+const ADMIN_LLM_PATH = "/admin/llms";
+
+// =============================================================================
+// Utilities
+// =============================================================================
+
+/**
+ * Extracts and validates a required string field from FormData.
+ * Throws an error if the field is missing or empty.
+ */
+function getRequiredFormField(
+  formData: FormData,
+  fieldName: string,
+  displayName?: string,
+): string {
+  const raw = formData.get(fieldName);
+  const value = raw ? String(raw).trim() : "";
+  if (!value) {
+    throw new Error(`${displayName || fieldName} is required`);
+  }
+  return value;
+}
+
+/**
+ * Extracts and validates a required positive number field from FormData.
+ * Throws an error if the field is missing, empty, or not a positive number.
+ */
+function getRequiredPositiveNumber(
+  formData: FormData,
+  fieldName: string,
+  displayName?: string,
+): number {
+  const raw = formData.get(fieldName);
+  const value = Number(raw);
+  if (raw === null || raw === "" || !Number.isFinite(value) || value <= 0) {
+    throw new Error(`${displayName || fieldName} must be a positive number`);
+  }
+  return value;
+}
+
+/**
+ * Extracts and validates a required number field from FormData.
+ * Throws an error if the field is missing, empty, or not a finite number.
+ */
+function getRequiredNumber(
+  formData: FormData,
+  fieldName: string,
+  displayName?: string,
+): number {
+  const raw = formData.get(fieldName);
+  const value = Number(raw);
+  if (raw === null || raw === "" || !Number.isFinite(value)) {
+    throw new Error(`${displayName || fieldName} is required`);
+  }
+  return value;
+}
+
+// =============================================================================
+// Provider Actions
+// =============================================================================
+
+export async function fetchLlmProviders(): Promise<LlmProvidersResponse> {
+  const response = await getV2ListLlmProviders({ include_models: true });
+  if (response.status !== 200) {
+    throw new Error("Failed to fetch LLM providers");
+  }
+  return response.data;
+}
+
+export async function createLlmProviderAction(formData: FormData) {
+  const payload: UpsertLlmProviderRequest = {
+    name: String(formData.get("name") || "").trim(),
+    display_name: String(formData.get("display_name") || "").trim(),
+    description: formData.get("description")
+      ? String(formData.get("description"))
+      : undefined,
+    default_credential_provider: formData.get("default_credential_provider")
+      ? String(formData.get("default_credential_provider")).trim()
+      : undefined,
+    default_credential_id: formData.get("default_credential_id")
+      ? String(formData.get("default_credential_id")).trim()
+      : undefined,
+    default_credential_type: formData.get("default_credential_type")
+      ? String(formData.get("default_credential_type")).trim()
+      : "api_key",
+    supports_tools: formData.getAll("supports_tools").includes("on"),
+    supports_json_output: formData
+      .getAll("supports_json_output")
+      .includes("on"),
+    supports_reasoning: formData.getAll("supports_reasoning").includes("on"),
+    supports_parallel_tool: formData
+      .getAll("supports_parallel_tool")
+      .includes("on"),
+    metadata: {},
+  };
+
+  const response = await postV2CreateLlmProvider(payload);
+  if (response.status !== 200) {
+    throw new Error("Failed to create LLM provider");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+export async function deleteLlmProviderAction(
+  formData: FormData,
+): Promise<void> {
+  const providerId = getRequiredFormField(
+    formData,
+    "provider_id",
+    "Provider id",
+  );
+
+  const response = await deleteV2DeleteLlmProvider(providerId);
+  if (response.status !== 200) {
+    const errorData = response.data as { detail?: string };
+    throw new Error(errorData?.detail || "Failed to delete provider");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+export async function updateLlmProviderAction(formData: FormData) {
+  const providerId = getRequiredFormField(
+    formData,
+    "provider_id",
+    "Provider id",
+  );
+
+  const payload: UpsertLlmProviderRequest = {
+    name: String(formData.get("name") || "").trim(),
+    display_name: String(formData.get("display_name") || "").trim(),
+    description: formData.get("description")
+      ? String(formData.get("description"))
+      : undefined,
+    default_credential_provider: formData.get("default_credential_provider")
+      ? String(formData.get("default_credential_provider")).trim()
+      : undefined,
+    default_credential_id: formData.get("default_credential_id")
+      ? String(formData.get("default_credential_id")).trim()
+      : undefined,
+    default_credential_type: formData.get("default_credential_type")
+      ? String(formData.get("default_credential_type")).trim()
+      : "api_key",
+    supports_tools: formData.getAll("supports_tools").includes("on"),
+    supports_json_output: formData
+      .getAll("supports_json_output")
+      .includes("on"),
+    supports_reasoning: formData.getAll("supports_reasoning").includes("on"),
+    supports_parallel_tool: formData
+      .getAll("supports_parallel_tool")
+      .includes("on"),
+    metadata: {},
+  };
+
+  const response = await patchV2UpdateLlmProvider(providerId, payload);
+  if (response.status !== 200) {
+    throw new Error("Failed to update LLM provider");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+// =============================================================================
+// Model Actions
+// =============================================================================
+
+export async function fetchLlmModels(): Promise<LlmModelsResponse> {
+  const response = await getV2ListLlmModels();
+  if (response.status !== 200) {
+    throw new Error("Failed to fetch LLM models");
+  }
+  return response.data;
+}
+
+export async function createLlmModelAction(formData: FormData) {
+  const providerId = getRequiredFormField(formData, "provider_id", "Provider");
+  const creatorId = formData.get("creator_id");
+  const contextWindow = getRequiredPositiveNumber(
+    formData,
+    "context_window",
+    "Context window",
+  );
+  const creditCost = getRequiredNumber(formData, "credit_cost", "Credit cost");
+
+  // Fetch provider to get default credentials
+  const providersResponse = await getV2ListLlmProviders({
+    include_models: false,
+  });
+  if (providersResponse.status !== 200) {
+    throw new Error("Failed to fetch providers");
+  }
+  const provider = providersResponse.data.providers.find(
+    (p) => p.id === providerId,
+  );
+
+  if (!provider) {
+    throw new Error("Provider not found");
+  }
+
+  const payload: CreateLlmModelRequest = {
+    slug: String(formData.get("slug") || "").trim(),
+    display_name: String(formData.get("display_name") || "").trim(),
+    description: formData.get("description")
+      ? String(formData.get("description"))
+      : undefined,
+    provider_id: providerId,
+    creator_id: creatorId ? String(creatorId) : undefined,
+    context_window: contextWindow,
+    max_output_tokens: formData.get("max_output_tokens")
+      ? Number(formData.get("max_output_tokens"))
+      : undefined,
+    is_enabled: formData.getAll("is_enabled").includes("on"),
+    capabilities: {},
+    metadata: {},
+    costs: [
+      {
+        unit: (formData.get("unit") as LlmCostUnit) || LlmCostUnit.RUN,
+        credit_cost: creditCost,
+        credential_provider:
+          provider.default_credential_provider || provider.name,
+        credential_id: provider.default_credential_id || undefined,
+        credential_type: provider.default_credential_type || "api_key",
+        metadata: {},
+      },
+    ],
+  };
+
+  const response = await postV2CreateLlmModel(payload);
+  if (response.status !== 200) {
+    throw new Error("Failed to create LLM model");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+export async function updateLlmModelAction(formData: FormData) {
+  const modelId = getRequiredFormField(formData, "model_id", "Model id");
+  const creatorId = formData.get("creator_id");
+
+  const payload: UpdateLlmModelRequest = {
+    display_name: formData.get("display_name")
+      ? String(formData.get("display_name"))
+      : undefined,
+    description: formData.get("description")
+      ? String(formData.get("description"))
+      : undefined,
+    provider_id: formData.get("provider_id")
+      ? String(formData.get("provider_id"))
+      : undefined,
+    creator_id: creatorId ? String(creatorId) : undefined,
+    context_window: formData.get("context_window")
+      ? Number(formData.get("context_window"))
+      : undefined,
+    max_output_tokens: formData.get("max_output_tokens")
+      ? Number(formData.get("max_output_tokens"))
+      : undefined,
+    is_enabled: formData.has("is_enabled")
+      ? formData.getAll("is_enabled").includes("on")
+      : undefined,
+    costs: formData.get("credit_cost")
+      ? [
+          {
+            unit: (formData.get("unit") as LlmCostUnit) || LlmCostUnit.RUN,
+            credit_cost: Number(formData.get("credit_cost")),
+            credential_provider: String(
+              formData.get("credential_provider") || "",
+            ).trim(),
+            credential_id: formData.get("credential_id")
+              ? String(formData.get("credential_id"))
+              : undefined,
+            credential_type: formData.get("credential_type")
+              ? String(formData.get("credential_type"))
+              : undefined,
+            metadata: {},
+          },
+        ]
+      : undefined,
+  };
+
+  const response = await patchV2UpdateLlmModel(modelId, payload);
+  if (response.status !== 200) {
+    throw new Error("Failed to update LLM model");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+export async function toggleLlmModelAction(formData: FormData): Promise<void> {
+  const modelId = getRequiredFormField(formData, "model_id", "Model id");
+  const shouldEnable = formData.get("is_enabled") === "true";
+  const migrateToSlug = formData.get("migrate_to_slug");
+  const migrationReason = formData.get("migration_reason");
+  const customCreditCost = formData.get("custom_credit_cost");
+
+  const payload: ToggleLlmModelRequest = {
+    is_enabled: shouldEnable,
+    migrate_to_slug: migrateToSlug ? String(migrateToSlug) : undefined,
+    migration_reason: migrationReason ? String(migrationReason) : undefined,
+    custom_credit_cost: customCreditCost ? Number(customCreditCost) : undefined,
+  };
+
+  const response = await patchV2ToggleLlmModelAvailability(modelId, payload);
+  if (response.status !== 200) {
+    throw new Error("Failed to toggle LLM model");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+export async function deleteLlmModelAction(formData: FormData): Promise<void> {
+  const modelId = getRequiredFormField(formData, "model_id", "Model id");
+  const rawReplacement = formData.get("replacement_model_slug");
+  const replacementModelSlug =
+    rawReplacement && String(rawReplacement).trim()
+      ? String(rawReplacement).trim()
+      : undefined;
+
+  const response = await deleteV2DeleteLlmModelAndMigrateWorkflows(modelId, {
+    replacement_model_slug: replacementModelSlug,
+  });
+  if (response.status !== 200) {
+    throw new Error("Failed to delete model");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+export async function fetchLlmModelUsage(
+  modelId: string,
+): Promise<LlmModelUsageResponse> {
+  const response = await getV2GetModelUsageCount(modelId);
+  if (response.status !== 200) {
+    throw new Error("Failed to fetch model usage");
+  }
+  return response.data;
+}
+
+// =============================================================================
+// Migration Actions
+// =============================================================================
+
+export async function fetchLlmMigrations(
+  includeReverted: boolean = false,
+): Promise<LlmMigrationsResponse> {
+  const response = await getV2ListModelMigrations({
+    include_reverted: includeReverted,
+  });
+  if (response.status !== 200) {
+    throw new Error("Failed to fetch migrations");
+  }
+  return response.data;
+}
+
+export async function revertLlmMigrationAction(
+  formData: FormData,
+): Promise<void> {
+  const migrationId = getRequiredFormField(
+    formData,
+    "migration_id",
+    "Migration id",
+  );
+
+  const response = await postV2RevertAModelMigration(migrationId, null);
+  if (response.status !== 200) {
+    throw new Error("Failed to revert migration");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+// =============================================================================
+// Creator Actions
+// =============================================================================
+
+export async function fetchLlmCreators(): Promise<LlmCreatorsResponse> {
+  const response = await getV2ListModelCreators();
+  if (response.status !== 200) {
+    throw new Error("Failed to fetch creators");
+  }
+  return response.data;
+}
+
+export async function createLlmCreatorAction(
+  formData: FormData,
+): Promise<void> {
+  const payload: UpsertLlmCreatorRequest = {
+    name: String(formData.get("name") || "").trim(),
+    display_name: String(formData.get("display_name") || "").trim(),
+    description: formData.get("description")
+      ? String(formData.get("description"))
+      : undefined,
+    website_url: formData.get("website_url")
+      ? String(formData.get("website_url")).trim()
+      : undefined,
+    logo_url: formData.get("logo_url")
+      ? String(formData.get("logo_url")).trim()
+      : undefined,
+    metadata: {},
+  };
+
+  const response = await postV2CreateModelCreator(payload);
+  if (response.status !== 200) {
+    throw new Error("Failed to create creator");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+export async function updateLlmCreatorAction(
+  formData: FormData,
+): Promise<void> {
+  const creatorId = getRequiredFormField(formData, "creator_id", "Creator id");
+
+  const payload: UpsertLlmCreatorRequest = {
+    name: String(formData.get("name") || "").trim(),
+    display_name: String(formData.get("display_name") || "").trim(),
+    description: formData.get("description")
+      ? String(formData.get("description"))
+      : undefined,
+    website_url: formData.get("website_url")
+      ? String(formData.get("website_url")).trim()
+      : undefined,
+    logo_url: formData.get("logo_url")
+      ? String(formData.get("logo_url")).trim()
+      : undefined,
+    metadata: {},
+  };
+
+  const response = await patchV2UpdateModelCreator(creatorId, payload);
+  if (response.status !== 200) {
+    throw new Error("Failed to update creator");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+export async function deleteLlmCreatorAction(
+  formData: FormData,
+): Promise<void> {
+  const creatorId = getRequiredFormField(formData, "creator_id", "Creator id");
+
+  const response = await deleteV2DeleteModelCreator(creatorId);
+  if (response.status !== 200) {
+    throw new Error("Failed to delete creator");
+  }
+  revalidatePath(ADMIN_LLM_PATH);
+}
+
+// =============================================================================
+// Recommended Model Actions
+// =============================================================================
+
+export async function setRecommendedModelAction(
+  formData: FormData,
+): Promise<void> {
+  const modelId = getRequiredFormField(formData, "model_id", "Model id");
+
+  const response = await postV2SetRecommendedModel({ model_id: modelId });
+  if (response.status !== 200) {
+    throw new Error("Failed to set recommended model");
+  }
+
+  revalidatePath(ADMIN_LLM_PATH);
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/AddCreatorModal.tsx

@@ -0,0 +1,147 @@
+"use client";
+
+import { useState } from "react";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import { createLlmCreatorAction } from "../actions";
+import { useRouter } from "next/navigation";
+
+export function AddCreatorModal() {
+  const [open, setOpen] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const router = useRouter();
+
+  async function handleSubmit(formData: FormData) {
+    setIsSubmitting(true);
+    setError(null);
+    try {
+      await createLlmCreatorAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to create creator");
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  return (
+    <Dialog
+      title="Add Creator"
+      controlled={{ isOpen: open, set: setOpen }}
+      styling={{ maxWidth: "512px" }}
+    >
+      <Dialog.Trigger>
+        <Button variant="primary" size="small">
+          Add Creator
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="mb-4 text-sm text-muted-foreground">
+          Add a new model creator (the organization that made/trained the
+          model).
+        </div>
+
+        <form action={handleSubmit} className="space-y-4">
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div className="space-y-2">
+              <label
+                htmlFor="name"
+                className="text-sm font-medium text-foreground"
+              >
+                Name (slug) <span className="text-destructive">*</span>
+              </label>
+              <input
+                id="name"
+                required
+                name="name"
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                placeholder="openai"
+              />
+              <p className="text-xs text-muted-foreground">
+                Lowercase identifier (e.g., openai, meta, anthropic)
+              </p>
+            </div>
+            <div className="space-y-2">
+              <label
+                htmlFor="display_name"
+                className="text-sm font-medium text-foreground"
+              >
+                Display Name <span className="text-destructive">*</span>
+              </label>
+              <input
+                id="display_name"
+                required
+                name="display_name"
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                placeholder="OpenAI"
+              />
+            </div>
+          </div>
+
+          <div className="space-y-2">
+            <label
+              htmlFor="description"
+              className="text-sm font-medium text-foreground"
+            >
+              Description
+            </label>
+            <textarea
+              id="description"
+              name="description"
+              rows={2}
+              className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+              placeholder="Creator of GPT models..."
+            />
+          </div>
+
+          <div className="space-y-2">
+            <label
+              htmlFor="website_url"
+              className="text-sm font-medium text-foreground"
+            >
+              Website URL
+            </label>
+            <input
+              id="website_url"
+              name="website_url"
+              type="url"
+              className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+              placeholder="https://openai.com"
+            />
+          </div>
+
+          {error && (
+            <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+              {error}
+            </div>
+          )}
+
+          <Dialog.Footer>
+            <Button
+              variant="ghost"
+              size="small"
+              type="button"
+              onClick={() => {
+                setOpen(false);
+                setError(null);
+              }}
+              disabled={isSubmitting}
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="primary"
+              size="small"
+              type="submit"
+              disabled={isSubmitting}
+            >
+              {isSubmitting ? "Creating..." : "Add Creator"}
+            </Button>
+          </Dialog.Footer>
+        </form>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/AddModelModal.tsx

@@ -0,0 +1,314 @@
+"use client";
+
+import { useState } from "react";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import type { LlmProvider } from "@/app/api/__generated__/models/llmProvider";
+import type { LlmModelCreator } from "@/app/api/__generated__/models/llmModelCreator";
+import { createLlmModelAction } from "../actions";
+import { useRouter } from "next/navigation";
+
+interface Props {
+  providers: LlmProvider[];
+  creators: LlmModelCreator[];
+}
+
+export function AddModelModal({ providers, creators }: Props) {
+  const [open, setOpen] = useState(false);
+  const [selectedCreatorId, setSelectedCreatorId] = useState("");
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const router = useRouter();
+
+  async function handleSubmit(formData: FormData) {
+    setIsSubmitting(true);
+    setError(null);
+    try {
+      await createLlmModelAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to create model");
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  // When provider changes, auto-select matching creator if one exists
+  function handleProviderChange(providerId: string) {
+    const provider = providers.find((p) => p.id === providerId);
+    if (provider) {
+      // Find creator with same name as provider (e.g., "openai" -> "openai")
+      const matchingCreator = creators.find((c) => c.name === provider.name);
+      if (matchingCreator) {
+        setSelectedCreatorId(matchingCreator.id);
+      } else {
+        // No matching creator (e.g., OpenRouter hosts other creators' models)
+        setSelectedCreatorId("");
+      }
+    }
+  }
+
+  return (
+    <Dialog
+      title="Add Model"
+      controlled={{ isOpen: open, set: setOpen }}
+      styling={{ maxWidth: "768px", maxHeight: "90vh", overflowY: "auto" }}
+    >
+      <Dialog.Trigger>
+        <Button variant="primary" size="small">
+          Add Model
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="mb-4 text-sm text-muted-foreground">
+          Register a new model slug, metadata, and pricing.
+        </div>
+
+        <form action={handleSubmit} className="space-y-6">
+          {/* Basic Information */}
+          <div className="space-y-4">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">
+                Basic Information
+              </h3>
+              <p className="text-xs text-muted-foreground">
+                Core model details
+              </p>
+            </div>
+            <div className="grid gap-4 sm:grid-cols-2">
+              <div className="space-y-2">
+                <label
+                  htmlFor="slug"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Model Slug <span className="text-destructive">*</span>
+                </label>
+                <input
+                  id="slug"
+                  required
+                  name="slug"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="gpt-4.1-mini-2025-04-14"
+                />
+              </div>
+              <div className="space-y-2">
+                <label
+                  htmlFor="display_name"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Display Name <span className="text-destructive">*</span>
+                </label>
+                <input
+                  id="display_name"
+                  required
+                  name="display_name"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="GPT 4.1 Mini"
+                />
+              </div>
+            </div>
+            <div className="space-y-2">
+              <label
+                htmlFor="description"
+                className="text-sm font-medium text-foreground"
+              >
+                Description
+              </label>
+              <textarea
+                id="description"
+                name="description"
+                rows={3}
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                placeholder="Optional description..."
+              />
+            </div>
+          </div>
+
+          {/* Model Configuration */}
+          <div className="space-y-4 border-t border-border pt-6">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">
+                Model Configuration
+              </h3>
+              <p className="text-xs text-muted-foreground">
+                Model capabilities and limits
+              </p>
+            </div>
+            <div className="grid gap-4 sm:grid-cols-2">
+              <div className="space-y-2">
+                <label
+                  htmlFor="provider_id"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Provider <span className="text-destructive">*</span>
+                </label>
+                <select
+                  id="provider_id"
+                  required
+                  name="provider_id"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  defaultValue=""
+                  onChange={(e) => handleProviderChange(e.target.value)}
+                >
+                  <option value="" disabled>
+                    Select provider
+                  </option>
+                  {providers.map((provider) => (
+                    <option key={provider.id} value={provider.id}>
+                      {provider.display_name} ({provider.name})
+                    </option>
+                  ))}
+                </select>
+                <p className="text-xs text-muted-foreground">
+                  Who hosts/serves the model
+                </p>
+              </div>
+              <div className="space-y-2">
+                <label
+                  htmlFor="creator_id"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Creator
+                </label>
+                <select
+                  id="creator_id"
+                  name="creator_id"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  value={selectedCreatorId}
+                  onChange={(e) => setSelectedCreatorId(e.target.value)}
+                >
+                  <option value="">No creator selected</option>
+                  {creators.map((creator) => (
+                    <option key={creator.id} value={creator.id}>
+                      {creator.display_name} ({creator.name})
+                    </option>
+                  ))}
+                </select>
+                <p className="text-xs text-muted-foreground">
+                  Who made/trained the model (e.g., OpenAI, Meta)
+                </p>
+              </div>
+            </div>
+            <div className="grid gap-4 sm:grid-cols-2">
+              <div className="space-y-2">
+                <label
+                  htmlFor="context_window"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Context Window <span className="text-destructive">*</span>
+                </label>
+                <input
+                  id="context_window"
+                  required
+                  type="number"
+                  name="context_window"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="128000"
+                  min={1}
+                />
+              </div>
+              <div className="space-y-2">
+                <label
+                  htmlFor="max_output_tokens"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Max Output Tokens
+                </label>
+                <input
+                  id="max_output_tokens"
+                  type="number"
+                  name="max_output_tokens"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="16384"
+                  min={1}
+                />
+              </div>
+            </div>
+          </div>
+
+          {/* Pricing */}
+          <div className="space-y-4 border-t border-border pt-6">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">Pricing</h3>
+              <p className="text-xs text-muted-foreground">
+                Credit cost per run (credentials are managed via the provider)
+              </p>
+            </div>
+            <div className="grid gap-4 sm:grid-cols-1">
+              <div className="space-y-2">
+                <label
+                  htmlFor="credit_cost"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Credit Cost <span className="text-destructive">*</span>
+                </label>
+                <input
+                  id="credit_cost"
+                  required
+                  type="number"
+                  name="credit_cost"
+                  step="1"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="5"
+                  min={0}
+                />
+              </div>
+            </div>
+            <p className="text-xs text-muted-foreground">
+              Credit cost is always in platform credits. Credentials are
+              inherited from the selected provider.
+            </p>
+          </div>
+
+          {/* Enabled Toggle */}
+          <div className="flex items-center gap-3 border-t border-border pt-6">
+            <input type="hidden" name="is_enabled" value="off" />
+            <input
+              id="is_enabled"
+              type="checkbox"
+              name="is_enabled"
+              defaultChecked
+              className="h-4 w-4 rounded border-input"
+            />
+            <label
+              htmlFor="is_enabled"
+              className="text-sm font-medium text-foreground"
+            >
+              Enabled by default
+            </label>
+          </div>
+
+          {error && (
+            <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+              {error}
+            </div>
+          )}
+
+          <Dialog.Footer>
+            <Button
+              variant="ghost"
+              size="small"
+              type="button"
+              onClick={() => {
+                setOpen(false);
+                setError(null);
+              }}
+              disabled={isSubmitting}
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="primary"
+              size="small"
+              type="submit"
+              disabled={isSubmitting}
+            >
+              {isSubmitting ? "Creating..." : "Save Model"}
+            </Button>
+          </Dialog.Footer>
+        </form>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/AddProviderModal.tsx

@@ -0,0 +1,268 @@
+"use client";
+
+import { useState } from "react";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import { createLlmProviderAction } from "../actions";
+import { useRouter } from "next/navigation";
+
+export function AddProviderModal() {
+  const [open, setOpen] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const router = useRouter();
+
+  async function handleSubmit(formData: FormData) {
+    setIsSubmitting(true);
+    setError(null);
+    try {
+      await createLlmProviderAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : "Failed to create provider",
+      );
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  return (
+    <Dialog
+      title="Add Provider"
+      controlled={{ isOpen: open, set: setOpen }}
+      styling={{ maxWidth: "768px", maxHeight: "90vh", overflowY: "auto" }}
+    >
+      <Dialog.Trigger>
+        <Button variant="primary" size="small">
+          Add Provider
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="mb-4 text-sm text-muted-foreground">
+          Define a new upstream provider and default credential information.
+        </div>
+
+        {/* Setup Instructions */}
+        <div className="mb-6 rounded-lg border border-primary/30 bg-primary/5 p-4">
+          <div className="space-y-2">
+            <h4 className="text-sm font-semibold text-foreground">
+              Before Adding a Provider
+            </h4>
+            <p className="text-xs text-muted-foreground">
+              To use a new provider, you must first configure its credentials in
+              the backend:
+            </p>
+            <ol className="list-inside list-decimal space-y-1 text-xs text-muted-foreground">
+              <li>
+                Add the credential to{" "}
+                <code className="rounded bg-muted px-1 py-0.5 font-mono">
+                  backend/integrations/credentials_store.py
+                </code>{" "}
+                with a UUID, provider name, and settings secret reference
+              </li>
+              <li>
+                Add it to the{" "}
+                <code className="rounded bg-muted px-1 py-0.5 font-mono">
+                  PROVIDER_CREDENTIALS
+                </code>{" "}
+                dictionary in{" "}
+                <code className="rounded bg-muted px-1 py-0.5 font-mono">
+                  backend/data/block_cost_config.py
+                </code>
+              </li>
+              <li>
+                Use the <strong>same provider name</strong> in the
+                &quot;Credential Provider&quot; field below that matches the key
+                in{" "}
+                <code className="rounded bg-muted px-1 py-0.5 font-mono">
+                  PROVIDER_CREDENTIALS
+                </code>
+              </li>
+            </ol>
+          </div>
+        </div>
+
+        <form action={handleSubmit} className="space-y-6">
+          {/* Basic Information */}
+          <div className="space-y-4">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">
+                Basic Information
+              </h3>
+              <p className="text-xs text-muted-foreground">
+                Core provider details
+              </p>
+            </div>
+            <div className="grid gap-4 sm:grid-cols-2">
+              <div className="space-y-2">
+                <label
+                  htmlFor="name"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Provider Slug <span className="text-destructive">*</span>
+                </label>
+                <input
+                  id="name"
+                  required
+                  name="name"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="e.g. openai"
+                />
+              </div>
+              <div className="space-y-2">
+                <label
+                  htmlFor="display_name"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Display Name <span className="text-destructive">*</span>
+                </label>
+                <input
+                  id="display_name"
+                  required
+                  name="display_name"
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="OpenAI"
+                />
+              </div>
+            </div>
+            <div className="space-y-2">
+              <label
+                htmlFor="description"
+                className="text-sm font-medium text-foreground"
+              >
+                Description
+              </label>
+              <textarea
+                id="description"
+                name="description"
+                rows={3}
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                placeholder="Optional description..."
+              />
+            </div>
+          </div>
+
+          {/* Default Credentials */}
+          <div className="space-y-4 border-t border-border pt-6">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">
+                Default Credentials
+              </h3>
+              <p className="text-xs text-muted-foreground">
+                Credential provider name that matches the key in{" "}
+                <code className="rounded bg-muted px-1 py-0.5 font-mono text-xs">
+                  PROVIDER_CREDENTIALS
+                </code>
+              </p>
+            </div>
+            <div className="space-y-2">
+              <label
+                htmlFor="default_credential_provider"
+                className="text-sm font-medium text-foreground"
+              >
+                Credential Provider <span className="text-destructive">*</span>
+              </label>
+              <input
+                id="default_credential_provider"
+                name="default_credential_provider"
+                required
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                placeholder="openai"
+              />
+              <p className="text-xs text-muted-foreground">
+                <strong>Important:</strong> This must exactly match the key in
+                the{" "}
+                <code className="rounded bg-muted px-1 py-0.5 font-mono text-xs">
+                  PROVIDER_CREDENTIALS
+                </code>{" "}
+                dictionary in{" "}
+                <code className="rounded bg-muted px-1 py-0.5 font-mono text-xs">
+                  block_cost_config.py
+                </code>
+                . Common values: &quot;openai&quot;, &quot;anthropic&quot;,
+                &quot;groq&quot;, &quot;open_router&quot;, etc.
+              </p>
+            </div>
+          </div>
+
+          {/* Capabilities */}
+          <div className="space-y-4 border-t border-border pt-6">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">
+                Capabilities
+              </h3>
+              <p className="text-xs text-muted-foreground">
+                Provider feature flags
+              </p>
+            </div>
+            <div className="grid gap-3 sm:grid-cols-2">
+              {[
+                { name: "supports_tools", label: "Supports tools" },
+                { name: "supports_json_output", label: "Supports JSON output" },
+                { name: "supports_reasoning", label: "Supports reasoning" },
+                {
+                  name: "supports_parallel_tool",
+                  label: "Supports parallel tool calls",
+                },
+              ].map(({ name, label }) => (
+                <div
+                  key={name}
+                  className="flex items-center gap-3 rounded-md border border-border bg-muted/30 px-4 py-3 transition-colors hover:bg-muted/50"
+                >
+                  <input type="hidden" name={name} value="off" />
+                  <input
+                    id={name}
+                    type="checkbox"
+                    name={name}
+                    defaultChecked={
+                      name !== "supports_reasoning" &&
+                      name !== "supports_parallel_tool"
+                    }
+                    className="h-4 w-4 rounded border-input"
+                  />
+                  <label
+                    htmlFor={name}
+                    className="text-sm font-medium text-foreground"
+                  >
+                    {label}
+                  </label>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {error && (
+            <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+              {error}
+            </div>
+          )}
+
+          <Dialog.Footer>
+            <Button
+              variant="ghost"
+              size="small"
+              type="button"
+              onClick={() => {
+                setOpen(false);
+                setError(null);
+              }}
+              disabled={isSubmitting}
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="primary"
+              size="small"
+              type="submit"
+              disabled={isSubmitting}
+            >
+              {isSubmitting ? "Creating..." : "Save Provider"}
+            </Button>
+          </Dialog.Footer>
+        </form>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/CreatorsTable.tsx

@@ -0,0 +1,195 @@
+"use client";
+
+import { useState } from "react";
+import type { LlmModelCreator } from "@/app/api/__generated__/models/llmModelCreator";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/atoms/Table/Table";
+import { Button } from "@/components/atoms/Button/Button";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { updateLlmCreatorAction } from "../actions";
+import { useRouter } from "next/navigation";
+import { DeleteCreatorModal } from "./DeleteCreatorModal";
+
+export function CreatorsTable({ creators }: { creators: LlmModelCreator[] }) {
+  if (!creators.length) {
+    return (
+      <div className="rounded-lg border border-dashed border-border p-6 text-center text-sm text-muted-foreground">
+        No creators registered yet.
+      </div>
+    );
+  }
+
+  return (
+    <div className="rounded-lg border">
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Creator</TableHead>
+            <TableHead>Description</TableHead>
+            <TableHead>Website</TableHead>
+            <TableHead>Actions</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {creators.map((creator) => (
+            <TableRow key={creator.id}>
+              <TableCell>
+                <div className="font-medium">{creator.display_name}</div>
+                <div className="text-xs text-muted-foreground">
+                  {creator.name}
+                </div>
+              </TableCell>
+              <TableCell>
+                <span className="text-sm text-muted-foreground">
+                  {creator.description || "—"}
+                </span>
+              </TableCell>
+              <TableCell>
+                {creator.website_url ? (
+                  <a
+                    href={creator.website_url}
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    className="text-sm text-primary hover:underline"
+                  >
+                    {(() => {
+                      try {
+                        return new URL(creator.website_url).hostname;
+                      } catch {
+                        return creator.website_url;
+                      }
+                    })()}
+                  </a>
+                ) : (
+                  <span className="text-muted-foreground">—</span>
+                )}
+              </TableCell>
+              <TableCell>
+                <div className="flex items-center justify-end gap-2">
+                  <EditCreatorModal creator={creator} />
+                  <DeleteCreatorModal creator={creator} />
+                </div>
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    </div>
+  );
+}
+
+function EditCreatorModal({ creator }: { creator: LlmModelCreator }) {
+  const [open, setOpen] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const router = useRouter();
+
+  async function handleSubmit(formData: FormData) {
+    setIsSubmitting(true);
+    setError(null);
+    try {
+      await updateLlmCreatorAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to update creator");
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  return (
+    <Dialog
+      title="Edit Creator"
+      controlled={{ isOpen: open, set: setOpen }}
+      styling={{ maxWidth: "512px" }}
+    >
+      <Dialog.Trigger>
+        <Button variant="outline" size="small" className="min-w-0">
+          Edit
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <form action={handleSubmit} className="space-y-4">
+          <input type="hidden" name="creator_id" value={creator.id} />
+
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div className="space-y-2">
+              <label className="text-sm font-medium">Name (slug)</label>
+              <input
+                required
+                name="name"
+                defaultValue={creator.name}
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
+              />
+            </div>
+            <div className="space-y-2">
+              <label className="text-sm font-medium">Display Name</label>
+              <input
+                required
+                name="display_name"
+                defaultValue={creator.display_name}
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
+              />
+            </div>
+          </div>
+
+          <div className="space-y-2">
+            <label className="text-sm font-medium">Description</label>
+            <textarea
+              name="description"
+              rows={2}
+              defaultValue={creator.description ?? ""}
+              className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
+            />
+          </div>
+
+          <div className="space-y-2">
+            <label className="text-sm font-medium">Website URL</label>
+            <input
+              name="website_url"
+              type="url"
+              defaultValue={creator.website_url ?? ""}
+              className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm"
+            />
+          </div>
+
+          {error && (
+            <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+              {error}
+            </div>
+          )}
+
+          <Dialog.Footer>
+            <Button
+              variant="ghost"
+              size="small"
+              type="button"
+              onClick={() => {
+                setOpen(false);
+                setError(null);
+              }}
+              disabled={isSubmitting}
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="primary"
+              size="small"
+              type="submit"
+              disabled={isSubmitting}
+            >
+              {isSubmitting ? "Updating..." : "Update"}
+            </Button>
+          </Dialog.Footer>
+        </form>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/DeleteCreatorModal.tsx

@@ -0,0 +1,107 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import type { LlmModelCreator } from "@/app/api/__generated__/models/llmModelCreator";
+import { deleteLlmCreatorAction } from "../actions";
+
+export function DeleteCreatorModal({ creator }: { creator: LlmModelCreator }) {
+  const [open, setOpen] = useState(false);
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const router = useRouter();
+
+  async function handleDelete(formData: FormData) {
+    setIsDeleting(true);
+    setError(null);
+    try {
+      await deleteLlmCreatorAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to delete creator");
+    } finally {
+      setIsDeleting(false);
+    }
+  }
+
+  return (
+    <Dialog
+      title="Delete Creator"
+      controlled={{ isOpen: open, set: setOpen }}
+      styling={{ maxWidth: "480px" }}
+    >
+      <Dialog.Trigger>
+        <Button
+          type="button"
+          variant="outline"
+          size="small"
+          className="min-w-0 text-destructive hover:bg-destructive/10"
+        >
+          Delete
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="space-y-4">
+          <div className="rounded-lg border border-amber-500/30 bg-amber-500/10 p-4 dark:border-amber-400/30 dark:bg-amber-400/10">
+            <div className="flex items-start gap-3">
+              <div className="flex-shrink-0 text-amber-600 dark:text-amber-400">
+                ⚠️
+              </div>
+              <div className="text-sm text-foreground">
+                <p className="font-semibold">You are about to delete:</p>
+                <p className="mt-1">
+                  <span className="font-medium">{creator.display_name}</span>{" "}
+                  <span className="text-muted-foreground">
+                    ({creator.name})
+                  </span>
+                </p>
+                <p className="mt-2 text-muted-foreground">
+                  Models using this creator will have their creator field
+                  cleared. This is safe and won&apos;t affect model
+                  functionality.
+                </p>
+              </div>
+            </div>
+          </div>
+
+          <form action={handleDelete} className="space-y-4">
+            <input type="hidden" name="creator_id" value={creator.id} />
+
+            {error && (
+              <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+                {error}
+              </div>
+            )}
+
+            <Dialog.Footer>
+              <Button
+                variant="ghost"
+                size="small"
+                onClick={() => {
+                  setOpen(false);
+                  setError(null);
+                }}
+                disabled={isDeleting}
+                type="button"
+              >
+                Cancel
+              </Button>
+              <Button
+                type="submit"
+                variant="primary"
+                size="small"
+                disabled={isDeleting}
+                className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+              >
+                {isDeleting ? "Deleting..." : "Delete Creator"}
+              </Button>
+            </Dialog.Footer>
+          </form>
+        </div>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/DeleteModelModal.tsx

@@ -0,0 +1,224 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import type { LlmModel } from "@/app/api/__generated__/models/llmModel";
+import { deleteLlmModelAction, fetchLlmModelUsage } from "../actions";
+
+export function DeleteModelModal({
+  model,
+  availableModels,
+}: {
+  model: LlmModel;
+  availableModels: LlmModel[];
+}) {
+  const router = useRouter();
+  const [open, setOpen] = useState(false);
+  const [selectedReplacement, setSelectedReplacement] = useState<string>("");
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [usageCount, setUsageCount] = useState<number | null>(null);
+  const [usageLoading, setUsageLoading] = useState(false);
+  const [usageError, setUsageError] = useState<string | null>(null);
+
+  // Filter out the current model and disabled models from replacement options
+  const replacementOptions = availableModels.filter(
+    (m) => m.id !== model.id && m.is_enabled,
+  );
+
+  // Check if migration is required (has blocks using this model)
+  const requiresMigration = usageCount !== null && usageCount > 0;
+
+  async function fetchUsage() {
+    setUsageLoading(true);
+    setUsageError(null);
+    try {
+      const usage = await fetchLlmModelUsage(model.id);
+      setUsageCount(usage.node_count);
+    } catch (err) {
+      console.error("Failed to fetch model usage:", err);
+      setUsageError("Failed to load usage count");
+      setUsageCount(null);
+    } finally {
+      setUsageLoading(false);
+    }
+  }
+
+  async function handleDelete(formData: FormData) {
+    setIsDeleting(true);
+    setError(null);
+    try {
+      await deleteLlmModelAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to delete model");
+    } finally {
+      setIsDeleting(false);
+    }
+  }
+
+  // Determine if delete button should be enabled
+  const canDelete =
+    !isDeleting &&
+    !usageLoading &&
+    usageCount !== null &&
+    (requiresMigration
+      ? selectedReplacement && replacementOptions.length > 0
+      : true);
+
+  return (
+    <Dialog
+      title="Delete Model"
+      controlled={{
+        isOpen: open,
+        set: async (isOpen) => {
+          setOpen(isOpen);
+          if (isOpen) {
+            setUsageCount(null);
+            setUsageError(null);
+            setError(null);
+            setSelectedReplacement("");
+            await fetchUsage();
+          }
+        },
+      }}
+      styling={{ maxWidth: "600px" }}
+    >
+      <Dialog.Trigger>
+        <Button
+          type="button"
+          variant="outline"
+          size="small"
+          className="min-w-0 text-destructive hover:bg-destructive/10"
+        >
+          Delete
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="mb-4 text-sm text-muted-foreground">
+          {requiresMigration
+            ? "This action cannot be undone. All workflows using this model will be migrated to the replacement model you select."
+            : "This action cannot be undone."}
+        </div>
+
+        <div className="space-y-4">
+          <div className="rounded-lg border border-amber-500/30 bg-amber-500/10 p-4 dark:border-amber-400/30 dark:bg-amber-400/10">
+            <div className="flex items-start gap-3">
+              <div className="flex-shrink-0 text-amber-600 dark:text-amber-400">
+                ⚠️
+              </div>
+              <div className="text-sm text-foreground">
+                <p className="font-semibold">You are about to delete:</p>
+                <p className="mt-1">
+                  <span className="font-medium">{model.display_name}</span>{" "}
+                  <span className="text-muted-foreground">({model.slug})</span>
+                </p>
+                {usageLoading && (
+                  <p className="mt-2 text-muted-foreground">
+                    Loading usage count...
+                  </p>
+                )}
+                {usageError && (
+                  <p className="mt-2 text-destructive">{usageError}</p>
+                )}
+                {!usageLoading && !usageError && usageCount !== null && (
+                  <p className="mt-2 font-semibold">
+                    Impact: {usageCount} block{usageCount !== 1 ? "s" : ""}{" "}
+                    currently use this model
+                  </p>
+                )}
+                {requiresMigration && (
+                  <p className="mt-2 text-muted-foreground">
+                    All workflows currently using this model will be
+                    automatically updated to use the replacement model you
+                    choose below.
+                  </p>
+                )}
+                {!usageLoading && usageCount === 0 && (
+                  <p className="mt-2 text-muted-foreground">
+                    No workflows are using this model. It can be safely deleted.
+                  </p>
+                )}
+              </div>
+            </div>
+          </div>
+
+          <form action={handleDelete} className="space-y-4">
+            <input type="hidden" name="model_id" value={model.id} />
+            <input
+              type="hidden"
+              name="replacement_model_slug"
+              value={selectedReplacement}
+            />
+
+            {requiresMigration && (
+              <label className="text-sm font-medium">
+                <span className="mb-2 block">
+                  Select Replacement Model{" "}
+                  <span className="text-destructive">*</span>
+                </span>
+                <select
+                  required
+                  value={selectedReplacement}
+                  onChange={(e) => setSelectedReplacement(e.target.value)}
+                  className="w-full rounded border border-input bg-background p-2 text-sm"
+                >
+                  <option value="">-- Choose a replacement model --</option>
+                  {replacementOptions.map((m) => (
+                    <option key={m.id} value={m.slug}>
+                      {m.display_name} ({m.slug})
+                    </option>
+                  ))}
+                </select>
+                {replacementOptions.length === 0 && (
+                  <p className="mt-2 text-xs text-destructive">
+                    No replacement models available. You must have at least one
+                    other enabled model before deleting this one.
+                  </p>
+                )}
+              </label>
+            )}
+
+            {error && (
+              <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+                {error}
+              </div>
+            )}
+
+            <Dialog.Footer>
+              <Button
+                variant="ghost"
+                size="small"
+                type="button"
+                onClick={() => {
+                  setOpen(false);
+                  setSelectedReplacement("");
+                  setError(null);
+                }}
+                disabled={isDeleting}
+              >
+                Cancel
+              </Button>
+              <Button
+                type="submit"
+                variant="primary"
+                size="small"
+                disabled={!canDelete}
+                className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+              >
+                {isDeleting
+                  ? "Deleting..."
+                  : requiresMigration
+                    ? "Delete and Migrate"
+                    : "Delete"}
+              </Button>
+            </Dialog.Footer>
+          </form>
+        </div>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/DeleteProviderModal.tsx

@@ -0,0 +1,129 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import type { LlmProvider } from "@/app/api/__generated__/models/llmProvider";
+import { deleteLlmProviderAction } from "../actions";
+
+export function DeleteProviderModal({ provider }: { provider: LlmProvider }) {
+  const [open, setOpen] = useState(false);
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const router = useRouter();
+
+  const modelCount = provider.models?.length ?? 0;
+  const hasModels = modelCount > 0;
+
+  async function handleDelete(formData: FormData) {
+    setIsDeleting(true);
+    setError(null);
+    try {
+      await deleteLlmProviderAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : "Failed to delete provider",
+      );
+    } finally {
+      setIsDeleting(false);
+    }
+  }
+
+  return (
+    <Dialog
+      title="Delete Provider"
+      controlled={{ isOpen: open, set: setOpen }}
+      styling={{ maxWidth: "480px" }}
+    >
+      <Dialog.Trigger>
+        <Button
+          type="button"
+          variant="outline"
+          size="small"
+          className="min-w-0 text-destructive hover:bg-destructive/10"
+        >
+          Delete
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="space-y-4">
+          <div
+            className={`rounded-lg border p-4 ${
+              hasModels
+                ? "border-destructive/30 bg-destructive/10"
+                : "border-amber-500/30 bg-amber-500/10 dark:border-amber-400/30 dark:bg-amber-400/10"
+            }`}
+          >
+            <div className="flex items-start gap-3">
+              <div
+                className={`flex-shrink-0 ${
+                  hasModels
+                    ? "text-destructive"
+                    : "text-amber-600 dark:text-amber-400"
+                }`}
+              >
+                {hasModels ? "🚫" : "⚠️"}
+              </div>
+              <div className="text-sm text-foreground">
+                <p className="font-semibold">You are about to delete:</p>
+                <p className="mt-1">
+                  <span className="font-medium">{provider.display_name}</span>{" "}
+                  <span className="text-muted-foreground">
+                    ({provider.name})
+                  </span>
+                </p>
+                {hasModels ? (
+                  <p className="mt-2 text-destructive">
+                    This provider has {modelCount} model(s). You must delete all
+                    models before you can delete this provider.
+                  </p>
+                ) : (
+                  <p className="mt-2 text-muted-foreground">
+                    This provider has no models and can be safely deleted.
+                  </p>
+                )}
+              </div>
+            </div>
+          </div>
+
+          <form action={handleDelete} className="space-y-4">
+            <input type="hidden" name="provider_id" value={provider.id} />
+
+            {error && (
+              <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+                {error}
+              </div>
+            )}
+
+            <Dialog.Footer>
+              <Button
+                variant="ghost"
+                size="small"
+                onClick={() => {
+                  setOpen(false);
+                  setError(null);
+                }}
+                disabled={isDeleting}
+                type="button"
+              >
+                Cancel
+              </Button>
+              <Button
+                type="submit"
+                variant="primary"
+                size="small"
+                disabled={isDeleting || hasModels}
+                className="bg-destructive text-destructive-foreground hover:bg-destructive/90 disabled:opacity-50"
+              >
+                {isDeleting ? "Deleting..." : "Delete Provider"}
+              </Button>
+            </Dialog.Footer>
+          </form>
+        </div>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/DisableModelModal.tsx

@@ -0,0 +1,288 @@
+"use client";
+
+import { useState } from "react";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import type { LlmModel } from "@/app/api/__generated__/models/llmModel";
+import { toggleLlmModelAction, fetchLlmModelUsage } from "../actions";
+
+export function DisableModelModal({
+  model,
+  availableModels,
+}: {
+  model: LlmModel;
+  availableModels: LlmModel[];
+}) {
+  const [open, setOpen] = useState(false);
+  const [isDisabling, setIsDisabling] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [usageCount, setUsageCount] = useState<number | null>(null);
+  const [selectedMigration, setSelectedMigration] = useState<string>("");
+  const [wantsMigration, setWantsMigration] = useState(false);
+  const [migrationReason, setMigrationReason] = useState("");
+  const [customCreditCost, setCustomCreditCost] = useState<string>("");
+
+  // Filter out the current model and disabled models from replacement options
+  const migrationOptions = availableModels.filter(
+    (m) => m.id !== model.id && m.is_enabled,
+  );
+
+  async function fetchUsage() {
+    try {
+      const usage = await fetchLlmModelUsage(model.id);
+      setUsageCount(usage.node_count);
+    } catch {
+      setUsageCount(null);
+    }
+  }
+
+  async function handleDisable(formData: FormData) {
+    setIsDisabling(true);
+    setError(null);
+    try {
+      await toggleLlmModelAction(formData);
+      setOpen(false);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to disable model");
+    } finally {
+      setIsDisabling(false);
+    }
+  }
+
+  function resetState() {
+    setError(null);
+    setSelectedMigration("");
+    setWantsMigration(false);
+    setMigrationReason("");
+    setCustomCreditCost("");
+  }
+
+  const hasUsage = usageCount !== null && usageCount > 0;
+
+  return (
+    <Dialog
+      title="Disable Model"
+      controlled={{
+        isOpen: open,
+        set: async (isOpen) => {
+          setOpen(isOpen);
+          if (isOpen) {
+            setUsageCount(null);
+            resetState();
+            await fetchUsage();
+          }
+        },
+      }}
+      styling={{ maxWidth: "600px" }}
+    >
+      <Dialog.Trigger>
+        <Button
+          type="button"
+          variant="outline"
+          size="small"
+          className="min-w-0"
+        >
+          Disable
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="mb-4 text-sm text-muted-foreground">
+          Disabling a model will hide it from users when creating new workflows.
+        </div>
+
+        <div className="space-y-4">
+          <div className="rounded-lg border border-amber-500/30 bg-amber-500/10 p-4 dark:border-amber-400/30 dark:bg-amber-400/10">
+            <div className="flex items-start gap-3">
+              <div className="flex-shrink-0 text-amber-600 dark:text-amber-400">
+                ⚠️
+              </div>
+              <div className="text-sm text-foreground">
+                <p className="font-semibold">You are about to disable:</p>
+                <p className="mt-1">
+                  <span className="font-medium">{model.display_name}</span>{" "}
+                  <span className="text-muted-foreground">({model.slug})</span>
+                </p>
+                {usageCount === null ? (
+                  <p className="mt-2 text-muted-foreground">
+                    Loading usage data...
+                  </p>
+                ) : usageCount > 0 ? (
+                  <p className="mt-2 font-semibold">
+                    Impact: {usageCount} block{usageCount !== 1 ? "s" : ""}{" "}
+                    currently use this model
+                  </p>
+                ) : (
+                  <p className="mt-2 text-muted-foreground">
+                    No workflows are currently using this model.
+                  </p>
+                )}
+              </div>
+            </div>
+          </div>
+
+          {hasUsage && (
+            <div className="space-y-4 rounded-lg border border-border bg-muted/50 p-4">
+              <label className="flex items-start gap-3">
+                <input
+                  type="checkbox"
+                  checked={wantsMigration}
+                  onChange={(e) => {
+                    setWantsMigration(e.target.checked);
+                    if (!e.target.checked) {
+                      setSelectedMigration("");
+                    }
+                  }}
+                  className="mt-1"
+                />
+                <div className="text-sm">
+                  <span className="font-medium">
+                    Migrate existing workflows to another model
+                  </span>
+                  <p className="mt-1 text-muted-foreground">
+                    Creates a revertible migration record. If unchecked,
+                    existing workflows will use automatic fallback to an enabled
+                    model from the same provider.
+                  </p>
+                </div>
+              </label>
+
+              {wantsMigration && (
+                <div className="space-y-4 border-t border-border pt-4">
+                  <label className="block text-sm font-medium">
+                    <span className="mb-2 block">
+                      Replacement Model{" "}
+                      <span className="text-destructive">*</span>
+                    </span>
+                    <select
+                      required
+                      value={selectedMigration}
+                      onChange={(e) => setSelectedMigration(e.target.value)}
+                      className="w-full rounded border border-input bg-background p-2 text-sm"
+                    >
+                      <option value="">-- Choose a replacement model --</option>
+                      {migrationOptions.map((m) => (
+                        <option key={m.id} value={m.slug}>
+                          {m.display_name} ({m.slug})
+                        </option>
+                      ))}
+                    </select>
+                    {migrationOptions.length === 0 && (
+                      <p className="mt-2 text-xs text-destructive">
+                        No other enabled models available for migration.
+                      </p>
+                    )}
+                  </label>
+
+                  <label className="block text-sm font-medium">
+                    <span className="mb-2 block">
+                      Migration Reason{" "}
+                      <span className="font-normal text-muted-foreground">
+                        (optional)
+                      </span>
+                    </span>
+                    <input
+                      type="text"
+                      value={migrationReason}
+                      onChange={(e) => setMigrationReason(e.target.value)}
+                      placeholder="e.g., Provider outage, Cost reduction"
+                      className="w-full rounded border border-input bg-background p-2 text-sm"
+                    />
+                    <p className="mt-1 text-xs text-muted-foreground">
+                      Helps track why the migration was made
+                    </p>
+                  </label>
+
+                  <label className="block text-sm font-medium">
+                    <span className="mb-2 block">
+                      Custom Credit Cost{" "}
+                      <span className="font-normal text-muted-foreground">
+                        (optional)
+                      </span>
+                    </span>
+                    <input
+                      type="number"
+                      min="0"
+                      value={customCreditCost}
+                      onChange={(e) => setCustomCreditCost(e.target.value)}
+                      placeholder="Leave blank to use target model's cost"
+                      className="w-full rounded border border-input bg-background p-2 text-sm"
+                    />
+                    <p className="mt-1 text-xs text-muted-foreground">
+                      Override pricing for migrated workflows. When set, billing
+                      will use this cost instead of the target model&apos;s
+                      cost.
+                    </p>
+                  </label>
+                </div>
+              )}
+            </div>
+          )}
+
+          <form action={handleDisable} className="space-y-4">
+            <input type="hidden" name="model_id" value={model.id} />
+            <input type="hidden" name="is_enabled" value="false" />
+            {wantsMigration && selectedMigration && (
+              <>
+                <input
+                  type="hidden"
+                  name="migrate_to_slug"
+                  value={selectedMigration}
+                />
+                {migrationReason && (
+                  <input
+                    type="hidden"
+                    name="migration_reason"
+                    value={migrationReason}
+                  />
+                )}
+                {customCreditCost && (
+                  <input
+                    type="hidden"
+                    name="custom_credit_cost"
+                    value={customCreditCost}
+                  />
+                )}
+              </>
+            )}
+
+            {error && (
+              <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+                {error}
+              </div>
+            )}
+
+            <Dialog.Footer>
+              <Button
+                variant="ghost"
+                size="small"
+                onClick={() => {
+                  setOpen(false);
+                  resetState();
+                }}
+                disabled={isDisabling}
+              >
+                Cancel
+              </Button>
+              <Button
+                type="submit"
+                variant="primary"
+                size="small"
+                disabled={
+                  isDisabling ||
+                  (wantsMigration && !selectedMigration) ||
+                  usageCount === null
+                }
+              >
+                {isDisabling
+                  ? "Disabling..."
+                  : wantsMigration && selectedMigration
+                    ? "Disable & Migrate"
+                    : "Disable Model"}
+              </Button>
+            </Dialog.Footer>
+          </form>
+        </div>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/EditModelModal.tsx

@@ -0,0 +1,223 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import type { LlmModel } from "@/app/api/__generated__/models/llmModel";
+import type { LlmModelCreator } from "@/app/api/__generated__/models/llmModelCreator";
+import type { LlmProvider } from "@/app/api/__generated__/models/llmProvider";
+import { updateLlmModelAction } from "../actions";
+
+export function EditModelModal({
+  model,
+  providers,
+  creators,
+}: {
+  model: LlmModel;
+  providers: LlmProvider[];
+  creators: LlmModelCreator[];
+}) {
+  const router = useRouter();
+  const [open, setOpen] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const cost = model.costs?.[0];
+  const provider = providers.find((p) => p.id === model.provider_id);
+
+  async function handleSubmit(formData: FormData) {
+    setIsSubmitting(true);
+    setError(null);
+    try {
+      await updateLlmModelAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to update model");
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  return (
+    <Dialog
+      title="Edit Model"
+      controlled={{ isOpen: open, set: setOpen }}
+      styling={{ maxWidth: "768px", maxHeight: "90vh", overflowY: "auto" }}
+    >
+      <Dialog.Trigger>
+        <Button variant="outline" size="small" className="min-w-0">
+          Edit
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="mb-4 text-sm text-muted-foreground">
+          Update model metadata and pricing information.
+        </div>
+        {error && (
+          <div className="mb-4 rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+            {error}
+          </div>
+        )}
+        <form action={handleSubmit} className="space-y-4">
+          <input type="hidden" name="model_id" value={model.id} />
+
+          <div className="grid gap-4 md:grid-cols-2">
+            <label className="text-sm font-medium">
+              Display Name
+              <input
+                required
+                name="display_name"
+                defaultValue={model.display_name}
+                className="mt-1 w-full rounded border border-input bg-background p-2 text-sm"
+              />
+            </label>
+            <label className="text-sm font-medium">
+              Provider
+              <select
+                required
+                name="provider_id"
+                className="mt-1 w-full rounded border border-input bg-background p-2 text-sm"
+                defaultValue={model.provider_id}
+              >
+                {providers.map((p) => (
+                  <option key={p.id} value={p.id}>
+                    {p.display_name} ({p.name})
+                  </option>
+                ))}
+              </select>
+              <span className="text-xs text-muted-foreground">
+                Who hosts/serves the model
+              </span>
+            </label>
+          </div>
+
+          <div className="grid gap-4 md:grid-cols-2">
+            <label className="text-sm font-medium">
+              Creator
+              <select
+                name="creator_id"
+                className="mt-1 w-full rounded border border-input bg-background p-2 text-sm"
+                defaultValue={model.creator_id ?? ""}
+              >
+                <option value="">No creator selected</option>
+                {creators.map((c) => (
+                  <option key={c.id} value={c.id}>
+                    {c.display_name} ({c.name})
+                  </option>
+                ))}
+              </select>
+              <span className="text-xs text-muted-foreground">
+                Who made/trained the model (e.g., OpenAI, Meta)
+              </span>
+            </label>
+          </div>
+
+          <label className="text-sm font-medium">
+            Description
+            <textarea
+              name="description"
+              rows={2}
+              defaultValue={model.description ?? ""}
+              className="mt-1 w-full rounded border border-input bg-background p-2 text-sm"
+              placeholder="Optional description..."
+            />
+          </label>
+
+          <div className="grid gap-4 md:grid-cols-2">
+            <label className="text-sm font-medium">
+              Context Window
+              <input
+                required
+                type="number"
+                name="context_window"
+                defaultValue={model.context_window}
+                className="mt-1 w-full rounded border border-input bg-background p-2 text-sm"
+                min={1}
+              />
+            </label>
+            <label className="text-sm font-medium">
+              Max Output Tokens
+              <input
+                type="number"
+                name="max_output_tokens"
+                defaultValue={model.max_output_tokens ?? undefined}
+                className="mt-1 w-full rounded border border-input bg-background p-2 text-sm"
+                min={1}
+              />
+            </label>
+          </div>
+
+          <div className="grid gap-4 md:grid-cols-2">
+            <label className="text-sm font-medium">
+              Credit Cost
+              <input
+                required
+                type="number"
+                name="credit_cost"
+                defaultValue={cost?.credit_cost ?? 0}
+                className="mt-1 w-full rounded border border-input bg-background p-2 text-sm"
+                min={0}
+              />
+              <span className="text-xs text-muted-foreground">
+                Credits charged per run
+              </span>
+            </label>
+            <label className="text-sm font-medium">
+              Credential Provider
+              <select
+                required
+                name="credential_provider"
+                defaultValue={cost?.credential_provider ?? provider?.name ?? ""}
+                className="mt-1 w-full rounded border border-input bg-background p-2 text-sm"
+              >
+                <option value="" disabled>
+                  Select provider
+                </option>
+                {providers.map((p) => (
+                  <option key={p.id} value={p.name}>
+                    {p.display_name} ({p.name})
+                  </option>
+                ))}
+              </select>
+              <span className="text-xs text-muted-foreground">
+                Must match a key in PROVIDER_CREDENTIALS
+              </span>
+            </label>
+          </div>
+          {/* Hidden defaults for credential_type and unit */}
+          <input
+            type="hidden"
+            name="credential_type"
+            value={
+              cost?.credential_type ??
+              provider?.default_credential_type ??
+              "api_key"
+            }
+          />
+          <input type="hidden" name="unit" value={cost?.unit ?? "RUN"} />
+
+          <Dialog.Footer>
+            <Button
+              type="button"
+              variant="ghost"
+              size="small"
+              onClick={() => setOpen(false)}
+              disabled={isSubmitting}
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="primary"
+              size="small"
+              type="submit"
+              disabled={isSubmitting}
+            >
+              {isSubmitting ? "Updating..." : "Update Model"}
+            </Button>
+          </Dialog.Footer>
+        </form>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/EditProviderModal.tsx

@@ -0,0 +1,263 @@
+"use client";
+
+import { useState } from "react";
+import { Dialog } from "@/components/molecules/Dialog/Dialog";
+import { Button } from "@/components/atoms/Button/Button";
+import { updateLlmProviderAction } from "../actions";
+import { useRouter } from "next/navigation";
+import type { LlmProvider } from "@/app/api/__generated__/models/llmProvider";
+
+export function EditProviderModal({ provider }: { provider: LlmProvider }) {
+  const [open, setOpen] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const router = useRouter();
+
+  async function handleSubmit(formData: FormData) {
+    setIsSubmitting(true);
+    setError(null);
+    try {
+      await updateLlmProviderAction(formData);
+      setOpen(false);
+      router.refresh();
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : "Failed to update provider",
+      );
+    } finally {
+      setIsSubmitting(false);
+    }
+  }
+
+  return (
+    <Dialog
+      title="Edit Provider"
+      controlled={{ isOpen: open, set: setOpen }}
+      styling={{ maxWidth: "768px", maxHeight: "90vh", overflowY: "auto" }}
+    >
+      <Dialog.Trigger>
+        <Button variant="outline" size="small">
+          Edit
+        </Button>
+      </Dialog.Trigger>
+      <Dialog.Content>
+        <div className="mb-4 text-sm text-muted-foreground">
+          Update provider configuration and capabilities.
+        </div>
+
+        <form action={handleSubmit} className="space-y-6">
+          <input type="hidden" name="provider_id" value={provider.id} />
+
+          {/* Basic Information */}
+          <div className="space-y-4">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">
+                Basic Information
+              </h3>
+              <p className="text-xs text-muted-foreground">
+                Core provider details
+              </p>
+            </div>
+            <div className="grid gap-4 sm:grid-cols-2">
+              <div className="space-y-2">
+                <label
+                  htmlFor="name"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Provider Slug <span className="text-destructive">*</span>
+                </label>
+                <input
+                  id="name"
+                  required
+                  name="name"
+                  defaultValue={provider.name}
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="e.g. openai"
+                />
+              </div>
+              <div className="space-y-2">
+                <label
+                  htmlFor="display_name"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Display Name <span className="text-destructive">*</span>
+                </label>
+                <input
+                  id="display_name"
+                  required
+                  name="display_name"
+                  defaultValue={provider.display_name}
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="OpenAI"
+                />
+              </div>
+            </div>
+            <div className="space-y-2">
+              <label
+                htmlFor="description"
+                className="text-sm font-medium text-foreground"
+              >
+                Description
+              </label>
+              <textarea
+                id="description"
+                name="description"
+                rows={3}
+                defaultValue={provider.description ?? ""}
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                placeholder="Optional description..."
+              />
+            </div>
+          </div>
+
+          {/* Default Credentials */}
+          <div className="space-y-4 border-t border-border pt-6">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">
+                Default Credentials
+              </h3>
+              <p className="text-xs text-muted-foreground">
+                Credential provider name that matches the key in{" "}
+                <code className="rounded bg-muted px-1 py-0.5 font-mono text-xs">
+                  PROVIDER_CREDENTIALS
+                </code>
+              </p>
+            </div>
+            <div className="grid gap-4 sm:grid-cols-2">
+              <div className="space-y-2">
+                <label
+                  htmlFor="default_credential_provider"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Credential Provider
+                </label>
+                <input
+                  id="default_credential_provider"
+                  name="default_credential_provider"
+                  defaultValue={provider.default_credential_provider ?? ""}
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="openai"
+                />
+              </div>
+              <div className="space-y-2">
+                <label
+                  htmlFor="default_credential_id"
+                  className="text-sm font-medium text-foreground"
+                >
+                  Credential ID
+                </label>
+                <input
+                  id="default_credential_id"
+                  name="default_credential_id"
+                  defaultValue={provider.default_credential_id ?? ""}
+                  className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                  placeholder="Optional credential ID"
+                />
+              </div>
+            </div>
+            <div className="space-y-2">
+              <label
+                htmlFor="default_credential_type"
+                className="text-sm font-medium text-foreground"
+              >
+                Credential Type
+              </label>
+              <input
+                id="default_credential_type"
+                name="default_credential_type"
+                defaultValue={provider.default_credential_type ?? "api_key"}
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm transition-colors placeholder:text-muted-foreground focus:border-primary focus:outline-none focus:ring-2 focus:ring-primary/20"
+                placeholder="api_key"
+              />
+            </div>
+          </div>
+
+          {/* Capabilities */}
+          <div className="space-y-4 border-t border-border pt-6">
+            <div className="space-y-1">
+              <h3 className="text-sm font-semibold text-foreground">
+                Capabilities
+              </h3>
+              <p className="text-xs text-muted-foreground">
+                Provider feature flags
+              </p>
+            </div>
+            <div className="grid gap-3 sm:grid-cols-2">
+              {[
+                {
+                  name: "supports_tools",
+                  label: "Supports tools",
+                  checked: provider.supports_tools,
+                },
+                {
+                  name: "supports_json_output",
+                  label: "Supports JSON output",
+                  checked: provider.supports_json_output,
+                },
+                {
+                  name: "supports_reasoning",
+                  label: "Supports reasoning",
+                  checked: provider.supports_reasoning,
+                },
+                {
+                  name: "supports_parallel_tool",
+                  label: "Supports parallel tool calls",
+                  checked: provider.supports_parallel_tool,
+                },
+              ].map(({ name, label, checked }) => (
+                <div
+                  key={name}
+                  className="flex items-center gap-3 rounded-md border border-border bg-muted/30 px-4 py-3 transition-colors hover:bg-muted/50"
+                >
+                  <input type="hidden" name={name} value="off" />
+                  <input
+                    id={name}
+                    type="checkbox"
+                    name={name}
+                    defaultChecked={checked}
+                    className="h-4 w-4 rounded border-input"
+                  />
+                  <label
+                    htmlFor={name}
+                    className="text-sm font-medium text-foreground"
+                  >
+                    {label}
+                  </label>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {error && (
+            <div className="rounded-lg border border-destructive/30 bg-destructive/10 p-3 text-sm text-destructive">
+              {error}
+            </div>
+          )}
+
+          <Dialog.Footer>
+            <Button
+              variant="ghost"
+              size="small"
+              type="button"
+              onClick={() => {
+                setOpen(false);
+                setError(null);
+              }}
+              disabled={isSubmitting}
+            >
+              Cancel
+            </Button>
+            <Button
+              variant="primary"
+              size="small"
+              type="submit"
+              disabled={isSubmitting}
+            >
+              {isSubmitting ? "Saving..." : "Save Changes"}
+            </Button>
+          </Dialog.Footer>
+        </form>
+      </Dialog.Content>
+    </Dialog>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/LlmRegistryDashboard.tsx

@@ -0,0 +1,131 @@
+"use client";
+
+import type { LlmModel } from "@/app/api/__generated__/models/llmModel";
+import type { LlmModelCreator } from "@/app/api/__generated__/models/llmModelCreator";
+import type { LlmModelMigration } from "@/app/api/__generated__/models/llmModelMigration";
+import type { LlmProvider } from "@/app/api/__generated__/models/llmProvider";
+import { ErrorBoundary } from "@/components/molecules/ErrorBoundary/ErrorBoundary";
+import { ErrorCard } from "@/components/molecules/ErrorCard/ErrorCard";
+import { AddProviderModal } from "./AddProviderModal";
+import { AddModelModal } from "./AddModelModal";
+import { AddCreatorModal } from "./AddCreatorModal";
+import { ProviderList } from "./ProviderList";
+import { ModelsTable } from "./ModelsTable";
+import { MigrationsTable } from "./MigrationsTable";
+import { CreatorsTable } from "./CreatorsTable";
+import { RecommendedModelSelector } from "./RecommendedModelSelector";
+
+interface Props {
+  providers: LlmProvider[];
+  models: LlmModel[];
+  migrations: LlmModelMigration[];
+  creators: LlmModelCreator[];
+}
+
+function AdminErrorFallback() {
+  return (
+    <div className="mx-auto max-w-xl p-6">
+      <ErrorCard
+        responseError={{
+          message:
+            "An error occurred while loading the LLM Registry. Please refresh the page.",
+        }}
+        context="llm-registry"
+        onRetry={() => window.location.reload()}
+      />
+    </div>
+  );
+}
+
+export function LlmRegistryDashboard({
+  providers,
+  models,
+  migrations,
+  creators,
+}: Props) {
+  return (
+    <ErrorBoundary fallback={<AdminErrorFallback />} context="llm-registry">
+      <div className="mx-auto p-6">
+        <div className="flex flex-col gap-6">
+          {/* Header */}
+          <div>
+            <h1 className="text-3xl font-bold">LLM Registry</h1>
+            <p className="text-muted-foreground">
+              Manage providers, creators, models, and credit pricing
+            </p>
+          </div>
+
+          {/* Active Migrations Section - Only show if there are migrations */}
+          {migrations.length > 0 && (
+            <div className="rounded-lg border border-primary/30 bg-primary/5 p-6 shadow-sm">
+              <div className="mb-4">
+                <h2 className="text-xl font-semibold">Active Migrations</h2>
+                <p className="mt-1 text-sm text-muted-foreground">
+                  These migrations can be reverted to restore workflows to their
+                  original model
+                </p>
+              </div>
+              <MigrationsTable migrations={migrations} />
+            </div>
+          )}
+
+          {/* Providers & Creators Section - Side by Side */}
+          <div className="grid gap-6 lg:grid-cols-2">
+            {/* Providers */}
+            <div className="rounded-lg border bg-card p-6 shadow-sm">
+              <div className="mb-4 flex items-center justify-between">
+                <div>
+                  <h2 className="text-xl font-semibold">Providers</h2>
+                  <p className="mt-1 text-sm text-muted-foreground">
+                    Who hosts/serves the models
+                  </p>
+                </div>
+                <AddProviderModal />
+              </div>
+              <ProviderList providers={providers} />
+            </div>
+
+            {/* Creators */}
+            <div className="rounded-lg border bg-card p-6 shadow-sm">
+              <div className="mb-4 flex items-center justify-between">
+                <div>
+                  <h2 className="text-xl font-semibold">Creators</h2>
+                  <p className="mt-1 text-sm text-muted-foreground">
+                    Who made/trained the models
+                  </p>
+                </div>
+                <AddCreatorModal />
+              </div>
+              <CreatorsTable creators={creators} />
+            </div>
+          </div>
+
+          {/* Models Section */}
+          <div className="rounded-lg border bg-card p-6 shadow-sm">
+            <div className="mb-4 flex items-center justify-between">
+              <div>
+                <h2 className="text-xl font-semibold">Models</h2>
+                <p className="mt-1 text-sm text-muted-foreground">
+                  Toggle availability, adjust context windows, and update credit
+                  pricing
+                </p>
+              </div>
+              <AddModelModal providers={providers} creators={creators} />
+            </div>
+
+            {/* Recommended Model Selector */}
+            <div className="mb-6">
+              <RecommendedModelSelector models={models} />
+            </div>
+
+            <ModelsTable
+              models={models}
+              providers={providers}
+              creators={creators}
+            />
+          </div>
+        </div>
+      </div>
+    </ErrorBoundary>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/MigrationsTable.tsx

@@ -0,0 +1,133 @@
+"use client";
+
+import { useState } from "react";
+import type { LlmModelMigration } from "@/app/api/__generated__/models/llmModelMigration";
+import { Button } from "@/components/atoms/Button/Button";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/atoms/Table/Table";
+import { revertLlmMigrationAction } from "../actions";
+
+export function MigrationsTable({
+  migrations,
+}: {
+  migrations: LlmModelMigration[];
+}) {
+  if (!migrations.length) {
+    return (
+      <div className="rounded-lg border border-dashed border-border p-6 text-center text-sm text-muted-foreground">
+        No active migrations. Migrations are created when you disable a model
+        with the &quot;Migrate existing workflows&quot; option.
+      </div>
+    );
+  }
+
+  return (
+    <div className="rounded-lg border">
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Migration</TableHead>
+            <TableHead>Reason</TableHead>
+            <TableHead>Nodes Affected</TableHead>
+            <TableHead>Custom Cost</TableHead>
+            <TableHead>Created</TableHead>
+            <TableHead className="text-right">Actions</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {migrations.map((migration) => (
+            <MigrationRow key={migration.id} migration={migration} />
+          ))}
+        </TableBody>
+      </Table>
+    </div>
+  );
+}
+
+function MigrationRow({ migration }: { migration: LlmModelMigration }) {
+  const [isReverting, setIsReverting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  async function handleRevert(formData: FormData) {
+    setIsReverting(true);
+    setError(null);
+    try {
+      await revertLlmMigrationAction(formData);
+    } catch (err) {
+      setError(
+        err instanceof Error ? err.message : "Failed to revert migration",
+      );
+    } finally {
+      setIsReverting(false);
+    }
+  }
+
+  const createdDate = new Date(migration.created_at);
+
+  return (
+    <>
+      <TableRow>
+        <TableCell>
+          <div className="text-sm">
+            <span className="font-medium">{migration.source_model_slug}</span>
+            <span className="mx-2 text-muted-foreground">→</span>
+            <span className="font-medium">{migration.target_model_slug}</span>
+          </div>
+        </TableCell>
+        <TableCell>
+          <div className="text-sm text-muted-foreground">
+            {migration.reason || "—"}
+          </div>
+        </TableCell>
+        <TableCell>
+          <div className="text-sm">{migration.node_count}</div>
+        </TableCell>
+        <TableCell>
+          <div className="text-sm">
+            {migration.custom_credit_cost !== null &&
+            migration.custom_credit_cost !== undefined
+              ? `${migration.custom_credit_cost} credits`
+              : "—"}
+          </div>
+        </TableCell>
+        <TableCell>
+          <div className="text-sm text-muted-foreground">
+            {createdDate.toLocaleDateString()}{" "}
+            {createdDate.toLocaleTimeString([], {
+              hour: "2-digit",
+              minute: "2-digit",
+            })}
+          </div>
+        </TableCell>
+        <TableCell className="text-right">
+          <form action={handleRevert} className="inline">
+            <input type="hidden" name="migration_id" value={migration.id} />
+            <Button
+              type="submit"
+              variant="outline"
+              size="small"
+              disabled={isReverting}
+            >
+              {isReverting ? "Reverting..." : "Revert"}
+            </Button>
+          </form>
+        </TableCell>
+      </TableRow>
+      {error && (
+        <TableRow>
+          <TableCell colSpan={6}>
+            <div className="rounded border border-destructive/30 bg-destructive/10 p-2 text-sm text-destructive">
+              {error}
+            </div>
+          </TableCell>
+        </TableRow>
+      )}
+    </>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/ModelsTable.tsx

@@ -0,0 +1,265 @@
+"use client";
+
+import { useState, useEffect, useRef } from "react";
+import type { LlmModel } from "@/app/api/__generated__/models/llmModel";
+import type { LlmModelCreator } from "@/app/api/__generated__/models/llmModelCreator";
+import type { LlmProvider } from "@/app/api/__generated__/models/llmProvider";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/atoms/Table/Table";
+import { Button } from "@/components/atoms/Button/Button";
+import { toggleLlmModelAction } from "../actions";
+import { DeleteModelModal } from "./DeleteModelModal";
+import { DisableModelModal } from "./DisableModelModal";
+import { EditModelModal } from "./EditModelModal";
+import { Star, Spinner } from "@phosphor-icons/react";
+import { getV2ListLlmModels } from "@/app/api/__generated__/endpoints/admin/admin";
+
+const PAGE_SIZE = 50;
+
+export function ModelsTable({
+  models: initialModels,
+  providers,
+  creators,
+}: {
+  models: LlmModel[];
+  providers: LlmProvider[];
+  creators: LlmModelCreator[];
+}) {
+  const [models, setModels] = useState<LlmModel[]>(initialModels);
+  const [currentPage, setCurrentPage] = useState(1);
+  const [hasMore, setHasMore] = useState(initialModels.length === PAGE_SIZE);
+  const [isLoading, setIsLoading] = useState(false);
+  const loadedPagesRef = useRef(1);
+
+  // Sync with parent when initialModels changes (e.g., after enable/disable)
+  // Re-fetch all loaded pages to preserve expanded state
+  useEffect(() => {
+    async function refetchAllPages() {
+      const pagesToLoad = loadedPagesRef.current;
+
+      if (pagesToLoad === 1) {
+        // Only first page loaded, just use initialModels
+        setModels(initialModels);
+        setHasMore(initialModels.length === PAGE_SIZE);
+        return;
+      }
+
+      // Re-fetch all pages we had loaded
+      const allModels: LlmModel[] = [...initialModels];
+      let lastPageHadFullResults = initialModels.length === PAGE_SIZE;
+
+      for (let page = 2; page <= pagesToLoad; page++) {
+        try {
+          const response = await getV2ListLlmModels({
+            page,
+            page_size: PAGE_SIZE,
+          });
+          if (response.status === 200) {
+            allModels.push(...response.data.models);
+            lastPageHadFullResults = response.data.models.length === PAGE_SIZE;
+          }
+        } catch (err) {
+          console.error(`Error refetching page ${page}:`, err);
+          break;
+        }
+      }
+
+      setModels(allModels);
+      setHasMore(lastPageHadFullResults);
+    }
+
+    refetchAllPages();
+  }, [initialModels]);
+
+  async function loadMore() {
+    if (isLoading) return;
+    setIsLoading(true);
+
+    try {
+      const nextPage = currentPage + 1;
+      const response = await getV2ListLlmModels({
+        page: nextPage,
+        page_size: PAGE_SIZE,
+      });
+
+      if (response.status === 200) {
+        setModels((prev) => [...prev, ...response.data.models]);
+        setCurrentPage(nextPage);
+        loadedPagesRef.current = nextPage;
+        setHasMore(response.data.models.length === PAGE_SIZE);
+      }
+    } catch (err) {
+      console.error("Error loading more models:", err);
+    } finally {
+      setIsLoading(false);
+    }
+  }
+  if (!models.length) {
+    return (
+      <div className="rounded-lg border border-dashed border-border p-6 text-center text-sm text-muted-foreground">
+        No models registered yet.
+      </div>
+    );
+  }
+
+  const providerLookup = new Map(
+    providers.map((provider) => [provider.id, provider]),
+  );
+
+  return (
+    <div>
+      <div className="rounded-lg border">
+        <Table>
+          <TableHeader>
+            <TableRow>
+              <TableHead>Model</TableHead>
+              <TableHead>Provider</TableHead>
+              <TableHead>Creator</TableHead>
+              <TableHead>Context Window</TableHead>
+              <TableHead>Max Output</TableHead>
+              <TableHead>Cost</TableHead>
+              <TableHead>Status</TableHead>
+              <TableHead>Actions</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            {models.map((model) => {
+              const cost = model.costs?.[0];
+              const provider = providerLookup.get(model.provider_id);
+              return (
+                <TableRow
+                  key={model.id}
+                  className={model.is_enabled ? "" : "opacity-60"}
+                >
+                  <TableCell>
+                    <div className="font-medium">{model.display_name}</div>
+                    <div className="text-xs text-muted-foreground">
+                      {model.slug}
+                    </div>
+                  </TableCell>
+                  <TableCell>
+                    {provider ? (
+                      <>
+                        <div>{provider.display_name}</div>
+                        <div className="text-xs text-muted-foreground">
+                          {provider.name}
+                        </div>
+                      </>
+                    ) : (
+                      model.provider_id
+                    )}
+                  </TableCell>
+                  <TableCell>
+                    {model.creator ? (
+                      <>
+                        <div>{model.creator.display_name}</div>
+                        <div className="text-xs text-muted-foreground">
+                          {model.creator.name}
+                        </div>
+                      </>
+                    ) : (
+                      <span className="text-muted-foreground">—</span>
+                    )}
+                  </TableCell>
+                  <TableCell>{model.context_window.toLocaleString()}</TableCell>
+                  <TableCell>
+                    {model.max_output_tokens
+                      ? model.max_output_tokens.toLocaleString()
+                      : "—"}
+                  </TableCell>
+                  <TableCell>
+                    {cost ? (
+                      <>
+                        <div className="font-medium">
+                          {cost.credit_cost} credits
+                        </div>
+                        <div className="text-xs text-muted-foreground">
+                          {cost.credential_provider}
+                        </div>
+                      </>
+                    ) : (
+                      "—"
+                    )}
+                  </TableCell>
+                  <TableCell>
+                    <div className="flex flex-col gap-1">
+                      <span
+                        className={`inline-flex rounded-full px-2.5 py-1 text-xs font-semibold ${
+                          model.is_enabled
+                            ? "bg-primary/10 text-primary"
+                            : "bg-muted text-muted-foreground"
+                        }`}
+                      >
+                        {model.is_enabled ? "Enabled" : "Disabled"}
+                      </span>
+                      {model.is_recommended && (
+                        <span className="inline-flex items-center gap-1 rounded-full bg-amber-500/10 px-2.5 py-1 text-xs font-semibold text-amber-600 dark:text-amber-400">
+                          <Star size={12} weight="fill" />
+                          Recommended
+                        </span>
+                      )}
+                    </div>
+                  </TableCell>
+                  <TableCell>
+                    <div className="flex items-center justify-end gap-2">
+                      {model.is_enabled ? (
+                        <DisableModelModal
+                          model={model}
+                          availableModels={models}
+                        />
+                      ) : (
+                        <EnableModelButton modelId={model.id} />
+                      )}
+                      <EditModelModal
+                        model={model}
+                        providers={providers}
+                        creators={creators}
+                      />
+                      <DeleteModelModal
+                        model={model}
+                        availableModels={models}
+                      />
+                    </div>
+                  </TableCell>
+                </TableRow>
+              );
+            })}
+          </TableBody>
+        </Table>
+      </div>
+
+      {hasMore && (
+        <div className="mt-4 flex justify-center">
+          <Button onClick={loadMore} disabled={isLoading} variant="outline">
+            {isLoading ? (
+              <>
+                <Spinner className="mr-2 h-4 w-4 animate-spin" />
+                Loading...
+              </>
+            ) : (
+              "Load More"
+            )}
+          </Button>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function EnableModelButton({ modelId }: { modelId: string }) {
+  return (
+    <form action={toggleLlmModelAction} className="inline">
+      <input type="hidden" name="model_id" value={modelId} />
+      <input type="hidden" name="is_enabled" value="true" />
+      <Button type="submit" variant="outline" size="small" className="min-w-0">
+        Enable
+      </Button>
+    </form>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/ProviderList.tsx

@@ -0,0 +1,94 @@
+"use client";
+
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/atoms/Table/Table";
+import type { LlmProvider } from "@/app/api/__generated__/models/llmProvider";
+import { DeleteProviderModal } from "./DeleteProviderModal";
+import { EditProviderModal } from "./EditProviderModal";
+
+export function ProviderList({ providers }: { providers: LlmProvider[] }) {
+  if (!providers.length) {
+    return (
+      <div className="rounded-lg border border-dashed border-border p-6 text-center text-sm text-muted-foreground">
+        No providers configured yet.
+      </div>
+    );
+  }
+
+  return (
+    <div className="rounded-lg border">
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Name</TableHead>
+            <TableHead>Display Name</TableHead>
+            <TableHead>Default Credential</TableHead>
+            <TableHead>Capabilities</TableHead>
+            <TableHead>Models</TableHead>
+            <TableHead className="w-[100px]">Actions</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {providers.map((provider) => (
+            <TableRow key={provider.id}>
+              <TableCell className="font-medium">{provider.name}</TableCell>
+              <TableCell>{provider.display_name}</TableCell>
+              <TableCell>
+                {provider.default_credential_provider
+                  ? `${provider.default_credential_provider} (${provider.default_credential_id ?? "id?"})`
+                  : "—"}
+              </TableCell>
+              <TableCell className="text-sm text-muted-foreground">
+                <div className="flex flex-wrap gap-2">
+                  {provider.supports_tools && (
+                    <span className="rounded bg-muted px-2 py-0.5 text-xs">
+                      Tools
+                    </span>
+                  )}
+                  {provider.supports_json_output && (
+                    <span className="rounded bg-muted px-2 py-0.5 text-xs">
+                      JSON
+                    </span>
+                  )}
+                  {provider.supports_reasoning && (
+                    <span className="rounded bg-muted px-2 py-0.5 text-xs">
+                      Reasoning
+                    </span>
+                  )}
+                  {provider.supports_parallel_tool && (
+                    <span className="rounded bg-muted px-2 py-0.5 text-xs">
+                      Parallel Tools
+                    </span>
+                  )}
+                </div>
+              </TableCell>
+              <TableCell className="text-sm">
+                <span
+                  className={
+                    (provider.models?.length ?? 0) > 0
+                      ? "text-foreground"
+                      : "text-muted-foreground"
+                  }
+                >
+                  {provider.models?.length ?? 0}
+                </span>
+              </TableCell>
+              <TableCell>
+                <div className="flex gap-2">
+                  <EditProviderModal provider={provider} />
+                  <DeleteProviderModal provider={provider} />
+                </div>
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/components/RecommendedModelSelector.tsx

@@ -0,0 +1,87 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import type { LlmModel } from "@/app/api/__generated__/models/llmModel";
+import { Button } from "@/components/atoms/Button/Button";
+import { setRecommendedModelAction } from "../actions";
+import { Star } from "@phosphor-icons/react";
+
+export function RecommendedModelSelector({ models }: { models: LlmModel[] }) {
+  const router = useRouter();
+  const enabledModels = models.filter((m) => m.is_enabled);
+  const currentRecommended = models.find((m) => m.is_recommended);
+
+  const [selectedModelId, setSelectedModelId] = useState<string>(
+    currentRecommended?.id || "",
+  );
+  const [isSaving, setIsSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const hasChanges = selectedModelId !== (currentRecommended?.id || "");
+
+  async function handleSave() {
+    if (!selectedModelId) return;
+
+    setIsSaving(true);
+    setError(null);
+    try {
+      const formData = new FormData();
+      formData.set("model_id", selectedModelId);
+      await setRecommendedModelAction(formData);
+      router.refresh();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to save");
+    } finally {
+      setIsSaving(false);
+    }
+  }
+
+  return (
+    <div className="rounded-lg border border-border bg-card p-4">
+      <div className="mb-3 flex items-center gap-2">
+        <Star size={20} weight="fill" className="text-amber-500" />
+        <h3 className="text-sm font-semibold">Recommended Model</h3>
+      </div>
+      <p className="mb-3 text-xs text-muted-foreground">
+        The recommended model is shown as the default suggestion in model
+        selection dropdowns throughout the platform.
+      </p>
+
+      <div className="flex items-center gap-3">
+        <select
+          value={selectedModelId}
+          onChange={(e) => setSelectedModelId(e.target.value)}
+          className="flex-1 rounded-md border border-input bg-background px-3 py-2 text-sm"
+          disabled={isSaving}
+        >
+          <option value="">-- Select a model --</option>
+          {enabledModels.map((model) => (
+            <option key={model.id} value={model.id}>
+              {model.display_name} ({model.slug})
+            </option>
+          ))}
+        </select>
+
+        <Button
+          type="button"
+          variant="primary"
+          size="small"
+          onClick={handleSave}
+          disabled={!hasChanges || !selectedModelId || isSaving}
+        >
+          {isSaving ? "Saving..." : "Save"}
+        </Button>
+      </div>
+
+      {error && <p className="mt-2 text-xs text-destructive">{error}</p>}
+
+      {currentRecommended && !hasChanges && (
+        <p className="mt-2 text-xs text-muted-foreground">
+          Currently set to:{" "}
+          <span className="font-medium">{currentRecommended.display_name}</span>
+        </p>
+      )}
+    </div>
+  );
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/getLlmRegistryPage.ts

@@ -0,0 +1,46 @@
+/**
+ * Server-side data fetching for LLM Registry page.
+ */
+
+import {
+  fetchLlmCreators,
+  fetchLlmMigrations,
+  fetchLlmModels,
+  fetchLlmProviders,
+} from "./actions";
+
+export async function getLlmRegistryPageData() {
+  // Fetch providers and models (required)
+  const [providersResponse, modelsResponse] = await Promise.all([
+    fetchLlmProviders(),
+    fetchLlmModels(),
+  ]);
+
+  // Fetch migrations separately with fallback (table might not exist yet)
+  let migrations: Awaited<ReturnType<typeof fetchLlmMigrations>>["migrations"] =
+    [];
+  try {
+    const migrationsResponse = await fetchLlmMigrations(false);
+    migrations = migrationsResponse.migrations;
+  } catch {
+    // Migrations table might not exist yet - that's ok, just show empty list
+    console.warn("Could not fetch migrations - table may not exist yet");
+  }
+
+  // Fetch creators separately with fallback (table might not exist yet)
+  let creators: Awaited<ReturnType<typeof fetchLlmCreators>>["creators"] = [];
+  try {
+    const creatorsResponse = await fetchLlmCreators();
+    creators = creatorsResponse.creators;
+  } catch {
+    // Creators table might not exist yet - that's ok, just show empty list
+    console.warn("Could not fetch creators - table may not exist yet");
+  }
+
+  return {
+    providers: providersResponse.providers,
+    models: modelsResponse.models,
+    migrations,
+    creators,
+  };
+}

autogpt_platform/frontend/src/app/(platform)/admin/llms/page.tsx

@@ -0,0 +1,14 @@
+import { withRoleAccess } from "@/lib/withRoleAccess";
+import { getLlmRegistryPageData } from "./getLlmRegistryPage";
+import { LlmRegistryDashboard } from "./components/LlmRegistryDashboard";
+
+async function LlmRegistryPage() {
+  const data = await getLlmRegistryPageData();
+  return <LlmRegistryDashboard {...data} />;
+}
+
+export default async function AdminLlmRegistryPage() {
+  const withAdminAccess = await withRoleAccess(["admin"]);
+  const ProtectedLlmRegistryPage = await withAdminAccess(LlmRegistryPage);
+  return <ProtectedLlmRegistryPage />;
+}

autogpt_platform/frontend/src/app/(platform)/build/components/NewControlPanel/NewBlockMenu/AllBlocksContent/useAllBlockContent.tsx

@@ -7,8 +7,9 @@ import { BlockCategoryResponse } from "@/app/api/__generated__/models/blockCateg
 import { BlockResponse } from "@/app/api/__generated__/models/blockResponse";
 import * as Sentry from "@sentry/nextjs";
 import { getQueryClient } from "@/lib/react-query/queryClient";
-import { useState } from "react";
+import { useState, useEffect } from "react";
 import { useToast } from "@/components/molecules/Toast/use-toast";
+import BackendApi from "@/lib/autogpt-server-api";
 
 export const useAllBlockContent = () => {
   const { toast } = useToast();
@@ -93,6 +94,32 @@ export const useAllBlockContent = () => {
   const isErrorOnLoadingMore = (categoryName: string) =>
     errorLoadingCategories.has(categoryName);
 
+  // Listen for LLM registry refresh notifications
+  useEffect(() => {
+    const api = new BackendApi();
+    const queryClient = getQueryClient();
+
+    const handleNotification = (notification: any) => {
+      if (
+        notification?.type === "LLM_REGISTRY_REFRESH" ||
+        notification?.event === "registry_updated"
+      ) {
+        // Invalidate all block-related queries to force refresh
+        const categoriesQueryKey = getGetV2GetBuilderBlockCategoriesQueryKey();
+        queryClient.invalidateQueries({ queryKey: categoriesQueryKey });
+      }
+    };
+
+    const unsubscribe = api.onWebSocketMessage(
+      "notification",
+      handleNotification,
+    );
+
+    return () => {
+      unsubscribe();
+    };
+  }, []);
+
   return {
     data,
     isLoading,

autogpt_platform/frontend/src/components/atoms/Table/Table.tsx

@@ -0,0 +1,123 @@
+import * as React from "react";
+
+import { cn } from "@/lib/utils";
+
+const Table = React.forwardRef<
+  HTMLTableElement,
+  React.HTMLAttributes<HTMLTableElement>
+>(({ className, ...props }, ref) => (
+  <div className="relative w-full overflow-auto">
+    <table
+      ref={ref}
+      className={cn("w-full caption-bottom text-sm", className)}
+      {...props}
+    />
+  </div>
+));
+Table.displayName = "Table";
+
+const TableHeader = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <thead ref={ref} className={cn("[&_tr]:border-b", className)} {...props} />
+));
+TableHeader.displayName = "TableHeader";
+
+const TableBody = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <tbody
+    ref={ref}
+    className={cn("[&_tr:last-child]:border-0", className)}
+    {...props}
+  />
+));
+TableBody.displayName = "TableBody";
+
+const TableFooter = React.forwardRef<
+  HTMLTableSectionElement,
+  React.HTMLAttributes<HTMLTableSectionElement>
+>(({ className, ...props }, ref) => (
+  <tfoot
+    ref={ref}
+    className={cn(
+      "border-t bg-neutral-100/50 font-medium dark:bg-neutral-800/50 [&>tr]:last:border-b-0",
+      className,
+    )}
+    {...props}
+  />
+));
+TableFooter.displayName = "TableFooter";
+
+const TableRow = React.forwardRef<
+  HTMLTableRowElement,
+  React.HTMLAttributes<HTMLTableRowElement>
+>(({ className, ...props }, ref) => (
+  <tr
+    ref={ref}
+    className={cn(
+      "border-b transition-colors data-[state=selected]:bg-neutral-100 hover:bg-neutral-100/50 dark:data-[state=selected]:bg-neutral-800 dark:hover:bg-neutral-800/50",
+      className,
+    )}
+    {...props}
+  />
+));
+TableRow.displayName = "TableRow";
+
+const TableHead = React.forwardRef<
+  HTMLTableCellElement,
+  React.ThHTMLAttributes<HTMLTableCellElement>
+>(({ className, ...props }, ref) => (
+  <th
+    ref={ref}
+    className={cn(
+      "h-10 px-2 text-left align-middle font-medium text-neutral-500 dark:text-neutral-400 [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]",
+      className,
+    )}
+    {...props}
+  />
+));
+TableHead.displayName = "TableHead";
+
+const TableCell = React.forwardRef<
+  HTMLTableCellElement,
+  React.TdHTMLAttributes<HTMLTableCellElement>
+>(({ className, ...props }, ref) => (
+  <td
+    ref={ref}
+    className={cn(
+      "p-2 align-middle [&:has([role=checkbox])]:pr-0 [&>[role=checkbox]]:translate-y-[2px]",
+      className,
+    )}
+    {...props}
+  />
+));
+TableCell.displayName = "TableCell";
+
+const TableCaption = React.forwardRef<
+  HTMLTableCaptionElement,
+  React.HTMLAttributes<HTMLTableCaptionElement>
+>(({ className, ...props }, ref) => (
+  <caption
+    ref={ref}
+    className={cn(
+      "mt-4 text-sm text-neutral-500 dark:text-neutral-400",
+      className,
+    )}
+    {...props}
+  />
+));
+TableCaption.displayName = "TableCaption";
+
+export {
+  Table,
+  TableHeader,
+  TableBody,
+  TableFooter,
+  TableHead,
+  TableRow,
+  TableCell,
+  TableCaption,
+};

autogpt_platform/frontend/src/components/molecules/Table/Table.tsx

@@ -6,7 +6,7 @@ import {
   TableHead,
   TableHeader,
   TableRow,
-} from "@/components/__legacy__/ui/table";
+} from "@/components/atoms/Table/Table";
 import { Button } from "@/components/atoms/Button/Button";
 import { Input } from "@/components/atoms/Input/Input";
 import { Text } from "@/components/atoms/Text/Text";

autogpt_platform/frontend/src/components/renderers/InputRenderer/utils/input-schema-pre-processor.ts

@@ -1,8 +1,19 @@
 import { RJSFSchema } from "@rjsf/utils";
 
+/**
+ * Options type for fields with label/value pairs (e.g., LLM model picker)
+ */
+type SchemaOption = {
+  label: string;
+  value: string;
+  group?: string;
+  description?: string;
+};
+
 /**
  * Pre-processes the input schema to ensure all properties have a type defined.
  * If a property doesn't have a type, it assigns a union of all supported JSON Schema types.
+ * Also converts custom 'options' array to RJSF's enum/enumNames format.
  */
 
 export function preprocessInputSchema(schema: RJSFSchema): RJSFSchema {
@@ -20,6 +31,20 @@ export function preprocessInputSchema(schema: RJSFSchema): RJSFSchema {
       if (property && typeof property === "object") {
         const processedProperty = { ...property };
 
+        // Convert custom 'options' array to RJSF's enum/enumNames format
+        // This enables proper label display for dropdowns like the LLM model picker
+        if (
+          (processedProperty as any).options &&
+          Array.isArray((processedProperty as any).options) &&
+          (processedProperty as any).options.length > 0
+        ) {
+          const options = (processedProperty as any).options as SchemaOption[];
+          processedProperty.enum = options.map((opt) => opt.value);
+          (processedProperty as any).enumNames = options.map(
+            (opt) => opt.label,
+          );
+        }
+
         // Only add type if no type is defined AND no anyOf/oneOf/allOf is present
         if (
           !processedProperty.type &&

autogpt_platform/frontend/src/lib/autogpt-server-api/types.ts

@@ -174,6 +174,7 @@ export type BlockIOStringSubSchema = BlockIOSubSchemaMeta & {
   default?: string;
   format?: string;
   maxLength?: number;
+  options?: { value: string; label: string; description?: string }[];
 };
 
 export type BlockIONumberSubSchema = BlockIOSubSchemaMeta & {

autogpt_platform/frontend/src/lib/utils.ts

@@ -284,17 +284,20 @@ export function fillObjectDefaultsFromSchema(
       // Apply simple default values
       obj[key] ??= propertySchema.default;
     } else if (
+      "type" in propertySchema &&
       propertySchema.type === "object" &&
       "properties" in propertySchema
     ) {
       // Recursively fill defaults for nested objects
       obj[key] = fillObjectDefaultsFromSchema(obj[key] ?? {}, propertySchema);
-    } else if (propertySchema.type === "array") {
+    } else if ("type" in propertySchema && propertySchema.type === "array") {
       obj[key] ??= [];
       // If the array items are objects, fill their defaults as well
       if (
         Array.isArray(obj[key]) &&
-        propertySchema.items?.type === "object" &&
+        propertySchema.items &&
+        "type" in propertySchema.items &&
+        propertySchema.items.type === "object" &&
         "properties" in propertySchema.items
       ) {
         for (const item of obj[key]) {

docs/integrations/block-integrations/ai_condition.md

@@ -20,7 +20,7 @@ The block uses a Large Language Model (LLM) to evaluate the condition by:
 | Condition | A plaintext English description of the condition to evaluate |
 | Yes Value | (Optional) The value to output if the condition is true. If not provided, Input Value will be used |
 | No Value | (Optional) The value to output if the condition is false. If not provided, Input Value will be used |
-| Model | The LLM model to use for evaluation (defaults to GPT-4o) |
+| Model | The LLM model to use for evaluation. Defaults to the platform's recommended model (configurable by your admin via the LLM Registry) |
 | Credentials | API credentials for the LLM provider |
 
 ## Outputs

docs/platform/llm-registry.md

@@ -0,0 +1,235 @@
+# LLM Registry Admin Guide
+
+The LLM Registry is a database-driven system that manages all available LLM models, providers, and creators across your AutoGPT platform. This allows platform administrators to dynamically control which models are available without requiring code deployments.
+
+## Overview
+
+The LLM Registry replaces the previous hardcoded model system with a flexible, admin-controlled registry accessible at `/admin/llms`. This enables you to:
+
+- Add and configure LLM models from any provider
+- Set model costs and pricing tiers
+- Enable or disable models at runtime
+- Migrate workflows to different models when needed
+- Configure a platform-wide recommended default model
+
+## Accessing the LLM Registry
+
+Navigate to `/admin/llms` in your AutoGPT platform (admin privileges required). The admin UI has four main sections:
+
+1. **Providers** — LLM providers (OpenAI, Anthropic, etc.)
+2. **Models** — Individual LLM models with configurations
+3. **Creators** — Organizations that created/trained models
+4. **Migrations** — Model migration history and management
+
+## Managing Providers
+
+Providers represent the API endpoints for LLM services (e.g., OpenAI, Anthropic, Groq).
+
+### Adding a Provider
+
+1. Click "Add Provider" in the Providers tab
+2. Fill in the provider details:
+   - **Name**: Internal identifier (e.g., `openai`, `anthropic`)
+   - **Display Name**: User-facing name
+   - **Description**: Optional provider description
+   - **Default Credentials**: Default credential provider name
+   - **Capabilities**: Check which features the provider supports:
+     - Tools/function calling
+     - JSON output mode
+     - Reasoning tokens
+     - Parallel tool calls
+
+### Editing a Provider
+
+Click the edit icon next to any provider to update its configuration. Changes take effect immediately.
+
+## Managing Models
+
+Models are the individual LLM variants available for blocks to use.
+
+### Adding a Model
+
+1. Click "Add Model" in the Models tab
+2. Configure the model:
+   - **Slug**: Unique identifier (e.g., `gpt-4o`, `claude-opus-4-6`)
+   - **Display Name**: User-facing name
+   - **Provider**: Select from your configured providers
+   - **Creator**: Select the organization that trained the model
+   - **Context Window**: Maximum input tokens
+   - **Max Output Tokens**: Maximum generation length
+   - **Enabled**: Whether the model is available for use
+   - **Costs**: Add cost entries for different credential providers and units (per-run or per-token)
+
+### Model Costs
+
+Each model can have multiple cost entries for different credential providers. For example:
+- OpenAI API credentials: 5 credits per run
+- Custom self-hosted deployment: 2 credits per run
+
+Cost units can be:
+- **RUN**: Flat cost per model invocation
+- **TOKEN**: Cost scales with token usage
+
+### Disabling a Model
+
+You have two options when disabling a model:
+
+#### Simple Disable
+Just uncheck "Enabled" on the model edit form. Workflows using this model will fail until it's re-enabled.
+
+#### Disable with Migration
+Use the "Toggle Model" feature to disable a model AND migrate all existing workflows to a replacement:
+
+1. Click "Toggle" on the model
+2. Select the replacement model slug
+3. Optionally set a custom credit cost for migrated workflows
+4. Provide a migration reason (e.g., "Provider outage")
+
+This creates a migration record and updates all `AgentNode` records using the old model.
+
+## Model Migrations
+
+The migration system tracks when workflows are moved from one model to another, allowing you to revert if needed.
+
+### Viewing Migrations
+
+The Migrations tab shows all model migration history with:
+- Source and target model
+- Number of nodes migrated
+- Migration reason
+- Timestamp
+- Revert status
+
+### Reverting a Migration
+
+If the original model becomes available again:
+
+1. Find the migration in the Migrations tab
+2. Click "Revert"
+3. Choose whether to re-enable the source model
+4. All affected workflows are switched back to the original model
+
+### Custom Pricing for Migrations
+
+When migrating, you can set a custom credit cost that overrides the target model's normal cost. This is useful if you want to:
+- Charge the same cost as the original model
+- Offer discounted pricing during a migration period
+- Apply special pricing for affected users
+
+The custom cost is stored in the migration record and applied to all affected workflows.
+
+## Recommended Model
+
+The platform can have one recommended model that serves as the default for all LLM blocks when no model is explicitly specified.
+
+### Setting the Recommended Model
+
+1. Go to the Models tab
+2. Use the "Recommended Model" selector at the top
+3. Choose the model you want as the platform default
+4. Save
+
+All blocks with `model` inputs using `default_factory=LlmModel.default` will use this model.
+
+### When to Change It
+
+- After adding a better/cheaper model
+- During provider outages or deprecations
+- For platform-wide cost optimization
+
+## Model Creators
+
+Creators represent the organizations that developed and trained the models (e.g., OpenAI, Meta, Anthropic).
+
+### Adding a Creator
+
+1. Click "Add Creator"
+2. Fill in:
+   - **Name**: Internal identifier
+   - **Display Name**: User-facing name
+   - **Description**: Optional background information
+   - **Website URL**: Link to creator's site
+   - **Logo URL**: Optional brand logo
+
+Creators are used for organization and attribution in the UI.
+
+## How Block Defaults Work
+
+When a block has a `model` input:
+
+- **If user selects a model**: That model is used
+- **If user leaves it blank**: The platform's recommended model is used
+- **If a model is disabled**: Workflows fail (unless migrated)
+- **If a fallback exists**: Same-provider fallback may be used automatically
+
+## Common Admin Tasks
+
+### Adding a New Provider and Models
+
+1. Add the provider (e.g., "groq")
+2. Add its creator if not already present (e.g., "Meta")
+3. Add individual models from that provider
+4. Configure costs for each model
+5. Enable the models you want available
+6. Optionally set one as the recommended default
+
+### Responding to a Provider Outage
+
+1. Go to the affected provider's models
+2. For each enabled model, click "Toggle"
+3. Select a replacement model from a different provider
+4. Set migration reason: "Provider outage"
+5. Optionally set custom cost to match original pricing
+6. When the provider recovers, revert the migrations
+
+### Deprecating Old Models
+
+1. Disable the deprecated model with migration
+2. Choose a newer/better replacement
+3. Reason: "Model deprecated by provider"
+4. Monitor costs and performance of the replacement
+5. After validation period, keep the migration permanent
+
+## Architecture Notes
+
+- Models are stored in the `LlmModel` database table
+- Costs are in `LlmModelCost` with foreign key to model
+- Migrations are tracked in `LlmModelMigration`
+- The registry is cached and refreshed automatically
+- Changes take effect immediately without deployments
+
+## Troubleshooting
+
+### "Model not found in registry"
+- Check that the model exists in `/admin/llms`
+- Verify the slug matches exactly (case-sensitive)
+- Refresh the registry if you just added it
+
+### "Model exists but is disabled"
+- Enable it in the model edit form, or
+- Provide a migration target when disabling
+
+### Workflows still using old model after migration
+- Check the migration record was created
+- Verify the migration wasn't reverted
+- Inspect the `AgentNode` records in the database
+
+## Best Practices
+
+1. **Always provide a migration target when disabling models** — prevents workflow failures
+2. **Use descriptive migration reasons** — helps with audit trails
+3. **Test new models before setting as recommended** — validate cost/performance
+4. **Keep at least one model from each major provider enabled** — redundancy during outages
+5. **Review migration history periodically** — clean up old migrations if needed
+6. **Document custom costs in migration reasons** — explain pricing changes
+
+## Security Considerations
+
+- Only platform admins should have access to `/admin/llms`
+- Model costs directly affect user credits and billing
+- Migration records are permanent for audit purposes
+- Credential provider names must match exactly with the credentials system
+
+---
+
+For questions or issues with the LLM Registry, contact your platform administrator.