updates package name for ui

Author: github-actions[bot]

.gitignore

@@ -8,6 +8,10 @@ private.*
 .venv
 bifrost-data
 
+# Enterprise
+ui/app/enterprise
+ui/components/enterprise
+
 # Temporary directories
 **/temp/
 /transports/ui

Makefile

@@ -16,7 +16,7 @@ BLUE=\033[0;34m
 CYAN=\033[0;36m
 NC=\033[0m # No Color
 
-.PHONY: all help dev build-ui build run install-air clean test install-ui setup-workspace work-init work-clean docs docker-build
+.PHONY: all help dev build-ui build run install-air clean test install-ui setup-workspace work-init work-clean docs docker-build cleanup-enterprise
 
 all: help
 
@@ -34,7 +34,13 @@ help: ## Show this help message
 	@echo "  LOG_LEVEL Logger level: debug|info|warn|error (default: info)"
 	@echo "  APP_DIR           App data directory inside container (default: /app/data)"
 
-install-ui:
+cleanup-enterprise: ## Clean up enterprise directories if present
+	@echo "$(GREEN)Cleaning up enterprise...$(NC)"
+	@if [ -d "ui/app/enterprise" ]; then rm -rf ui/app/enterprise; fi
+	@if [ -d "ui/app/_fallbacks/enterprise" ]; then rm -rf ui/app/_fallbacks/enterprise; fi
+	@echo "$(GREEN)Enterprise cleaned up$(NC)"
+
+install-ui: cleanup-enterprise
 	@which node > /dev/null || (echo "$(RED)Error: Node.js is not installed. Please install Node.js first.$(NC)" && exit 1)
 	@which npm > /dev/null || (echo "$(RED)Error: npm is not installed. Please install npm first.$(NC)" && exit 1)
 	@echo "$(GREEN)Node.js and npm are installed$(NC)"

transports/bifrost-http/handlers/cache.go

@@ -24,9 +24,9 @@ func NewCacheHandler(plugin schemas.Plugin, logger schemas.Logger) *CacheHandler
 	}
 }
 
-func (h *CacheHandler) RegisterRoutes(r *router.Router) {
-	r.DELETE("/api/cache/clear/{requestId}", h.clearCache)
-	r.DELETE("/api/cache/clear-by-key/{cacheKey}", h.clearCacheByKey)
+func (h *CacheHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
+	r.DELETE("/api/cache/clear/{requestId}", ChainMiddlewares(h.clearCache, middlewares...))
+	r.DELETE("/api/cache/clear-by-key/{cacheKey}", ChainMiddlewares(h.clearCacheByKey, middlewares...))
 }
 
 func (h *CacheHandler) clearCache(ctx *fasthttp.RequestCtx) {

transports/bifrost-http/handlers/completions.go

@@ -264,13 +264,13 @@ func (h *CompletionHandler) validateAudioFile(fileHeader *multipart.FileHeader)
 }
 
 // RegisterRoutes registers all completion-related routes
-func (h *CompletionHandler) RegisterRoutes(r *router.Router) {
+func (h *CompletionHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
 	// Completion endpoints
-	r.POST("/v1/text/completions", h.textCompletion)
-	r.POST("/v1/chat/completions", h.chatCompletion)
-	r.POST("/v1/embeddings", h.embeddings)
-	r.POST("/v1/audio/speech", h.speechCompletion)
-	r.POST("/v1/audio/transcriptions", h.transcriptionCompletion)
+	r.POST("/v1/text/completions", ChainMiddlewares(h.textCompletion, middlewares...))
+	r.POST("/v1/chat/completions", ChainMiddlewares(h.chatCompletion, middlewares...))
+	r.POST("/v1/embeddings", ChainMiddlewares(h.embeddings, middlewares...))
+	r.POST("/v1/audio/speech", ChainMiddlewares(h.speechCompletion, middlewares...))
+	r.POST("/v1/audio/transcriptions", ChainMiddlewares(h.transcriptionCompletion, middlewares...))
 }
 
 // textCompletion handles POST /v1/text/completions - Process text completion requests

transports/bifrost-http/handlers/config.go

@@ -33,14 +33,14 @@ func NewConfigHandler(client *bifrost.Bifrost, logger schemas.Logger, store *lib
 
 // RegisterRoutes registers the configuration-related routes.
 // It adds the `PUT /api/config` endpoint.
-func (h *ConfigHandler) RegisterRoutes(r *router.Router) {
-	r.GET("/api/config", h.getConfig)
-	r.PUT("/api/config", h.updateConfig)
-	r.GET("/api/version", h.getVersion)
+func (h *ConfigHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
+	r.GET("/api/config", ChainMiddlewares(h.getConfig, middlewares...))
+	r.PUT("/api/config", ChainMiddlewares(h.updateConfig, middlewares...))
+	r.GET("/api/version", ChainMiddlewares(h.getVersion, middlewares...))
 }
 
 // getVersion handles GET /api/version - Get the current version
-func (h *ConfigHandler) getVersion(ctx *fasthttp.RequestCtx) {
+func (h *ConfigHandler) getVersion(ctx *fasthttp.RequestCtx) {	
 	SendJSON(ctx, version, h.logger)
 }
 

transports/bifrost-http/handlers/governance.go

@@ -120,27 +120,27 @@ type UpdateCustomerRequest struct {
 }
 
 // RegisterRoutes registers all governance-related routes for the new hierarchical system
-func (h *GovernanceHandler) RegisterRoutes(r *router.Router) {
+func (h *GovernanceHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
 	// Virtual Key CRUD operations
-	r.GET("/api/governance/virtual-keys", h.getVirtualKeys)
-	r.POST("/api/governance/virtual-keys", h.createVirtualKey)
-	r.GET("/api/governance/virtual-keys/{vk_id}", h.getVirtualKey)
-	r.PUT("/api/governance/virtual-keys/{vk_id}", h.updateVirtualKey)
-	r.DELETE("/api/governance/virtual-keys/{vk_id}", h.deleteVirtualKey)
+	r.GET("/api/governance/virtual-keys", ChainMiddlewares(h.getVirtualKeys, middlewares...))
+	r.POST("/api/governance/virtual-keys", ChainMiddlewares(h.createVirtualKey, middlewares...))
+	r.GET("/api/governance/virtual-keys/{vk_id}", ChainMiddlewares(h.getVirtualKey, middlewares...))
+	r.PUT("/api/governance/virtual-keys/{vk_id}", ChainMiddlewares(h.updateVirtualKey, middlewares...))
+	r.DELETE("/api/governance/virtual-keys/{vk_id}", ChainMiddlewares(h.deleteVirtualKey, middlewares...))
 
 	// Team CRUD operations
-	r.GET("/api/governance/teams", h.getTeams)
-	r.POST("/api/governance/teams", h.createTeam)
-	r.GET("/api/governance/teams/{team_id}", h.getTeam)
-	r.PUT("/api/governance/teams/{team_id}", h.updateTeam)
-	r.DELETE("/api/governance/teams/{team_id}", h.deleteTeam)
+	r.GET("/api/governance/teams", ChainMiddlewares(h.getTeams, middlewares...))
+	r.POST("/api/governance/teams", ChainMiddlewares(h.createTeam, middlewares...))
+	r.GET("/api/governance/teams/{team_id}", ChainMiddlewares(h.getTeam, middlewares...))
+	r.PUT("/api/governance/teams/{team_id}", ChainMiddlewares(h.updateTeam, middlewares...))
+	r.DELETE("/api/governance/teams/{team_id}", ChainMiddlewares(h.deleteTeam, middlewares...))
 
 	// Customer CRUD operations
-	r.GET("/api/governance/customers", h.getCustomers)
-	r.POST("/api/governance/customers", h.createCustomer)
-	r.GET("/api/governance/customers/{customer_id}", h.getCustomer)
-	r.PUT("/api/governance/customers/{customer_id}", h.updateCustomer)
-	r.DELETE("/api/governance/customers/{customer_id}", h.deleteCustomer)
+	r.GET("/api/governance/customers", ChainMiddlewares(h.getCustomers, middlewares...))
+	r.POST("/api/governance/customers", ChainMiddlewares(h.createCustomer, middlewares...))
+	r.GET("/api/governance/customers/{customer_id}", ChainMiddlewares(h.getCustomer, middlewares...))
+	r.PUT("/api/governance/customers/{customer_id}", ChainMiddlewares(h.updateCustomer, middlewares...))
+	r.DELETE("/api/governance/customers/{customer_id}", ChainMiddlewares(h.deleteCustomer, middlewares...))
 }
 
 // Virtual Key CRUD Operations

transports/bifrost-http/handlers/logging.go

@@ -30,11 +30,11 @@ func NewLoggingHandler(logManager logging.LogManager, logger schemas.Logger) *Lo
 }
 
 // RegisterRoutes registers all logging-related routes
-func (h *LoggingHandler) RegisterRoutes(r *router.Router) {
+func (h *LoggingHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
 	// Log retrieval with filtering, search, and pagination
-	r.GET("/api/logs", h.getLogs)
-	r.GET("/api/logs/dropped", h.getDroppedRequests)
-	r.GET("/api/logs/models", h.getAvailableModels)
+	r.GET("/api/logs", ChainMiddlewares(h.getLogs, middlewares...))
+	r.GET("/api/logs/dropped", ChainMiddlewares(h.getDroppedRequests, middlewares...))
+	r.GET("/api/logs/models", ChainMiddlewares(h.getAvailableModels, middlewares...))
 }
 
 // getLogs handles GET /api/logs - Get logs with filtering, search, and pagination via query parameters

transports/bifrost-http/handlers/mcp.go

@@ -30,14 +30,14 @@ func NewMCPHandler(client *bifrost.Bifrost, logger schemas.Logger, store *lib.Co
 }
 
 // RegisterRoutes registers all MCP-related routes
-func (h *MCPHandler) RegisterRoutes(r *router.Router) {
+func (h *MCPHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
 	// MCP tool execution endpoint
-	r.POST("/v1/mcp/tool/execute", h.executeTool)
-	r.GET("/api/mcp/clients", h.getMCPClients)
-	r.POST("/api/mcp/client", h.addMCPClient)
-	r.PUT("/api/mcp/client/{name}", h.editMCPClientTools)
-	r.DELETE("/api/mcp/client/{name}", h.removeMCPClient)
-	r.POST("/api/mcp/client/{name}/reconnect", h.reconnectMCPClient)
+	r.POST("/v1/mcp/tool/execute", ChainMiddlewares(h.executeTool, middlewares...))
+	r.GET("/api/mcp/clients", ChainMiddlewares(h.getMCPClients, middlewares...))
+	r.POST("/api/mcp/client", ChainMiddlewares(h.addMCPClient, middlewares...))
+	r.PUT("/api/mcp/client/{name}", ChainMiddlewares(h.editMCPClientTools, middlewares...))
+	r.DELETE("/api/mcp/client/{name}", ChainMiddlewares(h.removeMCPClient, middlewares...))
+	r.POST("/api/mcp/client/{name}/reconnect", ChainMiddlewares(h.reconnectMCPClient, middlewares...))
 }
 
 // executeTool handles POST /v1/mcp/tool/execute - Execute MCP tool

transports/bifrost-http/handlers/middlewares.go

@@ -0,0 +1,22 @@
+package handlers
+
+import (
+	"github.com/valyala/fasthttp"
+)
+
+// ChainMiddlewares chains multiple middlewares together
+func ChainMiddlewares(handler fasthttp.RequestHandler, middlewares ...fasthttp.RequestHandler) fasthttp.RequestHandler {
+	// If no middlewares, return the original handler
+	if len(middlewares) == 0 {
+		return handler
+	}
+
+	return func(ctx *fasthttp.RequestCtx) {
+		// Execute all middlewares in order
+		for _, middleware := range middlewares {
+			middleware(ctx)
+		}
+		// Execute the handler last
+		handler(ctx)
+	}
+}

transports/bifrost-http/handlers/plugins.go

@@ -34,12 +34,12 @@ type UpdatePluginRequest struct {
 	Config  map[string]interface{} `json:"config"`
 }
 
-func (h *PluginsHandler) RegisterRoutes(r *router.Router) {
-	r.GET("/api/plugins", h.getPlugins)
-	r.GET("/api/plugins/{name}", h.getPlugin)
-	r.POST("/api/plugins", h.createPlugin)
-	r.PUT("/api/plugins/{name}", h.updatePlugin)
-	r.DELETE("/api/plugins/{name}", h.deletePlugin)
+func (h *PluginsHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
+	r.GET("/api/plugins", ChainMiddlewares(h.getPlugins, middlewares...))
+	r.GET("/api/plugins/{name}", ChainMiddlewares(h.getPlugin, middlewares...))
+	r.POST("/api/plugins", ChainMiddlewares(h.createPlugin, middlewares...))
+	r.PUT("/api/plugins/{name}", ChainMiddlewares(h.updatePlugin, middlewares...))
+	r.DELETE("/api/plugins/{name}", ChainMiddlewares(h.deletePlugin, middlewares...))
 }
 
 func (h *PluginsHandler) getPlugins(ctx *fasthttp.RequestCtx) {