feat: implement AI gateway phase one runtime

apps/api/internal/httpapi/catalog_handlers.go

@@ -0,0 +1,161 @@
+package httpapi
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/easyai/easyai-ai-gateway/apps/api/internal/store"
+)
+
+func (s *Server) listCatalogProviders(w http.ResponseWriter, r *http.Request) {
+	items, err := s.store.ListCatalogProviders(r.Context())
+	if err != nil {
+		s.logger.Error("list catalog providers failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "list catalog providers failed")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"items": items})
+}
+
+func (s *Server) createCatalogProvider(w http.ResponseWriter, r *http.Request) {
+	var input store.CatalogProviderInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid json body")
+		return
+	}
+	if strings.TrimSpace(input.ProviderKey) == "" || strings.TrimSpace(input.DisplayName) == "" {
+		writeError(w, http.StatusBadRequest, "providerKey and displayName are required")
+		return
+	}
+	item, err := s.store.CreateCatalogProvider(r.Context(), input)
+	if err != nil {
+		if store.IsUniqueViolation(err) {
+			writeError(w, http.StatusConflict, "provider key or code already exists")
+			return
+		}
+		s.logger.Error("create catalog provider failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "create catalog provider failed")
+		return
+	}
+	writeJSON(w, http.StatusCreated, item)
+}
+
+func (s *Server) updateCatalogProvider(w http.ResponseWriter, r *http.Request) {
+	var input store.CatalogProviderInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid json body")
+		return
+	}
+	if strings.TrimSpace(input.ProviderKey) == "" || strings.TrimSpace(input.DisplayName) == "" {
+		writeError(w, http.StatusBadRequest, "providerKey and displayName are required")
+		return
+	}
+	item, err := s.store.UpdateCatalogProvider(r.Context(), r.PathValue("providerID"), input)
+	if err != nil {
+		if store.IsNotFound(err) {
+			writeError(w, http.StatusNotFound, "catalog provider not found")
+			return
+		}
+		if store.IsUniqueViolation(err) {
+			writeError(w, http.StatusConflict, "provider key or code already exists")
+			return
+		}
+		s.logger.Error("update catalog provider failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "update catalog provider failed")
+		return
+	}
+	writeJSON(w, http.StatusOK, item)
+}
+
+func (s *Server) deleteCatalogProvider(w http.ResponseWriter, r *http.Request) {
+	if err := s.store.DeleteCatalogProvider(r.Context(), r.PathValue("providerID")); err != nil {
+		if store.IsNotFound(err) {
+			writeError(w, http.StatusNotFound, "catalog provider not found")
+			return
+		}
+		s.logger.Error("delete catalog provider failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "delete catalog provider failed")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func (s *Server) listBaseModels(w http.ResponseWriter, r *http.Request) {
+	items, err := s.store.ListBaseModels(r.Context())
+	if err != nil {
+		s.logger.Error("list base models failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "list base models failed")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"items": items})
+}
+
+func (s *Server) createBaseModel(w http.ResponseWriter, r *http.Request) {
+	var input store.BaseModelInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid json body")
+		return
+	}
+	if !validBaseModelInput(input) {
+		writeError(w, http.StatusBadRequest, "providerKey, providerModelName and modelType are required")
+		return
+	}
+	item, err := s.store.CreateBaseModel(r.Context(), input)
+	if err != nil {
+		if store.IsUniqueViolation(err) {
+			writeError(w, http.StatusConflict, "canonical model key already exists")
+			return
+		}
+		s.logger.Error("create base model failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "create base model failed")
+		return
+	}
+	writeJSON(w, http.StatusCreated, item)
+}
+
+func (s *Server) updateBaseModel(w http.ResponseWriter, r *http.Request) {
+	var input store.BaseModelInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid json body")
+		return
+	}
+	if !validBaseModelInput(input) {
+		writeError(w, http.StatusBadRequest, "providerKey, providerModelName and modelType are required")
+		return
+	}
+	item, err := s.store.UpdateBaseModel(r.Context(), r.PathValue("baseModelID"), input)
+	if err != nil {
+		if store.IsNotFound(err) {
+			writeError(w, http.StatusNotFound, "base model not found")
+			return
+		}
+		if store.IsUniqueViolation(err) {
+			writeError(w, http.StatusConflict, "canonical model key already exists")
+			return
+		}
+		s.logger.Error("update base model failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "update base model failed")
+		return
+	}
+	writeJSON(w, http.StatusOK, item)
+}
+
+func (s *Server) deleteBaseModel(w http.ResponseWriter, r *http.Request) {
+	if err := s.store.DeleteBaseModel(r.Context(), r.PathValue("baseModelID")); err != nil {
+		if store.IsNotFound(err) {
+			writeError(w, http.StatusNotFound, "base model not found")
+			return
+		}
+		s.logger.Error("delete base model failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "delete base model failed")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func validBaseModelInput(input store.BaseModelInput) bool {
+	return strings.TrimSpace(input.ProviderKey) != "" &&
+		strings.TrimSpace(input.ProviderModelName) != "" &&
+		strings.TrimSpace(input.ModelType) != ""
+}

apps/api/internal/httpapi/core_flow_integration_test.go

@@ -37,12 +37,14 @@ func TestCoreLocalFlow(t *testing.T) {
 	defer db.Close()
 
 	handler := NewServer(config.Config{
-		AppEnv:            "test",
-		HTTPAddr:          ":0",
-		DatabaseURL:       databaseURL,
-		IdentityMode:      "hybrid",
-		JWTSecret:         "test-secret",
-		CORSAllowedOrigin: "*",
+		AppEnv:                      "test",
+		HTTPAddr:                    ":0",
+		DatabaseURL:                 databaseURL,
+		IdentityMode:                "hybrid",
+		JWTSecret:                   "test-secret",
+		TaskProgressCallbackEnabled: true,
+		TaskProgressCallbackURL:     "http://callback.local/task-progress",
+		CORSAllowedOrigin:           "*",
 	}, db, slog.New(slog.NewTextHandler(io.Discard, nil)))
 	server := httptest.NewServer(handler)
 	defer server.Close()
@@ -117,6 +119,9 @@ func TestCoreLocalFlow(t *testing.T) {
 		t.Fatalf("connect test pool: %v", err)
 	}
 	defer testPool.Close()
+	if _, err := testPool.Exec(ctx, `UPDATE gateway_users SET roles = '["admin"]'::jsonb WHERE username = $1`, username); err != nil {
+		t.Fatalf("promote smoke user: %v", err)
+	}
 
 	inviteCode := "INVITE-" + suffixText
 	if _, err := testPool.Exec(ctx, `
@@ -167,7 +172,7 @@ VALUES ($1, 5, '{"purpose":"core-flow"}'::jsonb)`, inviteCode); err != nil {
 		PlatformKey string `json:"platformKey"`
 		Status      string `json:"status"`
 	}
-	doJSON(t, server.URL, http.MethodPost, "/api/v1/platforms", loginResponse.AccessToken, map[string]any{
+	doJSON(t, server.URL, http.MethodPost, "/api/v1/platforms", apiKeyResponse.Secret, map[string]any{
 		"provider":    "openai",
 		"platformKey": "openai-smoke-" + suffixText,
 		"name":        "OpenAI Smoke",
@@ -180,6 +185,47 @@ VALUES ($1, 5, '{"purpose":"core-flow"}'::jsonb)`, inviteCode); err != nil {
 		t.Fatalf("unexpected platform response: %+v", platform)
 	}
 
+	var baseModels struct {
+		Items []struct {
+			ID                string `json:"id"`
+			CanonicalModelKey string `json:"canonicalModelKey"`
+			ProviderModelName string `json:"providerModelName"`
+			ModelType         string `json:"modelType"`
+		} `json:"items"`
+	}
+	doJSON(t, server.URL, http.MethodGet, "/api/v1/catalog/base-models", apiKeyResponse.Secret, nil, http.StatusOK, &baseModels)
+	if len(baseModels.Items) < 300 {
+		t.Fatalf("server-main seed should include the migrated base model catalog: got %d", len(baseModels.Items))
+	}
+
+	baseModelInput := map[string]any{
+		"providerKey":       "openai",
+		"canonicalModelKey": "openai:smoke-base-" + suffixText,
+		"providerModelName": "smoke-base-" + suffixText,
+		"modelType":         "text_generate",
+		"displayName":       "Smoke Base Model",
+		"capabilities":      map[string]any{"originalTypes": []string{"text_generate"}},
+		"metadata":          map[string]any{"source": "test"},
+	}
+	var createdBaseModel struct {
+		ID                string `json:"id"`
+		CanonicalModelKey string `json:"canonicalModelKey"`
+		DisplayName       string `json:"displayName"`
+	}
+	doJSON(t, server.URL, http.MethodPost, "/api/v1/catalog/base-models", apiKeyResponse.Secret, baseModelInput, http.StatusCreated, &createdBaseModel)
+	if createdBaseModel.ID == "" || createdBaseModel.CanonicalModelKey != baseModelInput["canonicalModelKey"] {
+		t.Fatalf("unexpected created base model: %+v", createdBaseModel)
+	}
+	baseModelInput["displayName"] = "Smoke Base Model Updated"
+	var updatedBaseModel struct {
+		DisplayName string `json:"displayName"`
+	}
+	doJSON(t, server.URL, http.MethodPatch, "/api/v1/catalog/base-models/"+createdBaseModel.ID, apiKeyResponse.Secret, baseModelInput, http.StatusOK, &updatedBaseModel)
+	if updatedBaseModel.DisplayName != "Smoke Base Model Updated" {
+		t.Fatalf("unexpected updated base model: %+v", updatedBaseModel)
+	}
+	doJSON(t, server.URL, http.MethodDelete, "/api/v1/catalog/base-models/"+createdBaseModel.ID, apiKeyResponse.Secret, nil, http.StatusNoContent, nil)
+
 	var taskResponse struct {
 		Task struct {
 			ID      string         `json:"id"`
@@ -198,6 +244,109 @@ VALUES ($1, 5, '{"purpose":"core-flow"}'::jsonb)`, inviteCode); err != nil {
 		t.Fatalf("unexpected task response: %+v", taskResponse.Task)
 	}
 
+	var compatChat map[string]any
+	doJSON(t, server.URL, http.MethodPost, "/v1/chat/completions", apiKeyResponse.Secret, map[string]any{
+		"model":      "gpt-4o-mini",
+		"runMode":    "simulation",
+		"messages":   []map[string]any{{"role": "user", "content": "ping"}},
+		"simulation": true,
+	}, http.StatusOK, &compatChat)
+	if compatChat["object"] != "chat.completion" {
+		t.Fatalf("unexpected compatible chat response: %+v", compatChat)
+	}
+
+	var imageResponse struct {
+		Task struct {
+			ID     string         `json:"id"`
+			Status string         `json:"status"`
+			Result map[string]any `json:"result"`
+		} `json:"task"`
+	}
+	doJSON(t, server.URL, http.MethodPost, "/api/v1/images/generations", apiKeyResponse.Secret, map[string]any{
+		"model":      "gpt-image-1",
+		"runMode":    "simulation",
+		"prompt":     "a tiny gateway console",
+		"size":       "1024x1024",
+		"quality":    "medium",
+		"simulation": true,
+	}, http.StatusAccepted, &imageResponse)
+	if imageResponse.Task.Status != "succeeded" || imageResponse.Task.Result["id"] == "" {
+		t.Fatalf("unexpected image generation task: %+v", imageResponse.Task)
+	}
+
+	var imageEditResponse struct {
+		Task struct {
+			ID     string         `json:"id"`
+			Status string         `json:"status"`
+			Result map[string]any `json:"result"`
+		} `json:"task"`
+	}
+	doJSON(t, server.URL, http.MethodPost, "/api/v1/images/edits", apiKeyResponse.Secret, map[string]any{
+		"model":      "gpt-image-1",
+		"runMode":    "simulation",
+		"prompt":     "replace background with clean studio light",
+		"image":      "https://example.com/source.png",
+		"mask":       "https://example.com/mask.png",
+		"simulation": true,
+	}, http.StatusAccepted, &imageEditResponse)
+	if imageEditResponse.Task.Status != "succeeded" || imageEditResponse.Task.Result["id"] == "" {
+		t.Fatalf("unexpected image edit task: %+v", imageEditResponse.Task)
+	}
+
+	failoverModel := "phase1-failover-" + suffixText
+	var failedPlatform struct {
+		ID string `json:"id"`
+	}
+	doJSON(t, server.URL, http.MethodPost, "/api/v1/platforms", apiKeyResponse.Secret, map[string]any{
+		"provider":    "openai",
+		"platformKey": "openai-fail-" + suffixText,
+		"name":        "OpenAI Retryable Failure",
+		"baseUrl":     "https://api.openai.com/v1",
+		"authType":    "bearer",
+		"credentials": map[string]any{"mode": "simulation", "simulationFailure": "retryable_failure"},
+		"priority":    10,
+	}, http.StatusCreated, &failedPlatform)
+	var successPlatform struct {
+		ID string `json:"id"`
+	}
+	doJSON(t, server.URL, http.MethodPost, "/api/v1/platforms", apiKeyResponse.Secret, map[string]any{
+		"provider":    "openai",
+		"platformKey": "openai-success-" + suffixText,
+		"name":        "OpenAI Retry Success",
+		"baseUrl":     "https://api.openai.com/v1",
+		"authType":    "bearer",
+		"credentials": map[string]any{"mode": "simulation"},
+		"priority":    20,
+	}, http.StatusCreated, &successPlatform)
+	for _, platformID := range []string{failedPlatform.ID, successPlatform.ID} {
+		var platformModel map[string]any
+		doJSON(t, server.URL, http.MethodPost, "/api/v1/platforms/"+platformID+"/models", apiKeyResponse.Secret, map[string]any{
+			"canonicalModelKey": "openai:gpt-4o-mini",
+			"modelName":         failoverModel,
+			"modelAlias":        failoverModel,
+			"modelType":         "chat",
+			"displayName":       "Failover Smoke",
+			"retryPolicy":       map[string]any{"enabled": true, "maxAttempts": 2},
+		}, http.StatusCreated, &platformModel)
+		if platformModel["id"] == "" {
+			t.Fatalf("platform model was not created: %+v", platformModel)
+		}
+	}
+	var failoverTask struct {
+		Task struct {
+			ID     string `json:"id"`
+			Status string `json:"status"`
+		} `json:"task"`
+	}
+	doJSON(t, server.URL, http.MethodPost, "/api/v1/chat/completions", apiKeyResponse.Secret, map[string]any{
+		"model":    failoverModel,
+		"runMode":  "simulation",
+		"messages": []map[string]any{{"role": "user", "content": "retry please"}},
+	}, http.StatusAccepted, &failoverTask)
+	if failoverTask.Task.Status != "succeeded" {
+		t.Fatalf("failover task should succeed through second client: %+v", failoverTask.Task)
+	}
+
 	var taskDetail struct {
 		ID     string         `json:"id"`
 		Status string         `json:"status"`
@@ -222,6 +371,32 @@ VALUES ($1, 5, '{"purpose":"core-flow"}'::jsonb)`, inviteCode); err != nil {
 	if resp.StatusCode != http.StatusOK || !bytes.Contains(body, []byte("task.completed")) {
 		t.Fatalf("unexpected events response status=%d body=%s", resp.StatusCode, string(body))
 	}
+	if !bytes.Contains(body, []byte("task.progress")) {
+		t.Fatalf("events response should include progress events body=%s", string(body))
+	}
+
+	req, err = http.NewRequest(http.MethodGet, server.URL+"/api/v1/tasks/"+failoverTask.Task.ID+"/events", nil)
+	if err != nil {
+		t.Fatalf("build failover events request: %v", err)
+	}
+	req.Header.Set("Authorization", "Bearer "+apiKeyResponse.Secret)
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("failover events request: %v", err)
+	}
+	defer resp.Body.Close()
+	body, _ = io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK || !bytes.Contains(body, []byte("task.retrying")) {
+		t.Fatalf("failover events should include retrying event status=%d body=%s", resp.StatusCode, string(body))
+	}
+
+	var callbackRows int
+	if err := testPool.QueryRow(ctx, `SELECT count(*) FROM gateway_task_callback_outbox WHERE task_id = $1::uuid`, taskResponse.Task.ID).Scan(&callbackRows); err != nil {
+		t.Fatalf("read callback outbox: %v", err)
+	}
+	if callbackRows == 0 {
+		t.Fatal("task progress callback outbox should receive events")
+	}
 }
 
 func TestOriginAllowedSupportsCommaSeparatedOrigins(t *testing.T) {

apps/api/internal/httpapi/handlers.go

@@ -164,6 +164,32 @@ func (s *Server) createPlatform(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusCreated, platform)
 }
 
+func (s *Server) createPlatformModel(w http.ResponseWriter, r *http.Request) {
+	var input store.CreatePlatformModelInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid json body")
+		return
+	}
+	if pathPlatformID := r.PathValue("platformID"); pathPlatformID != "" {
+		input.PlatformID = pathPlatformID
+	}
+	if input.PlatformID == "" {
+		writeError(w, http.StatusBadRequest, "platformId is required")
+		return
+	}
+	model, err := s.store.CreatePlatformModel(r.Context(), input)
+	if err != nil {
+		if store.IsNotFound(err) {
+			writeError(w, http.StatusNotFound, "base model not found")
+			return
+		}
+		s.logger.Error("create platform model failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "create platform model failed")
+		return
+	}
+	writeJSON(w, http.StatusCreated, model)
+}
+
 func (s *Server) listModels(w http.ResponseWriter, r *http.Request) {
 	models, err := s.store.ListModels(r.Context())
 	if err != nil {
@@ -174,26 +200,6 @@ func (s *Server) listModels(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, map[string]any{"items": models})
 }
 
-func (s *Server) listCatalogProviders(w http.ResponseWriter, r *http.Request) {
-	items, err := s.store.ListCatalogProviders(r.Context())
-	if err != nil {
-		s.logger.Error("list catalog providers failed", "error", err)
-		writeError(w, http.StatusInternalServerError, "list catalog providers failed")
-		return
-	}
-	writeJSON(w, http.StatusOK, map[string]any{"items": items})
-}
-
-func (s *Server) listBaseModels(w http.ResponseWriter, r *http.Request) {
-	items, err := s.store.ListBaseModels(r.Context())
-	if err != nil {
-		s.logger.Error("list base models failed", "error", err)
-		writeError(w, http.StatusInternalServerError, "list base models failed")
-		return
-	}
-	writeJSON(w, http.StatusOK, map[string]any{"items": items})
-}
-
 func (s *Server) listPricingRules(w http.ResponseWriter, r *http.Request) {
 	items, err := s.store.ListPricingRules(r.Context())
 	if err != nil {
@@ -285,16 +291,32 @@ func (s *Server) disableAPIKey(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) estimatePricing(w http.ResponseWriter, r *http.Request) {
+	user, _ := auth.UserFromContext(r.Context())
 	var body map[string]any
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 		writeError(w, http.StatusBadRequest, "invalid json body")
 		return
 	}
-	writeJSON(w, http.StatusOK, map[string]any{
-		"items":    []any{},
-		"resolver": "effective-pricing-placeholder",
-		"request":  body,
-	})
+	model, _ := body["model"].(string)
+	kind, _ := body["kind"].(string)
+	if kind == "" {
+		kind = "chat.completions"
+	}
+	if model == "" {
+		writeError(w, http.StatusBadRequest, "model is required")
+		return
+	}
+	estimate, err := s.runner.Estimate(r.Context(), kind, model, body, user)
+	if err != nil {
+		if errors.Is(err, store.ErrNoModelCandidate) {
+			writeError(w, http.StatusNotFound, "no enabled platform model matches request")
+			return
+		}
+		s.logger.Error("estimate pricing failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "estimate pricing failed")
+		return
+	}
+	writeJSON(w, http.StatusOK, estimate)
 }
 
 func (s *Server) listRateLimitWindows(w http.ResponseWriter, r *http.Request) {
@@ -307,7 +329,7 @@ func (s *Server) listRateLimitWindows(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, map[string]any{"items": items})
 }
 
-func (s *Server) createTask(kind string) http.Handler {
+func (s *Server) createTask(kind string, compatible bool) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		user, ok := auth.UserFromContext(r.Context())
 		if !ok {
@@ -337,9 +359,25 @@ func (s *Server) createTask(kind string) http.Handler {
 			writeError(w, http.StatusInternalServerError, "create task failed")
 			return
 		}
+		result, runErr := s.runner.Execute(r.Context(), task, user)
+		if compatible {
+			if runErr != nil {
+				writeError(w, statusFromRunError(runErr), runErr.Error())
+				return
+			}
+			if boolValue(body, "stream") {
+				writeCompatibleStream(w, kind, model, result.Output)
+				return
+			}
+			writeJSON(w, http.StatusOK, result.Output)
+			return
+		}
+		if runErr != nil {
+			s.logger.Warn("task completed with failure", "kind", kind, "taskId", task.ID, "error", runErr)
+		}
 
 		writeJSON(w, http.StatusAccepted, map[string]any{
-			"task": task,
+			"task": result.Task,
 			"next": map[string]string{
 				"events": fmt.Sprintf("/api/v1/tasks/%s/events", task.ID),
 				"detail": fmt.Sprintf("/api/v1/tasks/%s", task.ID),
@@ -348,6 +386,22 @@ func (s *Server) createTask(kind string) http.Handler {
 	})
 }
 
+func statusFromRunError(err error) int {
+	switch {
+	case errors.Is(err, store.ErrNoModelCandidate):
+		return http.StatusNotFound
+	case errors.Is(err, store.ErrRateLimited):
+		return http.StatusTooManyRequests
+	default:
+		return http.StatusBadGateway
+	}
+}
+
+func boolValue(body map[string]any, key string) bool {
+	value, _ := body[key].(bool)
+	return value
+}
+
 func (s *Server) getTask(w http.ResponseWriter, r *http.Request) {
 	task, err := s.store.GetTask(r.Context(), r.PathValue("taskID"))
 	if err == nil {

apps/api/internal/httpapi/pricing_handlers.go

@@ -0,0 +1,94 @@
+package httpapi
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/easyai/easyai-ai-gateway/apps/api/internal/store"
+)
+
+func (s *Server) listPricingRuleSets(w http.ResponseWriter, r *http.Request) {
+	items, err := s.store.ListPricingRuleSets(r.Context())
+	if err != nil {
+		s.logger.Error("list pricing rule sets failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "list pricing rule sets failed")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"items": items})
+}
+
+func (s *Server) createPricingRuleSet(w http.ResponseWriter, r *http.Request) {
+	var input store.PricingRuleSetInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid json body")
+		return
+	}
+	if !validPricingRuleSetInput(input) {
+		writeError(w, http.StatusBadRequest, "ruleSetKey, name and at least one rule are required")
+		return
+	}
+	item, err := s.store.CreatePricingRuleSet(r.Context(), input)
+	if err != nil {
+		if store.IsUniqueViolation(err) {
+			writeError(w, http.StatusConflict, "pricing rule set key already exists")
+			return
+		}
+		s.logger.Error("create pricing rule set failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "create pricing rule set failed")
+		return
+	}
+	writeJSON(w, http.StatusCreated, item)
+}
+
+func (s *Server) updatePricingRuleSet(w http.ResponseWriter, r *http.Request) {
+	var input store.PricingRuleSetInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid json body")
+		return
+	}
+	if !validPricingRuleSetInput(input) {
+		writeError(w, http.StatusBadRequest, "ruleSetKey, name and at least one rule are required")
+		return
+	}
+	item, err := s.store.UpdatePricingRuleSet(r.Context(), r.PathValue("ruleSetID"), input)
+	if err != nil {
+		if store.IsNotFound(err) {
+			writeError(w, http.StatusNotFound, "pricing rule set not found")
+			return
+		}
+		if store.IsUniqueViolation(err) {
+			writeError(w, http.StatusConflict, "pricing rule set key already exists")
+			return
+		}
+		s.logger.Error("update pricing rule set failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "update pricing rule set failed")
+		return
+	}
+	writeJSON(w, http.StatusOK, item)
+}
+
+func (s *Server) deletePricingRuleSet(w http.ResponseWriter, r *http.Request) {
+	if err := s.store.DeletePricingRuleSet(r.Context(), r.PathValue("ruleSetID")); err != nil {
+		if store.IsNotFound(err) {
+			writeError(w, http.StatusNotFound, "pricing rule set not found")
+			return
+		}
+		s.logger.Error("delete pricing rule set failed", "error", err)
+		writeError(w, http.StatusInternalServerError, "delete pricing rule set failed")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func validPricingRuleSetInput(input store.PricingRuleSetInput) bool {
+	if strings.TrimSpace(input.RuleSetKey) == "" || strings.TrimSpace(input.Name) == "" || len(input.Rules) == 0 {
+		return false
+	}
+	for _, rule := range input.Rules {
+		if strings.TrimSpace(rule.ResourceType) == "" || strings.TrimSpace(rule.Unit) == "" {
+			return false
+		}
+	}
+	return true
+}

apps/api/internal/httpapi/server.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/easyai/easyai-ai-gateway/apps/api/internal/auth"
 	"github.com/easyai/easyai-ai-gateway/apps/api/internal/config"
+	"github.com/easyai/easyai-ai-gateway/apps/api/internal/runner"
 	"github.com/easyai/easyai-ai-gateway/apps/api/internal/store"
 )
 
@@ -14,6 +15,7 @@ type Server struct {
 	cfg    config.Config
 	store  *store.Store
 	auth   *auth.Authenticator
+	runner *runner.Service
 	logger *slog.Logger
 }
 
@@ -22,6 +24,7 @@ func NewServer(cfg config.Config, db *store.Store, logger *slog.Logger) http.Han
 		cfg:    cfg,
 		store:  db,
 		auth:   auth.New(cfg.JWTSecret, cfg.ServerMainBaseURL, cfg.ServerMainInternalToken),
+		runner: runner.New(cfg, db, logger),
 		logger: logger,
 	}
 	server.auth.LocalAPIKeyVerifier = db.VerifyLocalAPIKey
@@ -33,8 +36,16 @@ func NewServer(cfg config.Config, db *store.Store, logger *slog.Logger) http.Han
 	mux.Handle("POST /api/v1/auth/register", server.auth.Require(auth.PermissionPublic, http.HandlerFunc(server.register)))
 	mux.Handle("POST /api/v1/auth/login", server.auth.Require(auth.PermissionPublic, http.HandlerFunc(server.login)))
 	mux.Handle("GET /api/v1/me", server.auth.Require(auth.PermissionBasic, http.HandlerFunc(server.me)))
+	mux.Handle("GET /api/v1/public/catalog/providers", server.auth.Require(auth.PermissionPublic, http.HandlerFunc(server.listCatalogProviders)))
+	mux.Handle("GET /api/v1/public/catalog/base-models", server.auth.Require(auth.PermissionPublic, http.HandlerFunc(server.listBaseModels)))
 	mux.Handle("GET /api/v1/catalog/providers", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listCatalogProviders)))
+	mux.Handle("POST /api/v1/catalog/providers", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.createCatalogProvider)))
+	mux.Handle("PATCH /api/v1/catalog/providers/{providerID}", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.updateCatalogProvider)))
+	mux.Handle("DELETE /api/v1/catalog/providers/{providerID}", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.deleteCatalogProvider)))
 	mux.Handle("GET /api/v1/catalog/base-models", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listBaseModels)))
+	mux.Handle("POST /api/v1/catalog/base-models", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.createBaseModel)))
+	mux.Handle("PATCH /api/v1/catalog/base-models/{baseModelID}", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.updateBaseModel)))
+	mux.Handle("DELETE /api/v1/catalog/base-models/{baseModelID}", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.deleteBaseModel)))
 	mux.Handle("GET /api/v1/tenants", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listTenants)))
 	mux.Handle("GET /api/v1/users", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listUsers)))
 	mux.Handle("GET /api/v1/user-groups", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listUserGroups)))
@@ -42,16 +53,32 @@ func NewServer(cfg config.Config, db *store.Store, logger *slog.Logger) http.Han
 	mux.Handle("POST /api/v1/api-keys", server.auth.Require(auth.PermissionBasic, http.HandlerFunc(server.createAPIKey)))
 	mux.Handle("PATCH /api/v1/api-keys/{apiKeyID}/disable", server.auth.Require(auth.PermissionBasic, http.HandlerFunc(server.disableAPIKey)))
 	mux.Handle("GET /api/v1/pricing/rules", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listPricingRules)))
+	mux.Handle("GET /api/v1/pricing/rule-sets", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listPricingRuleSets)))
+	mux.Handle("POST /api/v1/pricing/rule-sets", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.createPricingRuleSet)))
+	mux.Handle("PATCH /api/v1/pricing/rule-sets/{ruleSetID}", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.updatePricingRuleSet)))
+	mux.Handle("DELETE /api/v1/pricing/rule-sets/{ruleSetID}", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.deletePricingRuleSet)))
 	mux.Handle("POST /api/v1/pricing/estimate", server.auth.Require(auth.PermissionBasic, http.HandlerFunc(server.estimatePricing)))
 	mux.Handle("GET /api/v1/platforms", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listPlatforms)))
 	mux.Handle("POST /api/v1/platforms", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.createPlatform)))
+	mux.Handle("POST /api/v1/platforms/{platformID}/models", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.createPlatformModel)))
+	mux.Handle("POST /api/v1/platform-models", server.auth.Require(auth.PermissionManager, http.HandlerFunc(server.createPlatformModel)))
 	mux.Handle("GET /api/v1/models", server.auth.Require(auth.PermissionBasic, http.HandlerFunc(server.listModels)))
 	mux.Handle("GET /api/v1/runtime/rate-limit-windows", server.auth.Require(auth.PermissionPower, http.HandlerFunc(server.listRateLimitWindows)))
-	mux.Handle("POST /api/v1/chat/completions", server.auth.Require(auth.PermissionBasic, server.createTask("chat.completions")))
-	mux.Handle("POST /api/v1/images/generations", server.auth.Require(auth.PermissionBasic, server.createTask("images.generations")))
-	mux.Handle("POST /api/v1/videos/generations", server.auth.Require(auth.PermissionBasic, server.createTask("videos.generations")))
+	mux.Handle("POST /api/v1/chat/completions", server.auth.Require(auth.PermissionBasic, server.createTask("chat.completions", false)))
+	mux.Handle("POST /api/v1/responses", server.auth.Require(auth.PermissionBasic, server.createTask("responses", false)))
+	mux.Handle("POST /api/v1/images/generations", server.auth.Require(auth.PermissionBasic, server.createTask("images.generations", false)))
+	mux.Handle("POST /api/v1/images/edits", server.auth.Require(auth.PermissionBasic, server.createTask("images.edits", false)))
+	mux.Handle("POST /api/v1/videos/generations", server.auth.Require(auth.PermissionBasic, server.createTask("videos.generations", false)))
 	mux.Handle("GET /api/v1/tasks/{taskID}", server.auth.Require(auth.PermissionBasic, http.HandlerFunc(server.getTask)))
 	mux.Handle("GET /api/v1/tasks/{taskID}/events", server.auth.Require(auth.PermissionBasic, http.HandlerFunc(server.taskEvents)))
+	mux.Handle("POST /chat/completions", server.auth.Require(auth.PermissionBasic, server.createTask("chat.completions", true)))
+	mux.Handle("POST /v1/chat/completions", server.auth.Require(auth.PermissionBasic, server.createTask("chat.completions", true)))
+	mux.Handle("POST /responses", server.auth.Require(auth.PermissionBasic, server.createTask("responses", true)))
+	mux.Handle("POST /v1/responses", server.auth.Require(auth.PermissionBasic, server.createTask("responses", true)))
+	mux.Handle("POST /images/generations", server.auth.Require(auth.PermissionBasic, server.createTask("images.generations", true)))
+	mux.Handle("POST /v1/images/generations", server.auth.Require(auth.PermissionBasic, server.createTask("images.generations", true)))
+	mux.Handle("POST /images/edits", server.auth.Require(auth.PermissionBasic, server.createTask("images.edits", true)))
+	mux.Handle("POST /v1/images/edits", server.auth.Require(auth.PermissionBasic, server.createTask("images.edits", true)))
 
 	return server.recover(server.cors(mux))
 }

apps/api/internal/httpapi/streaming.go

@@ -0,0 +1,45 @@
+package httpapi
+
+import "net/http"
+
+func writeCompatibleStream(w http.ResponseWriter, kind string, model string, output map[string]any) {
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+	content := extractOutputText(output)
+	if content == "" {
+		content = "done"
+	}
+	if kind == "responses" {
+		sendSSE(w, "response.output_text.delta", map[string]any{"type": "response.output_text.delta", "delta": content})
+		sendSSE(w, "response.completed", map[string]any{"type": "response.completed", "response": output})
+		return
+	}
+	sendSSE(w, "message", map[string]any{
+		"id":      output["id"],
+		"object":  "chat.completion.chunk",
+		"model":   model,
+		"choices": []any{map[string]any{"index": 0, "delta": map[string]any{"content": content}, "finish_reason": nil}},
+	})
+	sendSSE(w, "message", map[string]any{
+		"id":      output["id"],
+		"object":  "chat.completion.chunk",
+		"model":   model,
+		"choices": []any{map[string]any{"index": 0, "delta": map[string]any{}, "finish_reason": "stop"}},
+	})
+}
+
+func extractOutputText(output map[string]any) string {
+	if text, ok := output["output_text"].(string); ok {
+		return text
+	}
+	choices, _ := output["choices"].([]any)
+	for _, rawChoice := range choices {
+		choice, _ := rawChoice.(map[string]any)
+		message, _ := choice["message"].(map[string]any)
+		if content, ok := message["content"].(string); ok {
+			return content
+		}
+	}
+	return ""
+}