feat: add external models endpoint (opendatahub-io#6465)

* feat(gen-ai): add external models endpoint

Implement BFF endpoint to register external model endpoints (Gemini, OpenAI, Anthropic, vLLM).

- Add POST /gen-ai/api/v1/models/external endpoint
- Create ConfigMap (gen-ai-aa-external-models) for provider configuration
- Create Kubernetes Secret for API key storage
- Return AAModel response for compatibility with AI Available Assets
- Add OpenAPI specification with ExternalModelCreatedResponse
- Add unit tests and mock implementations
- Support provider types: remote::gemini, remote::openai, remote::anthropic, remote::vllm
- Support model types: llm, embedding

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* fix tests

* coderabbit fixes

* More coderabbit fixes

* fix openAPI schema for AAModel

* add 403 to /models/external

* check for response.data in mock BFF test

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: NickGagan

packages/gen-ai/bff/internal/api/app.go

@@ -316,6 +316,7 @@ func (app *App) Routes() http.Handler {
 
 	// AI Assets Models (Kubernetes)
 	apiRouter.GET(constants.ModelsAAPath, app.AttachNamespace(app.RequireAccessToService(app.ModelsAAHandler)))
+	apiRouter.POST(constants.ExternalModelsPath, app.AttachNamespace(app.RequireAccessToService(app.CreateExternalModelHandler)))
 
 	// Settings path namespace endpoints. This endpoint will get all the namespaces
 	apiRouter.GET(constants.NamespacesPath, app.RequireAccessToService(app.GetNamespaceHandler))

packages/gen-ai/bff/internal/api/external_models_handler.go

@@ -0,0 +1,112 @@
+package api
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/julienschmidt/httprouter"
+	"github.com/opendatahub-io/gen-ai/internal/constants"
+	"github.com/opendatahub-io/gen-ai/internal/integrations"
+	"github.com/opendatahub-io/gen-ai/internal/models"
+)
+
+type CreateExternalModelEnvelope Envelope[models.AAModel, None]
+
+// CreateExternalModelHandler handles the creation of external model endpoints
+func (app *App) CreateExternalModelHandler(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
+	ctx := r.Context()
+
+	// Get namespace from context
+	namespace, ok := r.Context().Value(constants.NamespaceQueryParameterKey).(string)
+	if !ok || namespace == "" {
+		app.badRequestResponse(w, r, fmt.Errorf("missing namespace in the context"))
+		return
+	}
+
+	// Get the request identity from context
+	identity, ok := ctx.Value(constants.RequestIdentityKey).(*integrations.RequestIdentity)
+	if !ok || identity == nil {
+		app.unauthorizedResponse(w, r, fmt.Errorf("missing RequestIdentity in context"))
+		return
+	}
+
+	// Parse request body
+	var req models.ExternalModelRequest
+	err := app.ReadJSON(w, r, &req)
+	if err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	// Validate required fields
+	if req.ModelID == "" {
+		app.badRequestResponse(w, r, fmt.Errorf("model_id is required"))
+		return
+	}
+	if req.ModelDisplayName == "" {
+		app.badRequestResponse(w, r, fmt.Errorf("model_display_name is required"))
+		return
+	}
+	if req.BaseURL == "" {
+		app.badRequestResponse(w, r, fmt.Errorf("base_url is required"))
+		return
+	}
+	if req.SecretValue == "" {
+		app.badRequestResponse(w, r, fmt.Errorf("secret_value is required"))
+		return
+	}
+	if req.ProviderType == "" {
+		app.badRequestResponse(w, r, fmt.Errorf("provider_type is required"))
+		return
+	}
+	if req.ModelType == "" {
+		app.badRequestResponse(w, r, fmt.Errorf("model_type is required"))
+		return
+	}
+
+	// Validate provider type
+	validProviderTypes := map[models.ProviderTypeEnum]bool{
+		models.ProviderTypeGemini:    true,
+		models.ProviderTypeOpenAI:    true,
+		models.ProviderTypeAnthropic: true,
+		models.ProviderTypeVLLM:      true,
+	}
+	if !validProviderTypes[req.ProviderType] {
+		app.badRequestResponse(w, r, fmt.Errorf("invalid provider_type: %s", req.ProviderType))
+		return
+	}
+
+	// Validate model type
+	validModelTypes := map[models.ModelTypeEnum]bool{
+		models.ModelTypeEmbedding: true,
+		models.ModelTypeLLM:       true,
+	}
+	if !validModelTypes[req.ModelType] {
+		app.badRequestResponse(w, r, fmt.Errorf("invalid model_type: %s", req.ModelType))
+		return
+	}
+
+	// Get Kubernetes client
+	client, err := app.kubernetesClientFactory.GetClient(ctx)
+	if err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	// Create external model
+	response, err := app.repositories.ExternalModels.CreateExternalModel(client, ctx, identity, namespace, req)
+	if err != nil {
+		app.serverErrorResponse(w, r, err)
+		return
+	}
+
+	// Return success response
+	envelope := CreateExternalModelEnvelope{
+		Data: *response,
+	}
+	err = app.WriteJSON(w, http.StatusCreated, envelope, nil)
+	if err != nil {
+		app.serverErrorResponse(w, r, err)
+		return
+	}
+}