observability added

Author: github-actions[bot]

Makefile

@@ -37,7 +37,7 @@ help: ## Show this help message
 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
+	@if [ -d "ui/app/enterprise" ]; then rm -rf ui/app/enterprise; fi
 	@echo "$(GREEN)Enterprise cleaned up$(NC)"
 
 install-ui: cleanup-enterprise

transports/bifrost-http/handlers/cache.go

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

transports/bifrost-http/handlers/completions.go

@@ -264,7 +264,7 @@ func (h *CompletionHandler) validateAudioFile(fileHeader *multipart.FileHeader)
 }
 
 // RegisterRoutes registers all completion-related routes
-func (h *CompletionHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
+func (h *CompletionHandler) RegisterRoutes(r *router.Router, middlewares ...BifrostHTTPMiddleware) {
 	// Completion endpoints
 	r.POST("/v1/text/completions", ChainMiddlewares(h.textCompletion, middlewares...))
 	r.POST("/v1/chat/completions", ChainMiddlewares(h.chatCompletion, middlewares...))

transports/bifrost-http/handlers/config.go

@@ -33,7 +33,7 @@ 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, middlewares ...fasthttp.RequestHandler) {
+func (h *ConfigHandler) RegisterRoutes(r *router.Router, middlewares ...BifrostHTTPMiddleware) {
 	r.GET("/api/config", ChainMiddlewares(h.getConfig, middlewares...))
 	r.PUT("/api/config", ChainMiddlewares(h.updateConfig, middlewares...))
 	r.GET("/api/version", ChainMiddlewares(h.getVersion, middlewares...))

transports/bifrost-http/handlers/governance.go

@@ -120,7 +120,7 @@ type UpdateCustomerRequest struct {
 }
 
 // RegisterRoutes registers all governance-related routes for the new hierarchical system
-func (h *GovernanceHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
+func (h *GovernanceHandler) RegisterRoutes(r *router.Router, middlewares ...BifrostHTTPMiddleware) {
 	// Virtual Key CRUD operations
 	r.GET("/api/governance/virtual-keys", ChainMiddlewares(h.getVirtualKeys, middlewares...))
 	r.POST("/api/governance/virtual-keys", ChainMiddlewares(h.createVirtualKey, middlewares...))

transports/bifrost-http/handlers/logging.go

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

transports/bifrost-http/handlers/mcp.go

@@ -30,7 +30,7 @@ func NewMCPHandler(client *bifrost.Bifrost, logger schemas.Logger, store *lib.Co
 }
 
 // RegisterRoutes registers all MCP-related routes
-func (h *MCPHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
+func (h *MCPHandler) RegisterRoutes(r *router.Router, middlewares ...BifrostHTTPMiddleware) {
 	// MCP tool execution endpoint
 	r.POST("/v1/mcp/tool/execute", ChainMiddlewares(h.executeTool, middlewares...))
 	r.GET("/api/mcp/clients", ChainMiddlewares(h.getMCPClients, middlewares...))

transports/bifrost-http/handlers/middlewares.go

@@ -1,20 +1,49 @@
 package handlers
 
 import (
+	"github.com/maximhq/bifrost/transports/bifrost-http/lib"
 	"github.com/valyala/fasthttp"
 )
 
+// BifrostHTTPMiddleware is a middleware function for the Bifrost HTTP transport
+type BifrostHTTPMiddleware func(ctx *fasthttp.RequestCtx)
+
+// CorsMiddleware handles CORS headers for localhost and configured allowed origins
+func CorsMiddleware(config *lib.Config, next fasthttp.RequestHandler) fasthttp.RequestHandler {
+	return func(ctx *fasthttp.RequestCtx) {
+		origin := string(ctx.Request.Header.Peek("Origin"))
+		// Check if origin is allowed (localhost always allowed + configured origins)
+		if IsOriginAllowed(origin, config.ClientConfig.AllowedOrigins) {
+			ctx.Response.Header.Set("Access-Control-Allow-Origin", origin)
+		}
+		// Setting headers
+		ctx.Response.Header.Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		ctx.Response.Header.Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
+		ctx.Response.Header.Set("Access-Control-Allow-Credentials", "true")
+		ctx.Response.Header.Set("Access-Control-Max-Age", "86400")
+		// Handle preflight OPTIONS requests
+		if string(ctx.Method()) == "OPTIONS" {
+			ctx.SetStatusCode(fasthttp.StatusOK)
+			return
+		}
+		next(ctx)
+	}
+}
+
 // ChainMiddlewares chains multiple middlewares together
-func ChainMiddlewares(handler fasthttp.RequestHandler, middlewares ...fasthttp.RequestHandler) fasthttp.RequestHandler {
+func ChainMiddlewares(handler fasthttp.RequestHandler, middlewares ...BifrostHTTPMiddleware) 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)
+			// Check if the response is set
+			if ctx.Response.StatusCode() != 0 {
+				return
+			}
 		}
 		// Execute the handler last
 		handler(ctx)

transports/bifrost-http/handlers/plugins.go

@@ -11,37 +11,43 @@ import (
 	"gorm.io/gorm"
 )
 
+// PluginsHandler is the handler for the plugins API
 type PluginsHandler struct {
 	logger      schemas.Logger
 	configStore configstore.ConfigStore
 }
 
+// NewPluginsHandler creates a new PluginsHandler
 func NewPluginsHandler(configStore configstore.ConfigStore, logger schemas.Logger) *PluginsHandler {
 	return &PluginsHandler{
 		configStore: configStore,
 		logger:      logger,
 	}
 }
 
+// CreatePluginRequest is the request body for creating a plugin
 type CreatePluginRequest struct {
-	Name    string                 `json:"name"`
-	Enabled bool                   `json:"enabled"`
-	Config  map[string]interface{} `json:"config"`
+	Name    string         `json:"name"`
+	Enabled bool           `json:"enabled"`
+	Config  map[string]any `json:"config"`
 }
 
+// UpdatePluginRequest is the request body for updating a plugin
 type UpdatePluginRequest struct {
-	Enabled bool                   `json:"enabled"`
-	Config  map[string]interface{} `json:"config"`
+	Enabled bool           `json:"enabled"`
+	Config  map[string]any `json:"config"`
 }
 
-func (h *PluginsHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
+// RegisterRoutes registers the routes for the PluginsHandler
+func (h *PluginsHandler) RegisterRoutes(r *router.Router, middlewares ...BifrostHTTPMiddleware) {
 	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...))
 }
 
+// getPlugins gets all plugins
 func (h *PluginsHandler) getPlugins(ctx *fasthttp.RequestCtx) {
 	plugins, err := h.configStore.GetPlugins()
 	if err != nil {
@@ -50,12 +56,13 @@ func (h *PluginsHandler) getPlugins(ctx *fasthttp.RequestCtx) {
 		return
 	}
 
-	SendJSON(ctx, map[string]interface{}{
+	SendJSON(ctx, map[string]any{
 		"plugins": plugins,
 		"count":   len(plugins),
 	}, h.logger)
 }
 
+// getPlugin gets a plugin by name
 func (h *PluginsHandler) getPlugin(ctx *fasthttp.RequestCtx) {
 	// Safely validate the "name" parameter
 	nameValue := ctx.UserValue("name")
@@ -91,6 +98,7 @@ func (h *PluginsHandler) getPlugin(ctx *fasthttp.RequestCtx) {
 	SendJSON(ctx, plugin, h.logger)
 }
 
+// createPlugin creates a new plugin
 func (h *PluginsHandler) createPlugin(ctx *fasthttp.RequestCtx) {
 	var request CreatePluginRequest
 	if err := json.Unmarshal(ctx.PostBody(), &request); err != nil {
@@ -130,12 +138,13 @@ func (h *PluginsHandler) createPlugin(ctx *fasthttp.RequestCtx) {
 	}
 
 	ctx.SetStatusCode(fasthttp.StatusCreated)
-	SendJSON(ctx, map[string]interface{}{
+	SendJSON(ctx, map[string]any{
 		"message": "Plugin created successfully",
 		"plugin":  plugin,
 	}, h.logger)
 }
 
+// updatePlugin updates an existing plugin
 func (h *PluginsHandler) updatePlugin(ctx *fasthttp.RequestCtx) {
 	// Safely validate the "name" parameter
 	nameValue := ctx.UserValue("name")
@@ -160,9 +169,16 @@ func (h *PluginsHandler) updatePlugin(ctx *fasthttp.RequestCtx) {
 
 	// Check if plugin exists
 	if _, err := h.configStore.GetPlugin(name); err != nil {
-		h.logger.Warn("plugin not found for update: %s", name)
-		SendError(ctx, fasthttp.StatusNotFound, "Plugin not found", h.logger)
-		return
+		// If doesn't exist, create it
+		if err := h.configStore.CreatePlugin(&configstore.TablePlugin{
+			Name:    name,
+			Enabled: false,
+			Config:  map[string]any{},
+		}); err != nil {
+			h.logger.Error("failed to create plugin: %v", err)
+			SendError(ctx, 500, "Failed to create plugin", h.logger)
+			return
+		}
 	}
 
 	var request UpdatePluginRequest
@@ -199,6 +215,7 @@ func (h *PluginsHandler) updatePlugin(ctx *fasthttp.RequestCtx) {
 	}, h.logger)
 }
 
+// deletePlugin deletes an existing plugin
 func (h *PluginsHandler) deletePlugin(ctx *fasthttp.RequestCtx) {
 	// Safely validate the "name" parameter
 	nameValue := ctx.UserValue("name")

transports/bifrost-http/handlers/providers.go

@@ -59,7 +59,7 @@ type ErrorResponse struct {
 }
 
 // RegisterRoutes registers all provider management routes
-func (h *ProviderHandler) RegisterRoutes(r *router.Router, middlewares ...fasthttp.RequestHandler) {
+func (h *ProviderHandler) RegisterRoutes(r *router.Router, middlewares ...BifrostHTTPMiddleware) {
 	// Provider CRUD operations
 	r.GET("/api/providers", ChainMiddlewares(h.listProviders, middlewares...))
 	r.GET("/api/providers/{provider}", ChainMiddlewares(h.getProvider, middlewares...))